Fix typing, typevar, genericalias, and symboltable

youknowone · youknowone · commit 2ea604aa8d52 · 2026-02-13T18:09:12.000+09:00
- TypeVar/ParamSpec repr: use infer_variance flag
- ParamSpec: add type_check on bound argument
- ParamSpecArgs/Kwargs: use equality instead of identity
- NoDefault: change to IMMUTABLETYPE flag
- subscript_generic: wrap TypeVarTuple in Unpack
- symboltable: selective name mangling in type param scopes
- symboltable: fix double default scanning for non-generic fns
- Unmark 4 passing tests in test_type_params
diff --git a/Lib/test/test_concurrent_futures/test_process_pool.py b/Lib/test/test_concurrent_futures/test_process_pool.py
@@ -85,7 +85,7 @@ def test_traceback(self):
         self.assertIn('raise RuntimeError(123) # some comment',
                       f1.getvalue())
 
-    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky EOFError')
+    @unittest.skip('TODO: RUSTPYTHON flaky EOFError')
     @hashlib_helper.requires_hashdigest('md5')
     def test_ressources_gced_in_workers(self):
         # Ensure that argument for a job are correctly gc-ed after the job
diff --git a/Lib/test/test_type_params.py b/Lib/test/test_type_params.py
@@ -243,7 +243,6 @@ def func[A, B](a: dict[A, B]):
         A, B = func.__type_params__
         self.assertEqual(func.__annotations__["a"], dict[A, B])
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; SyntaxError: the symbol 'list' must be present in the symbol table
     def test_function_access_02(self):
         code = """
             def func[A](a = list[A]()):
@@ -866,7 +865,6 @@ class Inner[T]:
         self.assertEqual(Outer.Inner._Inner__x, "inner")
         self.assertEqual(Outer._Outer__after, "after")
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; NameError: name '_Derived__Base' is not defined
     def test_no_mangling_in_bases(self):
         ns = run_code("""
             class __Base:
@@ -880,7 +878,6 @@ class Derived[T](__Base, __kwarg=1):
         self.assertEqual(Derived.__bases__, (ns["__Base"], Generic))
         self.assertEqual(Derived.kwargs, {"__kwarg": 1})
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; SyntaxError: the symbol '_Y__X' must be present in the symbol table
     def test_no_mangling_in_nested_scopes(self):
         ns = run_code("""
             from test.test_type_params import make_base
@@ -911,7 +908,6 @@ class Y[T: __X](
         base3 = Y.__bases__[3]
         self.assertEqual(list(base3.__arg__), [ns["__X"]])
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; SyntaxError: the symbol '_Foo__T' must be present in the symbol table
     def test_type_params_are_mangled(self):
         ns = run_code("""
             from test.test_type_params import make_base
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -1852,7 +1852,8 @@ impl Compiler {
             .code_stack
             .last()
             .and_then(|info| info.private.as_deref());
-        symboltable::mangle_name(private, name)
+        let mangled_names = self.current_symbol_table().mangled_names.as_ref();
+        symboltable::maybe_mangle_name(private, mangled_names, name)
     }
 
     // = compiler_nameop
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
@@ -68,6 +68,11 @@ pub struct SymbolTable {
 
     /// Whether `from __future__ import annotations` is active
     pub future_annotations: bool,
+
+    /// Names of type parameters that should still be mangled in type param scopes.
+    /// When Some, only names in this set are mangled; other names are left unmangled.
+    /// Set on type param blocks for generic classes; inherited by non-class child scopes.
+    pub mangled_names: Option<IndexSet<String>>,
 }
 
 impl SymbolTable {
@@ -88,6 +93,7 @@ impl SymbolTable {
             annotation_block: None,
             has_conditional_annotations: false,
             future_annotations: false,
+            mangled_names: None,
         }
     }
 
@@ -905,14 +911,26 @@ impl SymbolTableBuilder {
                     )
             })
             .unwrap_or(false);
