Merge remote-tracking branch 'upstream/master' into librt_base64_simd_cpu_dispatch

Author: mr-c

mypy/nodes.py

@@ -3732,12 +3732,18 @@ def get_method(self, name: str) -> FuncBase | Decorator | None:
         for cls in self.mro:
             if name in cls.names:
                 node = cls.names[name].node
-                if isinstance(node, SYMBOL_FUNCBASE_TYPES):
-                    return node
-                elif isinstance(node, Decorator):  # Two `if`s make `mypyc` happy
-                    return node
-                else:
-                    return None
+            elif possible_redefinitions := sorted(
+                [n for n in cls.names.keys() if n.startswith(f"{name}-redefinition")]
+            ):
+                node = cls.names[possible_redefinitions[-1]].node
+            else:
+                continue
+            if isinstance(node, SYMBOL_FUNCBASE_TYPES):
+                return node
+            elif isinstance(node, Decorator):  # Two `if`s make `mypyc` happy
+                return node
+            else:
+                return None
         return None
 
     def calculate_metaclass_type(self) -> mypy.types.Instance | None:

mypy/partially_defined.py

@@ -206,11 +206,13 @@ def __init__(self) -> None:
         # disable_branch_skip is used to disable skipping a branch due to a return/raise/etc. This is useful
         # in things like try/except/finally statements.
         self.disable_branch_skip = False
+        self.in_finally = False
 
     def copy(self) -> DefinedVariableTracker:
         result = DefinedVariableTracker()
         result.scopes = [s.copy() for s in self.scopes]
         result.disable_branch_skip = self.disable_branch_skip
+        result.in_finally = self.in_finally
         return result
 
     def _scope(self) -> Scope:
@@ -579,7 +581,9 @@ def process_try_stmt(self, o: TryStmt) -> None:
         self.tracker.end_branch_statement()
 
         if o.finally_body is not None:
+            self.tracker.in_finally = True
             o.finally_body.accept(self)
+            self.tracker.in_finally = False
 
     def visit_while_stmt(self, o: WhileStmt) -> None:
         o.expr.accept(self)
@@ -620,7 +624,10 @@ def visit_starred_pattern(self, o: StarredPattern) -> None:
     def visit_name_expr(self, o: NameExpr) -> None:
         if o.name in self.builtins and self.tracker.in_scope(ScopeType.Global):
             return
-        if self.tracker.is_possibly_undefined(o.name):
+        if (
+            self.tracker.is_possibly_undefined(o.name)
+            and self.tracker.in_finally == self.tracker.disable_branch_skip
+        ):
             # A variable is only defined in some branches.
             self.variable_may_be_undefined(o.name, o)
             # We don't want to report the error on the same variable multiple times.

mypy/semanal.py

