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

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

@@ -1,1302 +0,0 @@
-[case testGetAttribute]
-class A:
-    x: int
-
-def f(a: A) -> int:
-    return a.x
-[out]
-def f(a):
-    a :: __main__.A
-    r0 :: int
-L0:
-    r0 = a.x
-    return r0
-
-[case testSetAttribute]
-class A:
-    x: int
-
-def f(a: A) -> None:
-    a.x = 1
-[out]
-def f(a):
-    a :: __main__.A
-    r0 :: bool
-L0:
-    a.x = 2; r0 = is_error
-    return 1
-
-[case testUserClassInList]
-class C:
-    x: int
-
-def f() -> int:
-    c = C()
-    c.x = 5
-    a = [c]
-    d = a[0]
-    return d.x + 1
-[out]
-def f():
-    r0, c :: __main__.C
-    r1 :: bool
-    r2 :: list
-    r3 :: ptr
-    a :: list
-    r4 :: object
-    r5, d :: __main__.C
-    r6, r7 :: int
-L0:
-    r0 = C()
-    c = r0
-    c.x = 10; r1 = is_error
-    r2 = PyList_New(1)
-    r3 = list_items r2
-    buf_init_item r3, 0, c
-    keep_alive r2
-    a = r2
-    r4 = CPyList_GetItemShort(a, 0)
-    r5 = cast(__main__.C, r4)
-    d = r5
-    r6 = borrow d.x
-    r7 = CPyTagged_Add(r6, 2)
-    keep_alive d
-    return r7
-
-[case testMethodCall]
-class A:
-    def f(self, x: int, y: str) -> int:
-        return x + 10
-
-def g(a: A) -> None:
-    a.f(1, 'hi')
-[out]
-def A.f(self, x, y):
-    self :: __main__.A
-    x :: int
-    y :: str
-    r0 :: int
-L0:
-    r0 = CPyTagged_Add(x, 20)
-    return r0
-def g(a):
-    a :: __main__.A
-    r0 :: str
-    r1 :: int
-L0:
-    r0 = 'hi'
-    r1 = a.f(2, r0)
-    return 1
-
-[case testForwardUse]
-def g(a: A) -> int:
-    return a.n
-
-class A:
-    n : int
-
-[out]
-def g(a):
-    a :: __main__.A
-    r0 :: int
-L0:
-    r0 = a.n
-    return r0
-
-[case testOptionalMember]
-from typing import Optional
-class Node:
-    next: Optional[Node]
-    def length(self) -> int:
-        if self.next is not None:
-            return 1 + self.next.length()
-        return 1
-[out]
-def Node.length(self):
-    self :: __main__.Node
-    r0 :: union[__main__.Node, None]
-    r1 :: object
-    r2 :: bit
-    r3 :: union[__main__.Node, None]
-    r4 :: __main__.Node
-    r5, r6 :: int
-L0:
-    r0 = borrow self.next
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 != r1
-    keep_alive self
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    r3 = self.next
-    r4 = cast(__main__.Node, r3)
-    r5 = r4.length()
-    r6 = CPyTagged_Add(2, r5)
-    return r6
-L2:
-    return 2
-
-[case testSubclass]
-class A:
-    def __init__(self) -> None:
-        self.x = 10
-class B(A):
-    def __init__(self) -> None:
-        self.x = 20
-        self.y = 30
-[out]
-def A.__init__(self):
-    self :: __main__.A
-L0:
-    self.x = 20
-    return 1
-def B.__init__(self):
-    self :: __main__.B
-L0:
-    self.x = 40
-    self.y = 60
-    return 1
-
-[case testAttrLvalue]
-class O(object):
-    def __init__(self) -> None:
-        self.x = 1
-
-def increment(o: O) -> O:
-    o.x += 1
-    return o
-[out]
-def O.__init__(self):
-    self :: __main__.O
-L0:
-    self.x = 2
-    return 1
-def increment(o):
-    o :: __main__.O
-    r0, r1 :: int
-    r2 :: bool
-L0:
-    r0 = borrow o.x
-    r1 = CPyTagged_Add(r0, 2)
-    o.x = r1; r2 = is_error
-    return o
-
-[case testSubclass_toplevel]
-from typing import TypeVar, Generic
-from mypy_extensions import trait
-T = TypeVar('T')
-class C:
-    pass
-
-@trait
-class S:
-    pass
-
-class D(C, S, Generic[T]):
-    pass
-
-[out]
-def __top_level__():
-    r0, r1 :: object
-    r2 :: bit
-    r3 :: str
-    r4, r5 :: object
-    r6 :: str
-    r7 :: dict
-    r8, r9 :: object
-    r10 :: str
-    r11 :: dict
-    r12 :: object
-    r13 :: str
-    r14 :: dict
-    r15 :: str
-    r16, r17 :: object
-    r18 :: dict
-    r19 :: str
-    r20 :: i32
-    r21 :: bit
-    r22 :: object
-    r23 :: str
-    r24, r25 :: object
-    r26 :: bool
-    r27 :: str
-    r28 :: tuple
-    r29 :: i32
-    r30 :: bit
-    r31 :: dict
-    r32 :: str
-    r33 :: i32
-    r34 :: bit
-    r35 :: object
-    r36 :: str
-    r37, r38 :: object
-    r39 :: str
-    r40 :: tuple
-    r41 :: i32
-    r42 :: bit
-    r43 :: dict
-    r44 :: str
-    r45 :: i32
-    r46 :: bit
-    r47, r48 :: object
-    r49 :: dict
-    r50 :: str
-    r51 :: object
-    r52 :: dict
-    r53 :: str
-    r54, r55 :: object
-    r56 :: tuple
-    r57 :: str
-    r58, r59 :: object
-    r60 :: bool
-    r61, r62 :: str
-    r63 :: tuple
-    r64 :: i32
-    r65 :: bit
-    r66 :: dict
-    r67 :: str
-    r68 :: i32
-    r69 :: bit
-L0:
-    r0 = builtins :: module
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 != r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = 'builtins'
-    r4 = PyImport_Import(r3)
-    builtins = r4 :: module
-L2:
-    r5 = ('TypeVar', 'Generic')
-    r6 = 'typing'
-    r7 = __main__.globals :: static
-    r8 = CPyImport_ImportFromMany(r6, r5, r5, r7)
-    typing = r8 :: module
-    r9 = ('trait',)
-    r10 = 'mypy_extensions'
-    r11 = __main__.globals :: static
-    r12 = CPyImport_ImportFromMany(r10, r9, r9, r11)
-    mypy_extensions = r12 :: module
-    r13 = 'T'
-    r14 = __main__.globals :: static
-    r15 = 'TypeVar'
-    r16 = CPyDict_GetItem(r14, r15)
-    r17 = PyObject_CallFunctionObjArgs(r16, r13, 0)
-    r18 = __main__.globals :: static
-    r19 = 'T'
-    r20 = CPyDict_SetItem(r18, r19, r17)
-    r21 = r20 >= 0 :: signed
-    r22 = <error> :: object
-    r23 = '__main__'
-    r24 = __main__.C_template :: type
-    r25 = CPyType_FromTemplate(r24, r22, r23)
-    r26 = C_trait_vtable_setup()
-    r27 = '__mypyc_attrs__'
-    r28 = PyTuple_Pack(0)
-    r29 = PyObject_SetAttr(r25, r27, r28)
-    r30 = r29 >= 0 :: signed
-    __main__.C = r25 :: type
-    r31 = __main__.globals :: static
-    r32 = 'C'
-    r33 = CPyDict_SetItem(r31, r32, r25)
-    r34 = r33 >= 0 :: signed
-    r35 = <error> :: object
-    r36 = '__main__'
-    r37 = __main__.S_template :: type
-    r38 = CPyType_FromTemplate(r37, r35, r36)
-    r39 = '__mypyc_attrs__'
-    r40 = PyTuple_Pack(0)
-    r41 = PyObject_SetAttr(r38, r39, r40)
-    r42 = r41 >= 0 :: signed
-    __main__.S = r38 :: type
-    r43 = __main__.globals :: static
-    r44 = 'S'
-    r45 = CPyDict_SetItem(r43, r44, r38)
-    r46 = r45 >= 0 :: signed
-    r47 = __main__.C :: type
-    r48 = __main__.S :: type
-    r49 = __main__.globals :: static
-    r50 = 'Generic'
-    r51 = CPyDict_GetItem(r49, r50)
-    r52 = __main__.globals :: static
-    r53 = 'T'
-    r54 = CPyDict_GetItem(r52, r53)
-    r55 = PyObject_GetItem(r51, r54)
-    r56 = PyTuple_Pack(3, r47, r48, r55)
-    r57 = '__main__'
-    r58 = __main__.D_template :: type
-    r59 = CPyType_FromTemplate(r58, r56, r57)
-    r60 = D_trait_vtable_setup()
-    r61 = '__mypyc_attrs__'
-    r62 = '__dict__'
-    r63 = PyTuple_Pack(1, r62)
-    r64 = PyObject_SetAttr(r59, r61, r63)
-    r65 = r64 >= 0 :: signed
-    __main__.D = r59 :: type
-    r66 = __main__.globals :: static
-    r67 = 'D'
-    r68 = CPyDict_SetItem(r66, r67, r59)
-    r69 = r68 >= 0 :: signed
-    return 1
-
-[case testIsInstance]
-class A: pass
-class B(A): pass
-
-def f(x: A) -> B:
-    if isinstance(x, B):
-        return x
-    return B()
-[out]
-def f(x):
-    x :: __main__.A
-    r0 :: object
-    r1 :: ptr
-    r2 :: object
-    r3 :: bit
-    r4, r5 :: __main__.B
-L0:
-    r0 = __main__.B :: type
-    r1 = get_element_ptr x ob_type :: PyObject
-    r2 = load_mem r1 :: builtins.object*
-    keep_alive x
-    r3 = r2 == r0
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    r4 = cast(__main__.B, x)
-    return r4
-L2:
-    r5 = B()
-    return r5
-
-[case testIsInstanceTuple]
-from typing import Union
-class R: pass
-class A(R): pass
-class B(R): pass
-class C(R): pass
-
-def f(x: R) -> Union[A, B]:
-    if isinstance(x, (A, B)):
-        return x
-    return A()
-[out]
-def f(x):
-    x :: __main__.R
-    r0 :: object
-    r1 :: ptr
-    r2 :: object
-    r3 :: bit
-    r4 :: bool
-    r5 :: object
-    r6 :: ptr
-    r7 :: object
-    r8 :: bit
-    r9 :: union[__main__.A, __main__.B]
-    r10 :: __main__.A
-L0:
-    r0 = __main__.A :: type
-    r1 = get_element_ptr x ob_type :: PyObject
-    r2 = load_mem r1 :: builtins.object*
-    keep_alive x
-    r3 = r2 == r0
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    r4 = r3
-    goto L3
-L2:
-    r5 = __main__.B :: type
-    r6 = get_element_ptr x ob_type :: PyObject
-    r7 = load_mem r6 :: builtins.object*
-    keep_alive x
-    r8 = r7 == r5
-    r4 = r8
-L3:
-    if r4 goto L4 else goto L5 :: bool
-L4:
-    r9 = cast(union[__main__.A, __main__.B], x)
-    return r9
-L5:
-    r10 = A()
-    return r10
-
-[case testIsInstanceFewSubclasses]
-class R: pass
-class A(R): pass
-
-def f(x: object) -> R:
-    if isinstance(x, R):
-        return x
-    return A()
-[out]
-def f(x):
-    x, r0 :: object
-    r1 :: ptr
-    r2 :: object
-    r3 :: bit
-    r4 :: bool
-    r5 :: object
-    r6 :: ptr
-    r7 :: object
-    r8 :: bit
-    r9 :: __main__.R
-    r10 :: __main__.A
-L0:
-    r0 = __main__.A :: type
-    r1 = get_element_ptr x ob_type :: PyObject
-    r2 = load_mem r1 :: builtins.object*
-    keep_alive x
-    r3 = r2 == r0
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    r4 = r3
-    goto L3
-L2:
-    r5 = __main__.R :: type
-    r6 = get_element_ptr x ob_type :: PyObject
-    r7 = load_mem r6 :: builtins.object*
-    keep_alive x
-    r8 = r7 == r5
-    r4 = r8
-L3:
-    if r4 goto L4 else goto L5 :: bool
-L4:
-    r9 = cast(__main__.R, x)
-    return r9
-L5:
-    r10 = A()
-    return r10
-
-[case testIsInstanceFewSubclassesTrait]
-from mypy_extensions import trait
-class B: pass
-@trait
-class R: pass
-class A(B, R): pass
-class C(B, R): pass
-
-def f(x: object) -> R:
-    if isinstance(x, R):
-        return x
-    return A()
-[out]
-def f(x):
-    x, r0 :: object
-    r1 :: ptr
-    r2 :: object
-    r3 :: bit
-    r4 :: bool
-    r5 :: object
-    r6 :: ptr
-    r7 :: object
-    r8 :: bit
-    r9 :: __main__.R
-    r10 :: __main__.A
-L0:
-    r0 = __main__.A :: type
-    r1 = get_element_ptr x ob_type :: PyObject
-    r2 = load_mem r1 :: builtins.object*
-    keep_alive x
-    r3 = r2 == r0
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    r4 = r3
-    goto L3
-L2:
-    r5 = __main__.C :: type
-    r6 = get_element_ptr x ob_type :: PyObject
-    r7 = load_mem r6 :: builtins.object*
-    keep_alive x
-    r8 = r7 == r5
-    r4 = r8
-L3:
-    if r4 goto L4 else goto L5 :: bool
-L4:
-    r9 = cast(__main__.R, x)
-    return r9
-L5:
-    r10 = A()
-    return r10
-
-[case testIsInstanceManySubclasses]
-class R: pass
-class A(R): pass
-class B(R): pass
-class C(R): pass
-
-def f(x: object) -> R:
-    if isinstance(x, R):
-        return x
-    return B()
-[out]
-def f(x):
-    x, r0 :: object
-    r1 :: bool
-    r2 :: __main__.R
-    r3 :: __main__.B
-L0:
-    r0 = __main__.R :: type
-    r1 = CPy_TypeCheck(x, r0)
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = cast(__main__.R, x)
-    return r2
-L2:
-    r3 = B()
-    return r3
-
-[case testFakeSuper]
-class A:
-    def __init__(self, x: int) -> None:
-        self.x = x
-class B(A):
-    def __init__(self, x: int, y: int) -> None:
-        A.__init__(self, x)
-        self.y = y
-[out]
-def A.__init__(self, x):
-    self :: __main__.A
-    x :: int
-L0:
-    self.x = x
-    return 1
-def B.__init__(self, x, y):
-    self :: __main__.B
-    x, y :: int
-    r0 :: None
-L0:
-    r0 = A.__init__(self, x)
-    self.y = y
-    return 1
-
-[case testClassMethod]
-class C:
-    @staticmethod
-    def foo(x: int) -> int: return 10 + x
-    @classmethod
-    def bar(cls, x: int) -> int: return 10 + x
-
-def lol() -> int:
-    return C.foo(1) + C.bar(2)
-[out]
-def C.foo(x):
-    x, r0 :: int
-L0:
-    r0 = CPyTagged_Add(20, x)
-    return r0
-def C.bar(cls, x):
-    cls :: object
-    x, r0 :: int
-L0:
-    r0 = CPyTagged_Add(20, x)
-    return r0
-def lol():
-    r0 :: int
-    r1 :: object
-    r2, r3 :: int
-L0:
-    r0 = C.foo(2)
-    r1 = __main__.C :: type
-    r2 = C.bar(r1, 4)
-    r3 = CPyTagged_Add(r0, r2)
-    return r3
-
-[case testCallClassMethodViaCls]
-class C:
-    @classmethod
-    def f(cls, x: int) -> int:
-        return cls.g(x)
-
-    @classmethod
-    def g(cls, x: int) -> int:
-        return x
-
-class D:
-    @classmethod
-    def f(cls, x: int) -> int:
-        # TODO: This could aso be optimized, since g is not ever overridden
-        return cls.g(x)
-
-    @classmethod
-    def g(cls, x: int) -> int:
-        return x
-
-class DD(D):
-    pass
-[out]
-def C.f(cls, x):
-    cls :: object
-    x :: int
-    r0 :: object
-    r1 :: int
-L0:
-    r0 = __main__.C :: type
-    r1 = C.g(r0, x)
-    return r1
-def C.g(cls, x):
-    cls :: object
-    x :: int
-L0:
-    return x
-def D.f(cls, x):
-    cls :: object
-    x :: int
-    r0 :: str
-    r1, r2 :: object
-    r3 :: int
-L0:
-    r0 = 'g'
-    r1 = box(int, x)
-    r2 = CPyObject_CallMethodObjArgs(cls, r0, r1, 0)
-    r3 = unbox(int, r2)
-    return r3
-def D.g(cls, x):
-    cls :: object
-    x :: int
-L0:
-    return x
-
-[case testCannotAssignToClsArgument]
-from typing import Any, cast
-
-class C:
-    @classmethod
-    def m(cls) -> None:
-        cls = cast(Any, D)  # E: Cannot assign to the first argument of classmethod
-        cls, x = cast(Any, D), 1  # E: Cannot assign to the first argument of classmethod
-        cls, x = cast(Any, [1, 2])  # E: Cannot assign to the first argument of classmethod
-        cls.m()
-
-class D:
-    pass
-
-[case testSuper1]
-class A:
-    def __init__(self, x: int) -> None:
-        self.x = x
-class B(A):
-    def __init__(self, x: int, y: int) -> None:
-        super().__init__(x)
-        self.y = y
-[out]
-def A.__init__(self, x):
-    self :: __main__.A
-    x :: int
-L0:
-    self.x = x
-    return 1
-def B.__init__(self, x, y):
-    self :: __main__.B
-    x, y :: int
-    r0 :: None
-L0:
-    r0 = A.__init__(self, x)
-    self.y = y
-    return 1
-
-[case testSuper2]
-from mypy_extensions import trait
-@trait
-class T:
-    def foo(self) -> None: pass
-
-class X(T):
-    def foo(self) -> None:
-        super().foo()
-[out]
-def T.foo(self):
-    self :: __main__.T
-L0:
-    return 1
-def X.foo(self):
-    self :: __main__.X
-    r0 :: None
-L0:
-    r0 = T.foo(self)
-    return 1
-
-[case testSuperCallToObjectInitIsOmitted]
-class C:
-    def __init__(self) -> None:
-        super().__init__()
-class D: pass
-class E(D):
-    def __init__(self) -> None:
-        super().__init__()
-class F(C):
-    def __init__(self) -> None:
-        super().__init__()
-class DictSubclass(dict):
-    def __init__(self) -> None:
-        super().__init__()
-[out]
-def C.__init__(self):
-    self :: __main__.C
-L0:
-    return 1
-def E.__init__(self):
-    self :: __main__.E
-L0:
-    return 1
-def F.__init__(self):
-    self :: __main__.F
-    r0 :: None
-L0:
-    r0 = C.__init__(self)
-    return 1
-def DictSubclass.__init__(self):
-    self :: dict
-    r0 :: object
-    r1 :: str
-    r2, r3, r4 :: object
-    r5 :: str
-    r6, r7 :: object
-L0:
-    r0 = builtins :: module
-    r1 = 'super'
-    r2 = CPyObject_GetAttr(r0, r1)
-    r3 = __main__.DictSubclass :: type
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, self, 0)
-    r5 = '__init__'
-    r6 = CPyObject_GetAttr(r4, r5)
-    r7 = PyObject_CallFunctionObjArgs(r6, 0)
-    return 1
-
-[case testClassVariable]
-from typing import ClassVar
-class A:
-    x = 10  # type: ClassVar[int]
-
-def f() -> int:
-    return A.x
-[out]
-def f():
-    r0 :: object
-    r1 :: str
-    r2 :: object
-    r3 :: int
-L0:
-    r0 = __main__.A :: type
-    r1 = 'x'
-    r2 = CPyObject_GetAttr(r0, r1)
-    r3 = unbox(int, r2)
-    return r3
-
-[case testNoEqDefined]
-class A:
-    pass
-
-def f(a: A, b: A) -> bool:
-    return a == b
-
-def f2(a: A, b: A) -> bool:
-    return a != b
-
-[out]
-def f(a, b):
-    a, b :: __main__.A
-    r0 :: bit
-L0:
-    r0 = a == b
-    return r0
-def f2(a, b):
-    a, b :: __main__.A
-    r0 :: bit
-L0:
-    r0 = a != b
-    return r0
-
-[case testEqDefined]
-class Base:
-    def __eq__(self, other: object) -> bool:
-        return False
-class Derived(Base):
-    def __eq__(self, other: object) -> bool:
-        return True
-
-def f(a: Base, b: Base) -> bool:
-    return a == b
-
-def f2(a: Base, b: Base) -> bool:
-    return a != b
-
-def fOpt(a: Derived, b: Derived) -> bool:
-    return a == b
-
-def fOpt2(a: Derived, b: Derived) -> bool:
-    return a != b
-
-[out]
-def Base.__eq__(self, other):
-    self :: __main__.Base
-    other, r0 :: object
-L0:
-    r0 = box(bool, 0)
-    return r0
-def Base.__ne__(__mypyc_self__, rhs):
-    __mypyc_self__ :: __main__.Base
-    rhs, r0, r1 :: object
-    r2 :: bit
-    r3 :: i32
-    r4 :: bit
-    r5 :: bool
-    r6 :: object
-L0:
-    r0 = __mypyc_self__.__eq__(rhs)
-    r1 = load_address _Py_NotImplementedStruct
-    r2 = r0 == r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = PyObject_Not(r0)
-    r4 = r3 >= 0 :: signed
-    r5 = truncate r3: i32 to builtins.bool
-    r6 = box(bool, r5)
-    return r6
-L2:
-    return r1
-def Derived.__eq__(self, other):
-    self :: __main__.Derived
-    other, r0 :: object
-L0:
-    r0 = box(bool, 1)
-    return r0
-def f(a, b):
-    a, b :: __main__.Base
-    r0 :: object
-    r1 :: bool
-L0:
-    r0 = PyObject_RichCompare(a, b, 2)
-    r1 = unbox(bool, r0)
-    return r1
-def f2(a, b):
-    a, b :: __main__.Base
-    r0 :: object
-    r1 :: bool
-L0:
-    r0 = PyObject_RichCompare(a, b, 3)
-    r1 = unbox(bool, r0)
-    return r1
-def fOpt(a, b):
-    a, b :: __main__.Derived
-    r0 :: object
-    r1 :: bool
-L0:
-    r0 = a.__eq__(b)
-    r1 = unbox(bool, r0)
-    return r1
-def fOpt2(a, b):
-    a, b :: __main__.Derived
-    r0 :: object
-    r1 :: bool
-L0:
-    r0 = a.__ne__(b)
-    r1 = unbox(bool, r0)
-    return r1
-
-[case testEqDefinedLater]
-def f(a: 'Base', b: 'Base') -> bool:
-    return a == b
-
-def f2(a: 'Base', b: 'Base') -> bool:
-    return a != b
-
-def fOpt(a: 'Derived', b: 'Derived') -> bool:
-    return a == b
-
-def fOpt2(a: 'Derived', b: 'Derived') -> bool:
-    return a != b
-
-class Base:
-    pass
-class Derived(Base):
-    def __eq__(self, other: object) -> bool:
-        return True
-
-[out]
-def f(a, b):
-    a, b :: __main__.Base
-    r0 :: object
-    r1 :: bool
-L0:
-    r0 = PyObject_RichCompare(a, b, 2)
-    r1 = unbox(bool, r0)
-    return r1
-def f2(a, b):
-    a, b :: __main__.Base
-    r0 :: object
-    r1 :: bool
-L0:
-    r0 = PyObject_RichCompare(a, b, 3)
-    r1 = unbox(bool, r0)
-    return r1
-def fOpt(a, b):
-    a, b :: __main__.Derived
-    r0 :: object
-    r1 :: bool
-L0:
-    r0 = a.__eq__(b)
-    r1 = unbox(bool, r0)
-    return r1
-def fOpt2(a, b):
-    a, b :: __main__.Derived
-    r0 :: str
-    r1 :: object
-    r2 :: bool
-L0:
-    r0 = '__ne__'
-    r1 = CPyObject_CallMethodObjArgs(a, r0, b, 0)
-    r2 = unbox(bool, r1)
-    return r2
-def Derived.__eq__(self, other):
-    self :: __main__.Derived
-    other, r0 :: object
-L0:
-    r0 = box(bool, 1)
-    return r0
-def Derived.__ne__(__mypyc_self__, rhs):
-    __mypyc_self__ :: __main__.Derived
-    rhs, r0, r1 :: object
-    r2 :: bit
-    r3 :: i32
-    r4 :: bit
-    r5 :: bool
-    r6 :: object
-L0:
-    r0 = __mypyc_self__.__eq__(rhs)
-    r1 = load_address _Py_NotImplementedStruct
-    r2 = r0 == r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = PyObject_Not(r0)
-    r4 = r3 >= 0 :: signed
-    r5 = truncate r3: i32 to builtins.bool
-    r6 = box(bool, r5)
-    return r6
-L2:
-    return r1
-
-[case testDefaultVars]
-from typing import ClassVar, Optional
-class A:
-    x = 10
-    def lol(self) -> None:
-        self.x = 100
-
-LOL = 'lol'
-class B(A):
-    y = LOL
-    z: Optional[str] = None
-    b = True
-    bogus = None  # type: int
-[out]
-def A.lol(self):
-    self :: __main__.A
-    r0 :: bool
-L0:
-    self.x = 200; r0 = is_error
-    return 1
-def A.__mypyc_defaults_setup(__mypyc_self__):
-    __mypyc_self__ :: __main__.A
-L0:
-    __mypyc_self__.x = 20
-    return 1
-def B.__mypyc_defaults_setup(__mypyc_self__):
-    __mypyc_self__ :: __main__.B
-    r0 :: dict
-    r1 :: str
-    r2 :: object
-    r3 :: str
-    r4 :: object
-L0:
-    __mypyc_self__.x = 20
-    r0 = __main__.globals :: static
-    r1 = 'LOL'
-    r2 = CPyDict_GetItem(r0, r1)
-    r3 = cast(str, r2)
-    __mypyc_self__.y = r3
-    r4 = box(None, 1)
-    __mypyc_self__.z = r4
-    __mypyc_self__.b = 1
-    return 1
-
-[case testSubclassDictSpecalized]
-from typing import Dict
-class WelpDict(Dict[str, int]):
-    pass
-def foo(x: WelpDict) -> None:
-    # we care that the specalized op gets used
-    x.update(x)
-[out]
-def foo(x):
-    x :: dict
-    r0 :: i32
-    r1 :: bit
-L0:
-    r0 = CPyDict_Update(x, x)
-    r1 = r0 >= 0 :: signed
-    return 1
-
-[case testNoSpuriousLinearity]
-# Make sure that the non-trait MRO linearity check isn't affected by processing order
-class A(B): pass
-class B(C): pass
-class C: pass
-[out]
-
-[case testDeletableSemanticAnalysis]
-class Err1:
-    __deletable__ = 'x'  # E: "__deletable__" must be initialized with a list or tuple expression
-class Err2:
-    __deletable__ = [
-        1  # E: Invalid "__deletable__" item; string literal expected
-    ]
-class Err3:
-    __deletable__ = ['x', ['y'], 'z']  # E: Invalid "__deletable__" item; string literal expected
-class Err4:
-    __deletable__ = (1,)  # E: Invalid "__deletable__" item; string literal expected
-a = ['x']
-class Err5:
-    __deletable__ = a  # E: "__deletable__" must be initialized with a list or tuple expression
-
-class Ok1:
-    __deletable__ = ('x',)
-    x: int
-class Ok2:
-    __deletable__ = ['x']
-    x: int
-
-[case testInvalidDeletableAttribute]
-class NotDeletable:
-    __deletable__ = ['x']
-    x: int
-    y: int
-
-def g(o: NotDeletable) -> None:
-    del o.x
-    del o.y  # E: "y" cannot be deleted \
-             # N: Using "__deletable__ = ['<attr>']" in the class body enables "del obj.<attr>"
-
-class Base:
-    x: int
-
-class Deriv(Base):
-    __deletable__ = ['x']  # E: Attribute "x" not defined in "Deriv" (defined in "Base")
-
-class UndefinedDeletable:
-    __deletable__ = ['x']  # E: Attribute "x" not defined
-
-class DeletableProperty:
-    __deletable__ = ['prop']  # E: Cannot make property "prop" deletable
-
-    @property
-    def prop(self) -> int:
-        return 5
-
-[case testFinalDeletable]
-from typing import Final
-
-class DeletableFinal1:
-    x: Final[int]  # E: Deletable attribute cannot be final
-
-    __deletable__ = ['x']
-
-    def __init__(self, x: int) -> None:
-        self.x = x
-
-class DeletableFinal2:
-    X: Final = 0  # E: Deletable attribute cannot be final
-
-    __deletable__ = ['X']
-
-[case testNeedAnnotateClassVar]
-from typing import Final, ClassVar, Type
-
-class C:
-    a = 'A'
-    b: str = 'B'
-    f: Final = 'F'
-    c: ClassVar = 'C'
-
-class D(C):
-    pass
-
-def f() -> None:
-    C.a  # E: Cannot access instance attribute "a" through class object \
-         # N: (Hint: Use "x: Final = ..." or "x: ClassVar = ..." to define a class attribute)
-    C.b  # E: Cannot access instance attribute "b" through class object \
-         # N: (Hint: Use "x: Final = ..." or "x: ClassVar = ..." to define a class attribute)
-    C.f
-    C.c
-
-    D.a  # E: Cannot access instance attribute "a" through class object \
-         # N: (Hint: Use "x: Final = ..." or "x: ClassVar = ..." to define a class attribute)
-    D.b  # E: Cannot access instance attribute "b" through class object \
-         # N: (Hint: Use "x: Final = ..." or "x: ClassVar = ..." to define a class attribute)
-    D.f
-    D.c
-
-def g(c: Type[C], d: Type[D]) -> None:
-    c.a  # E: Cannot access instance attribute "a" through class object \
-         # N: (Hint: Use "x: Final = ..." or "x: ClassVar = ..." to define a class attribute)
-    c.f
-    c.c
-
-    d.a  # E: Cannot access instance attribute "a" through class object \
-         # N: (Hint: Use "x: Final = ..." or "x: ClassVar = ..." to define a class attribute)
-    d.f
-    d.c
-
-[case testSetAttributeWithDefaultInInit]
-class C:
-    s = ''
-
-    def __init__(self, s: str) -> None:
-        self.s = s
-[out]
-def C.__init__(self, s):
-    self :: __main__.C
-    s :: str
-    r0 :: bool
-L0:
-    self.s = s; r0 = is_error
-    return 1
-def C.__mypyc_defaults_setup(__mypyc_self__):
-    __mypyc_self__ :: __main__.C
-    r0 :: str
-L0:
-    r0 = ''
-    __mypyc_self__.s = r0
-    return 1
-
-[case testBorrowAttribute]
-def f(d: D) -> int:
-    return d.c.x
-
-class C:
-    x: int
-class D:
-    c: C
-[out]
-def f(d):
-    d :: __main__.D
-    r0 :: __main__.C
-    r1 :: int
-L0:
-    r0 = borrow d.c
-    r1 = r0.x
-    keep_alive d
-    return r1
-
-[case testNoBorrowOverPropertyAccess]
-class C:
-    d: D
-class D:
-    @property
-    def e(self) -> E:
-        return E()
-class E:
-    x: int
-def f(c: C) -> int:
-    return c.d.e.x
-[out]
-def D.e(self):
-    self :: __main__.D
-    r0 :: __main__.E
-L0:
-    r0 = E()
-    return r0
-def f(c):
-    c :: __main__.C
-    r0 :: __main__.D
-    r1 :: __main__.E
-    r2 :: int
-L0:
-    r0 = c.d
-    r1 = r0.e
-    r2 = r1.x
-    return r2
-
-[case testBorrowResultOfCustomGetItemInIfStatement]
-from typing import List
-
-class C:
-    def __getitem__(self, x: int) -> List[int]:
-        return []
-
-def f(x: C) -> None:
-    # In this case the keep_alive must come before the branch, as otherwise
-    # reference count transform will get confused.
-    if x[1][0] == 2:
-        y = 1
-    else:
-        y = 2
-[out]
-def C.__getitem__(self, x):
-    self :: __main__.C
-    x :: int
-    r0 :: list
-L0:
-    r0 = PyList_New(0)
-    return r0
-def f(x):
-    x :: __main__.C
-    r0 :: list
-    r1 :: object
-    r2 :: int
-    r3 :: bit
-    y :: int
-L0:
-    r0 = x.__getitem__(2)
-    r1 = CPyList_GetItemShortBorrow(r0, 0)
-    r2 = unbox(int, r1)
-    r3 = int_eq r2, 4
-    keep_alive r0
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    y = 2
-    goto L3
-L2:
-    y = 4
-L3:
-    return 1
-
-[case testIncompatibleDefinitionOfAttributeInSubclass]
-from mypy_extensions import trait
-
-class Base:
-    x: int
-
-class Bad1(Base):
-    x: bool  # E: Type of "x" is incompatible with definition in class "Base"
-
-class Good1(Base):
-    x: int
-
-class Good2(Base):
-    x: int = 0
-
-class Good3(Base):
-    x = 0
-
-class Good4(Base):
-    def __init__(self) -> None:
-        self.x = 0
-
-class Good5(Base):
-    def __init__(self) -> None:
-        self.x: int = 0
-
-class Base2(Base):
-    pass
-
-class Bad2(Base2):
-    x: bool = False  # E: Type of "x" is incompatible with definition in class "Base"
-
-class Bad3(Base):
-    x = False  # E: Type of "x" is incompatible with definition in class "Base"
-
-@trait
-class T:
-    y: object
-
-class E(T):
-    y: str  # E: Type of "y" is incompatible with definition in trait "T"