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

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

@@ -1,150 +0,0 @@
-[case testGenericFunction]
-from typing import TypeVar, List
-T = TypeVar('T')
-def f(x: T) -> T:
-    return x
-def g(x: List[T]) -> List[T]:
-    return [x[0]]
-def h(x: int, y: List[int]) -> None:
-    x = f(x)
-    y = g(y)
-[out]
-def f(x):
-    x :: object
-L0:
-    return x
-def g(x):
-    x :: list
-    r0 :: object
-    r1 :: list
-    r2 :: ptr
-L0:
-    r0 = CPyList_GetItemShort(x, 0)
-    r1 = PyList_New(1)
-    r2 = list_items r1
-    buf_init_item r2, 0, r0
-    keep_alive r1
-    return r1
-def h(x, y):
-    x :: int
-    y :: list
-    r0, r1 :: object
-    r2 :: int
-    r3 :: list
-L0:
-    r0 = box(int, x)
-    r1 = f(r0)
-    r2 = unbox(int, r1)
-    x = r2
-    r3 = g(y)
-    y = r3
-    return 1
-
-[case testGenericAttrAndTypeApplication]
-from typing import TypeVar, Generic
-T = TypeVar('T')
-class C(Generic[T]):
-    x: T
-def f() -> None:
-    c = C[int]()
-    c.x = 1
-    2 + c.x
-[out]
-def f():
-    r0, c :: __main__.C
-    r1 :: object
-    r2 :: bool
-    r3 :: object
-    r4, r5 :: int
-L0:
-    r0 = C()
-    c = r0
-    r1 = object 1
-    c.x = r1; r2 = is_error
-    r3 = borrow c.x
-    r4 = unbox(int, r3)
-    r5 = CPyTagged_Add(4, r4)
-    keep_alive c
-    return 1
-
-[case testGenericMethod]
-from typing import TypeVar, Generic
-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
-def f(x: C[int]) -> None:
-    y = x.get()
-    x.set(y + 1)
-    x = C(2)
-[out]
-def C.__init__(self, x):
-    self :: __main__.C
-    x :: object
-    r0 :: bool
-L0:
-    self.x = x; r0 = is_error
-    return 1
-def C.get(self):
-    self :: __main__.C
-    r0 :: object
-L0:
-    r0 = self.x
-    return r0
-def C.set(self, y):
-    self :: __main__.C
-    y :: object
-    r0 :: bool
-L0:
-    self.x = y; r0 = is_error
-    return 1
-def f(x):
-    x :: __main__.C
-    r0 :: object
-    r1, y, r2 :: int
-    r3 :: object
-    r4 :: None
-    r5 :: object
-    r6 :: __main__.C
-L0:
-    r0 = x.get()
-    r1 = unbox(int, r0)
-    y = r1
-    r2 = CPyTagged_Add(y, 2)
-    r3 = box(int, r2)
-    r4 = x.set(r3)
-    r5 = object 2
-    r6 = C(r5)
-    x = r6
-    return 1
-
-[case testMax]
-from typing import TypeVar
-T = TypeVar('T')
-def f(x: T, y: T) -> T:
-    return max(x, y)
-[out]
-def f(x, y):
-    x, y, r0 :: object
-    r1 :: i32
-    r2 :: bit
-    r3 :: bool
-    r4 :: object
-L0:
-    r0 = PyObject_RichCompare(y, x, 4)
-    r1 = PyObject_IsTrue(r0)
-    r2 = r1 >= 0 :: signed
-    r3 = truncate r1: i32 to builtins.bool
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    r4 = y
-    goto L3
-L2:
-    r4 = x
-L3:
-    return r4

jaclang/vendor/mypyc/test-data/irbuild-glue-methods.test

