Add more documentation and more renames

- Privatize RealWireRefRoot - Rename InstantiationList => InstantiationCache - Rename NameElem => GlobalUUID - Rename TemplateInput => Parameter - Move everything from delayed_constraint.rs => type_inference.rs
pc2 · Jan 13, 2025 · 65e503b · 65e503b
1 parent f5b025d
commit 65e503b
Show file tree

Hide file tree

Showing 27 changed files with 546 additions and 338 deletions.
diff --git a/src/codegen/system_verilog.rs b/src/codegen/system_verilog.rs
@@ -322,7 +322,7 @@ impl<'g, 'out, Stream: std::fmt::Write> CodeGenerationContext<'g, 'out, Stream>
         self.program_text.write_str(" #(").unwrap();
         let mut first = true;
         concrete_template_args.iter().for_each(|(arg_id, arg)| {
-            let arg_name = &link_info.template_arguments[arg_id].name;
+            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")

diff --git a/src/compiler_top.rs b/src/compiler_top.rs
@@ -173,7 +173,7 @@ impl Linker {
                 &self.files[md.link_info.file],
             );
             // Can immediately instantiate modules that have no template args
-            if md.link_info.template_arguments.is_empty() {
+            if md.link_info.template_parameters.is_empty() {
                 let _inst = md.instantiations.instantiate(md, self, FlatAlloc::new());
             }
             span_debugger.defuse();

diff --git a/src/dev_aid/lsp/hover_info.rs b/src/dev_aid/lsp/hover_info.rs
@@ -7,11 +7,11 @@ use lsp_types::{LanguageString, MarkedString};
 
 use crate::flattening::{DeclarationKind, IdentifierType, InterfaceToDomainMap, Module};
 use crate::instantiation::{SubModuleOrWire, CALCULATE_LATENCY_LATER};
-use crate::linker::{Documentation, FileData, LinkInfo, NameElem};
+use crate::linker::{Documentation, FileData, LinkInfo, GlobalUUID};
 
 use crate::typing::{
     abstract_type::DomainType,
-    template::{GenerativeTemplateInputKind, TemplateInputKind, TypeTemplateInputKind},
+    template::{GenerativeParameterKind, ParameterKind, TypeParameterKind},
 };
 
 use super::tree_walk::{InModule, LocationInfo};
@@ -126,7 +126,7 @@ pub fn hover(info: LocationInfo, linker: &Linker, file_data: &FileData) -> Vec<M
             let typ_str = decl
                 .typ
                 .typ
-                .display(&linker.types, &md.link_info.template_arguments).to_string();
+                .display(&linker.types, &md.link_info.template_parameters).to_string();
             details_vec.push(&typ_str);
 
             details_vec.push(&decl.name);
@@ -175,39 +175,39 @@ pub fn hover(info: LocationInfo, linker: &Linker, file_data: &FileData) -> Vec<M
                             .push(Cow::Owned(DomainType::physical_to_string(ph, &md.domains)))
                     }
                 }
-                DomainType::DomainVariable(_) => unreachable!("Variables should have been eliminated already")
+                DomainType::Unknown(_) => unreachable!("Variables should have been eliminated already")
             };
             details_vec.push(Cow::Owned(
                 wire.typ
                     .typ
-                    .display(&linker.types, &md.link_info.template_arguments).to_string(),
+                    .display(&linker.types, &md.link_info.template_parameters).to_string(),
             ));
             hover.sus_code(details_vec.join(" "));
             hover.gather_hover_infos(md, id, wire.typ.domain.is_generative());
         }
         LocationInfo::Type(typ, link_info) => {
             hover.sus_code(
-                typ.display(&linker.types, &link_info.template_arguments).to_string(),
+                typ.display(&linker.types, &link_info.template_parameters).to_string(),
             );
         }
