Implement vm logics related with ParamSpec, TypeVarTuple

moreal · youknowone · commit dfe23f207f2c · 2025-02-10T15:55:47.000+09:00
diff --git a/compiler/codegen/src/compile.rs b/compiler/codegen/src/compile.rs
@@ -1095,8 +1095,27 @@ impl Compiler {
                         self.store_name(name.as_ref())?;
                     }
                 }
-                located_ast::TypeParam::ParamSpec(_) => todo!(),
-                located_ast::TypeParam::TypeVarTuple(_) => todo!(),
+                located_ast::TypeParam::ParamSpec(located_ast::TypeParamParamSpec {
+                    name, ..
+                }) => {
+                    self.emit_load_const(ConstantData::Str {
+                        value: name.to_string(),
+                    });
+                    emit!(self, Instruction::ParamSpec);
+                    emit!(self, Instruction::Duplicate);
+                    self.store_name(name.as_ref())?;
+                }
+                located_ast::TypeParam::TypeVarTuple(located_ast::TypeParamTypeVarTuple {
+                    name,
+                    ..
+                }) => {
+                    self.emit_load_const(ConstantData::Str {
+                        value: name.to_string(),
+                    });
+                    emit!(self, Instruction::TypeVarTuple);
+                    emit!(self, Instruction::Duplicate);
+                    self.store_name(name.as_ref())?;
+                }
             };
         }
         emit!(
diff --git a/compiler/codegen/src/symboltable.rs b/compiler/codegen/src/symboltable.rs
@@ -1257,8 +1257,18 @@ impl SymbolTableBuilder {
                         self.scan_expression(binding, ExpressionContext::Load)?;
                     }
                 }
-                ast::located::TypeParam::ParamSpec(_) => todo!(),
-                ast::located::TypeParam::TypeVarTuple(_) => todo!(),
+                ast::located::TypeParam::ParamSpec(ast::TypeParamParamSpec {
+                    name,
+                    range: param_spec_range,
+                }) => {
+                    self.register_name(name, SymbolUsage::Assigned, param_spec_range.start)?;
+                }
+                ast::located::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple {
+                    name,
+                    range: type_var_tuple_range,
+                }) => {
+                    self.register_name(name, SymbolUsage::Assigned, type_var_tuple_range.start)?;
+                }
             }
         }
         Ok(())
diff --git a/compiler/core/src/bytecode.rs b/compiler/core/src/bytecode.rs
@@ -595,10 +595,12 @@ pub enum Instruction {
     TypeVarWithBound,
     TypeVarWithConstraint,
     TypeAlias,
+    TypeVarTuple,
+    ParamSpec,
     // If you add a new instruction here, be sure to keep LAST_INSTRUCTION updated
 }
 // This must be kept up to date to avoid marshaling errors
-const LAST_INSTRUCTION: Instruction = Instruction::TypeAlias;
+const LAST_INSTRUCTION: Instruction = Instruction::ParamSpec;
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
 
 impl From<Instruction> for u8 {
@@ -1291,6 +1293,8 @@ impl Instruction {
             TypeVarWithBound => -1,
             TypeVarWithConstraint => -1,
             TypeAlias => -2,
+            ParamSpec => 0,
+            TypeVarTuple => 0,
         }
     }
 
@@ -1460,6 +1464,8 @@ impl Instruction {
             TypeVarWithBound => w!(TypeVarWithBound),
             TypeVarWithConstraint => w!(TypeVarWithConstraint),
             TypeAlias => w!(TypeAlias),
+            ParamSpec => w!(ParamSpec),
+            TypeVarTuple => w!(TypeVarTuple),
         }
     }
 }
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -1202,6 +1202,23 @@ impl ExecutingFrame<'_> {
                 self.push_value(type_alias.into_ref(&vm.ctx).into());
                 Ok(None)
             }
+            bytecode::Instruction::ParamSpec => {
+                let param_spec_name = self.pop_value();
+                let param_spec: PyObjectRef = _typing::make_paramspec(param_spec_name.clone())
+                    .into_ref(&vm.ctx)
+                    .into();
+                self.push_value(param_spec);
+                Ok(None)
+            }
+            bytecode::Instruction::TypeVarTuple => {
+                let type_var_tuple_name = self.pop_value();
+                let type_var_tuple: PyObjectRef =
+                    _typing::make_typevartuple(type_var_tuple_name.clone())
+                        .into_ref(&vm.ctx)
+                        .into();
+                self.push_value(type_var_tuple);
+                Ok(None)
+            }
         }
     }
 
