[case testEmptyClass]

class Empty: pass

def f(e: Empty) -> Empty:

return e

class EmptyEllipsis: ...

def g(e: EmptyEllipsis) -> EmptyEllipsis:

return e

[file driver.py]

from native import Empty, EmptyEllipsis, f, g

print(isinstance(Empty, type))

print(Empty)

print(str(Empty())[:20])

e = Empty()

print(f(e) is e)

print(isinstance(EmptyEllipsis, type))

print(EmptyEllipsis)

print(str(EmptyEllipsis())[:28])

e2 = EmptyEllipsis()

print(g(e2) is e2)

[out]

True

<class 'native.Empty'>

<native.Empty object

True

True

<class 'native.EmptyEllipsis'>

<native.EmptyEllipsis object

True

[case testClassWithFields]

class C:

x: int

y: int

z: 'D'

class D:

pass

[file driver.py]

from native import C

from testutil import assertRaises

c = C()

assert not hasattr(c, 'x')

assert not hasattr(c, 'y')

c.x = 1

c.y = 2

print(c.x)

print(c.y)

c.x = 10**30

print(c.x)

c.x = 10**30+1

print(c.x)

assert hasattr(c, 'x')

assert hasattr(c, 'y')

assert not hasattr(c, 'z')

with assertRaises(AttributeError, "'C' object attribute 'x' cannot be deleted"):

del c.x

assert hasattr(c, 'x')

assert hasattr(c, 'y')

with assertRaises(AttributeError, "'C' object attribute 'y' cannot be deleted"):

del c.y

assert hasattr(c, 'y')

c.x = 10**30+2

print(c.x)

assert hasattr(c, 'x')

[out]

1

2

1000000000000000000000000000000

1000000000000000000000000000001

1000000000000000000000000000002

[case testTypedDictWithFields]

import collections

import json

from typing import TypedDict

class C(TypedDict):

x: collections.deque

spam: json.JSONDecoder

[file driver.py]

from native import C

from collections import deque

from json import JSONDecoder

print(C.__annotations__["x"] is deque)

print(C.__annotations__["spam"] is JSONDecoder)

[typing fixtures/typing-full.pyi]

[out]

True

True

[case testTypedDictWithFieldsAs]

import json as _json

from typing import TypedDict

class C(TypedDict):

spam: _json.JSONDecoder

[file driver.py]

from native import C

from json import JSONDecoder

print(C.__annotations__["spam"] is JSONDecoder)

[typing fixtures/typing-full.pyi]

[out]

True

[case testTypedDictWithFieldsFrom]

from json import decoder

from typing import TypedDict

class C(TypedDict):

spam: decoder.JSONDecoder

[file driver.py]

from native import C

from json import JSONDecoder

print(C.__annotations__["spam"] is JSONDecoder)

[typing fixtures/typing-full.pyi]

[out]

True

[case testClassWithDeletableAttributes]

from typing import Any, cast

from testutil import assertRaises

class C:

__deletable__ = ['x', 'y']

x: int

y: int

z: int

def test_delete() -> None:

c = C()

c.x = 1

c.y = 2

c.z = 3

del c.x

del c.y

assert c.z == 3

with assertRaises(AttributeError, "attribute 'x' of 'C' undefined"):

c.x

with assertRaises(AttributeError, "attribute 'y' of 'C' undefined"):

c.y

def test_delete_any() -> None:

c: Any = C()

c.x = 1

c.y = 2

c.z = 3

del c.x

del c.y

with assertRaises(AttributeError, "'C' object attribute 'z' cannot be deleted"):

del c.z

assert c.z == 3

with assertRaises(AttributeError):

c.x

with assertRaises(AttributeError):

c.y

class Base:

__deletable__ = ['a']

a: int

b: int

class Deriv(Base):

__deletable__ = ('c',)

c: str

d: str

def test_delete_with_inheritance() -> None:

d = Deriv()

d.a = 0

d.b = 1

d.c = 'X'

d.d = 'Y'

del d.a

with assertRaises(AttributeError):

d.a

del d.c

with assertRaises(AttributeError):

d.c

assert d.b == 1

assert d.d == 'Y'

def test_delete_with_inheritance_any() -> None:

d: Any = Deriv()

d.a = 0

d.b = 1

d.c = 'X'

