Merge branch 'master' into PyObject_CallObject

Author: BobTheBuidler

mypy/fastparse.py

@@ -188,6 +188,13 @@ def ast3_parse(
     ast_TypeVar = Any
     ast_TypeVarTuple = Any
 
+if sys.version_info >= (3, 14):
+    ast_TemplateStr = ast3.TemplateStr
+    ast_Interpolation = ast3.Interpolation
+else:
+    ast_TemplateStr = Any
+    ast_Interpolation = Any
+
 N = TypeVar("N", bound=Node)
 
 # There is no way to create reasonable fallbacks at this stage,
@@ -1705,6 +1712,21 @@ def visit_FormattedValue(self, n: ast3.FormattedValue) -> Expression:
         )
         return self.set_line(result_expression, n)
 
+    # TemplateStr(expr* values)
+    def visit_TemplateStr(self, n: ast_TemplateStr) -> Expression:
+        self.fail(
+            ErrorMessage("PEP 750 template strings are not yet supported"),
+            n.lineno,
+            n.col_offset,
+            blocker=False,
+        )
+        e = TempNode(AnyType(TypeOfAny.from_error))
+        return self.set_line(e, n)
+
+    # Interpolation(expr value, constant str, int conversion, expr? format_spec)
+    def visit_Interpolation(self, n: ast_Interpolation) -> Expression:
+        assert False, "Unreachable"
+
     # Attribute(expr value, identifier attr, expr_context ctx)
     def visit_Attribute(self, n: Attribute) -> MemberExpr | SuperExpr:
         value = n.value

mypy/stubtest.py

