Refactor ConcreteTemplateArg

pc2 · Jan 14, 2025 · 960cd28 · 960cd28
1 parent 5ac655f
commit 960cd28
Show file tree

Hide file tree

Showing 5 changed files with 17 additions and 25 deletions.
diff --git a/src/codegen/system_verilog.rs b/src/codegen/system_verilog.rs
@@ -324,11 +324,11 @@ impl<'g, 'out, Stream: std::fmt::Write> CodeGenerationContext<'g, 'out, Stream>
         concrete_template_args.iter().for_each(|(arg_id, arg)| {
             let arg_name = &link_info.template_parameters[arg_id].name;
             let arg_value = match arg {
-                ConcreteTemplateArg::Type(..) => {
-                    unreachable!("No extern module type arguments. Should have been caught by Lint")
-                }
-                ConcreteTemplateArg::Value(value, _) => {
-                    value.inline_constant_to_string()
+                ConcreteTemplateArg::Provided(r#type, _) => {
+                    match r#type {
+                        ConcreteType::Value(value) => value.inline_constant_to_string(),
+                        _ => unreachable!("No extern module type arguments. Should have been caught by Lint")
+                    }
                 }
                 ConcreteTemplateArg::NotProvided => unreachable!("All args are known at codegen"),
             };
@@ -338,7 +338,7 @@ impl<'g, 'out, Stream: std::fmt::Write> CodeGenerationContext<'g, 'out, Stream>
                 first = false;
             }
             self.program_text.write_char('.').unwrap();
-            self.program_text.write_str(&arg_name).unwrap();
+            self.program_text.write_str(arg_name).unwrap();
             self.program_text.write_char('(').unwrap();
             self.program_text.write_str(&arg_value).unwrap();
             self.program_text.write_char(')').unwrap();

diff --git a/src/instantiation/concrete_typecheck.rs b/src/instantiation/concrete_typecheck.rs
@@ -176,7 +176,7 @@ fn try_to_attach_value_to_template_arg(template_wire_referernce: FlatID, found_v
     let ConcreteType::Value(v) = found_value else {return}; // We don't have a value to assign
     if let Some(template_id) = can_expression_be_value_inferred(submodule_link_info, template_wire_referernce) {
         if let ConcreteTemplateArg::NotProvided = &template_args[template_id] {
-            template_args[template_id] = ConcreteTemplateArg::Value(v.clone(), HowDoWeKnowTheTemplateArg::Inferred)
+            template_args[template_id] = ConcreteTemplateArg::Provided(ConcreteType::Value(v.clone()), HowDoWeKnowTheTemplateArg::Inferred)
         }
     }
 }
@@ -197,7 +197,7 @@ fn infer_parameters_by_walking_type(port_wr_typ: &WrittenType, connected_typ: &C
         WrittenType::TemplateVariable(_span, template_id) => {
             if !connected_typ.contains_unknown() {
                 if let ConcreteTemplateArg::NotProvided = &template_args[*template_id] {
-                    template_args[*template_id] = ConcreteTemplateArg::Type(connected_typ.clone(), HowDoWeKnowTheTemplateArg::Inferred)
+                    template_args[*template_id] = ConcreteTemplateArg::Provided(connected_typ.clone(), HowDoWeKnowTheTemplateArg::Inferred)
                 }
             }
         }
@@ -241,7 +241,7 @@ impl DelayedConstraint<InstantiationContext<'_, '_>> for SubmoduleTypecheckConst
                 ConcreteTemplateArg::NotProvided => {
                     return DelayedConstraintStatus::NoProgress;
                 }
-                ConcreteTemplateArg::Type(..) | ConcreteTemplateArg::Value(..) => {}
+                ConcreteTemplateArg::Provided(..) => {}
             }
         }
 

diff --git a/src/instantiation/execute.rs b/src/instantiation/execute.rs
@@ -672,12 +672,12 @@ impl<'fl, 'l> InstantiationContext<'fl, 'l> {
                     for (_id, v) in &submodule.module_ref.template_args {
                         template_args.alloc(match v {
                             Some(arg) => match &arg.kind {
-                                TemplateArgKind::Type(typ) => ConcreteTemplateArg::Type(
+                                TemplateArgKind::Type(typ) => ConcreteTemplateArg::Provided(
                                     self.concretize_type(typ)?,
                                     HowDoWeKnowTheTemplateArg::Given,
                                 ),
-                                TemplateArgKind::Value(v) => ConcreteTemplateArg::Value(
-                                    self.generation_state.get_generation_value(*v)?.clone(),
+                                TemplateArgKind::Value(v) => ConcreteTemplateArg::Provided(
+                                    ConcreteType::Value(self.generation_state.get_generation_value(*v)?.clone()),
                                     HowDoWeKnowTheTemplateArg::Given,
                                 ),
                             },

diff --git a/src/to_string.rs b/src/to_string.rs
@@ -322,7 +322,7 @@ where
         let arg_in_target = &target_link_info.template_parameters[id];
         write!(result, "    {}: ", arg_in_target.name).unwrap();
         match arg {
-            ConcreteTemplateArg::Type(concrete_type, how_do_we_know_the_template_arg) => {
+            ConcreteTemplateArg::Provided(concrete_type, how_do_we_know_the_template_arg) => {
                 writeln!(
                     result,
                     "type {} /* {} */,",
@@ -331,14 +331,6 @@ where
                 )
                 .unwrap();
             }
-            ConcreteTemplateArg::Value(value, how_do_we_know_the_template_arg) => {
-                writeln!(
-                    result,
-                    "{} /* {} */,",
-                    value, how_do_we_know_the_template_arg
-                )
-                .unwrap();
-            }
             ConcreteTemplateArg::NotProvided => {
                 writeln!(result, "/* Could not infer */").unwrap();
             }

diff --git a/src/typing/template.rs b/src/typing/template.rs
@@ -130,15 +130,15 @@ impl Display for HowDoWeKnowTheTemplateArg {
     }
 }
 
+
 /// Represents the value we're passing into a template argument.
 ///
 /// It is the instantiated variant of [TemplateArg]
 ///
 /// And it is passed to a [crate::flattening::Module], [crate::flattening::StructType], or [crate::flattening::NamedConstant]'s [Parameter]
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ConcreteTemplateArg {
-    Type(ConcreteType, HowDoWeKnowTheTemplateArg),
-    Value(Value, HowDoWeKnowTheTemplateArg),
+    Provided(ConcreteType, HowDoWeKnowTheTemplateArg),
     /// It has not been explicitly provided,
     /// yet [crate::typing::type_inference] may replace this value when it can figure it out from the context
     NotProvided,
@@ -147,14 +147,14 @@ pub enum ConcreteTemplateArg {
 impl ConcreteTemplateArg {
     #[track_caller]
     pub fn unwrap_type(&self) -> &ConcreteType {
-        let Self::Type(t, _) = self else {
+        let Self::Provided(t, _) = self else {
             unreachable!()
         };
         t
     }
     #[track_caller]
     pub fn unwrap_value(&self) -> &Value {
-        let Self::Value(v, _) = self else {
+        let ConcreteType::Value(v) = self.unwrap_type() else {
             unreachable!()
         };
         v