d.d = 'Y'

del d.a

with assertRaises(AttributeError):

d.a

del d.c

with assertRaises(AttributeError):

d.c

with assertRaises(AttributeError):

del d.b

assert d.b == 1

with assertRaises(AttributeError):

del d.d

assert d.d == 'Y'

def decorator(cls):

return cls

@decorator

class NonExt:

x: int

y: int

# No effect in a non-native class

__deletable__ = ['x']

def test_non_ext() -> None:

n = NonExt()

n.x = 2

n.y = 3

del n.x

del n.y

with assertRaises(AttributeError):

n.x

with assertRaises(AttributeError):

n.y

def test_non_ext_any() -> None:

n: Any = NonExt()

n.x = 2

n.y = 3

del n.x

del n.y

with assertRaises(AttributeError):

n.x

with assertRaises(AttributeError):

n.y

[case testNonExtMisc]

from typing import Any, overload

def decorator(cls) -> Any:

return cls

@decorator

class C:

def __init__(self) -> None:

self.c = 3

def get_c(self) -> int:

return self.c

@decorator

class B(C):

def __init__(self) -> None:

super().__init__()

self.b = 2

def get_b(self) -> int:

return self.b

@decorator

class A(B):

def __init__(self) -> None:

super().__init__()

self.a = 1

@classmethod

def constant(cls) -> int:

return 4

def get_a(self) -> int:

return self.a

@decorator

class Overload:

@overload

def get(self, index: int) -> int: ...

@overload

def get(self, index: str) -> str: ...

def get(self, index: Any) -> Any:

return index

def get(c: Overload, s: str) -> str:

return c.get(s)

@decorator

class Var:

x = 'xy'

def get_class_var() -> str:

return Var.x

[file driver.py]

from native import A, Overload, get, get_class_var

a = A()

assert a.a == 1

assert a.b == 2

assert a.c == 3

assert a.get_a() == 1

assert a.get_b() == 2

assert a.get_c() == 3

assert A.constant() == 4

o = Overload()

assert get(o, "test") == "test"

assert o.get(20) == 20

assert get_class_var() == 'xy'

[case testEnum]

from enum import Enum

class TestEnum(Enum):

_order_ = "a b"

a = 1

b = 2

@classmethod

def test(cls) -> int:

return 3

assert TestEnum.test() == 3

import enum

class Pokemon(enum.Enum):

magikarp = 1

squirtle = 2

slowbro = 3

assert Pokemon.magikarp.value == 1

assert Pokemon.squirtle.name == 'squirtle'

[file other.py]

# Force a multi-module test to make sure we can compile multi-file with

# non-extension classes

[file driver.py]

import sys

# "_order_" isn't supported in 3.5

if sys.version_info[:2] > (3, 5):

from native import TestEnum

assert TestEnum.a.name == 'a'

assert TestEnum.a.value == 1

assert TestEnum.b.name == 'b'

assert TestEnum.b.value == 2

[case testRunSuperYieldFromDict]

from typing import Any, Iterator

class DictSubclass(dict):

def items(self) -> Iterator[Any]:

yield 1

yield from super().items()

def test_sub_dict() -> None:

assert list(DictSubclass().items()) == [1]

[case testGetAttribute]

class C:

x: int

y: int

def getx(c: C) -> int:

return c.x

def gety(c: C) -> int:

return c.y

[file driver.py]

from native import C, getx, gety

c = C()

c.x = 10**30

c.y = 10**30 + 1

print(getx(c))

print(gety(c))

[out]

1000000000000000000000000000000

1000000000000000000000000000001

[case testSetAttribute]

class C:

x: int

y: int

def setx(c: C, v: int) -> None:

c.x = v

def sety(c: C, v: int) -> None:

c.y = v

[file driver.py]

from native import C, setx, sety

c = C()

setx(c, 10**30)

sety(c, 10**30 + 1)

print(c.x)

print(c.y)

setx(c, 4)

sety(c, 5)

print(c.x, c.y)

setx(c, 10**30 + 2)

sety(c, 10**30 + 3)

print(c.x)

print(c.y)

[out]

1000000000000000000000000000000

1000000000000000000000000000001

4 5

1000000000000000000000000000002

1000000000000000000000000000003

[case testAttributeTypes]

from typing import List, Tuple

class C:

a: List[int]

b: bool

c: C

d: object

e: int

def setattrs(o: C, a: List[int], b: bool, c: C) -> None:

o.a = a

o.b = b

o.c = c

def getattrs(o: C) -> Tuple[List[int], bool, C]:

return o.a, o.b, o.c

[file driver.py]

from native import C, setattrs, getattrs

from testutil import assertRaises

c1 = C()

c2 = C()

aa = [2]

setattrs(c1, aa, True, c2)

a, b, c = getattrs(c1)

assert a is aa

assert b is True

assert c is c2

o = object()

c1.d = o

assert c1.d is o

c3 = C()

with assertRaises(AttributeError, "attribute 'a' of 'C' undefined"):

c3.a

with assertRaises(AttributeError, "attribute 'b' of 'C' undefined"):

c3.b

with assertRaises(AttributeError, "attribute 'c' of 'C' undefined"):

c3.c

with assertRaises(AttributeError, "attribute 'd' of 'C' undefined"):

c3.d

with assertRaises(AttributeError, "attribute 'e' of 'C' undefined"):

c3.e

[case testInitMethodWithMissingNoneReturnAnnotation]

class C:

def __init__(self):

self.x = 42

[file driver.py]

from native import C

c = C()

assert c is not None

assert c.x == 42

[case testConstructClassWithDefaultConstructor]

class C:

a: int

b: int

def f() -> C:

c = C()

c.a = 13

return c

[file driver.py]

from native import f, C

c = f()

assert c.a == 13

assert type(c) == C

assert not hasattr(c, 'b')

[case testCastUserClass]

from typing import List

class C:

x: int

def f(a: List[C]) -> C:

return a[0]

[file driver.py]

from native import f, C

c = C()

assert f([c]) is c

[case testClass1]

class A:

def __init__(self, x: int) -> None:

self.x = x

def foo(self) -> int:

return self.x+1

def foo() -> int:

a = A(20)

return a.foo()

[file driver.py]

from native import A, foo

a = A(10)

assert a.foo() == 11

assert foo() == 21

[case testClassKwargs]

class X:

def __init__(self, msg: str, **variables: int) -> None:

self.msg = msg

self.variables = variables

[file driver.py]

import traceback

from native import X

x = X('hello', a=0, b=1)

assert x.msg == 'hello'

assert x.variables == {'a': 0, 'b': 1}

try:

X('hello', msg='hello')

except TypeError as e:

print(f"{type(e).__name__}: {e}")

[out]

TypeError: argument for __init__() given by name ('msg') and position (1)

[case testGenericClass]

from typing import TypeVar, Generic, Sequence

T = TypeVar('T')

class C(Generic[T]):

x: T

def __init__(self, x: T) -> None:

self.x = x

def get(self) -> T:

return self.x

def set(self, y: T) -> None:

self.x = y

# Test subclassing generic classes both with and without a generic param

class A(Sequence[int]):

pass

class B(Sequence[T]):

pass

def f(c: C[int]) -> int:

y = c.get()

d = C[int](2)

c.set(c.get() + 1 + d.get())

c.x = c.x + 2

return c.x

[file driver.py]

from native import C, f

c = C(6)

assert f(c) == 11

c.x = 'x'

assert c.x == 'x'

c.set([1])

assert c.x == [1]

assert c.get() == [1]

[case testSubclass1]

from typing import Tuple

class A:

def __init__(self) -> None:

self.x = 10

def hi(self, suffix: str) -> str:

return str(self.x) + suffix

class B(A):

def __init__(self) -> None:

self.x = 20

self.y = 'world'

def hi(self, suffix: str) -> str:

return 'hello ' + str(self.y) + suffix

def use_a(x: A) -> Tuple[int, str]:

return (x.x, x.hi(''))

def use_b(x: B) -> str:

return x.hi('')

[file driver.py]

from native import A, B, use_a, use_b

a = A()

b = B()

assert use_a(a) == (10, '10')

assert use_a(b) == (20, 'hello world')

assert a.x == 10

assert b.x == 20

assert b.y == 'world'

assert a.hi('!') == '10!'

assert b.hi('!') == 'hello world!'

assert use_b(b) == 'hello world'

[case testSubclassSpecialize1]

class A:

def foo(self, x: int) -> object:

print('A')

