Add more test cases

Author: p-sawicki

mypyc/test-data/fixtures/typing-full.pyi

@@ -32,6 +32,7 @@ Final = 0
 TypedDict = 0
 NoReturn = 0
 NewType = 0
+Self = 0
 Callable: _SpecialForm
 Union: _SpecialForm
 Literal: _SpecialForm
@@ -175,6 +176,3 @@ class _TypedDict(Mapping[str, object]):
 
 class TypeAliasType:
     pass
-
-def Self(self, parameters):
-    raise TypeError(f"{self} is not subscriptable")

mypyc/test-data/irbuild-classes.test

@@ -1608,6 +1608,29 @@ L0:
     r0 = CPy_TYPE(x)
     return r0
 
+[case testDunderNew]
+from __future__ import annotations
+
+class Test:
+    val: int
+
+    def __new__(cls, val: int) -> Test:
+        obj = super().__new__(cls)
+        obj.val = val
+        return obj
+
+[out]
+def Test.__new__(cls, val):
+    cls :: object
+    val :: int
+    r0, obj :: __main__.Test
+    r1 :: bool
+L0:
+    r0 = __mypyc__Test_setup(cls)
+    obj = r0
+    obj.val = val; r1 = is_error
+    return obj
+
 [case testUnsupportedDunderNew]
 from __future__ import annotations
 from mypy_extensions import mypyc_attr

mypyc/test-data/run-classes.test

@@ -3280,13 +3280,68 @@ class Dyn: pass
 
 [case testDunderNew]
 from __future__ import annotations
-from typing import Union
+from typing import Any, Union
+
+from testutil import assertRaises 
 
 class Add:
     l: IntLike
     r: IntLike
 