-        LocationInfo::TemplateInput(in_obj, link_info, _template_id, template_arg) => {
+        LocationInfo::Parameter(in_obj, link_info, _template_id, template_arg) => {
             match &template_arg.kind {
-                TemplateInputKind::Type(TypeTemplateInputKind {  }) => {
+                ParameterKind::Type(TypeParameterKind {  }) => {
                     hover.monospace(format!("type {}", template_arg.name));
                 }
-                TemplateInputKind::Generative(GenerativeTemplateInputKind {
+                ParameterKind::Generative(GenerativeParameterKind {
                     decl_span: _,
                     declaration_instruction,
                 }) => {
-                    let NameElem::Module(md_id) = in_obj else {
+                    let GlobalUUID::Module(md_id) = in_obj else {
                         todo!("Non-module template args")
                     };
                     let md = &linker.modules[md_id];
                     let decl = md.link_info.instructions[*declaration_instruction].unwrap_declaration();
                     hover.sus_code(format!(
                         "param {} {}",
                         decl.typ_expr
-                            .display(&linker.types, &link_info.template_arguments),
+                            .display(&linker.types, &link_info.template_parameters),
                         template_arg.name
                     ));
                     hover.gather_hover_infos(md, *declaration_instruction, true);
@@ -220,15 +220,15 @@ pub fn hover(info: LocationInfo, linker: &Linker, file_data: &FileData) -> Vec<M
             let file = &linker.files[link_info.file];
             hover.sus_code(format!("{}", link_info.get_full_name_and_template_args(&file.file_text)));
             match global {
-                NameElem::Module(md_uuid) => {
+                GlobalUUID::Module(md_uuid) => {
                     let md = &linker.modules[md_uuid];
                     hover.sus_code(md.make_all_ports_info_string(
                         &linker.files[md.link_info.file].file_text,
                         None,
                     ));
                 }
-                NameElem::Type(_) => {}
-                NameElem::Constant(_) => {}
+                GlobalUUID::Type(_) => {}
+                GlobalUUID::Constant(_) => {}
             }
         }
         LocationInfo::Port(_sm, md, port_id) => {

diff --git a/src/dev_aid/lsp/mod.rs b/src/dev_aid/lsp/mod.rs
@@ -392,7 +392,7 @@ fn handle_request(
                         .push((submod_decl.name.as_ref().unwrap().1, md.link_info.file)),
                     LocationInfo::InModule(_, _, _, InModule::Temporary(_)) => {}
                     LocationInfo::Type(_, _) => {}
-                    LocationInfo::TemplateInput(_, link_info, _, template_arg) => {
+                    LocationInfo::Parameter(_, link_info, _, template_arg) => {
                         goto_definition_list.push((template_arg.name_span, link_info.file))
                     }
                     LocationInfo::Global(id) => {

diff --git a/src/dev_aid/lsp/semantic_tokens.rs b/src/dev_aid/lsp/semantic_tokens.rs
@@ -9,10 +9,10 @@ use lsp_types::{
 use crate::{
     dev_aid::lsp::to_position,
     flattening::IdentifierType,
-    linker::{FileData, NameElem},
+    linker::{FileData, GlobalUUID},
 };
 
-use crate::typing::{abstract_type::DomainType, template::TemplateInputKind};
+use crate::typing::{abstract_type::DomainType, template::ParameterKind};
 
 use super::tree_walk::{self, InModule, LocationInfo};
 
@@ -154,16 +154,16 @@ fn walk_name_color(file: &FileData, linker: &Linker) -> Vec<(Span, IDEIdentifier
                 }
                 LocationInfo::InModule(_md_id, _, _, InModule::Temporary(_)) => return,
                 LocationInfo::Type(_, _) => return,
-                LocationInfo::TemplateInput(_id, _link_info, _, template_arg) => {
+                LocationInfo::Parameter(_id, _link_info, _, template_arg) => {
                     match &template_arg.kind {
-                        TemplateInputKind::Type(_) => IDEIdentifierType::Type,
-                        TemplateInputKind::Generative(_) => IDEIdentifierType::Generative,
+                        ParameterKind::Type(_) => IDEIdentifierType::Type,
+                        ParameterKind::Generative(_) => IDEIdentifierType::Generative,
                     }
                 }
                 LocationInfo::Global(g) => match g {
-                    NameElem::Module(_) => IDEIdentifierType::Interface,
-                    NameElem::Type(_) => IDEIdentifierType::Type,
-                    NameElem::Constant(_) => IDEIdentifierType::Constant,
+                    GlobalUUID::Module(_) => IDEIdentifierType::Interface,
+                    GlobalUUID::Type(_) => IDEIdentifierType::Type,
+                    GlobalUUID::Constant(_) => IDEIdentifierType::Constant,
                 },
                 LocationInfo::Port(_, md, port_id) => {
                     let interface = md.ports[port_id].domain;