@@ -510,7 +510,9 @@ def _verify_disjoint_base(
     if stub.is_final:
         return
     is_disjoint_runtime = _is_disjoint_base(runtime)
-    if is_disjoint_runtime and not stub.is_disjoint_base:
+    # Don't complain about missing @disjoint_base if there are __slots__, because
+    # in that case we can infer that it's a disjoint base.
+    if is_disjoint_runtime and not stub.is_disjoint_base and not runtime.__dict__.get("__slots__"):
         yield Error(
             object_path,
             "is a disjoint base at runtime, but isn't marked with @disjoint_base in the stub",
@@ -936,6 +938,7 @@ def from_overloadedfuncdef(stub: nodes.OverloadedFuncDef) -> Signature[nodes.Arg
                     or arg.pos_only
                     or assume_positional_only
                     or arg.variable.name.strip("_") == "self"
+                    or (index == 0 and arg.variable.name.strip("_") == "cls")
                     else arg.variable.name
                 )
                 all_args.setdefault(name, []).append((arg, index))
@@ -1006,6 +1009,7 @@ def _verify_signature(
             and not stub_arg.pos_only
             and not stub_arg.variable.name.startswith("__")
             and stub_arg.variable.name.strip("_") != "self"
+            and stub_arg.variable.name.strip("_") != "cls"
             and not is_dunder(function_name, exclude_special=True)  # noisy for dunder methods
         ):
             yield (
@@ -1017,6 +1021,7 @@ def _verify_signature(
             and (stub_arg.pos_only or stub_arg.variable.name.startswith("__"))
             and not runtime_arg.name.startswith("__")
             and stub_arg.variable.name.strip("_") != "self"
+            and stub_arg.variable.name.strip("_") != "cls"
             and not is_dunder(function_name, exclude_special=True)  # noisy for dunder methods
         ):
             yield (
@@ -1660,6 +1665,71 @@ def is_read_only_property(runtime: object) -> bool:
 
 
 def safe_inspect_signature(runtime: Any) -> inspect.Signature | None:
+    if (
+        hasattr(runtime, "__name__")
+        and runtime.__name__ == "__init__"
+        and hasattr(runtime, "__text_signature__")
+        and runtime.__text_signature__ == "($self, /, *args, **kwargs)"
+        and hasattr(runtime, "__objclass__")
+        and hasattr(runtime.__objclass__, "__text_signature__")
+        and runtime.__objclass__.__text_signature__ is not None
+    ):
+        # This is an __init__ method with the generic C-class signature.
+        # In this case, the underlying class often has a better signature,
+        # which we can convert into an __init__ signature by adding in the
+        # self parameter.
+        try:
+            s = inspect.signature(runtime.__objclass__)
+
+            parameter_kind: inspect._ParameterKind = inspect.Parameter.POSITIONAL_OR_KEYWORD
+            if s.parameters:
+                first_parameter = next(iter(s.parameters.values()))
+                if first_parameter.kind == inspect.Parameter.POSITIONAL_ONLY:
+                    parameter_kind = inspect.Parameter.POSITIONAL_ONLY
+            return s.replace(
+                parameters=[inspect.Parameter("self", parameter_kind), *s.parameters.values()]
+            )
+        except Exception:
+            pass
+
+    if (
+        hasattr(runtime, "__name__")
+        and runtime.__name__ == "__new__"
+        and hasattr(runtime, "__text_signature__")
+        and runtime.__text_signature__ == "($type, *args, **kwargs)"
+        and hasattr(runtime, "__self__")
+        and hasattr(runtime.__self__, "__text_signature__")
+        and runtime.__self__.__text_signature__ is not None
+    ):
+        # This is a __new__ method with the generic C-class signature.
+        # In this case, the underlying class often has a better signature,
+        # which we can convert into a __new__ signature by adding in the
+        # cls parameter.
+
+        # If the attached class has a valid __init__, skip recovering a
+        # signature for this __new__ method.
+        has_init = False
+        if (
+            hasattr(runtime.__self__, "__init__")
+            and hasattr(runtime.__self__.__init__, "__objclass__")
+            and runtime.__self__.__init__.__objclass__ is runtime.__self__
+        ):
+            has_init = True
+
+        if not has_init:
+            try:
+                s = inspect.signature(runtime.__self__)
+                parameter_kind = inspect.Parameter.POSITIONAL_OR_KEYWORD
+                if s.parameters:
+                    first_parameter = next(iter(s.parameters.values()))
+                    if first_parameter.kind == inspect.Parameter.POSITIONAL_ONLY:
+                        parameter_kind = inspect.Parameter.POSITIONAL_ONLY
+                return s.replace(
+                    parameters=[inspect.Parameter("cls", parameter_kind), *s.parameters.values()]
+                )
+            except Exception:
+                pass
+
     try:
         try:
             return inspect.signature(runtime)

mypy/test/testcheck.py

@@ -47,6 +47,8 @@
     typecheck_files.remove("check-python312.test")
 if sys.version_info < (3, 13):
     typecheck_files.remove("check-python313.test")
+if sys.version_info < (3, 14):
+    typecheck_files.remove("check-python314.test")
 
 
 class TypeCheckSuite(DataSuite):

mypy/test/testparse.py

@@ -27,6 +27,8 @@ class ParserSuite(DataSuite):
         files.remove("parse-python312.test")
     if sys.version_info < (3, 13):
         files.remove("parse-python313.test")
+    if sys.version_info < (3, 14):
+        files.remove("parse-python314.test")
 
     def run_case(self, testcase: DataDrivenTestCase) -> None:
         test_parser(testcase)
@@ -46,6 +48,8 @@ def test_parser(testcase: DataDrivenTestCase) -> None:
         options.python_version = (3, 12)
     elif testcase.file.endswith("python313.test"):
         options.python_version = (3, 13)
+    elif testcase.file.endswith("python314.test"):
+        options.python_version = (3, 14)
     else:
         options.python_version = defaults.PYTHON3_VERSION
 

mypy/test/teststubtest.py

@@ -1430,6 +1430,31 @@ class BytesEnum(bytes, enum.Enum):
             """,
             error=None,
         )
+        yield Case(
+            stub="""
+            class HasSlotsAndNothingElse:
+                __slots__ = ("x",)
+                x: int
+
+            class HasInheritedSlots(HasSlotsAndNothingElse):
+                pass
+
+            class HasEmptySlots:
+                __slots__ = ()
+            """,
+            runtime="""
+            class HasSlotsAndNothingElse:
+                __slots__ = ("x",)
+                x: int
+
+            class HasInheritedSlots(HasSlotsAndNothingElse):
+                pass
+
+            class HasEmptySlots:
+                __slots__ = ()
+            """,
+            error=None,
+        )
 
     @collect_cases
     def test_decorator(self) -> Iterator[Case]:

mypyc/irbuild/ll_builder.py

@@ -128,6 +128,8 @@
 from mypyc.primitives.bytes_ops import bytes_compare
 from mypyc.primitives.dict_ops import (
     dict_build_op,
+    dict_copy,
+    dict_copy_op,
     dict_new_op,
     dict_ssize_t_size_op,
     dict_update_in_display_op,
@@ -807,19 +809,40 @@ def _construct_varargs(
                         return value, None
                     elif len(args) == 2 and args[1][1] == ARG_STAR2:
                         # fn(*args, **kwargs)
+                        # TODO: extend to cover(*args, **k, **w, **a, **r, **g, **s)
                         if is_tuple_rprimitive(value.type) or isinstance(value.type, RTuple):
                             star_result = value
                         elif is_list_rprimitive(value.type):
                             star_result = self.primitive_op(list_tuple_op, [value], line)
                         else:
                             star_result = self.primitive_op(sequence_tuple_op, [value], line)
-                        continue
+
+                        star2_arg = args[1]
+                        star2_value = star2_arg[0]
+                        if is_dict_rprimitive(star2_value.type):
+                            star2_fastpath_op = dict_copy_op
+                        else:
+                            star2_fastpath_op = dict_copy
+                        return star_result, self.primitive_op(
+                            star2_fastpath_op, [star2_value], line
+                        )
                         # elif ...: TODO extend this to optimize fn(*args, k=1, **kwargs) case
                     # TODO optimize this case using the length utils - currently in review
                     star_result = self.new_list_op(star_values, line)
                 self.primitive_op(list_extend_op, [star_result, value], line)
             elif kind == ARG_STAR2:
                 if star2_result is None:
+                    if len(args) == 1:
+                        # early exit with fastpath if the only arg is ARG_STAR2
+                        # TODO: can we maintain an empty tuple in memory and just reuse it again and again?
+                        if is_dict_rprimitive(value.type):
+                            star2_fastpath_op = dict_copy_op
+                        else:
+                            star2_fastpath_op = dict_copy
+                        return self.new_tuple([], line), self.primitive_op(
+                            star2_fastpath_op, [value], line
+                        )
+
                     star2_result = self._create_dict(star2_keys, star2_values, line)
 
                 self.call_c(dict_update_in_display_op, [star2_result, value], line=line)

mypyc/primitives/dict_ops.py

@@ -53,7 +53,7 @@
 )
 
 # Construct a dictionary from another dictionary.
-function_op(
+dict_copy_op = function_op(
     name="builtins.dict",
     arg_types=[dict_rprimitive],
     return_type=dict_rprimitive,

mypyc/test-data/irbuild-basic.test

@@ -1735,12 +1735,10 @@ def g():
     r6, r7 :: dict
     r8 :: str
     r9 :: object
-    r10 :: dict
-    r11 :: i32
-    r12 :: bit
-    r13 :: tuple
-    r14 :: object
-    r15 :: tuple[int, int, int]
+    r10 :: tuple
+    r11 :: dict
+    r12 :: object
+    r13 :: tuple[int, int, int]
 L0:
     r0 = 'a'
     r1 = 'b'
@@ -1752,13 +1750,11 @@ L0:
     r7 = __main__.globals :: static
     r8 = 'f'
     r9 = CPyDict_GetItem(r7, r8)
-    r10 = PyDict_New()
-    r11 = CPyDict_UpdateInDisplay(r10, r6)
-    r12 = r11 >= 0 :: signed
-    r13 = PyTuple_Pack(0)
-    r14 = PyObject_Call(r9, r13, r10)
-    r15 = unbox(tuple[int, int, int], r14)
-    return r15
+    r10 = PyTuple_Pack(0)
+    r11 = PyDict_Copy(r6)
+    r12 = PyObject_Call(r9, r10, r11)
+    r13 = unbox(tuple[int, int, int], r12)
+    return r13
 def h():
     r0, r1 :: str
     r2, r3 :: object
@@ -3660,18 +3656,14 @@ def wrapper_deco_obj.__call__(__mypyc_self__, lst, kwargs):
     r1 :: object
     r2 :: tuple
     r3 :: dict
-    r4 :: i32
-    r5 :: bit
-    r6 :: object
+    r4 :: object
 L0:
     r0 = __mypyc_self__.__mypyc_env__
     r1 = r0.fn
     r2 = PyList_AsTuple(lst)
-    r3 = PyDict_New()
-    r4 = CPyDict_UpdateInDisplay(r3, kwargs)
-    r5 = r4 >= 0 :: signed
-    r6 = PyObject_Call(r1, r2, r3)
-    return r6
+    r3 = PyDict_Copy(kwargs)
+    r4 = PyObject_Call(r1, r2, r3)
+    return r4
 def deco(fn):
     fn :: object
     r0 :: __main__.deco_env
@@ -3765,18 +3757,14 @@ def wrapper_deco_obj.__call__(__mypyc_self__, args, kwargs):
     r1 :: object
     r2 :: tuple
     r3 :: dict
-    r4 :: i32
-    r5 :: bit
-    r6 :: object
+    r4 :: object
 L0:
     r0 = __mypyc_self__.__mypyc_env__
     r1 = r0.fn
     r2 = PySequence_Tuple(args)
-    r3 = PyDict_New()
-    r4 = CPyDict_UpdateInDisplay(r3, kwargs)
-    r5 = r4 >= 0 :: signed
-    r6 = PyObject_Call(r1, r2, r3)
-    return r6
+    r3 = PyDict_Copy(kwargs)
+    r4 = PyObject_Call(r1, r2, r3)
+    return r4
 def deco(fn):
     fn :: object
     r0 :: __main__.deco_env

mypyc/test-data/irbuild-generics.test

@@ -167,17 +167,13 @@ def execute(func, args, kwargs):
     func :: object
     args :: tuple
     kwargs, r0 :: dict
-    r1 :: i32
-    r2 :: bit
-    r3 :: object
-    r4 :: int
+    r1 :: object
+    r2 :: int
 L0:
-    r0 = PyDict_New()
-    r1 = CPyDict_UpdateInDisplay(r0, kwargs)
-    r2 = r1 >= 0 :: signed
-    r3 = PyObject_Call(func, args, r0)
-    r4 = unbox(int, r3)
-    return r4
+    r0 = PyDict_Copy(kwargs)
+    r1 = PyObject_Call(func, args, r0)
+    r2 = unbox(int, r1)
+    return r2
 def f(x):
     x :: int
 L0:
@@ -703,10 +699,8 @@ def inner_deco_obj.__call__(__mypyc_self__, args, kwargs):
     r22, can_iter, r23, can_use_keys, r24, can_use_values :: list
     r25 :: object
     r26 :: dict
-    r27 :: i32
-    r28 :: bit
-    r29 :: object
-    r30 :: int
+    r27 :: object
+    r28 :: int
 L0:
     r0 = __mypyc_self__.__mypyc_env__
     r1 = var_object_size args
@@ -758,12 +752,10 @@ L9:
     r24 = CPyDict_Values(kwargs)
     can_use_values = r24
     r25 = r0.func
-    r26 = PyDict_New()
-    r27 = CPyDict_UpdateInDisplay(r26, kwargs)
-    r28 = r27 >= 0 :: signed
-    r29 = PyObject_Call(r25, args, r26)
-    r30 = unbox(int, r29)
-    return r30
+    r26 = PyDict_Copy(kwargs)
+    r27 = PyObject_Call(r25, args, r26)
+    r28 = unbox(int, r27)
+    return r28
 def deco(func):
     func :: object
     r0 :: __main__.deco_env