-    def __new__(cls, l: IntLike, r: IntLike) -> IntLike:  # type: ignore[misc]
+    def __new__(cls, l: IntLike, r: IntLike) -> Any:
+        return (
+            l if r == 0 else
+            r if l == 0 else
+            super().__new__(cls)
+        )
+
+    def __init__(self, l: IntLike, r: IntLike):
+        self.l = l
+        self.r = r
+
+IntLike = Union[int, Add]
+
+class RaisesException:
+    def __new__(cls, val: int) -> RaisesException:
+        if val == 0:
+            raise RuntimeError("Invalid value!")
+        return super().__new__(cls)
+    
+    def __init__(self, val: int) -> None:
+        self.val = val
+
+def test_dunder_new() -> None:
+    add_instance: Any = Add(1, 5)
+    assert type(add_instance) == Add
+    assert add_instance.l == 1
+    assert add_instance.r == 5
+
+    # TODO: explicit types should not be needed but mypy does not use
+    # the return type of __new__ which makes mypyc add casts to Add.
+    right_int: Any = Add(0, 5)
+    assert type(right_int) == int
+    assert right_int == 5
+
+    left_int: Any = Add(1, 0)
+    assert type(left_int) == int
+    assert left_int == 1
+
+    with assertRaises(RuntimeError, "Invalid value!"):
+        raised = RaisesException(0)
+    
+    not_raised = RaisesException(1)
+    assert not_raised.val == 1
+
+
+[case testDunderNewInInterpreted]
+from __future__ import annotations
+from typing import Any, Union
+
+class Add:
+    l: IntLike
+    r: IntLike
+
+    def __new__(cls, l: IntLike, r: IntLike) -> Any:
         print(f'running __new__ with {l} and {r}')
 
         return (
@@ -3302,18 +3357,32 @@ class Add:
     def __repr__(self) -> str:
         return f'({self.l} + {self.r})'
 
-    def __add__(self, other: IntLike) -> IntLike:
-        return Add(self, other)
-
 IntLike = Union[int, Add]
 
+class RaisesException:
+    def __new__(cls, val: int) -> RaisesException:
+        if val == 0:
+            raise RuntimeError("Invalid value!")
+        return super().__new__(cls)
+    
+    def __init__(self, val: int) -> None:
+        self.val = val
+
 [file driver.py]
-from native import Add
+from native import Add, RaisesException
+
+from testutil import assertRaises
 
 print(f'{Add(1, 5)=}')
 print(f'{Add(0, 5)=}')
 print(f'{Add(1, 0)=}')
 
+with assertRaises(RuntimeError, "Invalid value!"):
+    raised = RaisesException(0)
+    
+not_raised = RaisesException(1)
+assert not_raised.val == 1
+
 [out]
 running __new__ with 1 and 5
 Add(1, 5)=(1 + 5)
@@ -3325,45 +3394,126 @@ Add(1, 0)=1
 [case testInheritedDunderNew]
 from __future__ import annotations
 from mypy_extensions import mypyc_attr
+from typing import Self
 
 from m import interpreted_subclass
 
 @mypyc_attr(allow_interpreted_subclasses=True)
 class Base:
     val: int
 
-    def __new__(cls, val: int) -> Base:
+    def __new__(cls, val: int) -> Self:
         obj = super().__new__(cls)
         obj.val = val + 1
         return obj
 
-    def __init__(self, val: int):
-        pass
+    def __init__(self, val: int) -> None:
+        self.init_val = val
 
 class Sub(Base):
-    def __new__(cls, val: int) -> Base:  # type: ignore[misc]
+    def __new__(cls, val: int) -> Self:
         return super().__new__(cls, val + 1)
 
-    def __init__(self, val: int):
-        pass
+    def __init__(self, val: int) -> None:
+        super().__init__(val)
+        self.init_val = self.init_val * 2
+
+class SubWithoutNew(Base):
+    def __init__(self, val: int) -> None:
+        super().__init__(val)
+        self.init_val = self.init_val * 2
+
+class BaseWithoutInterpretedSubclasses:
+    val: int
+
+    def __new__(cls, val: int) -> Self:
+        obj = super().__new__(cls)
+        obj.val = val + 1
+        return obj
+
+    def __init__(self, val: int) -> None:
+        self.init_val = val
+
+class SubNoInterpreted(BaseWithoutInterpretedSubclasses):
+    def __new__(cls, val: int) -> Self:
+        return super().__new__(cls, val + 1)
+
+    def __init__(self, val: int) -> None:
+        super().__init__(val)
+        self.init_val = self.init_val * 2
+
+class SubNoInterpretedWithoutNew(BaseWithoutInterpretedSubclasses):
+    def __init__(self, val: int) -> None:
+        super().__init__(val)
+        self.init_val = self.init_val * 2
 
 def test_inherited_dunder_new() -> None:
+    b = Base(42)
+    assert type(b) == Base
+    assert b.val == 43
+    assert b.init_val == 42
+
     s = Sub(42)
+    assert type(s) == Sub
+    assert s.val == 44
+    assert s.init_val == 84
+
+    s2 = SubWithoutNew(42)
+    assert type(s2) == SubWithoutNew
+    assert s2.val == 43
+    assert s2.init_val == 84
+
+def test_inherited_dunder_new_without_interpreted_subclasses() -> None:
+    b = BaseWithoutInterpretedSubclasses(42)
+    assert type(b) == BaseWithoutInterpretedSubclasses
+    assert b.val == 43
+    assert b.init_val == 42
+
+    s = SubNoInterpreted(42)
+    assert type(s) == SubNoInterpreted
     assert s.val == 44
+    assert s.init_val == 84
+
+    s2 = SubNoInterpretedWithoutNew(42)
+    assert type(s2) == SubNoInterpretedWithoutNew
+    assert s2.val == 43
+    assert s2.init_val == 84
 
 def test_interpreted_subclass() -> None:
     interpreted_subclass(Base)
 
 [file m.py]
 from __future__ import annotations
+from typing import Self
 
 def interpreted_subclass(base) -> None:
+    b = base(42)
+    assert type(b) == base
+    assert b.val == 43
+    assert b.init_val == 42
+
     class InterpretedSub(base):
-        def __new__(cls, val: int) -> base:
+        def __new__(cls, val: int) -> Self:
             return super().__new__(cls, val + 1)
+        
+        def __init__(self, val: int) -> None:
+            super().__init__(val)
+            self.init_val : int = self.init_val * 2
 
     s = InterpretedSub(42)
+    assert type(s) == InterpretedSub
     assert s.val == 44
+    assert s.init_val == 84
+
+    class InterpretedSubWithoutNew(base):
+        def __init__(self, val: int) -> None:
+            super().__init__(val)
+            self.init_val : int = self.init_val * 2
+    
+    s2 = InterpretedSubWithoutNew(42)
+    assert type(s2) == InterpretedSubWithoutNew
+    assert s2.val == 43
+    assert s2.init_val == 84
 
 [case testDunderNewInitArgMismatch]
 from __future__ import annotations
@@ -3463,56 +3613,80 @@ with assertRaises(AttributeError, "attribute 'val' of 'Test2' undefined"):
 
 [case testDunderNewAttributeAccess]
 from __future__ import annotations
+
+from mypy_extensions import u8
 from testutil import assertRaises
 
 class Test:
     native: int
     generic: object
-    def __new__(cls, native: int, generic: object) -> Test:
+    bitfield: u8
+    default: int = 5
+
+    def __new__(cls, native: int, generic: object, bitfield: u8) -> Test:
         obj = super().__new__(cls)
 
         with assertRaises(AttributeError, "attribute 'native' of 'Test' undefined"):
             print(obj.native)
         with assertRaises(AttributeError, "attribute 'generic' of 'Test' undefined"):
             print(obj.generic)
+        with assertRaises(AttributeError, "attribute 'bitfield' of 'Test' undefined"):
+            print(obj.bitfield)
 
         obj.native = native
         obj.generic = generic
+        obj.bitfield = bitfield
 
         obj.native = obj.native + 1
         obj.generic = obj.generic.__str__()
+        obj.bitfield = obj.bitfield & 0x0F
+        obj.default = obj.default * 2
         return obj
 
 def test_attribute_access() -> None:
-    t = Test(42, {})
+    t = Test(42, {}, 0xCC)
     assert t.native == 43
     assert t.generic == "{}"
+    assert t.bitfield == 0x0C
+    assert t.default == 10
 
 [case testDunderNewAttributeAccessInInterpreted]
 from __future__ import annotations
+
+from mypy_extensions import u8
 from testutil import assertRaises
 
 class Test:
     native: int
     generic: object
-    def __new__(cls, native: int, generic: object) -> Test:
+    bitfield: u8
+    default: int = 5
+
+    def __new__(cls, native: int, generic: object, bitfield: u8) -> Test:
         obj = super().__new__(cls)
 
         with assertRaises(AttributeError, "attribute 'native' of 'Test' undefined"):
             print(obj.native)
         with assertRaises(AttributeError, "attribute 'generic' of 'Test' undefined"):
             print(obj.generic)
+        with assertRaises(AttributeError, "attribute 'bitfield' of 'Test' undefined"):
+            print(obj.bitfield)
 
         obj.native = native
         obj.generic = generic
+        obj.bitfield = bitfield
 
         obj.native = obj.native + 1
         obj.generic = obj.generic.__str__()
+        obj.bitfield = obj.bitfield & 0x0F
+        obj.default = obj.default * 2
         return obj
 
 [file driver.py]
 from native import Test
 
-t = Test(42, {})
+t = Test(42, {}, 0xCC)
 assert t.native == 43
 assert t.generic == "{}"
+assert t.bitfield == 0x0C
+assert t.default == 10