return str(x)

def bar(self, x: int) -> None:

print(x + 1)

class B(A):

def foo(self, x: object) -> int:

print('B')

return id(x)

def bar(self, x: object) -> None:

print(x)

def use_a(x: A, y: int) -> object:

x.bar(10)

return x.foo(y)

def use_b(x: B, y: object) -> int:

return x.foo(y)

[file driver.py]

from native import A, B, use_a, use_b

a = A()

b = B()

o = object()

i = 10

assert a.foo(10) == '10'

assert b.foo(o) == id(o)

assert use_a(a, 10) == '10'

assert use_b(b, o) == id(o)

assert use_a(b, i) == id(i)

[out]

A

B

11

A

B

10

B

[case testSubclassSpecialize2]

class A:

def foo(self, x: int) -> object:

print('A')

return str(x)

class B(A):

def foo(self, x: object) -> object:

print('B')

return x

class C(B):

def foo(self, x: object) -> int:

print('C')

return id(x)

def use_a(x: A, y: int) -> object:

return x.foo(y)

def use_b(x: B, y: object) -> object:

return x.foo(y)

def use_c(x: C, y: object) -> int:

return x.foo(y)

[file driver.py]

from native import A, B, C, use_a, use_b, use_c

a = A()

b = B()

c = C()

o = object()

i = 10

assert a.foo(10) == '10'

assert b.foo(o) == o

assert c.foo(o) == id(o)

assert use_a(a, 10) == '10'

assert use_a(b, i) is i

assert use_a(c, i) == id(i)

assert use_b(b, o) == o

assert use_b(c, o) == id(o)

assert use_c(c, o) == id(o)

[out]

A

B

C

A

B

C

B

C

C

[case testIsInstance]

from typing import Optional

class X: pass

class A(X): pass

class B(A): pass

def isa(x: object) -> bool:

return isinstance(x, A)

def isint(x: object) -> bool:

return isinstance(x, int)

def isstr(x: object) -> bool:

return isinstance(x, str)

def islist(x: object) -> bool:

return isinstance(x, list)

def ist(x: object, t: object) -> bool: # TODO: Second argument should be 'type'

return isinstance(x, t)

def pointless(x: Optional[X]) -> str:

if isinstance(x, A):

return str(x)

return ''

[file driver.py]

from native import X, A, B, isa, isint, isstr, islist, ist

assert isa(1) == False

assert isa(A()) == True

assert isa(B()) == True

assert isa(X()) == False

assert isint(1) == True

assert isint('') == False

assert isint(A()) == False

assert isstr(1) == False

assert isstr('') == True

assert islist(1) == False

assert islist([]) == True

assert ist(1, int) == True

assert ist(1, str) == False

try:

ist(1, 2)

except TypeError:

pass

else:

assert False

[case testSubclassUninitAttr]

class X:

x: int

class A(X):

pass

[file driver.py]

import traceback

from native import A

try:

A().x

except AttributeError:

traceback.print_exc()

[out]

Traceback (most recent call last):

File "driver.py", line 4, in <module>

A().x

AttributeError: attribute 'x' of 'X' undefined

[case testClassMethods]

from typing import ClassVar, Any, final

from mypy_extensions import mypyc_attr

from interp import make_interpreted_subclass

class C:

lurr: ClassVar[int] = 9

@staticmethod

def foo(x: int) -> int:

return 10 + x

@classmethod

def bar(cls, x: int) -> int:

return cls.lurr + x

@staticmethod

def baz(x: int, y: int = 10) -> int:

return y - x

@classmethod

def quux(cls, x: int, y: int = 10) -> int:

return y - x

@classmethod

def call_other(cls, x: int) -> int:

return cls.quux(x, 3)

class D(C):

def f(self) -> int:

return super().foo(1) + super().bar(2) + super().baz(10) + super().quux(10)

def ctest1() -> int:

return C.foo(1) + C.bar(2) + C.baz(10) + C.quux(10) + C.quux(y=10, x=9)

def ctest2() -> int:

c = C()

return c.foo(1) + c.bar(2) + c.baz(10)

CAny: Any = C

def test_classmethod_using_any() -> None:

assert CAny.foo(10) == 20

assert CAny.bar(10) == 19

def test_classmethod_on_instance() -> None:

c = C()