-        let table = SymbolTable::new(name.to_owned(), typ, line_number, is_nested);
+        // Inherit mangled_names from parent for non-class scopes
+        let inherited_mangled_names = self
+            .tables
+            .last()
+            .and_then(|t| t.mangled_names.clone())
+            .filter(|_| typ != CompilerScope::Class);
+        let mut table = SymbolTable::new(name.to_owned(), typ, line_number, is_nested);
+        table.mangled_names = inherited_mangled_names;
         self.tables.push(table);
         // Save parent's varnames and start fresh for the new scope
         self.varnames_stack
             .push(core::mem::take(&mut self.current_varnames));
     }
 
-    fn enter_type_param_block(&mut self, name: &str, line_number: u32) -> SymbolTableResult {
+    fn enter_type_param_block(
+        &mut self,
+        name: &str,
+        line_number: u32,
+        for_class: bool,
+    ) -> SymbolTableResult {
         // Check if we're in a class scope
         let in_class = self
             .tables
@@ -921,16 +939,21 @@ impl SymbolTableBuilder {
 
         self.enter_scope(name, CompilerScope::TypeParams, line_number);
 
-        // If we're in a class, mark that this type param scope can see the class scope
+        // Set properties on the newly created type param scope
         if let Some(table) = self.tables.last_mut() {
             table.can_see_class_scope = in_class;
-
-            // Add __classdict__ as a USE symbol in type param scope if in class
-            if in_class {
-                self.register_name("__classdict__", SymbolUsage::Used, TextRange::default())?;
+            // For generic classes, create mangled_names set so that only
+            // type parameter names get mangled (not bases or other expressions)
+            if for_class {
+                table.mangled_names = Some(IndexSet::default());
             }
         }
 
+        // Add __classdict__ as a USE symbol in type param scope if in class
+        if in_class {
+            self.register_name("__classdict__", SymbolUsage::Used, TextRange::default())?;
+        }
+
         // Register .type_params as a SET symbol (it will be converted to cell variable later)
         self.register_name(".type_params", SymbolUsage::Assigned, TextRange::default())?;
 
@@ -1202,12 +1225,20 @@ impl SymbolTableBuilder {
                     None
                 };
 
+                // For generic functions, scan defaults before entering type_param_block
+                // (defaults are evaluated in the enclosing scope, not the type param scope)
+                let has_type_params = type_params.is_some();
+                if has_type_params {
+                    self.scan_parameter_defaults(parameters)?;
+                }
+
                 // For generic functions, enter type_param block FIRST so that
                 // annotation scopes are nested inside and can see type parameters.
                 if let Some(type_params) = type_params {
                     self.enter_type_param_block(
                         &format!("<generic parameters of {}>", name.as_str()),
                         self.line_index_start(type_params.range),
+                        false,
                     )?;
                     self.scan_type_params(type_params)?;
                 }
@@ -1223,6 +1254,7 @@ impl SymbolTableBuilder {
                     self.line_index_start(*range),
                     has_return_annotation,
                     *is_async,
+                    has_type_params, // skip_defaults: already scanned above
                 )?;
                 self.scan_statements(body)?;
                 self.leave_scope();
@@ -1244,11 +1276,16 @@ impl SymbolTableBuilder {
                 range,
                 node_index: _,
             }) => {
+                // Save class_name for the entire ClassDef processing
+                let prev_class = self.class_name.take();
                 if let Some(type_params) = type_params {
                     self.enter_type_param_block(
                         &format!("<generic parameters of {}>", name.as_str()),
                         self.line_index_start(type_params.range),
+                        true, // for_class: enable selective mangling
                     )?;
+                    // Set class_name for mangling in type param scope
+                    self.class_name = Some(name.to_string());
                     self.scan_type_params(type_params)?;
                 }
                 self.enter_scope(
@@ -1257,18 +1294,19 @@ impl SymbolTableBuilder {
                     self.line_index_start(*range),
                 );
                 // Reset in_conditional_block for new class scope
-                // (each scope has its own conditional context)
                 let saved_in_conditional = self.in_conditional_block;
                 self.in_conditional_block = false;
-                let prev_class = self.class_name.replace(name.to_string());
+                // Set class_name for mangling in class body
+                self.class_name = Some(name.to_string());
                 self.register_name("__module__", SymbolUsage::Assigned, *range)?;
                 self.register_name("__qualname__", SymbolUsage::Assigned, *range)?;
                 self.register_name("__doc__", SymbolUsage::Assigned, *range)?;
                 self.register_name("__class__", SymbolUsage::Assigned, *range)?;
                 self.scan_statements(body)?;
                 self.leave_scope();
                 self.in_conditional_block = saved_in_conditional;
-                self.class_name = prev_class;
+                // Bases/keywords are scanned in type_param scope (if generic)
+                // class_name is still set, so mangling works via mangled_names filtering
                 if let Some(arguments) = arguments {
                     self.scan_expressions(&arguments.args, ExpressionContext::Load)?;
                     for keyword in &arguments.keywords {
@@ -1278,6 +1316,8 @@ impl SymbolTableBuilder {
                 if type_params.is_some() {
                     self.leave_scope();
                 }
+                // Restore class_name after all ClassDef processing
+                self.class_name = prev_class;
                 self.scan_decorators(decorator_list, ExpressionContext::Load)?;
                 self.register_ident(name, SymbolUsage::Assigned)?;
             }
@@ -1506,6 +1546,7 @@ impl SymbolTableBuilder {
                     self.enter_type_param_block(
                         "TypeAlias",
                         self.line_index_start(type_params.range),
+                        false,
                     )?;
                     self.scan_type_params(type_params)?;
                 }
@@ -1833,6 +1874,7 @@ impl SymbolTableBuilder {
                         self.line_index_start(expression.range()),
                         false, // lambdas have no return annotation
                         false, // lambdas are never async
+                        false, // don't skip defaults
                     )?;
                 } else {
                     self.enter_scope(
@@ -2233,23 +2275,32 @@ impl SymbolTableBuilder {
         Ok(())
     }
 
+    /// Scan default parameter values (evaluated in the enclosing scope)
+    fn scan_parameter_defaults(&mut self, parameters: &ast::Parameters) -> SymbolTableResult {
+        for default in parameters
+            .posonlyargs
+            .iter()
+            .chain(parameters.args.iter())
+            .chain(parameters.kwonlyargs.iter())
+            .filter_map(|arg| arg.default.as_ref())
+        {
+            self.scan_expression(default, ExpressionContext::Load)?;
+        }
+        Ok(())
+    }
+
     fn enter_scope_with_parameters(
         &mut self,
         name: &str,
         parameters: &ast::Parameters,
         line_number: u32,
         has_return_annotation: bool,
         is_async: bool,
+        skip_defaults: bool,
     ) -> SymbolTableResult {
-        // Evaluate eventual default parameters:
-        for default in parameters
-            .posonlyargs
-            .iter()
-            .chain(parameters.args.iter())
-            .chain(parameters.kwonlyargs.iter())
-            .filter_map(|arg| arg.default.as_ref())
-        {
-            self.scan_expression(default, ExpressionContext::Load)?; // not ExprContext?
+        // Evaluate eventual default parameters (unless already scanned before type_param_block):
+        if !skip_defaults {
+            self.scan_parameter_defaults(parameters)?;
         }
 
         // Annotations are scanned in outer scope:
@@ -2381,7 +2432,18 @@ impl SymbolTableBuilder {
         let scope_depth = self.tables.len();
         let table = self.tables.last_mut().unwrap();
 
-        let name = mangle_name(self.class_name.as_deref(), name);
+        // Add type param names to mangled_names set for selective mangling
+        if matches!(role, SymbolUsage::TypeParam)
+            && let Some(ref mut set) = table.mangled_names
+        {
+            set.insert(name.to_owned());
+        }
+
+        let name = maybe_mangle_name(
+            self.class_name.as_deref(),
+            table.mangled_names.as_ref(),
+            name,
+        );
         // Some checks for the symbol that present on this scope level:
         let symbol = if let Some(symbol) = table.symbols.get_mut(name.as_ref()) {
             let flags = &symbol.flags;
@@ -2582,3 +2644,19 @@ pub(crate) fn mangle_name<'a>(class_name: Option<&str>, name: &'a str) -> Cow<'a
     ret.push_str(name);
     ret.into()
 }
+
+/// Selective mangling for type parameter scopes around generic classes.
+/// If `mangled_names` is Some, only mangle names that are in the set;
+/// other names are left unmangled.
+pub(crate) fn maybe_mangle_name<'a>(
+    class_name: Option<&str>,
+    mangled_names: Option<&IndexSet<String>>,
+    name: &'a str,
+) -> Cow<'a, str> {
+    if let Some(set) = mangled_names
+        && !set.contains(name)
+    {
+        return name.into();
+    }
+    mangle_name(class_name, name)
+}
diff --git a/crates/vm/src/builtins/genericalias.rs b/crates/vm/src/builtins/genericalias.rs
@@ -720,24 +720,51 @@ impl crate::types::IterNext for PyGenericAliasIterator {
     }
 }
 
-/// Creates a GenericAlias from type parameters, equivalent to CPython's _Py_subscript_generic
-/// This is used for PEP 695 classes to create Generic[T] from type parameters
+/// Creates a GenericAlias from type parameters, equivalent to _Py_subscript_generic.
+/// This is used for PEP 695 classes to create Generic[T] from type parameters.
 // _Py_subscript_generic
 pub fn subscript_generic(type_params: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-    // Get typing module and _GenericAlias
     let typing_module = vm.import("typing", 0)?;
     let generic_type = typing_module.get_attr("Generic", vm)?;
-
-    // Call typing._GenericAlias(Generic, type_params)
     let generic_alias_class = typing_module.get_attr("_GenericAlias", vm)?;
 
-    let args = if let Ok(tuple) = type_params.try_to_ref::<PyTuple>(vm) {
+    let params = if let Ok(tuple) = type_params.try_to_ref::<PyTuple>(vm) {
         tuple.to_owned()
     } else {
         PyTuple::new_ref(vec![type_params], &vm.ctx)
     };
 
-    // Create _GenericAlias instance
+    // Unpack TypeVarTuples: wrap each TypeVarTuple in Unpack[...]
+    let mut new_args = Vec::with_capacity(params.len());
+    let mut needs_unpack = false;
+    for param in params.iter() {
+        if param
+            .downcast_ref::<crate::stdlib::typing::TypeVarTuple>()
+            .is_some()
+        {
+            needs_unpack = true;
+            break;
+        }
+    }
+
+    let args = if needs_unpack {
+        let unpack_cls = typing_module.get_attr("Unpack", vm)?;
+        for param in params.iter() {
+            if param
+                .downcast_ref::<crate::stdlib::typing::TypeVarTuple>()
+                .is_some()
+            {
+                let unpacked = vm.call_method(&unpack_cls, "__getitem__", (param.clone(),))?;
+                new_args.push(unpacked);
+            } else {
+                new_args.push(param.clone());
+            }
+        }
+        PyTuple::new_ref(new_args, &vm.ctx)
+    } else {
+        params
+    };
+
     generic_alias_class.call((generic_type, args.to_pyobject(vm)), vm)
 }
 
diff --git a/crates/vm/src/stdlib/typevar.rs b/crates/vm/src/stdlib/typevar.rs
diff --git a/crates/vm/src/stdlib/typing.rs b/crates/vm/src/stdlib/typing.rs

Original file line number	Diff line number	Diff line change
`@@ -1852,7 +1852,8 @@ impl Compiler {`
`1852`	`1852`	`.code_stack`
`1853`	`1853`	`.last()`
`1854`	`1854`	`.and_then(\|info\| info.private.as_deref());`
`1855`		`- symboltable::mangle_name(private, name)`
	`1855`	`+ let mangled_names = self.current_symbol_table().mangled_names.as_ref();`
	`1856`	`+ symboltable::maybe_mangle_name(private, mangled_names, name)`
`1856`	`1857`	`}`
`1857`	`1858`
`1858`	`1859`	`// = compiler_nameop`