Tipragot
628be439b8
Cela permet de ne pas avoir de problèmes de compatibilité car python est dans le git.
438 lines
9.5 KiB
Plaintext
438 lines
9.5 KiB
Plaintext
# 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")
|