Address review comments pt.2

Author: p-sawicki

mypyc/irbuild/specialize.py

@@ -30,6 +30,7 @@
     NameExpr,
     RefExpr,
     StrExpr,
+    SuperExpr,
     TupleExpr,
     Var,
 )
@@ -1012,11 +1013,20 @@ def translate_object_new(builder: IRBuilder, expr: CallExpr, callee: RefExpr) ->
     if fn.name != "__new__":
         return None
 
+    is_super_new = isinstance(expr.callee, SuperExpr)
+    is_object_new = (
+        isinstance(callee, MemberExpr)
+        and isinstance(callee.expr, NameExpr)
+        and callee.expr.fullname == "builtins.object"
+    )
+    if not (is_super_new or is_object_new):
+        return None
+
     ir = builder.get_current_class_ir()
     if ir is None:
         return None
 
-    call = "object.__new__()"
+    call = '"object.__new__()"'
     if not ir.is_ext_class:
         builder.error(f"{call} not supported for non-extension classes", expr.line)
         return None

mypyc/irbuild/statement.py

@@ -182,19 +182,24 @@ def check_unsupported_cls_assignment(builder: IRBuilder, stmt: AssignmentStmt) -
         return
 
     cls_arg = method_args[0]
-    lvalues: list[Expression] = []
-    for lvalue in stmt.lvalues:
-        if isinstance(lvalue, (TupleExpr, ListExpr)):
-            lvalues += lvalue.items
-        else:
-            lvalues.append(lvalue)
+
+    def flatten(lvalues: list[Expression]) -> list[Expression]:
+        flat = []
+        for lvalue in lvalues:
+            if isinstance(lvalue, (TupleExpr, ListExpr)):
+                flat += flatten(lvalue.items)
+            else:
+                flat.append(lvalue)
+        return flat
+
+    lvalues = flatten(stmt.lvalues)
 
     for lvalue in lvalues:
         if isinstance(lvalue, NameExpr) and lvalue.name == cls_arg:
             # Disallowed because it could break the transformation of object.__new__ calls
             # inside __new__ methods.
             builder.error(
-                f"Assignment to argument {cls_arg} in __new__ method unsupported", stmt.line
+                f'Assignment to argument "{cls_arg}" in "__new__" method unsupported', stmt.line
             )
 
 

mypyc/test-data/irbuild-classes.test

@@ -2022,43 +2022,48 @@ from typing import Any
 @mypyc_attr(native_class=False)
 class NonNative:
     def __new__(cls) -> NonNative:
-        return super().__new__(cls)  # E: object.__new__() not supported for non-extension classes
+        return super().__new__(cls)  # E: "object.__new__()" not supported for non-extension classes
 
 class InheritsPython(dict):
     def __new__(cls) -> InheritsPython:
-        return super().__new__(cls)  # E: object.__new__() not supported for classes inheriting from non-native classes
+        return super().__new__(cls)  # E: "object.__new__()" not supported for classes inheriting from non-native classes
 
 @mypyc_attr(native_class=False)
 class NonNativeObjectNew:
     def __new__(cls) -> NonNativeObjectNew:
-        return object.__new__(cls)  # E: object.__new__() not supported for non-extension classes
+        return object.__new__(cls)  # E: "object.__new__()" not supported for non-extension classes
 
 class InheritsPythonObjectNew(dict):
     def __new__(cls) -> InheritsPythonObjectNew:
-        return object.__new__(cls)  # E: object.__new__() not supported for classes inheriting from non-native classes
+        return object.__new__(cls)  # E: "object.__new__()" not supported for classes inheriting from non-native classes
 
 class ClsAssignment:
     def __new__(cls: Any) -> Any:
-        cls = str  # E: Assignment to argument cls in __new__ method unsupported
+        cls = str  # E: Assignment to argument "cls" in "__new__" method unsupported
         return super().__new__(cls)
 
 class ClsTupleAssignment:
     def __new__(class_i_want: Any, val: int) -> Any:
-        class_i_want, val = dict, 1  # E: Assignment to argument class_i_want in __new__ method unsupported
+        class_i_want, val = dict, 1  # E: Assignment to argument "class_i_want" in "__new__" method unsupported
         return object.__new__(class_i_want)
 
 class ClsListAssignment:
     def __new__(cls: Any, val: str) -> Any:
-        [cls, val] = [object, "object"]  # E: Assignment to argument cls in __new__ method unsupported
+        [cls, val] = [object, "object"]  # E: Assignment to argument "cls" in "__new__" method unsupported
+        return object.__new__(cls)
+
+class ClsNestedAssignment:
+    def __new__(cls: Any, val1: str, val2: int) -> Any:
+        [val1, [val2, cls]] = ["val1", [2, int]]  # E: Assignment to argument "cls" in "__new__" method unsupported
         return object.__new__(cls)
 
 class WrongNumberOfArgs:
     def __new__(cls):
-        return super().__new__()  # E: object.__new__() supported only with 1 argument, got 0
+        return super().__new__()  # E: "object.__new__()" supported only with 1 argument, got 0
 
 class WrongNumberOfArgsObjectNew:
     def __new__(cls):
-        return object.__new__(cls, 1)  # E: object.__new__() supported only with 1 argument, got 2
+        return object.__new__(cls, 1)  # E: "object.__new__()" supported only with 1 argument, got 2
 
 [case testClassWithFreeList]
 from mypy_extensions import mypyc_attr, trait

mypyc/test-data/run-classes.test

@@ -3945,6 +3945,53 @@ assert t.generic == "{}"
 assert t.bitfield == 0x0C
 assert t.default == 10
 
+[case testUntransformedDunderNewCalls]
+from testutil import assertRaises
+from typing import Any
+
+class TestStrCls:
+    def __new__(cls):
+        return str.__new__(cls)
+
+    @classmethod
+    def factory(cls):
+        return str.__new__(cls)
+
+class TestStrStr:
+    def __new__(cls):
+        return str.__new__(str)
+
+    @classmethod
+    def factory(cls):
+        return str.__new__(str)
+
+class TestStrInt:
+    def __new__(cls):
+        return str.__new__(int)
+
+    @classmethod
+    def factory(cls):
+        return str.__new__(int)
+
+def test_untransformed_dunder_new() -> None:
+    with assertRaises(TypeError, "str.__new__(TestStrCls): TestStrCls is not a subtype of str"):
+        i = TestStrCls()
+
+    j: Any = TestStrStr()
+    assert j == ""
+
+    with assertRaises(TypeError, "str.__new__(int): int is not a subtype of str"):
+        k = TestStrInt()
+
+    with assertRaises(TypeError, "str.__new__(TestStrCls): TestStrCls is not a subtype of str"):
+        i = TestStrCls.factory()
+
+    j = TestStrStr.factory()
+    assert j == ""
+
+    with assertRaises(TypeError, "str.__new__(int): int is not a subtype of str"):
+        k = TestStrInt.factory()
+
 [case testPerTypeFreeList]
 from __future__ import annotations