Also support non-native classes

Author: JukkaL

mypyc/irbuild/builder.py

@@ -424,6 +424,10 @@ def new_tuple(self, items: list[Value], line: int) -> Value:
     def debug_print(self, toprint: str | Value) -> None:
         return self.builder.debug_print(toprint)
 
+    def set_immortal_if_free_threaded(self, v: Value, line: int) -> None:
+        """Make an object immortal on free-threaded builds (to avoid contention)."""
+        self.builder.set_immortal_if_free_threaded(v, line)
+
     # Helpers for IR building
 
     def add_to_non_ext_dict(
@@ -433,6 +437,10 @@ def add_to_non_ext_dict(
         key_unicode = self.load_str(key)
         self.primitive_op(dict_set_item_op, [non_ext.dict, key_unicode, val], line)
 
+        # It's important that accessing class dictionary items from multiple threads
+        # doesn't cause contention.
+        self.builder.set_immortal_if_free_threaded(val, line)
+
     def gen_import(self, id: str, line: int) -> None:
         self.imports[id] = None
 

mypyc/irbuild/classdef.py

@@ -4,7 +4,6 @@
 
 from abc import abstractmethod
 from typing import Callable, Final
-import sys
 
 from mypy.nodes import (
     EXCLUDED_ENUM_ATTRIBUTES,
@@ -29,7 +28,7 @@
     is_class_var,
 )
 from mypy.types import Instance, UnboundType, get_proper_type
-from mypyc.common import PROPSET_PREFIX, IS_FREE_THREADED
+from mypyc.common import PROPSET_PREFIX
 from mypyc.ir.class_ir import ClassIR, NonExtClassInfo
 from mypyc.ir.func_ir import FuncDecl, FuncSignature
 from mypyc.ir.ops import (
@@ -82,7 +81,6 @@
     py_calc_meta_op,
     pytype_from_template_op,
     type_object_op,
-    set_immortal_op,
 )
 from mypyc.subtype import is_subtype
 
@@ -264,6 +262,9 @@ def finalize(self, ir: ClassIR) -> None:
         non_ext_class = load_non_ext_class(self.builder, ir, self.non_ext, self.cdef.line)
         non_ext_class = load_decorated_class(self.builder, self.cdef, non_ext_class)
 
+        # Try to avoid contention when using free threading.
+        self.builder.set_immortal_if_free_threaded(non_ext_class, self.cdef.line)
+
         # Save the decorated class
         self.builder.add(
             InitStatic(non_ext_class, self.cdef.name, self.builder.module_name, NAMESPACE_TYPE)
@@ -451,10 +452,11 @@ def allocate_class(builder: IRBuilder, cdef: ClassDef) -> Value:
     )
     # Create the class
     tp = builder.call_c(pytype_from_template_op, [template, tp_bases, modname], cdef.line)
-    if IS_FREE_THREADED and sys.version_info >= (3, 14):
-        # Set type object to be immortal, as otherwise reference count contention
-        # can cause a massive performance hit in the worst case.
-        builder.call_c(set_immortal_op, [tp], cdef.line)
+
+    # Set type object to be immortal if free threaded, as otherwise reference count contention
+    # can cause a big performance hit.
+    builder.set_immortal_if_free_threaded(tp, cdef.line)
+
     # Immediately fix up the trait vtables, before doing anything with the class.
     ir = builder.mapper.type_to_ir[cdef.info]
     if not ir.is_trait and not ir.builtin_base:

mypyc/irbuild/ll_builder.py

@@ -6,6 +6,7 @@
 
 from __future__ import annotations
 
+import sys
 from collections.abc import Sequence
 from typing import Callable, Final, Optional
 
@@ -16,6 +17,7 @@
 from mypyc.common import (
     BITMAP_BITS,
     FAST_ISINSTANCE_MAX_SUBCLASSES,
+    IS_FREE_THREADED,
     MAX_LITERAL_SHORT_INT,
     MAX_SHORT_INT,
     MIN_LITERAL_SHORT_INT,
@@ -164,6 +166,7 @@
     fast_isinstance_op,
     none_object_op,
     not_implemented_op,
+    set_immortal_op,
     var_object_size,
 )
 from mypyc.primitives.registry import (
@@ -2322,6 +2325,11 @@ def new_tuple_with_length(self, length: Value, line: int) -> Value:
     def int_to_float(self, n: Value, line: int) -> Value:
         return self.primitive_op(int_to_float_op, [n], line)
 
+    def set_immortal_if_free_threaded(self, v: Value, line: int) -> None:
+        """Make an object immortal on free-threaded builds (to avoid contention)."""
+        if IS_FREE_THREADED and sys.version_info >= (3, 14):
+            self.call_c(set_immortal_op, [v], line)
+
     # Internal helpers
 
     def decompose_union_helper(