@@ -1,437 +0,0 @@
-# Test cases for glue methods.
-#
-# These are used when subclass method signature has a different representation
-# compared to the base class.
-
-[case testSubclassSpecialize2]
-class A:
-    def foo(self, x: int) -> object:
-        return str(x)
-class B(A):
-    def foo(self, x: object) -> object:
-        return x
-class C(B):
-    def foo(self, x: object) -> int:
-        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)
-[out]
-def A.foo(self, x):
-    self :: __main__.A
-    x :: int
-    r0 :: str
-L0:
-    r0 = CPyTagged_Str(x)
-    return r0
-def B.foo(self, x):
-    self :: __main__.B
-    x :: object
-L0:
-    return x
-def B.foo__A_glue(self, x):
-    self :: __main__.B
-    x :: int
-    r0, r1 :: object
-L0:
-    r0 = box(int, x)
-    r1 = B.foo(self, r0)
-    return r1
-def C.foo(self, x):
-    self :: __main__.C
-    x :: object
-    r0 :: int
-L0:
-    r0 = CPyTagged_Id(x)
-    return r0
-def C.foo__B_glue(self, x):
-    self :: __main__.C
-    x :: object
-    r0 :: int
-    r1 :: object
-L0:
-    r0 = C.foo(self, x)
-    r1 = box(int, r0)
-    return r1
-def C.foo__A_glue(self, x):
-    self :: __main__.C
-    x :: int
-    r0 :: object
-    r1 :: int
-    r2 :: object
-L0:
-    r0 = box(int, x)
-    r1 = C.foo(self, r0)
-    r2 = box(int, r1)
-    return r2
-def use_a(x, y):
-    x :: __main__.A
-    y :: int
-    r0 :: object
-L0:
-    r0 = x.foo(y)
-    return r0
-def use_b(x, y):
-    x :: __main__.B
-    y, r0 :: object
-L0:
-    r0 = x.foo(y)
-    return r0
-def use_c(x, y):
-    x :: __main__.C
-    y :: object
-    r0 :: int
-L0:
-    r0 = x.foo(y)
-    return r0
-
-[case testPropertyDerivedGen]
-from typing import Callable
-class BaseProperty:
-    @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
-
-    @property
-    def next(self) -> DerivedProperty:
-        return DerivedProperty(self._incr_func, self._incr_func(self.value))
-
-    def __init__(self, incr_func: Callable[[int], int], value: int) -> None:
-        BaseProperty.__init__(self, value)
-        self._incr_func = incr_func
-
-
-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
-[out]
-def BaseProperty.value(self):
-    self :: __main__.BaseProperty
-    r0 :: int
-    r1 :: object
-L0:
-    r0 = self._incrementer
-    r1 = box(int, r0)
-    return r1
-def BaseProperty.bad_value(self):
-    self :: __main__.BaseProperty
-    r0 :: int
-    r1 :: object
-L0:
-    r0 = self._incrementer
-    r1 = box(int, r0)
-    return r1
-def BaseProperty.next(self):
-    self :: __main__.BaseProperty
-    r0, r1 :: int
-    r2 :: __main__.BaseProperty
-L0:
-    r0 = borrow self._incrementer
-    r1 = CPyTagged_Add(r0, 2)
-    keep_alive self
-    r2 = BaseProperty(r1)
-    return r2
-def BaseProperty.__init__(self, value):
-    self :: __main__.BaseProperty
-    value :: int
-L0:
-    self._incrementer = value
-    return 1
-def DerivedProperty.value(self):
-    self :: __main__.DerivedProperty
-    r0 :: int
-L0:
-    r0 = self._incrementer
-    return r0
-def DerivedProperty.value__BaseProperty_glue(__mypyc_self__):
-    __mypyc_self__ :: __main__.DerivedProperty
-    r0 :: int
-    r1 :: object
-L0:
-    r0 = __mypyc_self__.value
-    r1 = box(int, r0)
-    return r1
-def DerivedProperty.bad_value(self):
-    self :: __main__.DerivedProperty
-    r0 :: int
-    r1 :: object
-L0:
-    r0 = self._incrementer
-    r1 = box(int, r0)
-    return r1
-def DerivedProperty.next(self):
-    self :: __main__.DerivedProperty
-    r0 :: object
-    r1 :: int
-    r2, r3, r4 :: object
-    r5 :: int
-    r6 :: __main__.DerivedProperty
-L0:
-    r0 = self._incr_func
-    r1 = self.value
-    r2 = self._incr_func
-    r3 = box(int, r1)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = unbox(int, r4)
-    r6 = DerivedProperty(r0, r5)
-    return r6
-def DerivedProperty.next__BaseProperty_glue(__mypyc_self__):
-    __mypyc_self__, r0 :: __main__.DerivedProperty
-L0:
-    r0 = __mypyc_self__.next
-    return r0
-def DerivedProperty.__init__(self, incr_func, value):
-    self :: __main__.DerivedProperty
-    incr_func :: object
-    value :: int
-    r0 :: None
-L0:
-    r0 = BaseProperty.__init__(self, value)
-    self._incr_func = incr_func
-    return 1
-def AgainProperty.next(self):
-    self :: __main__.AgainProperty
-    r0 :: object
-    r1 :: int
-    r2, r3, r4 :: object
-    r5 :: int
-    r6, r7, r8 :: object
-    r9 :: int
-    r10 :: __main__.AgainProperty
-L0:
-    r0 = self._incr_func
-    r1 = self.value
-    r2 = self._incr_func
-    r3 = box(int, r1)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = unbox(int, r4)
-    r6 = self._incr_func
-    r7 = box(int, r5)
-    r8 = PyObject_CallFunctionObjArgs(r6, r7, 0)
-    r9 = unbox(int, r8)
-    r10 = AgainProperty(r0, r9)
-    return r10
-def AgainProperty.next__DerivedProperty_glue(__mypyc_self__):
-    __mypyc_self__, r0 :: __main__.AgainProperty
-L0:
-    r0 = __mypyc_self__.next
-    return r0
-def AgainProperty.next__BaseProperty_glue(__mypyc_self__):
-    __mypyc_self__, r0 :: __main__.AgainProperty
-L0:
-    r0 = __mypyc_self__.next
-    return r0
-def AgainProperty.bad_value(self):
-    self :: __main__.AgainProperty
-    r0 :: int
-L0:
-    r0 = self._incrementer
-    return r0
-def AgainProperty.bad_value__DerivedProperty_glue(__mypyc_self__):
-    __mypyc_self__ :: __main__.AgainProperty
-    r0 :: int
-    r1 :: object
-L0:
-    r0 = __mypyc_self__.bad_value
-    r1 = box(int, r0)
-    return r1
-def AgainProperty.bad_value__BaseProperty_glue(__mypyc_self__):
-    __mypyc_self__ :: __main__.AgainProperty
-    r0 :: int
-    r1 :: object
-L0:
-    r0 = __mypyc_self__.bad_value
-    r1 = box(int, r0)
-    return r1
-
-[case testPropertyTraitSubclassing]
-from mypy_extensions import trait
-@trait
-class SubclassedTrait:
-    @property
-    def this(self) -> SubclassedTrait:
-        return self
-
-    @property
-    def boxed(self) -> object:
-        return 3
-
-class DerivingObject(SubclassedTrait):
-    @property
-    def this(self) -> DerivingObject:
-        return self
-
-    @property
-    def boxed(self) -> int:
-        return 5
-[out]
-def SubclassedTrait.this(self):
-    self :: __main__.SubclassedTrait
-L0:
-    return self
-def SubclassedTrait.boxed(self):
-    self :: __main__.SubclassedTrait
-    r0 :: object
-L0:
-    r0 = object 3
-    return r0
-def DerivingObject.this(self):
-    self :: __main__.DerivingObject
-L0:
-    return self
-def DerivingObject.this__SubclassedTrait_glue(__mypyc_self__):
-    __mypyc_self__, r0 :: __main__.DerivingObject
-L0:
-    r0 = __mypyc_self__.this
-    return r0
-def DerivingObject.boxed(self):
-    self :: __main__.DerivingObject
-L0:
-    return 10
-def DerivingObject.boxed__SubclassedTrait_glue(__mypyc_self__):
-    __mypyc_self__ :: __main__.DerivingObject
-    r0 :: int
-    r1 :: object
-L0:
-    r0 = __mypyc_self__.boxed
-    r1 = box(int, r0)
-    return r1
-
-[case testI64GlueWithExtraDefaultArg]
-from mypy_extensions import i64
-
-class C:
-    def f(self) -> None: pass
-
-class D(C):
-    def f(self, x: i64 = 44) -> None: pass
-[out]
-def C.f(self):
-    self :: __main__.C
-L0:
-    return 1
-def D.f(self, x, __bitmap):
-    self :: __main__.D
-    x :: i64
-    __bitmap, r0 :: u32
-    r1 :: bit
-L0:
-    r0 = __bitmap & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    x = 44
-L2:
-    return 1
-def D.f__C_glue(self):
-    self :: __main__.D
-    r0 :: None
-L0:
-    r0 = D.f(self, 0, 0)
-    return r0
-
-[case testI64GlueWithSecondDefaultArg]
-from mypy_extensions import i64
-
-class C:
-    def f(self, x: i64 = 11) -> None: pass
-class D(C):
-    def f(self, x: i64 = 12, y: i64 = 13) -> None: pass
-[out]
-def C.f(self, x, __bitmap):
-    self :: __main__.C
-    x :: i64
-    __bitmap, r0 :: u32
-    r1 :: bit
-L0:
-    r0 = __bitmap & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    x = 11
-L2:
-    return 1
-def D.f(self, x, y, __bitmap):
-    self :: __main__.D
-    x, y :: i64
-    __bitmap, r0 :: u32
-    r1 :: bit
-    r2 :: u32
-    r3 :: bit
-L0:
-    r0 = __bitmap & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    x = 12
-L2:
-    r2 = __bitmap & 2
-    r3 = r2 == 0
-    if r3 goto L3 else goto L4 :: bool
-L3:
-    y = 13
-L4:
-    return 1
-def D.f__C_glue(self, x, __bitmap):
-    self :: __main__.D
-    x :: i64
-    __bitmap :: u32
-    r0 :: None
-L0:
-    r0 = D.f(self, x, 0, __bitmap)
-    return r0
-
-[case testI64GlueWithInvalidOverride]
-from mypy_extensions import i64
-
-class C:
-    def f(self, x: i64, y: i64 = 5) -> None: pass
-    def ff(self, x: int) -> None: pass
-class CC(C):
-    def f(self, x: i64 = 12, y: i64 = 5) -> None: pass  # Line 7
-    def ff(self, x: int = 12) -> None: pass
-
-class D:
-    def f(self, x: int) -> None: pass
-class DD(D):
-    def f(self, x: i64) -> None: pass  # Line 13
-
-class E:
-    def f(self, x: i64) -> None: pass
-class EE(E):
-    def f(self, x: int) -> None: pass  # Line 18
-[out]
-main:7: error: An argument with type "i64" cannot be given a default value in a method override
-main:13: error: Incompatible argument type "i64" (base class has type "int")
-main:18: error: Incompatible argument type "int" (base class has type "i64")