ci: apply black formatting + fix ruff errors + repair NameError

VaggelisD · VaggelisD · commit 2b2c69001b4a · 2026-04-23T18:03:53.000+03:00
- Run black on files that diverged from the 25.9.0 pre-commit config.
- Fix ruff UP006/UP035 (typing.Dict/List -&gt; dict/list) in the small
  root-level test fixtures.
- emitfunc.emit_method_call: the guarded-direct path (added by the
  allow_interpreted_subclasses commit) referenced a no-longer-defined
  `method` variable. Use method_decl through the new helpers to match
  the direct call path. Fixes type check and 5 run-classes tests.
diff --git a/mypyc/codegen/emitclass.py b/mypyc/codegen/emitclass.py
@@ -364,7 +364,12 @@ def emit_line() -> None:
     generate_methods_table(cl, methods_name, setup_name if generate_full else None, emitter)
     emit_line()
 
-    flags = ["Py_TPFLAGS_DEFAULT", "Py_TPFLAGS_HEAPTYPE", "Py_TPFLAGS_BASETYPE", "CPy_TPFLAGS_MYPYC_COMPILED"]
+    flags = [
+        "Py_TPFLAGS_DEFAULT",
+        "Py_TPFLAGS_HEAPTYPE",
+        "Py_TPFLAGS_BASETYPE",
+        "CPy_TPFLAGS_MYPYC_COMPILED",
+    ]
     if generate_full:
         flags.append("Py_TPFLAGS_HAVE_GC")
     if cl.has_method("__call__"):
diff --git a/mypyc/codegen/emitfunc.py b/mypyc/codegen/emitfunc.py
@@ -644,9 +644,7 @@ def emit_method_call(self, dest: str, op_obj: Value, name: str, op_args: list[Va
         obj_args = (
             []
             if method_decl.kind == FUNC_STATICMETHOD
-            else [f"(PyObject *)Py_TYPE({obj})"]
-            if method_decl.kind == FUNC_CLASSMETHOD
-            else [obj]
+            else [f"(PyObject *)Py_TYPE({obj})"] if method_decl.kind == FUNC_CLASSMETHOD else [obj]
         )
         args = ", ".join(obj_args + [self.reg(arg) for arg in op_args])
         mtype = native_function_type_from_decl(method_decl, self.emitter)
@@ -665,8 +663,7 @@ def emit_method_call(self, dest: str, op_obj: Value, name: str, op_args: list[Va
                 and class_ir.is_method_final_among_compiled(name)
             )
             if use_guarded_direct:
-                lib = self.emitter.get_group_prefix(method.decl)
-                direct_call = f"{lib}{NATIVE_PREFIX}{method.cname(self.names)}({args})"
+                direct_call = f"{self.emitter.native_function_call(method_decl)}({args})"
                 self.emit_line(f"if (Py_TYPE({obj})->tp_flags & CPy_TPFLAGS_MYPYC_COMPILED) {{")
                 self.emit_line(f"{dest}{direct_call};")
                 self.emit_line("} else {")
diff --git a/mypyc/codegen/emitmodule.py b/mypyc/codegen/emitmodule.py
@@ -899,10 +899,10 @@ def generate_shared_lib_init(self, emitter: Emitter) -> None:
             )
             if self.context.group_deps:
                 emitter.emit_line(
-                    'static PyObject *_mypyc_fromlist = NULL; '
-                    'if (!_mypyc_fromlist) { '
+                    "static PyObject *_mypyc_fromlist = NULL; "
+                    "if (!_mypyc_fromlist) { "
                     '_mypyc_fromlist = Py_BuildValue("(s)", "*"); '
-                    'if (!_mypyc_fromlist) return -1; }'
+                    "if (!_mypyc_fromlist) return -1; }"
                 )
                 emitter.emit_line("PyObject *tmp;")
                 emitter.emit_line("PyObject *caps;")
@@ -920,7 +920,7 @@ def generate_shared_lib_init(self, emitter: Emitter) -> None:
                     'caps = PyObject_GetAttrString(tmp, "exports");',
                     "Py_DECREF(tmp);",
                     "if (!caps) return -1;",
-                    'struct export_table_{g} *pexports_{g} = '
+                    "struct export_table_{g} *pexports_{g} = "
                     '(struct export_table_{g} *)PyCapsule_GetPointer(caps, "{lib}.exports");'.format(
                         g=egroup, lib=shared_lib_name(group)
                     ),
diff --git a/mypyc/codegen/emitwrapper.py b/mypyc/codegen/emitwrapper.py
@@ -706,9 +706,7 @@ def generate_set_del_item_wrapper_inner(
     native_args = ", ".join(f"arg_{arg.name}" for arg in args)
     emitter.emit_line(
         "{}val = {}({});".format(
-            emitter.ctype_spaced(fn.ret_type),
-            emitter.native_function_call(fn.decl),
-            native_args,
+            emitter.ctype_spaced(fn.ret_type), emitter.native_function_call(fn.decl), native_args
         )
     )
     emitter.emit_error_check("val", fn.ret_type, "goto fail;")
@@ -946,9 +944,7 @@ def emit_call(self, not_implemented_handler: str = "") -> None:
         else:
             if not_implemented_handler and not isinstance(ret_type, RInstance):
                 # The return value type may overlap with NotImplemented.
-                emitter.emit_line(
-                    f"PyObject *retbox = {self.target_native_call}({native_args});"
-                )
+                emitter.emit_line(f"PyObject *retbox = {self.target_native_call}({native_args});")
                 emitter.emit_lines(
                     "if (retbox == Py_NotImplemented) {",
                     not_implemented_handler,
diff --git a/mypyc/irbuild/env_class.py b/mypyc/irbuild/env_class.py
@@ -76,7 +76,9 @@ def finalize_env_class(builder: IRBuilder, prefix: str = "") -> None:
     # environment class. Comprehension scopes have no arguments to add.
     if not builder.fn_info.is_comprehension_scope:
         if builder.fn_info.is_nested:
-            add_args_to_env(builder, local=False, base=builder.fn_info.callable_class, prefix=prefix)
+            add_args_to_env(
+                builder, local=False, base=builder.fn_info.callable_class, prefix=prefix
+            )
         else:
             add_args_to_env(builder, local=False, base=builder.fn_info, prefix=prefix)
 
@@ -101,7 +103,11 @@ def instantiate_env_class(builder: IRBuilder) -> Value:
         # Top-level functions and comprehension scopes store env reg directly.
         builder.fn_info._curr_env_reg = curr_env_reg
         # Comprehension scopes link to parent env if it exists.
-        if builder.fn_info.is_nested and builder.fn_infos[-2]._env_class is not None and builder.fn_infos[-2]._curr_env_reg is not None:
+        if (
+            builder.fn_info.is_nested
+            and builder.fn_infos[-2]._env_class is not None
+            and builder.fn_infos[-2]._curr_env_reg is not None
+        ):
             builder.add(
                 SetAttr(
                     curr_env_reg,
@@ -167,7 +173,9 @@ def load_outer_envs(builder: IRBuilder, base: ImplicitClass) -> None:
 
     # Load the first outer environment. This one is special because it gets saved in the
     # FuncInfo instance's prev_env_reg field.
-    if (index > 1 or (index == 1 and builder.fn_infos[1].contains_nested)) and builder.fn_infos[index]._env_class is not None:
+    if (index > 1 or (index == 1 and builder.fn_infos[1].contains_nested)) and builder.fn_infos[
+        index
+    ]._env_class is not None:
         # outer_env = builder.fn_infos[index].environment
         outer_env = builder.symtables[index]
         if isinstance(base, GeneratorClass):
@@ -234,7 +242,9 @@ def add_vars_to_env(builder: IRBuilder, prefix: str = "") -> None:
     env_for_func: FuncInfo | ImplicitClass = builder.fn_info
     if builder.fn_info.is_generator:
         env_for_func = builder.fn_info.generator_class
-    elif (builder.fn_info.is_nested or builder.fn_info.in_non_ext) and not builder.fn_info.is_comprehension_scope:
+    elif (
+        builder.fn_info.is_nested or builder.fn_info.in_non_ext
+    ) and not builder.fn_info.is_comprehension_scope:
         env_for_func = builder.fn_info.callable_class
 
     if builder.fn_info.fitem in builder.free_variables:
diff --git a/mypyc/irbuild/expression.py b/mypyc/irbuild/expression.py
@@ -206,9 +206,7 @@ def transform_name_expr(builder: IRBuilder, expr: NameExpr) -> Value:
             return builder.py_get_attr(builder.class_body_obj, expr.name, expr.line)
         else:
             return builder.primitive_op(
-                dict_get_item_op,
-                [builder.class_body_obj, builder.load_str(expr.name)],
-                expr.line,
+                dict_get_item_op, [builder.class_body_obj, builder.load_str(expr.name)], expr.line
             )
 
     return builder.load_global(expr)
@@ -1190,9 +1188,7 @@ def transform_dictionary_comprehension(builder: IRBuilder, o: DictionaryComprehe
         return builder.none()
 
     if o in builder.comp_to_fitem:
-        return _translate_comprehension_with_scope(
-            builder, o, lambda: _dict_comp_body(builder, o)
-        )
+        return _translate_comprehension_with_scope(builder, o, lambda: _dict_comp_body(builder, o))
     return _dict_comp_body(builder, o)
 
 
diff --git a/mypyc/irbuild/function.py b/mypyc/irbuild/function.py
@@ -848,12 +848,7 @@ def gen_glue_property(
 
 
 def gen_glue_property_setter(
-    builder: IRBuilder,
-    sig: FuncSignature,
-    target: FuncIR,
-    cls: ClassIR,
-    base: ClassIR,
-    line: int,
+    builder: IRBuilder, sig: FuncSignature, target: FuncIR, cls: ClassIR, base: ClassIR, line: int
 ) -> FuncIR:
     """Generate a shadow glue method for a property setter.
 
@@ -875,7 +870,7 @@ def gen_glue_property_setter(
 
     # Extract the property name from "__mypyc_setter__<name>"
     # mypyc encodes e.g. "_chunks" as "__mypyc_setter___3_chunks"
-    prop_name = target.name[len("__mypyc_setter__"):]
+    prop_name = target.name[len("__mypyc_setter__") :]
     # Decode mypyc's private name mangling: "_3_foo" -> "_foo", "_3foo" -> "_foo"
     if prop_name.startswith("_") and len(prop_name) > 1 and prop_name[1].isdigit():
         end_of_digits = 2
@@ -885,7 +880,11 @@ def gen_glue_property_setter(
 
     builder.primitive_op(
         py_setattr_op,
-        [self_arg, builder.load_str(prop_name), builder.coerce(value_arg, object_rprimitive, line)],
+        [
+            self_arg,
+            builder.load_str(prop_name),
+            builder.coerce(value_arg, object_rprimitive, line),
+        ],
         line,
     )
     # Return 1 (success). If py_setattr_op failed, the Python exception is set
diff --git a/mypyc/irbuild/prebuildvisitor.py b/mypyc/irbuild/prebuildvisitor.py
@@ -192,9 +192,7 @@ def visit_func(self, func: FuncItem) -> None:
         super().visit_func(func)
         self.funcs.pop()
 
-    def _visit_comprehension_with_scope(
-        self, o: GeneratorExpr | DictionaryComprehension
-    ) -> None:
+    def _visit_comprehension_with_scope(self, o: GeneratorExpr | DictionaryComprehension) -> None:
         """Visit a comprehension that contains lambdas.
 
         Creates a synthetic FuncDef to represent the comprehension's scope,
diff --git a/test_subclass_base.py b/test_subclass_base.py
@@ -1,11 +1,11 @@
 """Compiled base class."""
+
 from mypy_extensions import mypyc_attr
-from typing import Dict
 
 
 @mypyc_attr(allow_interpreted_subclasses=True)
 class Base:
-    MAPPING: Dict[str, int] = {"a": 1, "b": 2}
+    MAPPING: dict[str, int] = {"a": 1, "b": 2}
     FLAG: bool = False
 
     def lookup(self, key: str) -> int:
diff --git a/test_subclass_child.py b/test_subclass_child.py
@@ -1,4 +1,5 @@
 """Non-compiled child class — tests attribute override visibility."""
+
 from test_subclass_base import Base
 
 
@@ -17,7 +18,9 @@ def test() -> None:
     s = Sub()
     assert s.lookup("a") == 1
     result = s.lookup("c")
-    assert result == 3, f"Expected 3, got {result} — compiled method doesn't see subclass override!"
+    assert (
+        result == 3
+    ), f"Expected 3, got {result} — compiled method doesn't see subclass override!"
     assert s.check_flag(), "Expected True — compiled method doesn't see subclass override!"
     print("Sub OK — interpreted subclass overrides work!")
 
diff --git a/test_vtable_property.py b/test_vtable_property.py
@@ -4,13 +4,15 @@
 use fdef.name as key. This shifts all subsequent vtable entries, so
 methods after properties get called at wrong indices -> segfault.
 """
+
+from typing import Callable, Optional
+
 from mypy_extensions import mypyc_attr
-from typing import List, Optional, Callable
 
 
 class Core:
     def __init__(self) -> None:
-        self.chunks: List[List[int]] = [[1, 2], [3, 4]]
+        self.chunks: list[list[int]] = [[1, 2], [3, 4]]
         self.sql: str = ""
         self.counter: int = 0
 
@@ -29,11 +31,11 @@ def sql(self, value: str) -> None:
         self._core.sql = value
 
     @property
-    def _chunks(self) -> List[List[int]]:
+    def _chunks(self) -> list[list[int]]:
         return self._core.chunks
 
     @_chunks.setter
-    def _chunks(self, value: List[List[int]]) -> None:
+    def _chunks(self, value: list[list[int]]) -> None:
         self._core.chunks = value
 
     @property
@@ -45,16 +47,16 @@ def _counter(self, value: int) -> None:
         self._core.counter = value
 
     # Methods AFTER the properties — these will be at wrong vtable offsets
-    def parse(self, tokens: List[int], sql: str) -> List[int]:
+    def parse(self, tokens: list[int], sql: str) -> list[int]:
         return self._parse(tokens, sql)
 
-    def _parse(self, tokens: List[int], sql: str) -> List[int]:
+    def _parse(self, tokens: list[int], sql: str) -> list[int]:
         self.sql = sql
         self._chunks = [tokens]
         return self._parse_batch(lambda self: self._parse_item())
 
-    def _parse_batch(self, callback: Callable[["Base"], Optional[int]]) -> List[int]:
-        results: List[int] = []
+    def _parse_batch(self, callback: Callable[["Base"], Optional[int]]) -> list[int]:
+        results: list[int] = []
         for chunk in self._chunks:
             for item in chunk:
                 r = callback(self)
