Use GlobalReference for named constants in WireReference too

This finally concludes the shift to HM for abstract typing
pc2 · Nov 5, 2024 · 96a50c3 · 96a50c3
1 parent 10e4d0b
commit 96a50c3
Show file tree

Hide file tree

Showing 8 changed files with 19 additions and 45 deletions.
diff --git a/src/dev_aid/lsp/tree_walk.rs b/src/dev_aid/lsp/tree_walk.rs
@@ -254,7 +254,7 @@ impl<'linker, Visitor: FnMut(Span, LocationInfo<'linker>), Pruner: Fn(Span) -> b
                 );
             }
             WireReferenceRoot::NamedConstant(cst, span) => {
-                self.visit(*span, LocationInfo::Global(NameElem::Constant(*cst)))
+                self.visit(*span, LocationInfo::Global(NameElem::Constant(cst.id)))
             }
             WireReferenceRoot::SubModulePort(port) => {
                 if let Some(span) = port.port_name_span {

diff --git a/src/flattening/flatten.rs b/src/flattening/flatten.rs
@@ -991,7 +991,7 @@ impl<'l, 'errs> FlatteningContext<'l, 'errs> {
                     }
                 },
                 LocalOrGlobal::Constant(cst_ref) => {
-                    let root = WireReferenceRoot::NamedConstant(cst_ref.id, expr_span); // TODO Constants with templates
+                    let root = WireReferenceRoot::NamedConstant(cst_ref, expr_span);
                     PartialWireReference::WireReference(WireReference {
                         root,
                         is_generative: true,

diff --git a/src/flattening/mod.rs b/src/flattening/mod.rs
@@ -251,10 +251,10 @@ impl WireReferencePathElement {
 }
 
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug)]
 pub enum WireReferenceRoot {
     LocalDecl(FlatID, Span),
-    NamedConstant(ConstantUUID, Span),
+    NamedConstant(GlobalReference<ConstantUUID>, Span),
     SubModulePort(PortInfo),
 }
 

diff --git a/src/flattening/typechecking.rs b/src/flattening/typechecking.rs
@@ -111,7 +111,7 @@ impl<'l, 'errs> TypeCheckingContext<'l, 'errs> {
                 (decl_root.decl_span, self.errors.file)
             }
             WireReferenceRoot::NamedConstant(cst, _) => {
-                let linker_cst = &self.globals[*cst];
+                let linker_cst = &self.globals[cst.id];
                 linker_cst.link_info.get_span_file()
             }
             WireReferenceRoot::SubModulePort(port) => {
@@ -143,8 +143,14 @@ impl<'l, 'errs> TypeCheckingContext<'l, 'errs> {
                 decl_root.typ.clone()
             }
             WireReferenceRoot::NamedConstant(cst, _) => {
-                let linker_cst = &self.globals[*cst];
-                linker_cst.get_full_type()
+                let linker_cst = &self.globals[cst.id];
+                let decl = linker_cst.link_info.instructions[linker_cst.output_decl].unwrap_wire_declaration();
+                let typ = AbstractType::Unknown(self.type_checker.alloc_typ_variable());
+                self.type_checker.unify_with_written_type_substitute_templates_must_succeed(&decl.typ_expr, &typ, &cst.template_arg_types);
+                FullType {
+                    typ,
+                    domain: DomainType::Generative
+                }
             }
             WireReferenceRoot::SubModulePort(port) => {
                 self.get_type_of_port(port.port, port.submodule_decl)

diff --git a/src/instantiation/execute.rs b/src/instantiation/execute.rs
@@ -203,8 +203,8 @@ impl<'fl, 'l> InstantiationContext<'fl, 'l> {
                 SubModuleOrWire::SubModule(_) => unreachable!(),
                 SubModuleOrWire::Unnasigned => unreachable!(),
             },
-            WireReferenceRoot::NamedConstant(cst_id, _) => {
-                let cst = &self.linker.constants[*cst_id];
+            WireReferenceRoot::NamedConstant(cst, _) => {
+                let cst = &self.linker.constants[cst.id];
                 RealWireRefRoot::Constant(cst.val.clone())
             }
             WireReferenceRoot::SubModulePort(port) => {
@@ -357,8 +357,8 @@ impl<'fl, 'l> InstantiationContext<'fl, 'l> {
             &WireReferenceRoot::LocalDecl(decl_id, _span) => {
                 self.generation_state.get_generation_value(decl_id)?.clone()
             }
-            WireReferenceRoot::NamedConstant(const_id, _span) => {
-                self.linker.constants[*const_id].get_value().clone()
+            WireReferenceRoot::NamedConstant(cst, _span) => {
+                self.linker.constants[cst.id].get_value().clone()
             }
             &WireReferenceRoot::SubModulePort(_) => {
                 todo!("Don't yet support compile time functions")

diff --git a/src/linker/mod.rs b/src/linker/mod.rs
@@ -24,11 +24,7 @@ use crate::errors::{CompileError, ErrorInfo, ErrorLevel, ErrorStore};
 
 use crate::flattening::{StructType, TypingAllocator};
 
-use crate::typing::{
-    abstract_type::{DomainType, FullType},
-    concrete_type::ConcreteType,
-    template::TemplateInputs,
-};
+use crate::typing::template::TemplateInputs;
 
 use self::checkpoint::CheckPoint;
 
@@ -138,15 +134,6 @@ pub struct NamedConstant {
 }
 
 impl NamedConstant {
-    pub fn get_concrete_type(&self) -> &ConcreteType {
-        &self.val.typ
-    }
-    pub fn get_full_type(&self) -> FullType {
-        FullType {
-            typ: self.get_concrete_type().into(),
-            domain: DomainType::Generative,
-        }
-    }
     pub fn get_value(&self) -> &TypedValue {
         &self.val
     }

diff --git a/src/typing/abstract_type.rs b/src/typing/abstract_type.rs
@@ -105,6 +105,7 @@ impl TypeUnifier {
         self.type_substitutor.alloc()
     }
 
+    #[allow(dead_code)]
     pub fn alloc_domain_variable(&self) -> DomainVariableID {
         self.domain_substitutor.alloc()
     }

diff --git a/src/typing/concrete_type.rs b/src/typing/concrete_type.rs
@@ -3,8 +3,6 @@ use crate::prelude::*;
 
 use std::ops::{Deref, Index};
 
-use super::abstract_type::AbstractType;
-use super::type_inference::TypeVariableID;
 use crate::linker::get_builtin_type;
 use crate::{
     flattening::{BinaryOperator, UnaryOperator},
@@ -23,24 +21,6 @@ pub enum ConcreteType {
     Error,
 }
 
-impl Into<AbstractType> for &ConcreteType {
-    fn into(self) -> AbstractType {
-        match self {
-            ConcreteType::Named(name) => AbstractType::Named(*name),
-            ConcreteType::Value(_) => {
-                unreachable!("Turning a ConcreteType::Value into an AbstractType");
-            }
-            ConcreteType::Array(arr) => {
-                let (sub, _sz) = arr.deref();
-                let concrete_sub: AbstractType = sub.into();
-                AbstractType::Array(Box::new(concrete_sub))
-            }
-            ConcreteType::Unknown => AbstractType::Unknown(TypeVariableID::PLACEHOLDER),
-            ConcreteType::Error => AbstractType::Error,
-        }
-    }
-}
-
 /// Panics on Type Errors that should have been caught by [AbstractType]
 ///
 /// TODO Add checks for array sizes being equal etc.