@@ -7030,7 +7030,12 @@ def add_symbol_table_node(
             if not is_same_symbol(old, new):
                 if isinstance(new, (FuncDef, Decorator, OverloadedFuncDef, TypeInfo)):
                     self.add_redefinition(names, name, symbol)
-                if not (isinstance(new, (FuncDef, Decorator)) and self.set_original_def(old, new)):
+                if isinstance(old, Var) and is_init_only(old):
+                    if old.has_explicit_value:
+                        self.fail("InitVar with default value cannot be redefined", context)
+                elif not (
+                    isinstance(new, (FuncDef, Decorator)) and self.set_original_def(old, new)
+                ):
                     self.name_already_defined(name, context, existing)
         elif type_param or (
             name not in self.missing_names[-1] and "*" not in self.missing_names[-1]
@@ -8279,3 +8284,10 @@ def halt(self, reason: str = ...) -> NoReturn:
     return isinstance(stmt, PassStmt) or (
         isinstance(stmt, ExpressionStmt) and isinstance(stmt.expr, EllipsisExpr)
     )
+
+
+def is_init_only(node: Var) -> bool:
+    return (
+        isinstance(type := get_proper_type(node.type), Instance)
+        and type.type.fullname == "dataclasses.InitVar"
+    )

mypy/typeshed/stubs/librt/librt/strings.pyi

@@ -0,0 +1,13 @@
+from typing import final
+
+from mypy_extensions import i64, u8
+
+@final
+class BytesWriter:
+    def append(self, /, x: int) -> None: ...
+    def write(self, /, b: bytes) -> None: ...
+    def getvalue(self) -> bytes: ...
+    def truncate(self, /, size: i64) -> None: ...
+    def __len__(self) -> i64: ...
+    def __getitem__(self, /, i: i64) -> u8: ...
+    def __setitem__(self, /, i: i64, x: u8) -> None: ...

mypy/version.py

@@ -8,7 +8,7 @@
 # - Release versions have the form "1.2.3".
 # - Dev versions have the form "1.2.3+dev" (PLUS sign to conform to PEP 440).
 # - Before 1.0 we had the form "0.NNN".
-__version__ = "1.19.0+dev"
+__version__ = "1.20.0+dev"
 base_version = __version__
 
 mypy_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

mypyc/build.py

@@ -53,6 +53,7 @@ class ModDesc(NamedTuple):
 
 LIBRT_MODULES = [
     ModDesc("librt.internal", ["librt_internal.c"], [], []),
+    ModDesc("librt.strings", ["librt_strings.c"], [], []),
     ModDesc(
         "librt.base64",
         [

mypyc/codegen/emitmodule.py

@@ -611,6 +611,8 @@ def generate_c_for_modules(self) -> list[tuple[str, str]]:
             ext_declarations.emit_line("#include <librt_internal.h>")
         if any("librt.base64" in mod.capsules for mod in self.modules.values()):
             ext_declarations.emit_line("#include <librt_base64.h>")
+        if any("librt.strings" in mod.capsules for mod in self.modules.values()):
+            ext_declarations.emit_line("#include <librt_strings.h>")
 
         declarations = Emitter(self.context)
         declarations.emit_line(f"#ifndef MYPYC_LIBRT_INTERNAL{self.group_suffix}_H")
@@ -1045,6 +1047,10 @@ def emit_module_exec_func(
             emitter.emit_line("if (import_librt_base64() < 0) {")
             emitter.emit_line("return -1;")
             emitter.emit_line("}")
+        if "librt.strings" in module.capsules:
+            emitter.emit_line("if (import_librt_strings() < 0) {")
+            emitter.emit_line("return -1;")
+            emitter.emit_line("}")
         emitter.emit_line("PyObject* modname = NULL;")
         if self.multi_phase_init:
             emitter.emit_line(f"{module_static} = module;")

mypyc/ir/ops.py

@@ -37,13 +37,15 @@ class to enable the new behavior. Sometimes adding a new abstract
     RStruct,
     RTuple,
     RType,
+    RUnion,
     RVoid,
     bit_rprimitive,
     bool_rprimitive,
     cstring_rprimitive,
     float_rprimitive,
     int_rprimitive,
     is_bool_or_bit_rprimitive,
+    is_fixed_width_rtype,
     is_int_rprimitive,
     is_none_rprimitive,
     is_pointer_rprimitive,
@@ -688,7 +690,7 @@ class PrimitiveDescription:
     Primitives get lowered into lower-level ops before code generation.
 
     If c_function_name is provided, a primitive will be lowered into a CallC op.
-    Otherwise custom logic will need to be implemented to transform the
+    Otherwise, custom logic will need to be implemented to transform the
     primitive into lower-level ops.
     """
 
@@ -737,11 +739,24 @@ def __init__(
         # Capsule that needs to imported and configured to call the primitive
         # (name of the target module, e.g. "librt.base64").
         self.capsule = capsule
+        # Native integer types such as u8 can cause ambiguity in primitive
+        # matching, since these are assignable to plain int *and* vice versa.
+        # If this flag is set, the primitive has native integer types and must
+        # be matched using more complex rules.
+        self.is_ambiguous = any(has_fixed_width_int(t) for t in arg_types)
 
     def __repr__(self) -> str:
         return f"<PrimitiveDescription {self.name!r}: {self.arg_types}>"
 
 
+def has_fixed_width_int(t: RType) -> bool:
+    if isinstance(t, RTuple):
+        return any(has_fixed_width_int(t) for t in t.types)
+    elif isinstance(t, RUnion):
+        return any(has_fixed_width_int(t) for t in t.items)
+    return is_fixed_width_rtype(t)
+
+
 @final
 class PrimitiveOp(RegisterOp):
     """A higher-level primitive operation.

mypyc/ir/rtypes.py

@@ -514,7 +514,11 @@ def __hash__(self) -> int:
 
 KNOWN_NATIVE_TYPES: Final = {
     name: RPrimitive(name, is_unboxed=False, is_refcounted=True)
-    for name in ["librt.internal.WriteBuffer", "librt.internal.ReadBuffer"]
+    for name in [
+        "librt.internal.WriteBuffer",
+        "librt.internal.ReadBuffer",
+        "librt.strings.BytesWriter",
+    ]
 }
 
 

mypyc/irbuild/expression.py

@@ -296,8 +296,8 @@ def transform_super_expr(builder: IRBuilder, o: SuperExpr) -> Value:
         # Grab first argument
         vself: Value = next(iter_env)
         if builder.fn_info.is_generator:
-            # grab sixth argument (see comment in translate_super_method_call)
-            self_targ = list(builder.symtables[-1].values())[6]
+            # grab seventh argument (see comment in translate_super_method_call)
+            self_targ = list(builder.symtables[-1].values())[7]
             vself = builder.read(self_targ, builder.fn_info.fitem.line)
         elif not ir.is_ext_class:
             vself = next(iter_env)  # second argument is self if non_extension class