Call setup function only when first argument matches outer function

Author: p-sawicki

mypyc/codegen/emitclass.py

@@ -678,8 +678,10 @@ def emit_null_check() -> None:
         emit_null_check()
         return
     prefix = emitter.get_group_prefix(new_fn.decl) + NATIVE_PREFIX if native_prefix else PREFIX
-    new_args = ", ".join([type_arg, new_args])
-    emitter.emit_line(f"PyObject *self = {prefix}{new_fn.cname(emitter.names)}({new_args});")
+    all_args = type_arg
+    if new_args != "":
+        all_args += ", " + new_args
+    emitter.emit_line(f"PyObject *self = {prefix}{new_fn.cname(emitter.names)}({all_args});")
     emit_null_check()
 
     # skip __init__ if __new__ returns some other type

mypyc/irbuild/expression.py

@@ -483,8 +483,15 @@ def translate_super_method_call(builder: IRBuilder, expr: CallExpr, callee: Supe
                 assert (
                     len(expr.args) == 1
                 ), f"Expected object.__new__() call to have exactly 1 argument, got {len(expr.args)}"
-                subtype = builder.accept(expr.args[0])
-                return builder.add(Call(ir.setup, [subtype], expr.line))
+                typ_arg = expr.args[0]
+                method_args = builder.fn_info.fitem.arg_names
+                if (
+                    isinstance(typ_arg, NameExpr)
+                    and len(method_args) > 0
+                    and method_args[0] == typ_arg.name
+                ):
+                    subtype = builder.accept(expr.args[0])
+                    return builder.add(Call(ir.setup, [subtype], expr.line))
 
         if callee.name == "__new__":
             call = "super().__new__()"

mypyc/test-data/irbuild-classes.test

@@ -1619,6 +1619,21 @@ class Test:
         obj.val = val
         return obj
 
+def fn() -> Test:
+    return Test.__new__(Test, 42)
+
+class NewClassMethod:
+    val: int
+
+    @classmethod
+    def __new__(cls, val: int) -> NewClassMethod:
+        obj = super().__new__(cls)
+        obj.val = val
+        return obj
+
+def fn2() -> NewClassMethod:
+    return NewClassMethod.__new__(42)
+
 [out]
 def Test.__new__(cls, val):
     cls :: object
@@ -1630,6 +1645,30 @@ L0:
     obj = r0
     obj.val = val; r1 = is_error
     return obj
+def fn():
+    r0 :: object
+    r1 :: __main__.Test
+L0:
+    r0 = __main__.Test :: type
+    r1 = Test.__new__(r0, 84)
+    return r1
+def NewClassMethod.__new__(cls, val):
+    cls :: object
+    val :: int
+    r0, obj :: __main__.NewClassMethod
+    r1 :: bool
+L0:
+    r0 = __mypyc__NewClassMethod_setup(cls)
+    obj = r0
+    obj.val = val; r1 = is_error
+    return obj
+def fn2():
+    r0 :: object
+    r1 :: __main__.NewClassMethod
+L0:
+    r0 = __main__.NewClassMethod :: type
+    r1 = NewClassMethod.__new__(r0, 84)
+    return r1
 
 [case testUnsupportedDunderNew]
 from __future__ import annotations

mypyc/test-data/run-classes.test

@@ -3310,6 +3310,10 @@ class RaisesException:
     def __init__(self, val: int) -> None:
         self.val = val
 
+class ClsArgNotPassed:
+    def __new__(cls) -> Any:
+        return super().__new__(str)
+
 def test_dunder_new() -> None:
     add_instance: Any = Add(1, 5)
     assert type(add_instance) == Add
@@ -3332,6 +3336,9 @@ def test_dunder_new() -> None:
     not_raised = RaisesException(1)
     assert not_raised.val == 1
 
+    with assertRaises(TypeError, "object.__new__(str) is not safe, use str.__new__()"):
+        str_as_cls = ClsArgNotPassed()
+
 
 [case testDunderNewInInterpreted]
 from __future__ import annotations
@@ -3368,8 +3375,12 @@ class RaisesException:
     def __init__(self, val: int) -> None:
         self.val = val
 
+class ClsArgNotPassed:
+    def __new__(cls) -> Any:
+        return super().__new__(str)
+
 [file driver.py]
-from native import Add, RaisesException
+from native import Add, ClsArgNotPassed, RaisesException
 
 from testutil import assertRaises
 
@@ -3383,6 +3394,9 @@ with assertRaises(RuntimeError, "Invalid value!"):
 not_raised = RaisesException(1)
 assert not_raised.val == 1
 
+with assertRaises(TypeError, "object.__new__(str) is not safe, use str.__new__()"):
+    str_as_cls = ClsArgNotPassed()
+
 [out]
 running __new__ with 1 and 5
 Add(1, 5)=(1 + 5)
@@ -3394,14 +3408,15 @@ Add(1, 0)=1
 [case testInheritedDunderNew]
 from __future__ import annotations
 from mypy_extensions import mypyc_attr
+from typing_extensions import Self
 
 from m import interpreted_subclass
 
 @mypyc_attr(allow_interpreted_subclasses=True)
 class Base:
     val: int
 
-    def __new__(cls, val: int):
+    def __new__(cls, val: int) -> Self:
         obj = super().__new__(cls)
         obj.val = val + 1
         return obj
@@ -3410,7 +3425,7 @@ class Base:
         self.init_val = val
 
 class Sub(Base):
-    def __new__(cls, val: int):
+    def __new__(cls, val: int) -> Self:
         return super().__new__(cls, val + 1)
 
     def __init__(self, val: int) -> None:
@@ -3425,7 +3440,7 @@ class SubWithoutNew(Base):
 class BaseWithoutInterpretedSubclasses:
     val: int
 
-    def __new__(cls, val: int):
+    def __new__(cls, val: int) -> Self:
         obj = super().__new__(cls)
         obj.val = val + 1
         return obj
@@ -3434,7 +3449,7 @@ class BaseWithoutInterpretedSubclasses:
         self.init_val = val
 
 class SubNoInterpreted(BaseWithoutInterpretedSubclasses):
-    def __new__(cls, val: int):
+    def __new__(cls, val: int) -> Self:
         return super().__new__(cls, val + 1)
 
     def __init__(self, val: int) -> None:
@@ -3483,6 +3498,7 @@ def test_interpreted_subclass() -> None:
 
 [file m.py]
 from __future__ import annotations
+from typing_extensions import Self
 
 def interpreted_subclass(base) -> None:
     b = base(42)
@@ -3491,7 +3507,7 @@ def interpreted_subclass(base) -> None:
     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: