retry

Author: youknowone

Lib/test/test_typing.py

@@ -6106,6 +6106,8 @@ class C(Generic[T]): pass
         self.assertIs(get_origin((*tuple[*Ts],)[0]), tuple)
         self.assertIs(get_origin(Unpack[Tuple[Unpack[Ts]]]), Unpack)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_get_args(self):
         T = TypeVar('T')
         class C(Generic[T]): pass

compiler/codegen/src/compile.rs

@@ -1212,6 +1212,7 @@ impl Compiler<'_> {
     /// Store each type parameter so it is accessible to the current scope, and leave a tuple of
     /// all the type parameters on the stack.
     fn compile_type_params(&mut self, type_params: &TypeParams) -> CompileResult<()> {
+        // First, compile each type parameter and store it
         for type_param in &type_params.type_params {
             match type_param {
                 TypeParam::TypeVar(TypeParamTypeVar { name, bound, .. }) => {
@@ -1664,8 +1665,12 @@ impl Compiler<'_> {
         let qualified_name = self.qualified_path.join(".");
 
         // If there are type params, we need to push a special symbol table just for them
-        if type_params.is_some() {
+        if let Some(type_params) = type_params {
             self.push_symbol_table();
+            // Compile type parameters and store as .type_params
+            self.compile_type_params(type_params)?;
+            let dot_type_params = self.name(".type_params");
+            emit!(self, Instruction::StoreLocal(dot_type_params));
         }
 
         self.push_output(bytecode::CodeFlags::empty(), 0, 0, 0, name.to_owned());
@@ -1688,6 +1693,18 @@ impl Compiler<'_> {
         if Self::find_ann(body) {
             emit!(self, Instruction::SetupAnnotation);
         }
+
+        // Set __type_params__ from .type_params if we have type parameters (PEP 695)
+        if type_params.is_some() {
+            // Load .type_params from enclosing scope
+            let dot_type_params = self.name(".type_params");
+            emit!(self, Instruction::LoadNameAny(dot_type_params));
+
+            // Store as __type_params__
+            let dunder_type_params = self.name("__type_params__");
+            emit!(self, Instruction::StoreLocal(dunder_type_params));
+        }
+
         self.compile_statements(body)?;
 
         let classcell_idx = self
@@ -1721,8 +1738,10 @@ impl Compiler<'_> {
         let mut func_flags = bytecode::MakeFunctionFlags::empty();
 
         // Prepare generic type parameters:
-        if let Some(type_params) = type_params {
-            self.compile_type_params(type_params)?;
+        if type_params.is_some() {
+            // Load .type_params from the type params scope
+            let dot_type_params = self.name(".type_params");
+            emit!(self, Instruction::LoadNameAny(dot_type_params));
             func_flags |= bytecode::MakeFunctionFlags::TYPE_PARAMS;
         }
 

compiler/codegen/src/symboltable.rs

@@ -1267,6 +1267,7 @@ impl SymbolTableBuilder<'_> {
     }
 
     fn scan_type_params(&mut self, type_params: &TypeParams) -> SymbolTableResult {
+        // First register all type parameters
         for type_param in &type_params.type_params {
             match type_param {
                 TypeParam::TypeVar(TypeParamTypeVar {

vm/src/stdlib/builtins.rs

@@ -932,6 +932,23 @@ mod builtins {
             ))
         })?;
 
+        // For PEP 695 classes, set .type_params in namespace before calling the function
+        if let Ok(type_params) = function
+            .as_object()
+            .get_attr(identifier!(vm, __type_params__), vm)
+        {
+            if let Some(type_params_tuple) = type_params.downcast_ref::<PyTuple>() {
+                if !type_params_tuple.is_empty() {
+                    // Set .type_params in namespace so the compiler-generated code can use it
+                    namespace.as_object().set_item(
+                        vm.ctx.intern_str(".type_params"),
+                        type_params,
+                        vm,
+                    )?;
+                }
+            }
+        }
+
         let classcell = function.invoke_with_locals(().into(), Some(namespace.clone()), vm)?;
         let classcell = <Option<PyCellRef>>::try_from_object(vm, classcell)?;
 
@@ -943,48 +960,23 @@ mod builtins {
             )?;
         }
 
-        // Check if we need to set __parameters__ for PEP 695 classes
-        let function_obj: PyObjectRef = function.clone().into();
-        let has_type_params =
-            if let Ok(type_params) = function_obj.get_attr(identifier!(vm, __type_params__), vm) {
-                if let Ok(type_params_tuple) = type_params.downcast::<PyTuple>() {
-                    !type_params_tuple.is_empty()
-                } else {
-                    false
-                }
-            } else {
-                false
-            };
-
-        let needs_parameters = if has_type_params {
-            if let Ok(bases_tuple) = bases.clone().downcast::<PyTuple>() {
-                bases_tuple.iter().any(|base| {
-                    if let Ok(base_name) = base.get_attr(identifier!(vm, __name__), vm) {
-                        if let Ok(name_str) = base_name.downcast::<PyStr>() {
-                            let name = name_str.as_str();
-                            return name == "Protocol" || name == "Generic";
-                        }
-                    }
-                    false
-                })
-            } else {
-                false
-            }
-        } else {
-            false
-        };
+        // Remove .type_params from namespace before creating the class
+        namespace
+            .as_object()
+            .del_item(vm.ctx.intern_str(".type_params"), vm)
+            .ok();
 
         let args = FuncArgs::new(vec![name_obj.into(), bases, namespace.into()], kwargs);
         let class = metaclass.call(args, vm)?;
 
-        // Set __type_params__ on the class if the function has type params
-        if has_type_params {
-            if let Ok(type_params) = function_obj.get_attr(identifier!(vm, __type_params__), vm) {
-                class.set_attr(identifier!(vm, __type_params__), type_params.clone(), vm)?;
-
-                if needs_parameters {
-                    // Set __parameters__ to the same value as __type_params__
-                    class.set_attr(identifier!(vm, __parameters__), type_params, vm)?;
+        // For PEP 695 classes, set __type_params__ on the class from the function
+        if let Ok(type_params) = function
+            .as_object()
+            .get_attr(identifier!(vm, __type_params__), vm)
+        {
+            if let Some(type_params_tuple) = type_params.downcast_ref::<PyTuple>() {
+                if !type_params_tuple.is_empty() {
+                    class.set_attr(identifier!(vm, __type_params__), type_params, vm)?;
                 }
             }
         }