jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/test-data/run-classes.test

@@ -1,2505 +0,0 @@
-[case testEmptyClass]
-class Empty: pass
-
-def f(e: Empty) -> Empty:
-    return e
-[file driver.py]
-from native import Empty, f
-
-print(isinstance(Empty, type))
-print(Empty)
-print(str(Empty())[:20])
-
-e = Empty()
-print(f(e) is e)
-[out]
-True
-<class 'native.Empty'>
-<native.Empty 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 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 : int = 1
-    b : int = 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 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 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
-from typing_extensions import 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):
-        @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 testSubclassPy]
-from b import B, V
-class A(B):
-    def __init__(self, x: int, y: int) -> None:
-        super().__init__(y)
-        self.x = x
-
-    def foo(self, x: int) -> int:
-        print("hi", x)
-        return x+1
-
-class C(V[int]):
-    def f(self) -> int: return 10
-
-assert isinstance(C(), V)
-
-def f(x: A) -> None:
-    print(x.x)
-    print(x.y)
-    print(x.foo(20))
-
-[file b.py]
-from typing import Generic, TypeVar
-T = TypeVar('T')
-
-class B:
-    def __init__(self, y: int) -> None:
-        self.y = y
-    def foo(self, x: int) -> int:
-        print("parent!")
-        return x + self.y
-    def bar(self) -> None:
-        print("hello!", self.y)
-
-class V(Generic[T]):
-    def f(self) -> T:
-        raise Exception('unimplemented')
-[file driver.py]
-import native
-a = native.A(10, 20)
-a.foo(10)
-a.bar()
-native.f(a)
-[out]
-hi 10
-hello! 20
-10
-20
-hi 20
-21
-
-[case testDisallowSubclassFromPy]
-# We'll want to allow this at some point but right now we need to
-# disallow it because it doesn't work.
-class A:
-    pass
-[file b.py]
-from native import A
-
-# It would be better if we disallowed it at class decl time but it is
-# really easy to do in __new__
-
-class B(A):
-    pass
-
-[file driver.py]
-from b import B
-try:
-    B()
-except TypeError:
-    pass
-else:
-    assert False, "instantiating was supposed to fail"
-
-[case testClassVariable]
-MYPY = False
-if MYPY:
-    from typing import ClassVar
-class A:
-    x = 10  # type: ClassVar[int]
-
-def g(x: int) -> None:
-    A.x = 10
-def f() -> int:
-    return A.x
-[file driver.py]
-from native import A, f
-assert f() == 10
-A.x = 200
-assert f() == 200
-
-[case testDefaultVars]
-from typing import Optional
-class A:
-    x = 10
-    w: object = 10
-    def lol(self) -> None:
-        self.x = 100
-
-LOL = 'lol'
-class B(A):
-    y = LOL
-    z = None  # type: Optional[str]
-    b = True
-    bogus = None  # type: int
-
-def g() -> None:
-    a = A()
-    assert a.x == 10
-    a.x = 20
-    assert a.x == 20
-    b = B()
-    assert b.x == 10
-    b.x = 20
-    assert b.x == 20
-    assert b.y == 'lol'
-    b.y = 'rofl'
-    assert b.y == 'rofl'
-    assert b.z is None
-[file driver.py]
-from native import *
-g()
-
-a = A()
-assert a.x == 10
-a.x = 20
-assert a.x == 20
-b = B()
-assert b.x == 10
-b.x = 20
-assert b.x == 20
-assert b.y == 'lol'
-b.y = 'rofl'
-assert b.y == 'rofl'
-assert b.z is None
-# N.B: this doesn't match cpython
-assert not hasattr(b, 'bogus')
-
-[case testProtocol]
-from typing_extensions import Protocol
-
-class Proto(Protocol):
-    def foo(self, x: int) -> None:
-        pass
-
-    def bar(self, x: int) -> None:
-        pass
-
-class A:
-    def foo(self, x: int) -> None:
-        print("A:", x)
-
-    def bar(self, *args: int, **kwargs: int) -> None:
-        print("A:", args, kwargs)
-
-class B(A, Proto):
-    def foo(self, x: int) -> None:
-        print("B:", x)
-
-    def bar(self, *args: int, **kwargs: int) -> None:
-        print("B:", args, kwargs)
-
-def f(x: Proto) -> None:
-    x.foo(20)
-    x.bar(x=20)
-
-[file driver.py]
-from native import A, B, f
-
-f(A())
-f(B())
-
-# ... this exploits a bug in glue methods to distinguish whether we
-# are making a direct call or a pycall...
-[out]
-A: 20
-A: () {'x': 20}
-B: 20
-B: (20,) {}
-
-[case testMethodOverrideDefault1]
-class A:
-    def foo(self, x: int) -> None:
-        pass
-class B(A):
-    def foo(self, x: int, y: int = 10) -> None:
-        print(x, y)
-
-def a(x: A) -> None:
-    x.foo(1)
-def b(x: B) -> None:
-    x.foo(2)
-    x.foo(2, 3)
-
-[file driver.py]
-from native import B, a, b
-a(B())
-b(B())
-[out]
-1 10
-2 10
-2 3
-
-[case testMethodOverrideDefault2]
-class A:
-    def foo(self, *, x: int = -1) -> None:
-        pass
-    def bar(self, *, x: int = -1, y: int = -1) -> None:
-        pass
-    def baz(self, x: int = -1) -> None:
-        pass
-class B(A):
-    def foo(self, *, y: int = 0, x: int = 0) -> None:
-        print(x, y)
-    def bar(self, *, y: int = 0, x: int = 0) -> None:
-        print(x, y)
-    def baz(self, x: int = 0, *, y: int = 0) -> None:
-        print(x, y)
-
-def a(x: A) -> None:
-    x.foo(x=1)
-    x.bar(x=1, y=2)
-    x.bar(x=2, y=1)
-    x.baz()
-    x.baz(1)
-    x.baz(x=2)
-
-[file driver.py]
-from native import B, a
-a(B())
-[out]
-1 0
-1 2
-2 1
-0 0
-1 0
-2 0
-
-[case testMethodOverrideDefault3]
-class A:
-    @classmethod
-    def foo(cls, *, x: int = 0) -> None:
-        pass
-    @staticmethod
-    def bar(*, x: int = 0) -> None:
-        pass
-    @staticmethod
-    def baz() -> object:
-        pass
-class B(A):
-    @classmethod
-    def foo(cls, *, y: int = 0, x: int = 0) -> None:
-        print(x, y)
-        print(cls.__name__)  # type: ignore
-    @staticmethod
-    def bar(*, y: int = 0, x: int = 0) -> None:
-        print(x, y)
-    @staticmethod
-    def baz() -> int:
-        return 10
-
-# This is just to make sure that this stuff works even when the
-# methods might be overridden.
-class C(B):
-    @classmethod
-    def foo(cls, *, y: int = 0, x: int = 0) -> None:
-        pass
-    @staticmethod
-    def bar(*, y: int = 0, x: int = 0) -> None:
-        pass
-    @staticmethod
-    def baz() -> int:
-        return 10
-
-def a(x: A) -> None:
-    x.foo(x=1)
-    x.bar(x=1)
-    print(x.baz())
-
-[file driver.py]
-from native import B, a
-a(B())
-[out]
-1 0
-B
-1 0
-10
-
-[case testMethodOverrideDefault4]
-class Foo:
-    def f(self, x: int=20, *, z: int=10) -> None:
-        pass
-
-class Bar(Foo):
-    def f(self, *args: int, **kwargs: int) -> None:
-        print("stuff", args, kwargs)
-
-z: Foo = Bar()
-z.f(1, z=50)
-z.f()
-
-[out]
-stuff (1,) {'z': 50}
-stuff () {}
-
-[case testMethodOverrideDefault5]
-from testutil import make_python_function
-from mypy_extensions import mypyc_attr
-from typing import TypeVar, Any
-
-@mypyc_attr(allow_interpreted_subclasses=True)
-class Foo:
-    def f(self, x: int=20, *, z: int=10) -> None:
-        print("Foo", x, z)
-
-@make_python_function
-def baz_f(self: Any, *args: int, **kwargs: int) -> None:
-    print("Baz", args, kwargs)
-
-# Make an "interpreted" subtype of Foo
-type2: Any = type
-Bar = type2('Bar', (Foo,), {})
-Baz = type2('Baz', (Foo,), {'f': baz_f})
-
-y: Foo = Bar()
-y.f(1, z=2)
-y.f()
-
-z: Foo = Baz()
-z.f(1, z=2)
-z.f()
-
-[out]
-Foo 1 2
-Foo 20 10
-Baz (1,) {'z': 2}
-Baz () {}
-
-[case testMethodOverrideDefault6]
-from typing import Optional
-
-class Foo:
-    def f(self, x: int=20) -> None:
-        pass
-
-class Bar(Foo):
-    def f(self, x: Optional[int]=None) -> None:
-        print(x)
-
-z: Foo = Bar()
-z.f(1)
-z.f()
-
-[out]
-1
-None
-
-[case testMethodOverrideDefault7]
-from typing import TypeVar, Any
-
-class Foo:
-    def f(self, x: int, *args: int, **kwargs: int) -> None:
-        print("Foo", x, args, kwargs)
-
-class Bar(Foo):
-    def f(self, *args: int, **kwargs: int) -> None:
-        print("Bar", args, kwargs)
-
-z: Foo = Bar()
-z.f(1, z=2)
-z.f(1, 2, 3)
-# z.f(x=5)  # Not tested because we (knowingly) do the wrong thing and pass it as positional
-
-[out]
-Bar (1,) {'z': 2}
-Bar (1, 2, 3) {}
---Bar () {'x': 5}
-
-[case testMethodOverrideDefault8]
-from typing import TypeVar, Any
-
-class Foo:
-    def f(self, *args: int, **kwargs: int) -> None:
-        print("Foo", args, kwargs)
-
-class Bar(Foo):
-    def f(self, x: int = 10, *args: int, **kwargs: int) -> None:
-        print("Bar", x, args, kwargs)
-
-z: Foo = Bar()
-z.f(1, z=2)
-z.f(1, 2, 3)
-z.f()
-
-[out]
-Bar 1 () {'z': 2}
-Bar 1 (2, 3) {}
-Bar 10 () {}
-
-[case testMethodOverrideDefault9]
-from testutil import make_python_function
-from mypy_extensions import mypyc_attr
-from typing import TypeVar, Any
-
-@mypyc_attr(allow_interpreted_subclasses=True)
-class Foo:
-    def f(self, x: int=20, y: int=40) -> None:
-        print("Foo", x, y)
-
-# This sort of argument renaming is dodgy and not really sound but we
-# shouldn't break it when they aren't actually used by name...
-# (They *ought* to be positional only!)
-@make_python_function
-def baz_f(self, a: int=30, y: int=50) -> None:
-    print("Baz", a, y)
-
-# Make an "interpreted" subtype of Foo
-type2: Any = type
-Baz = type2('Baz', (Foo,), {'f': baz_f})
-
-z: Foo = Baz()
-z.f()
-z.f(y=1)
-z.f(1, 2)
-# Not tested because we don't (and probably won't) match cpython here
-# from testutil import assertRaises
-# with assertRaises(TypeError):
-#     z.f(x=7)
-
-[out]
-Baz 30 50
-Baz 30 1
-Baz 1 2
-
-[case testOverride]
-class A:
-    def f(self) -> int:
-        return 0
-    def g(self) -> int:
-        return 1
-
-class B(A):
-    def g(self) -> int:
-        return 2
-
-class C(B):
-    def f(self) -> int:
-        return 3
-
-def test() -> None:
-    ba: A = B()
-    ca: A = C()
-    assert ba.f() == 0
-    assert ba.g() == 2
-    assert ca.f() == 3
-    assert ca.g() == 2
-    cc = C()
-    assert cc.f() == 3
-    assert cc.g() == 2
-    print('ok')
-[file driver.py]
-import native
-native.test()
-[out]
-ok
-
-[case testNoMetaclass]
-from foo import Base
-
-class Nothing(Base):  # type: ignore
-    pass
-
-[file foo.py]
-from typing import Any
-class Meta(type):
-    pass
-
-class _Base(metaclass=Meta):
-    pass
-Base = _Base  # type: Any
-
-[file driver.py]
-try:
-    import native
-except TypeError as e:
-    assert(str(e) == "mypyc classes can't have a metaclass")
-
-[case testMetaclass]
-from meta import Meta
-
-class Nothing(metaclass=Meta):
-    pass
-
-def ident(x): return x
-
-@ident
-class Test:
-    pass
-
-[file meta.py]
-class Meta(type):
-    def __new__(mcs, name, bases, dct):
-        dct['X'] = 10
-        return super().__new__(mcs, name, bases, dct)
-
-
-[file driver.py]
-from native import Nothing
-assert Nothing.X == 10
-
-[case testPickling]
-from mypy_extensions import trait, mypyc_attr
-from typing import Any, TypeVar, Generic
-
-def dec(x: Any) -> Any:
-    return x
-
-@mypyc_attr(allow_interpreted_subclasses=True)
-class A:
-    x: int
-    y: str
-
-@mypyc_attr(allow_interpreted_subclasses=True)
-class B(A):
-    z: bool
-
-    def __init__(self, x: int, y: str, z: bool) -> None:
-        self.x = x
-        self.y = y
-        self.z = z
-
-@trait
-class T:
-    a: str
-
-class C(B, T):
-    w: object
-
-    # property shouldn't go in
-    @property
-    def foo(self) -> int:
-        return 0
-
-@dec
-class D:
-    x: int
-
-class E(D):
-    y: int
-
-
-U = TypeVar('U')
-
-class F(Generic[U]):
-    y: int
-
-class G(F[int]):
-    pass
-
-[file driver.py]
-from native import A, B, T, C, D, E, F, G
-
-import copy
-import pickle
-
-assert A.__mypyc_attrs__ == ('x', 'y')
-assert B.__mypyc_attrs__ == ('z', 'x', 'y')
-assert T.__mypyc_attrs__ == ('a',)
-assert C.__mypyc_attrs__ == ('w', 'z', 'x', 'y', 'a')
-assert not hasattr(D, '__mypyc_attrs__')
-assert E.__mypyc_attrs__ == ('y', '__dict__')
-assert F.__mypyc_attrs__ == ('y', '__dict__')
-assert G.__mypyc_attrs__ == ('y', '__dict__')
-
-b = B(10, '20', False)
-assert b.__getstate__() == {'z': False, 'x': 10, 'y': '20'}
-b2 = copy.copy(b)
-assert b is not b2 and b.y == b2.y
-
-b3 = pickle.loads(pickle.dumps(b))
-assert b is not b3 and b.y == b3.y
-
-e = E()
-e.x = 10
-e.y = 20
-
-assert e.__getstate__() == {'y': 20, '__dict__': {'x': 10}}
-e2 = pickle.loads(pickle.dumps(e))
-assert e is not e2 and e.x == e2.x and e.y == e2.y
-
-
-[case testInterpretedParentInit]
-from interp import C
-from typing import TypeVar
-
-T = TypeVar('T')
-
-def dec(x: T) -> T:
-    return x
-
-@dec
-class A:
-    def __init__(self, x: int) -> None:
-        self.x = x
-
-class B(A):
-    s = 'test'
-
-def b(x: int) -> B: return B(x)
-
-class D(C):
-    s = 'test'
-
-def d(x: int) -> D: return D(x)
-
-
-[file interp.py]
-class C:
-    def __init__(self, x: int) -> None:
-        self.x = x
-
-[file driver.py]
-from native import b, d, B, D
-
-def test(f, v):
-    x = f(v)
-    assert x.x == v
-    assert x.s == 'test'
-
-test(b, 20)
-test(d, 30)
-test(B, -1)
-test(D, -2)
-
-[case testInterpretedInherit]
-from typing import TypeVar, Any, overload
-from mypy_extensions import mypyc_attr, trait
-
-T = TypeVar('T')
-def dec(x: T) -> T: return x
-
-@mypyc_attr(allow_interpreted_subclasses=True)
-class Top:
-    def spam(self) -> str:
-        return "grandparent"
-
-@mypyc_attr(allow_interpreted_subclasses=True)
-@trait
-class Trait:
-    def trait_method(self) -> str:
-        return "trait"
-
-@mypyc_attr(allow_interpreted_subclasses=True)
-class Foo(Top, Trait):
-    def __init__(self, x: int) -> None:
-        self.x = x
-
-    def foo(self) -> str:
-        return "parent foo: " + self.bar(self.x)
-
-    def bar(self, x: int) -> str:
-        return "parent bar: {}".format(x + self.x)
-
-    @dec
-    def decorated(self) -> str:
-        return "decorated parent"
-
-    @property
-    def read_property(self) -> str:
-        return "parent prop"
-
-    @overload
-    def overloaded(self, index: int) -> int: ...
-
-    @overload
-    def overloaded(self, index: str) -> str: ...
-
-    def overloaded(self, index: Any) -> Any:
-        return index
-
-def foo(x: Foo) -> str:
-    return x.foo()
-
-def bar(x: Foo, y: int) -> str:
-    return x.bar(y)
-
-def spam(x: Top) -> str:
-    return x.spam()
-
-def decorated(x: Foo) -> str:
-    return x.decorated()
-
-def prop(x: Foo) -> str:
-    return x.read_property
-
-def trait_method(x: Trait) -> str:
-    return x.trait_method()
-
-def overloaded(x: Foo, s: str) -> str:
-    return x.overloaded(s)
-
-[file interp.py]
-from typing import Any
-from native import Foo
-
-class Bar(Foo):
-    def bar(self, x: int) -> str:
-        return "child bar: {}".format(x + self.x)
-
-    def spam(self) -> str:
-        assert super().spam() == "grandparent"
-        return "child"
-
-    @property
-    def read_property(self) -> str:
-        return "child prop"
-
-    def decorated(self) -> str:
-        return "decorated child"
-
-    def trait_method(self) -> str:
-        return "child"
-
-    def overloaded(self, index: Any) -> Any:
-        return index + index
-
-
-class InterpBase:
-    def eggs(self) -> str:
-        return "eggs"
-
-class Baz(InterpBase, Bar):
-    def __init__(self) -> None:
-        super().__init__(1000)
-        self.z = self.read_property
-
-[file driver.py]
-from native import Foo, foo, bar, spam, decorated, overloaded, prop, trait_method
-from interp import Bar, Baz
-from unittest.mock import patch
-from testutil import assertRaises
-
-x = Foo(10)
-y = Bar(20)
-z = Baz()
-
-assert isinstance(y, Bar)
-assert y.x == 20
-assert y.bar(10) == "child bar: 30"
-assert y.foo() == "parent foo: child bar: 40"
-assert foo(y) == "parent foo: child bar: 40"
-assert bar(y, 30) == "child bar: 50"
-y.x = 30
-assert bar(y, 30) == "child bar: 60"
-
-assert spam(y) == "child"
-assert y.read_property == "child prop"
-assert prop(x) == "parent prop"
-assert prop(y) == "child prop"
-assert y.decorated() == "decorated child"
-assert decorated(y) == "decorated child"
-assert y.overloaded("test") == "testtest"
-assert overloaded(y, "test") == "testtest"
-
-assert y.trait_method() == "child"
-assert trait_method(y) == "child"
-
-assert z.bar(10) == "child bar: 1010"
-assert bar(z, 10) == "child bar: 1010"
-assert z.z == "child prop"
-assert z.eggs() == "eggs"
-
-with patch("interp.Bar.spam", lambda self: "monkey patched"):
-    assert y.spam() == "monkey patched"
-    spam(y) == "monkey patched"
-
-with patch("interp.Bar.spam", lambda self: 20):
-    assert y.spam() == 20
-    with assertRaises(TypeError, "str object expected; got int"):
-        spam(y)
-
-with assertRaises(TypeError, "int object expected; got str"):
-    y.x = "test"
-
-[case testProperty]
-from typing import Callable
-from mypy_extensions import trait
-class Temperature:
-    @property
-    def celsius(self) -> float:
-        return 5.0 * (self.fahrenheit - 32.0) / 9.0
-
-    def __init__(self, fahrenheit: float) -> None:
-        self.fahrenheit = fahrenheit
-
-    def print_temp(self) -> None:
-        print("F:", self.fahrenheit, "C:", self.celsius)
-
-    @property
-    def rankine(self) -> float:
-        raise NotImplementedError
-
-class Access:
-    @property
-    def number_of_accesses(self) -> int:
-        self._count += 1
-        return self._count
-    def __init__(self) -> None:
-        self._count = 0
-
-from typing import Callable
-class BaseProperty:
-    @property
-    def doc(self) -> str:
-        return "Represents a sequence of values. Updates itself by next, which is a new value."
-
-    @property
-    def value(self) -> object:
-        return self._incrementer
-
-    @property
-    def bad_value(self) -> object:
-        return self._incrementer
-
-    @property
-    def next(self) -> BaseProperty:
-        return BaseProperty(self._incrementer + 1)
-
-    def __init__(self, value: int) -> None:
-        self._incrementer = value
-
-class DerivedProperty(BaseProperty):
-    @property
-    def value(self) -> int:
-        return self._incrementer
-
-    @property
-    def bad_value(self) -> object:
-        return self._incrementer
-
-    def __init__(self, incr_func: Callable[[int], int], value: int) -> None:
-        BaseProperty.__init__(self, value)
-        self._incr_func = incr_func
-
-    @property
-    def next(self) -> DerivedProperty:
-        return DerivedProperty(self._incr_func, self._incr_func(self.value))
-
-class AgainProperty(DerivedProperty):
-    @property
-    def next(self) -> AgainProperty:
-        return AgainProperty(self._incr_func, self._incr_func(self._incr_func(self.value)))
-
-    @property
-    def bad_value(self) -> int:
-        return self._incrementer
-
-def print_first_n(n: int, thing: BaseProperty) -> None:
-    vals = []
-    cur_thing = thing
-    for _ in range(n):
-        vals.append(cur_thing.value)
-        cur_thing = cur_thing.next
-    print ('', vals)
-
-@trait
-class Trait:
-    @property
-    def value(self) -> int:
-        return 3
-
-class Printer(Trait):
-    def print_value(self) -> None:
-        print(self.value)
-
-[file driver.py]
-from native import Temperature, Access
-import traceback
-x = Temperature(32.0)
-try:
-    print (x.rankine)
-except NotImplementedError as e:
-    traceback.print_exc()
-print (x.celsius)
-x.print_temp()
-
-y = Temperature(212.0)
-print (y.celsius)
-y.print_temp()
-
-z = Access()
-print (z.number_of_accesses)
-print (z.number_of_accesses)
-print (z.number_of_accesses)
-print (z.number_of_accesses)
-
-from native import BaseProperty, DerivedProperty, AgainProperty, print_first_n
-a = BaseProperty(7)
-b = DerivedProperty((lambda x: x // 2 if (x % 2 == 0) else 3 * x + 1), 7)
-c = AgainProperty((lambda x: x // 2 if (x % 2 == 0) else 3 * x + 1), 7)
-
-def py_print_first_n(n: int, thing: BaseProperty) -> None:
-    vals = []
-    cur_thing = thing
-    for _ in range(n):
-        vals.append(cur_thing.value)
-        cur_thing = cur_thing.next
-    print ('', vals)
-
-py_print_first_n(20, a)
-py_print_first_n(20, b)
-py_print_first_n(20, c)
-
-print(a.next.next.next.bad_value)
-print(b.next.next.next.bad_value)
-print(c.next.next.next.bad_value)
-
-print_first_n(20, a)
-print_first_n(20, b)
-print_first_n(20, c)
-
-print (a.doc)
-print (b.doc)
-print (c.doc)
-
-from native import Printer
-Printer().print_value()
-print (Printer().value)
-[out]
-Traceback (most recent call last):
-  File "driver.py", line 5, in <module>
-    print (x.rankine)
-  File "native.py", line 16, in rankine
-    raise NotImplementedError
-NotImplementedError
-0.0
-F: 32.0 C: 0.0
-100.0
-F: 212.0 C: 100.0
-1
-2
-3
-4
- [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
- [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1]
- [7, 11, 17, 26, 40, 10, 16, 4, 1, 2, 4, 1, 2, 4, 1, 2, 4, 1, 2, 4]
-10
-34
-26
- [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
- [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1]
- [7, 11, 17, 26, 40, 10, 16, 4, 1, 2, 4, 1, 2, 4, 1, 2, 4, 1, 2, 4]
-Represents a sequence of values. Updates itself by next, which is a new value.
-Represents a sequence of values. Updates itself by next, which is a new value.
-Represents a sequence of values. Updates itself by next, which is a new value.
-3
-3
-[out version>=3.11]
-Traceback (most recent call last):
-  File "driver.py", line 5, in <module>
-    print (x.rankine)
-           ^^^^^^^^^
-  File "native.py", line 16, in rankine
-    raise NotImplementedError
-NotImplementedError
-0.0
-F: 32.0 C: 0.0
-100.0
-F: 212.0 C: 100.0
-1
-2
-3
-4
- [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
- [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1]
- [7, 11, 17, 26, 40, 10, 16, 4, 1, 2, 4, 1, 2, 4, 1, 2, 4, 1, 2, 4]
-10
-34
-26
- [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
- [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1]
- [7, 11, 17, 26, 40, 10, 16, 4, 1, 2, 4, 1, 2, 4, 1, 2, 4, 1, 2, 4]
-Represents a sequence of values. Updates itself by next, which is a new value.
-Represents a sequence of values. Updates itself by next, which is a new value.
-Represents a sequence of values. Updates itself by next, which is a new value.
-3
-3
-
-[case testPropertySetters]
-
-from mypy_extensions import trait
-
-class Foo():
-    def __init__(self) -> None:
-        self.attr = "unmodified"
-
-class A:
-    def __init__(self) -> None:
-        self._x = 0
-        self._foo = Foo()
-
-    @property
-    def x(self) -> int:
-        return self._x
-
-    @x.setter
-    def x(self, val : int) -> None:
-        self._x = val
-
-    @property
-    def foo(self) -> Foo:
-        return self._foo
-
-    @foo.setter
-    def foo(self, val : Foo) -> None:
-        self._foo = val
-
-# Overrides base property setters and getters
-class B(A):
-    def __init__(self) -> None:
-        self._x = 10
-
-    @property
-    def x(self) -> int:
-        return self._x + 1
-
-    @x.setter
-    def x(self, val : int) -> None:
-        self._x = val + 1
-
-# Inherits base property setters and getters
-class C(A):
-    def __init__(self) -> None:
-        A.__init__(self)
-
-@trait
-class D():
-    def __init__(self) -> None:
-        self._x = 0
-
-    @property
-    def x(self) -> int:
-        return self._x
-
-    @x.setter
-    def x(self, val : int) -> None:
-        self._x = val
-
-#Inherits trait property setters and getters
-class E(D):
-    def __init__(self) -> None:
-        D.__init__(self)
-
-#Overrides trait property setters and getters
-class F(D):
-    def __init__(self) -> None:
-        self._x = 10
-
-    @property
-    def x(self) -> int:
-        return self._x + 10
-
-    @x.setter
-    def x(self, val : int) -> None:
-        self._x = val + 10
-
-# # Property setter and getter are subtypes of base property setters and getters
-# # class G(A):
-# #   def __init__(self) -> None:
-# #       A.__init__(self)
-
-# #   @property
-# #   def y(self) -> int:
-# #       return self._y
-
-# #   @y.setter
-# #   def y(self, val : object) -> None:
-# #       self._y = val
-
-# No inheritance, just plain setter/getter
-class G:
-    def __init__(self, x: int) -> None:
-        self._x = x
-
-    @property
-    def x(self) -> int:
-        return self._x
-
-    @x.setter
-    def x(self, x: int) -> None:
-        self._x = x
-
-class H:
-    def __init__(self, g: G) -> None:
-        self.g = g
-        self.g.x = 5  # Should not be treated as initialization
-
-[file other.py]
-# Run in both interpreted and compiled mode
-
-from native import A, B, C, D, E, F, G
-
-a = A()
-assert a.x == 0
-assert a._x == 0
-a.x = 1
-assert a.x == 1
-assert a._x == 1
-a._x = 0
-assert a.x == 0
-assert a._x == 0
-b = B()
-assert b.x == 11
-assert b._x == 10
-b.x = 11
-assert b.x == 13
-b._x = 11
-assert b.x == 12
-c = C()
-assert c.x == 0
-c.x = 1000
-assert c.x == 1000
-e = E()
-assert e.x == 0
-e.x = 1000
-assert e.x == 1000
-f = F()
-assert f.x == 20
-f.x = 30
-assert f.x == 50
-g = G(4)
-g.x = 20
-assert g.x == 20
-
-[file driver.py]
-# Run the tests in both interpreted and compiled mode
-import other
-import other_interpreted
-
-[out]
-
-[case testAttributeOverridesProperty]
-from typing import Any
-from mypy_extensions import trait
-
-@trait
-class T1:
-    @property
-    def x(self) -> int: ...
-    @property
-    def y(self) -> int: ...
-
-class C1(T1):
-    x: int = 1
-    y: int = 4
-
-def test_read_only_property_in_trait_implemented_as_attribute() -> None:
-    c = C1()
-    c.x = 5
-    assert c.x == 5
-    assert c.y == 4
-    c.y = 6
-    assert c.y == 6
-    t: T1 = C1()
-    assert t.y == 4
-    t = c
-    assert t.x == 5
-    assert t.y == 6
-    a: Any = c
-    assert a.x == 5
-    assert a.y == 6
-    a.x = 7
-    a.y = 8
-    assert a.x == 7
-    assert a.y == 8
-
-class B2:
-    @property
-    def x(self) -> int:
-        return 11
-
-    @property
-    def y(self) -> int:
-        return 25
-
-class C2(B2):
-    x: int = 1
-    y: int = 4
-
-def test_read_only_property_in_class_implemented_as_attribute() -> None:
-    c = C2()
-    c.x = 5
-    assert c.x == 5
-    assert c.y == 4
-    c.y = 6
-    assert c.y == 6
-    b: B2 = C2()
-    assert b.y == 4
-    b = c
-    assert b.x == 5
-    assert b.y == 6
-    a: Any = c
-    assert a.x == 5
-    assert a.y == 6
-    a.x = 7
-    a.y = 8
-    assert a.x == 7
-    assert a.y == 8
-
-@trait
-class T3:
-    @property
-    def x(self) -> int: ...
-    @property
-    def y(self) -> int: ...
-
-class B3:
-    x: int = 1
-    y: int = 4
-
-class C3(B3, T3):
-    pass
-
-def test_read_only_property_implemented_as_attribute_indirectly() -> None:
-    c = C3()
-    c.x = 5
-    assert c.x == 5
-    assert c.y == 4
-    c.y = 6
-    assert c.y == 6
-    t: T3 = C3()
-    assert t.y == 4
-    t = c
-    assert t.x == 5
-    assert t.y == 6
-    a: Any = c
-    assert a.x == 5
-    assert a.y == 6
-    a.x = 7
-    a.y = 8
-    assert a.x == 7
-    assert a.y == 8
-
-@trait
-class T4:
-    @property
-    def x(self) -> int: ...
-    @x.setter
-    def x(self, v1: int) -> None: ...
-
-    @property
-    def y(self) -> int: ...
-    @y.setter
-    def y(self, v2: int) -> None: ...
-
-class C4(T4):
-    x: int = 1
-    y: int = 4
-
-def test_read_write_property_implemented_as_attribute() -> None:
-    c = C4()
-    c.x = 5
-    assert c.x == 5
-    assert c.y == 4
-    c.y = 6
-    assert c.y == 6
-    t: T4 = C4()
-    assert t.y == 4
-    t.x = 5
-    assert t.x == 5
-    t.y = 6
-    assert t.y == 6
-    a: Any = c
-    assert a.x == 5
-    assert a.y == 6
-    a.x = 7
-    a.y = 8
-    assert a.x == 7
-    assert a.y == 8
-
-@trait
-class T5:
-    @property
-    def x(self) -> int: ...
-    @x.setter
-    def x(self, v1: int) -> None: ...
-
-    @property
-    def y(self) -> int: ...
-    @y.setter
-    def y(self, v2: int) -> None: ...
-
-class B5:
-    x: int = 1
-    y: int = 4
-
-class BB5(B5):
-    pass
-
-class C5(BB5, T5):
-    pass
-
-def test_read_write_property_indirectly_implemented_as_attribute() -> None:
-    c = C5()
-    c.x = 5
-    assert c.x == 5
-    assert c.y == 4
-    c.y = 6
-    assert c.y == 6
-    t: T5 = C5()
-    assert t.y == 4
-    t.x = 5
-    assert t.x == 5
-    t.y = 6
-    assert t.y == 6
-    a: Any = c
-    assert a.x == 5
-    assert a.y == 6
-    a.x = 7
-    a.y = 8
-    assert a.x == 7
-    assert a.y == 8
-
-[case testSubclassAttributeAccess]
-from mypy_extensions import trait
-
-class A:
-    v = 0
-
-class B(A):
-    v = 1
-
-class C(B):
-    v = 2
-
-[file driver.py]
-from native import A, B, C
-
-a = A()
-b = B()
-c = C()
-
-[case testCopyAlwaysDefinedAttributes]
-import copy
-from typing import Union
-
-class A: pass
-
-class C:
-    def __init__(self, n: int = 0) -> None:
-        self.n = n
-        self.s = ""
-        self.t = ("", 0)
-        self.u: Union[str, bytes] = ''
-        self.a = A()
-
-def test_copy() -> None:
-    c1 = C()
-    c1.n = 1
-    c1.s = "x"
-    c2 = copy.copy(c1)
-    assert c2.n == 1
-    assert c2.s == "x"
-    assert c2.t == ("", 0)
-    assert c2.u == ''
-    assert c2.a is c1.a
-
-[case testNonNativeCallsToDunderNewAndInit]
-from typing import Any
-from testutil import assertRaises
-
-count_c = 0
-
-class C:
-    def __init__(self) -> None:
-        self.x = 'a'  # Always defined attribute
-        global count_c
-        count_c += 1
-
-    def get(self) -> str:
-        return self.x
-
-def test_no_init_args() -> None:
-    global count_c
-    count_c = 0
-
-    # Use Any to get non-native semantics
-    cls: Any = C
-    # __new__ implicitly calls __init__ for native classes
-    obj = cls.__new__(cls)
-    assert obj.get() == 'a'
-    assert count_c == 1
-    # Make sure we don't call __init__ twice
-    obj2 = cls()
-    assert obj2.get() == 'a'
-    assert count_c == 2
-
-count_d = 0
-
-class D:
-    def __init__(self, x: str) -> None:
-        self.x = x  # Always defined attribute
-        global count_d
-        count_d += 1
-
-    def get(self) -> str:
-        return self.x
-
-def test_init_arg() -> None:
-    global count_d
-    count_d = 0
-
-    # Use Any to get non-native semantics
-    cls: Any = D
-    # __new__ implicitly calls __init__ for native classes
-    obj = cls.__new__(cls, 'abc')
-    assert obj.get() == 'abc'
-    assert count_d == 1
-    # Make sure we don't call __init__ twice
-    obj2 = cls('x')
-    assert obj2.get() == 'x'
-    assert count_d == 2
-    # Keyword args should work
-    obj = cls.__new__(cls, x='abc')
-    assert obj.get() == 'abc'
-    assert count_d == 3
-
-def test_invalid_init_args() -> None:
-    # Use Any to get non-native semantics
-    cls: Any = D
-    with assertRaises(TypeError):
-        cls()
-    with assertRaises(TypeError):
-        cls(y='x')
-    with assertRaises(TypeError):
-        cls(1)
-
-[case testTryDeletingAlwaysDefinedAttribute]
-from typing import Any
-from testutil import assertRaises
-
-class C:
-    def __init__(self) -> None:
-        self.x = 0
-
-class D(C):
-    pass
-
-def test_try_deleting_always_defined_attr() -> None:
-    c: Any = C()
-    with assertRaises(AttributeError):
-        del c.x
-    d: Any = D()
-    with assertRaises(AttributeError):
-        del d.x
-
-[case testAlwaysDefinedAttributeAndAllowInterpretedSubclasses]
-from mypy_extensions import mypyc_attr
-
-from m import define_interpreted_subclass
-
-@mypyc_attr(allow_interpreted_subclasses=True)
-class Base:
-    x = 5
-    y: int
-    def __init__(self, s: str) -> None:
-        self.s = s
-
-class DerivedNative(Base):
-    def __init__(self) -> None:
-        super().__init__('x')
-        self.z = 3
-
-def test_native_subclass() -> None:
-    o = DerivedNative()
-    assert o.x == 5
-    assert o.s == 'x'
-    assert o.z == 3
-
-def test_interpreted_subclass() -> None:
-    define_interpreted_subclass(Base)
-
-[file m.py]
-from testutil import assertRaises
-
-def define_interpreted_subclass(b):
-    class DerivedInterpreted1(b):
-        def __init__(self):
-            # Don't call base class __init__
-            pass
-    d1 = DerivedInterpreted1()
-    assert d1.x == 5
-    with assertRaises(AttributeError):
-        d1.y
-    with assertRaises(AttributeError):
-        d1.s
-    with assertRaises(AttributeError):
-        del d1.x
-
-    class DerivedInterpreted1(b):
-        def __init__(self):
-            super().__init__('y')
-    d2 = DerivedInterpreted1()
-    assert d2.x == 5
-    assert d2.s == 'y'
-    with assertRaises(AttributeError):
-        d2.y
-    with assertRaises(AttributeError):
-        del d2.x
-
-[case testBaseClassSometimesDefinesAttribute]
-class C:
-    def __init__(self, b: bool) -> None:
-        if b:
-            self.x = [1]
-
-class D(C):
-    def __init__(self, b: bool) -> None:
-        super().__init__(b)
-        self.x = [2]
-
-def test_base_class() -> None:
-    c = C(True)
-    assert c.x == [1]
-    c = C(False)
-    try:
-        c.x
-    except AttributeError:
-        return
-    assert False
-
-def test_subclass() -> None:
-    d = D(True)
-    assert d.x == [2]
-    d = D(False)
-    assert d.x == [2]
-
-[case testSerializableClass]
-from mypy_extensions import mypyc_attr
-from typing import Any
-import copy
-from testutil import assertRaises
-
-@mypyc_attr(serializable=True)
-class Base:
-    def __init__(self, s: str) -> None:
-        self.s = s
-
-class Derived(Base):
-    def __init__(self, s: str, n: int) -> None:
-        super().__init__(s)
-        self.n = n
-
-def test_copy_base() -> None:
-    o = Base('xyz')
-    o2 = copy.copy(o)
-    assert isinstance(o2, Base)
-    assert o2 is not o
-    assert o2.s == 'xyz'
-
-def test_copy_derived() -> None:
-    d = Derived('xyz', 5)
-    d2 = copy.copy(d)
-    assert isinstance(d2, Derived)
-    assert d2 is not d
-    assert d2.s == 'xyz'
-    assert d2.n == 5
-
-class NonSerializable:
-    def __init__(self, s: str) -> None:
-        self.s = s
-
-@mypyc_attr(serializable=True)
-class SerializableSub(NonSerializable):
-    def __init__(self, s: str, n: int) -> None:
-        super().__init__(s)
-        self.n = n
-
-def test_serializable_sub_class() -> None:
-    n = NonSerializable('xyz')
-    assert n.s == 'xyz'
-
-    with assertRaises(TypeError):
-        copy.copy(n)
-
-    s = SerializableSub('foo', 6)
-    s2 = copy.copy(s)
-    assert s2 is not s
-    assert s2.s == 'foo'
-    assert s2.n == 6
-
-def test_serializable_sub_class_call_new() -> None:
-    t: Any = SerializableSub
-    sub: SerializableSub = t.__new__(t)
-    with assertRaises(AttributeError):
-        sub.s
-    with assertRaises(AttributeError):
-        sub.n
-    base: NonSerializable = sub
-    with assertRaises(AttributeError):
-        base.s
-
-[case testClassWithInherited__call__]
-class Base:
-    def __call__(self) -> int:
-        return 1
-
-class Derived(Base):
-    pass
-
-assert Derived()() == 1
-
-[case testClassWithFinalAttribute]
-from typing_extensions import Final
-
-class C:
-    A: Final = -1
-    a: Final = [A]
-
-def test_final_attribute() -> None:
-    assert C.A == -1
-    assert C.a == [-1]