Compile starred annotations (RustPython#5881)

* Fix starred annotation

* uncomment starred annotation

Author: youknowone

Lib/test/test_typing.py

@@ -80,6 +80,7 @@ struct Compiler<'src> {
     ctx: CompileContext,
     class_name: Option<String>,
     opts: CompileOpts,
+    in_annotation: bool,
 }
 
 enum DoneWithFuture {
@@ -335,6 +336,7 @@ impl<'src> Compiler<'src> {
             },
             class_name: None,
             opts,
+            in_annotation: false,
         }
     }
 }
@@ -2897,7 +2899,11 @@ impl Compiler<'_> {
                     .into(),
             });
         } else {
-            self.compile_expression(annotation)?;
+            let was_in_annotation = self.in_annotation;
+            self.in_annotation = true;
+            let result = self.compile_expression(annotation);
+            self.in_annotation = was_in_annotation;
+            result?;
         }
         Ok(())
     }
@@ -3504,8 +3510,15 @@ impl Compiler<'_> {
                     Self::contains_await(elt),
                 )?;
             }
-            Expr::Starred(_) => {
-                return Err(self.error(CodegenErrorType::InvalidStarExpr));
+            Expr::Starred(ExprStarred { value, .. }) => {
+                if self.in_annotation {
+                    // In annotation context, starred expressions are allowed (PEP 646)
+                    // For now, just compile the inner value without wrapping with Unpack
+                    // This is a temporary solution until we figure out how to properly import typing
+                    self.compile_expression(value)?;
+                } else {
+                    return Err(self.error(CodegenErrorType::InvalidStarExpr));
+                }
             }
             Expr::If(ExprIf {
                 test, body, orelse, ..

compiler/codegen/src/compile.rs

@@ -69,7 +69,7 @@ impl PyAsyncGen {
 
     #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::new(cls, args, vm)
+        PyGenericAlias::from_args(cls, args, vm)
     }
 }
 

vm/src/builtins/asyncgenerator.rs

@@ -322,7 +322,7 @@ impl PyDict {
 
     #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::new(cls, args, vm)
+        PyGenericAlias::from_args(cls, args, vm)
     }
 }
 

vm/src/builtins/dict.rs

@@ -57,7 +57,7 @@ impl Constructor for PyEnumerate {
 impl PyEnumerate {
     #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::new(cls, args, vm)
+        PyGenericAlias::from_args(cls, args, vm)
     }
 }
 

vm/src/builtins/enumerate.rs

@@ -63,7 +63,12 @@ impl Constructor for PyGenericAlias {
             return Err(vm.new_type_error("GenericAlias() takes no keyword arguments"));
         }
         let (origin, arguments): (_, PyObjectRef) = args.bind(vm)?;
-        PyGenericAlias::new(origin, arguments, vm)
+        let args = if let Ok(tuple) = arguments.try_to_ref::<PyTuple>(vm) {
+            tuple.to_owned()
+        } else {
+            PyTuple::new_ref(vec![arguments], &vm.ctx)
+        };
+        PyGenericAlias::new(origin, args, false, vm)
             .into_ref_with_type(vm, cls)
             .map(Into::into)
     }
@@ -84,35 +89,24 @@ impl Constructor for PyGenericAlias {
     flags(BASETYPE)
 )]
 impl PyGenericAlias {
-    pub fn new(origin: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> Self {
-        let args = if let Ok(tuple) = args.try_to_ref::<PyTuple>(vm) {
-            tuple.to_owned()
-        } else {
-            PyTuple::new_ref(vec![args], &vm.ctx)
-        };
-
+    pub fn new(origin: PyTypeRef, args: PyTupleRef, starred: bool, vm: &VirtualMachine) -> Self {
         let parameters = make_parameters(&args, vm);
         Self {
             origin,
             args,
             parameters,
-            starred: false, // default to false
+            starred,
         }
     }
 
-    fn with_tuple_args(
-        origin: PyTypeRef,
-        args: PyTupleRef,
-        starred: bool,
-        vm: &VirtualMachine,
-    ) -> Self {
-        let parameters = make_parameters(&args, vm);
-        Self {
-            origin,
-            args,
-            parameters,
-            starred,
-        }
+    /// Create a GenericAlias from an origin and PyObjectRef arguments (helper for compatibility)
+    pub fn from_args(origin: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> Self {
+        let args = if let Ok(tuple) = args.try_to_ref::<PyTuple>(vm) {
+            tuple.to_owned()
+        } else {
+            PyTuple::new_ref(vec![args], &vm.ctx)
+        };
+        Self::new(origin, args, false, vm)
     }
 
     fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
@@ -146,7 +140,7 @@ impl PyGenericAlias {
             }
         }
 
-        Ok(format!(
+        let repr_str = format!(
             "{}[{}]",
             repr_item(self.origin.clone().into(), vm)?,
             if self.args.is_empty() {
@@ -158,7 +152,14 @@ impl PyGenericAlias {
                     .collect::<PyResult<Vec<_>>>()?
                     .join(", ")
             }
-        ))
+        );
+
+        // Add * prefix if this is a starred GenericAlias
+        Ok(if self.starred {
+            format!("*{repr_str}")
+        } else {
+            repr_str
+        })
     }
 
     #[pygetset]
@@ -200,10 +201,7 @@ impl PyGenericAlias {
             vm,
         )?;
 
-        Ok(
-            PyGenericAlias::new(zelf.origin.clone(), new_args.to_pyobject(vm), vm)
-                .into_pyobject(vm),
-        )
+        Ok(PyGenericAlias::new(zelf.origin.clone(), new_args, false, vm).into_pyobject(vm))
     }
 
     #[pymethod]
@@ -598,7 +596,7 @@ impl Iterable for PyGenericAlias {
         // CPython's ga_iter creates an iterator that yields one starred GenericAlias
         // we don't have gaiterobject yet
 
-        let starred_alias = PyGenericAlias::with_tuple_args(
+        let starred_alias = PyGenericAlias::new(
             zelf.origin.clone(),
             zelf.args.clone(),
             true, // starred

vm/src/builtins/genericalias.rs

@@ -337,7 +337,7 @@ impl PyList {
 
     #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::new(cls, args, vm)
+        PyGenericAlias::from_args(cls, args, vm)
     }
 }
 

vm/src/builtins/list.rs

@@ -176,7 +176,7 @@ impl PyMappingProxy {
 
     #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::new(cls, args, vm)
+        PyGenericAlias::from_args(cls, args, vm)
     }
 
     #[pymethod]

vm/src/builtins/mappingproxy.rs

@@ -790,7 +790,7 @@ impl PySet {
 
     #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::new(cls, args, vm)
+        PyGenericAlias::from_args(cls, args, vm)
     }
 }
 
@@ -1134,7 +1134,7 @@ impl PyFrozenSet {
 
     #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::new(cls, args, vm)
+        PyGenericAlias::from_args(cls, args, vm)
     }
 }
 

vm/src/builtins/set.rs

@@ -343,7 +343,7 @@ impl PyTuple {
 
     #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::new(cls, args, vm)
+        PyGenericAlias::from_args(cls, args, vm)
     }
 }