assert c.foo(10) == 20

assert c.bar(10) == 19

assert c.call_other(1) == 2

def test_classmethod_misc() -> None:

assert ctest1() == 23

assert ctest2() == 22

assert C.call_other(2) == 1

def test_classmethod_using_super() -> None:

d = D()

assert d.f() == 22

@final

class F1:

@classmethod

def f(cls, x: int) -> int:

return cls.g(x)

@classmethod

def g(cls, x: int) -> int:

return x + 1

class F2: # Implicitly final (no subclasses)

@classmethod

def f(cls, x: int) -> int:

return cls.g(x)

@classmethod

def g(cls, x: int) -> int:

return x + 1

def test_classmethod_of_final_class() -> None:

assert F1.f(5) == 6

assert F2.f(7) == 8

@mypyc_attr(allow_interpreted_subclasses=True)

class CI:

@classmethod

def f(cls, x: int) -> int:

return cls.g(x)

@classmethod

def g(cls, x: int) -> int:

return x + 1

def test_classmethod_with_allow_interpreted() -> None:

assert CI.f(4) == 5

sub = make_interpreted_subclass(CI)

assert sub.f(4) == 7

[file interp.py]

def make_interpreted_subclass(base):

class Sub(base): # type: ignore[misc, valid-type]

@classmethod

def g(cls, x: int) -> int:

return x + 3

return Sub

[case testSuper]

from mypy_extensions import trait

from typing import List

class A:

def __init__(self, x: int) -> None:

self.x = x

def foo(self, x: int) -> int:

return x

class B(A):

def __init__(self, x: int, y: int) -> None:

super().__init__(x)

self.y = y

def foo(self, x: int) -> int:

return super().foo(x+1)

class C(B):

def __init__(self, x: int, y: int) -> None:

super(C, self).__init__(x, y + 1)

def foo(self, x: int) -> int:

# should go to A, not B

return super(B, self).foo(x+1)

class X:

def __init__(self, x: int) -> None:

self.x = x

class Y(X):

pass

class Z(Y):

def __init__(self, x: int, y: int) -> None:

super().__init__(x)

self.y = y

@trait

class T:

def v_int(self, x: int) -> None: pass

def v_list(self, x: List[int]) -> None:

if x:

self.v_int(x[0])

self.v_list(x[1:])

class PrintList(T):

def v_int(self, x: int) -> None:

print(x)

def v_list(self, x: List[int]) -> None:

print('yo!')

super().v_list(x)

[file driver.py]

import traceback

from native import *

b = B(10, 20)

assert b.x == 10 and b.y == 20

c = C(10, 20)

assert c.x == 10 and c.y == 21

z = Z(10, 20)

assert z.x == 10 and z.y == 20

assert c.foo(10) == 11

PrintList().v_list([1,2,3])

[out]

yo!

1

yo!

2

yo!

3

yo!

[case testSubclassException]

class Failure(Exception):

def __init__(self, x: int) -> None:

self.x = x

def foo() -> None:

raise Failure(10)

def heyo() -> int:

try:

foo()

except Failure as e:

return e.x

return -1

[file driver.py]

from native import foo, heyo, Failure

try:

foo()

except Failure as e:

assert str(e) == '10'

assert e.x == 10

heyo()

[case testSubclassDict]

from typing import Dict

class WelpDict(Dict[str, int]):

def __init__(self) -> None:

self.emarhavil = 3

def foo(self) -> int:

return self.emarhavil

def welp() -> int:

x = WelpDict()

x['a'] = 10

x['b'] = 15

x.emarhavil = 5

return x['a'] + x['b'] + x.emarhavil + x.foo()

[file driver.py]

from native import welp

assert welp() == 35

[case testSubclassUnsupportedException]

from mypy_extensions import mypyc_attr

@mypyc_attr(native_class=False)

class MyError(ZeroDivisionError):

pass

@mypyc_attr(native_class=False)

class MyError2(ZeroDivisionError):

def __init__(self, s: str) -> None:

super().__init__(s + "!")

self.x = s.upper()

def f() -> None:

raise MyError("foobar")

def test_non_native_exception_subclass_basics() -> None:

e = MyError()

assert isinstance(e, MyError)

assert isinstance(e, ZeroDivisionError)

assert isinstance(e, Exception)

e = MyError("x")