diff --git a/vm/src/stdlib/typing.rs b/vm/src/stdlib/typing.rs
@@ -75,18 +75,31 @@ pub(crate) mod _typing {
     #[pyclass(name = "ParamSpec")]
     #[derive(Debug, PyPayload)]
     #[allow(dead_code)]
-    struct ParamSpec {}
+    pub(crate) struct ParamSpec {
+        name: PyObjectRef,
+    }
+
     #[pyclass(flags(BASETYPE))]
     impl ParamSpec {}
 
+    pub(crate) fn make_paramspec(name: PyObjectRef) -> ParamSpec {
+        ParamSpec { name }
+    }
+
     #[pyattr]
     #[pyclass(name = "TypeVarTuple")]
     #[derive(Debug, PyPayload)]
     #[allow(dead_code)]
-    pub(crate) struct TypeVarTuple {}
+    pub(crate) struct TypeVarTuple {
+        name: PyObjectRef,
+    }
     #[pyclass(flags(BASETYPE))]
     impl TypeVarTuple {}
 
+    pub(crate) fn make_typevartuple(name: PyObjectRef) -> TypeVarTuple {
+        TypeVarTuple { name }
+    }
+
     #[pyattr]
     #[pyclass(name = "ParamSpecArgs")]
     #[derive(Debug, PyPayload)]

Original file line number	Diff line number	Diff line change
`@@ -1257,8 +1257,18 @@ impl SymbolTableBuilder {`
`1257`	`1257`	`self.scan_expression(binding, ExpressionContext::Load)?;`
`1258`	`1258`	`}`
`1259`	`1259`	`}`
`1260`		`- ast::located::TypeParam::ParamSpec(_) => todo!(),`
`1261`		`- ast::located::TypeParam::TypeVarTuple(_) => todo!(),`
	`1260`	`+ ast::located::TypeParam::ParamSpec(ast::TypeParamParamSpec {`
	`1261`	`+ name,`
	`1262`	`+ range: param_spec_range,`
	`1263`	`+ }) => {`
	`1264`	`+ self.register_name(name, SymbolUsage::Assigned, param_spec_range.start)?;`
	`1265`	`+ }`
	`1266`	`+ ast::located::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple {`
	`1267`	`+ name,`
	`1268`	`+ range: type_var_tuple_range,`
	`1269`	`+ }) => {`
	`1270`	`+ self.register_name(name, SymbolUsage::Assigned, type_var_tuple_range.start)?;`
	`1271`	`+ }`
`1262`	`1272`	`}`
`1263`	`1273`	`}`
`1264`	`1274`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -595,10 +595,12 @@ pub enum Instruction {`
`595`	`595`	`TypeVarWithBound,`
`596`	`596`	`TypeVarWithConstraint,`
`597`	`597`	`TypeAlias,`
	`598`	`+ TypeVarTuple,`
	`599`	`+ ParamSpec,`
`598`	`600`	`// If you add a new instruction here, be sure to keep LAST_INSTRUCTION updated`
`599`	`601`	`}`
`600`	`602`	`// This must be kept up to date to avoid marshaling errors`
`601`		`-const LAST_INSTRUCTION: Instruction = Instruction::TypeAlias;`
	`603`	`+const LAST_INSTRUCTION: Instruction = Instruction::ParamSpec;`
`602`	`604`	`const _: () = assert!(mem::size_of::<Instruction>() == 1);`
`603`	`605`
`604`	`606`	`impl From<Instruction> for u8 {`
`@@ -1291,6 +1293,8 @@ impl Instruction {`
`1291`	`1293`	`TypeVarWithBound => -1,`
`1292`	`1294`	`TypeVarWithConstraint => -1,`
`1293`	`1295`	`TypeAlias => -2,`
	`1296`	`+ ParamSpec => 0,`
	`1297`	`+ TypeVarTuple => 0,`
`1294`	`1298`	`}`
`1295`	`1299`	`}`
`1296`	`1300`
`@@ -1460,6 +1464,8 @@ impl Instruction {`
`1460`	`1464`	`TypeVarWithBound => w!(TypeVarWithBound),`
`1461`	`1465`	`TypeVarWithConstraint => w!(TypeVarWithConstraint),`
`1462`	`1466`	`TypeAlias => w!(TypeAlias),`
	`1467`	`+ ParamSpec => w!(ParamSpec),`
	`1468`	`+ TypeVarTuple => w!(TypeVarTuple),`
`1463`	`1469`	`}`
`1464`	`1470`	`}`
`1465`	`1471`	`}`