Resolve SymbolId of user defined types after pass1

dalance · dalance · commit f99611875784 · 2025-01-05T18:41:37.000+09:00
diff --git a/crates/analyzer/src/analyzer.rs b/crates/analyzer/src/analyzer.rs
@@ -281,6 +281,7 @@ impl Analyzer {
 
     pub fn analyze_post_pass1() {
         symbol_table::apply_import();
+        symbol_table::resolve_user_defined();
     }
 
     pub fn analyze_pass2<T: AsRef<Path>>(
@@ -349,35 +350,35 @@ fn traverse_type_symbol(id: SymbolId, path: &VarRefPath) -> Vec<VarRefPath> {
         match &symbol.kind {
             SymbolKind::Variable(x) => {
                 if let TypeKind::UserDefined(ref x) = x.r#type.kind {
-                    if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {
-                        return traverse_type_symbol(symbol.found.id, path);
+                    if let Some(id) = x.symbol {
+                        return traverse_type_symbol(id, path);
                     }
                 } else {
                     return vec![path.clone()];
                 }
             }
             SymbolKind::StructMember(x) => {
                 if let TypeKind::UserDefined(ref x) = x.r#type.kind {
-                    if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {
-                        return traverse_type_symbol(symbol.found.id, path);
+                    if let Some(id) = x.symbol {
+                        return traverse_type_symbol(id, path);
                     }
                 } else {
                     return vec![path.clone()];
                 }
             }
             SymbolKind::UnionMember(x) => {
                 if let TypeKind::UserDefined(ref x) = x.r#type.kind {
-                    if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {
-                        return traverse_type_symbol(symbol.found.id, path);
+                    if let Some(id) = x.symbol {
+                        return traverse_type_symbol(id, path);
                     }
                 } else {
                     return vec![path.clone()];
                 }
             }
             SymbolKind::TypeDef(x) => {
                 if let TypeKind::UserDefined(ref x) = x.r#type.kind {
-                    if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {
-                        return traverse_type_symbol(symbol.found.id, path);
+                    if let Some(id) = x.symbol {
+                        return traverse_type_symbol(id, path);
                     }
                 } else {
                     return vec![path.clone()];
@@ -387,8 +388,8 @@ fn traverse_type_symbol(id: SymbolId, path: &VarRefPath) -> Vec<VarRefPath> {
                 let r#type: Result<crate::symbol::Type, ()> = (&x.value).try_into();
                 if let Ok(r#type) = r#type {
                     if let TypeKind::UserDefined(ref x) = r#type.kind {
-                        if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {
-                            return traverse_type_symbol(symbol.found.id, path);
+                        if let Some(id) = x.symbol {
+                            return traverse_type_symbol(id, path);
                         }
                     } else {
                         return vec![path.clone()];
@@ -451,8 +452,8 @@ fn traverse_assignable_symbol(id: SymbolId, path: &VarRefPath) -> Vec<VarRefPath
             SymbolKind::Port(x) if is_assignable(&x.direction) && !x.is_proto => {
                 if let Some(ref x) = x.r#type {
                     if let TypeKind::UserDefined(ref x) = x.kind {
-                        if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {
-                            return traverse_type_symbol(symbol.found.id, path);
+                        if let Some(id) = x.symbol {
+                            return traverse_type_symbol(id, path);
                         }
                     } else {
                         return vec![path.clone()];
@@ -465,8 +466,8 @@ fn traverse_assignable_symbol(id: SymbolId, path: &VarRefPath) -> Vec<VarRefPath
                     || x.affiliation == VariableAffiliation::StatementBlock =>
             {
                 if let TypeKind::UserDefined(ref x) = x.r#type.kind {
-                    if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {
-                        return traverse_type_symbol(symbol.found.id, path);
+                    if let Some(id) = x.symbol {
+                        return traverse_type_symbol(id, path);
                     }
                 } else {
                     return vec![path.clone()];
diff --git a/crates/analyzer/src/handlers/check_msb_lsb.rs b/crates/analyzer/src/handlers/check_msb_lsb.rs
@@ -1,6 +1,5 @@
 use crate::analyzer_error::AnalyzerError;
 use crate::msb_table;
-use crate::namespace::Namespace;
 use crate::namespace_table;
 use crate::symbol::Type as SymType;
 use crate::symbol::{Direction, SymbolKind, TypeKind};
@@ -40,13 +39,14 @@ impl Handler for CheckMsbLsb<'_> {
     }
 }
 
-fn trace_type(r#type: &SymType, namespace: &Namespace) -> Vec<(SymType, Option<SymbolKind>)> {
+fn trace_type(r#type: &SymType) -> Vec<(SymType, Option<SymbolKind>)> {
     let mut ret = vec![(r#type.clone(), None)];
     if let TypeKind::UserDefined(ref x) = r#type.kind {
-        if let Ok(symbol) = symbol_table::resolve((&SymbolPath::new(x), namespace)) {
-            ret.last_mut().unwrap().1 = Some(symbol.found.kind.clone());
-            if let SymbolKind::TypeDef(ref x) = symbol.found.kind {
-                ret.append(&mut trace_type(&x.r#type, namespace));
+        if let Some(id) = x.symbol {
+            let symbol = symbol_table::get(id).unwrap();
+            ret.last_mut().unwrap().1 = Some(symbol.kind.clone());
+            if let SymbolKind::TypeDef(ref x) = symbol.kind {
+                ret.append(&mut trace_type(&x.r#type));
             }
         }
     }
@@ -72,8 +72,6 @@ impl VerylGrammarTrait for CheckMsbLsb<'_> {
                 let resolved = if let Ok(x) =
                     symbol_table::resolve(self.identifier_path.last().unwrap().clone())
                 {
-                    let namespace = &x.found.namespace;
-
                     let via_interface = x.full_path.iter().any(|path| {
                         let symbol = symbol_table::get(*path).unwrap();
                         match symbol.kind {
@@ -98,7 +96,7 @@ impl VerylGrammarTrait for CheckMsbLsb<'_> {
                     };
 
                     if let Some(x) = r#type {
-                        let types = trace_type(&x, namespace);
+                        let types = trace_type(&x);
                         let mut select_dimension = *self.select_dimension.last().unwrap();
 
                         let mut demension_number = None;
diff --git a/crates/analyzer/src/handlers/create_symbol_table.rs b/crates/analyzer/src/handlers/create_symbol_table.rs
@@ -6,7 +6,6 @@ use crate::evaluator::Evaluated;
 use crate::evaluator::Evaluator;
 use crate::namespace::Namespace;
 use crate::namespace_table;
-use crate::symbol;
 use crate::symbol::ClockDomain as SymClockDomain;
 use crate::symbol::Direction as SymDirection;
 use crate::symbol::Type as SymType;
@@ -116,16 +115,6 @@ impl<'a> CreateSymbolTable<'a> {
     }
 
     fn insert_symbol(&mut self, token: &Token, kind: SymbolKind, public: bool) -> Option<SymbolId> {
-        self.insert_symbol_with_type(token, kind, public, None)
-    }
-
-    fn insert_symbol_with_type(
-        &mut self,
-        token: &Token,
-        kind: SymbolKind,
-        public: bool,
-        r#type: Option<symbol::Type>,
-    ) -> Option<SymbolId> {
         let line = token.line;
         let doc_comment = if let TokenSource::File(file) = token.source {
             if line == 0 {
@@ -157,7 +146,6 @@ impl<'a> CreateSymbolTable<'a> {
             symbol.allow_unused = true;
         }
 
-        symbol.r#type = r#type;
         let id = symbol_table::insert(token, symbol);
         if id.is_none() {
             self.errors.push(AnalyzerError::duplicated_identifier(
@@ -590,12 +578,9 @@ impl VerylGrammarTrait for CreateSymbolTable<'_> {
             };
             let kind = SymbolKind::Variable(property);
 
-            if let Some(id) = self.insert_symbol_with_type(
-                &arg.identifier.identifier_token.token,
-                kind.clone(),
-                false,
-                None,
-            ) {
+            if let Some(id) =
+                self.insert_symbol(&arg.identifier.identifier_token.token, kind.clone(), false)
+            {
                 if self.is_default_clock_candidate(kind.clone()) {
                     self.default_clock_candidates.push(id);
                 } else if self.is_default_reset_candidate(kind.clone()) {
diff --git a/crates/analyzer/src/symbol.rs b/crates/analyzer/src/symbol.rs
@@ -72,7 +72,6 @@ pub struct Symbol {
     pub allow_unused: bool,
     pub public: bool,
     pub doc_comment: DocComment,
-    pub r#type: Option<Type>,
 }
 
 impl Symbol {
@@ -95,7 +94,6 @@ impl Symbol {
             allow_unused: false,
             public,
             doc_comment,
-            r#type: None,
         }
     }
 
@@ -428,6 +426,32 @@ impl SymbolKind {
             _ => None,
         }
     }
+
+    pub fn get_type(&self) -> Option<&Type> {
+        match self {
+            SymbolKind::Port(x) => x.r#type.as_ref(),
+            SymbolKind::Variable(x) => Some(&x.r#type),
+            SymbolKind::Function(x) => x.ret.as_ref(),
+            SymbolKind::Parameter(x) => Some(&x.r#type),
+            SymbolKind::StructMember(x) => Some(&x.r#type),
+            SymbolKind::UnionMember(x) => Some(&x.r#type),
+            SymbolKind::TypeDef(x) => Some(&x.r#type),
+            _ => None,
+        }
+    }
+
+    pub fn get_type_mut(&mut self) -> Option<&mut Type> {
+        match self {
+            SymbolKind::Port(x) => x.r#type.as_mut(),
+            SymbolKind::Variable(x) => Some(&mut x.r#type),
+            SymbolKind::Function(x) => x.ret.as_mut(),
+            SymbolKind::Parameter(x) => Some(&mut x.r#type),
+            SymbolKind::StructMember(x) => Some(&mut x.r#type),
+            SymbolKind::UnionMember(x) => Some(&mut x.r#type),
+            SymbolKind::TypeDef(x) => Some(&mut x.r#type),
+            _ => None,
+        }
+    }
 }
 
 impl fmt::Display for SymbolKind {
@@ -608,7 +632,7 @@ pub enum TypeKind {
     F64,
     Type,
     String,
-    UserDefined(Vec<StrId>),
+    UserDefined(UserDefinedType),
 }
 
 impl TypeKind {
@@ -631,6 +655,18 @@ impl TypeKind {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UserDefinedType {
+    pub path: Vec<StrId>,
+    pub symbol: Option<SymbolId>,
+}
+
+impl UserDefinedType {
+    fn new(path: Vec<StrId>) -> Self {
+        Self { path, symbol: None }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum TypeModifier {
     Tri,
@@ -665,9 +701,9 @@ impl fmt::Display for Type {
             TypeKind::F64 => text.push_str("f64"),
             TypeKind::Type => text.push_str("type"),
             TypeKind::String => text.push_str("string"),
-            TypeKind::UserDefined(paths) => {
-                text.push_str(&format!("{}", paths.first().unwrap()));
-                for path in &paths[1..] {
+            TypeKind::UserDefined(x) => {
+                text.push_str(&format!("{}", x.path.first().unwrap()));
+                for path in &x.path[1..] {
                     text.push_str(&format!("::{path}"));
                 }
             }
@@ -801,7 +837,7 @@ impl TryFrom<&syntax_tree::Expression> for Type {
                     for x in &x.scoped_identifier.scoped_identifier_list {
                         name.push(x.identifier.identifier_token.token.text);
                     }
-                    let kind = TypeKind::UserDefined(name);
+                    let kind = TypeKind::UserDefined(UserDefinedType::new(name));
                     let mut width = Vec::new();
                     if let Some(ref x) = x.expression_identifier_opt {
                         let x = &x.width;
@@ -902,7 +938,7 @@ impl From<&syntax_tree::ScalarType> for Type {
                 for x in &ident.scoped_identifier_list {
                     name.push(x.identifier.identifier_token.token.text);
                 }
-                let kind = TypeKind::UserDefined(name);
+                let kind = TypeKind::UserDefined(UserDefinedType::new(name));
                 let mut width = Vec::new();
                 if let Some(ref x) = x.scalar_type_opt {
                     let x = &x.width;
diff --git a/crates/analyzer/src/symbol_table.rs b/crates/analyzer/src/symbol_table.rs
@@ -118,12 +118,12 @@ impl SymbolTable {
         if let TypeKind::UserDefined(ref x) = kind {
             // Detect infinite loop in trace_user_defined
             if let Some(last_found) = context.last_found {
-                if *x.first().unwrap() == last_found.token.text {
+                if *x.path.first().unwrap() == last_found.token.text {
                     return Ok(context);
                 }
             }
 
-            let symbol = self.resolve(&SymbolPath::new(x), &context.namespace)?;
+            let symbol = self.resolve(&SymbolPath::new(&x.path), &context.namespace)?;
             match symbol.found.kind {
                 SymbolKind::SystemVerilog => context.sv_member = true,
                 SymbolKind::TypeDef(x) => {
@@ -447,6 +447,32 @@ impl SymbolTable {
         }
     }
 
+    pub fn get_user_defined(&self) -> Vec<(SymbolId, SymbolId)> {
+        let mut resolved = Vec::new();
+        for symbol in self.symbol_table.values() {
+            if let Some(x) = symbol.kind.get_type() {
+                if let TypeKind::UserDefined(x) = &x.kind {
+                    let path = SymbolPath::new(&x.path);
+                    if let Ok(type_symbol) = self.resolve(&path, &symbol.namespace) {
+                        resolved.push((symbol.id, type_symbol.found.id));
+                    }
+                }
+            }
+        }
+        resolved
+    }
+
+    pub fn set_user_defined(&mut self, resolved: Vec<(SymbolId, SymbolId)>) {
+        for (id, type_id) in resolved {
+            let symbol = self.symbol_table.get_mut(&id).unwrap();
+            if let Some(x) = symbol.kind.get_type_mut() {
+                if let TypeKind::UserDefined(x) = &mut x.kind {
+                    x.symbol = Some(type_id);
+                }
+            }
+        }
+    }
+
     pub fn add_project_local(&mut self, prj: StrId, from: StrId, to: StrId) {
         self.project_local_table
             .entry(prj)
@@ -1073,6 +1099,11 @@ pub fn apply_import() {
     SYMBOL_TABLE.with(|f| f.borrow_mut().apply_import())
 }
 
+pub fn resolve_user_defined() {
+    let resolved = SYMBOL_TABLE.with(|f| f.borrow().get_user_defined());
+    SYMBOL_TABLE.with(|f| f.borrow_mut().set_user_defined(resolved))
+}
+
 pub fn add_project_local(prj: StrId, from: StrId, to: StrId) {
     SYMBOL_TABLE.with(|f| f.borrow_mut().add_project_local(prj, from, to))
 }
diff --git a/crates/languageserver/src/server.rs b/crates/languageserver/src/server.rs
@@ -912,16 +912,18 @@ fn completion_member(url: &Url, line: usize, column: usize, text: &str) -> Vec<C
                 VerylSymbolKind::Port(x) => {
                     if let Some(ref x) = x.r#type {
                         if let TypeKind::UserDefined(ref x) = x.kind {
-                            if let Ok(symbol) = symbol_table::resolve((x, &namespace)) {
-                                items.append(&mut get_member(&symbol.found));
+                            if let Some(id) = x.symbol {
+                                let symbol = symbol_table::get(id).unwrap();
+                                items.append(&mut get_member(&symbol));
                             }
                         }
                     }
                 }
                 VerylSymbolKind::Variable(x) => {
                     if let TypeKind::UserDefined(ref x) = x.r#type.kind {
-                        if let Ok(symbol) = symbol_table::resolve((x, &namespace)) {
-                            items.append(&mut get_member(&symbol.found));
+                        if let Some(id) = x.symbol {
+                            let symbol = symbol_table::get(id).unwrap();
+                            items.append(&mut get_member(&symbol));
                         }
                     }
                 }

Original file line number	Diff line number	Diff line change
`@@ -281,6 +281,7 @@ impl Analyzer {`
`281`	`281`
`282`	`282`	`pub fn analyze_post_pass1() {`
`283`	`283`	`symbol_table::apply_import();`
	`284`	`+ symbol_table::resolve_user_defined();`
`284`	`285`	`}`
`285`	`286`
`286`	`287`	`pub fn analyze_pass2<T: AsRef<Path>>(`
`@@ -349,35 +350,35 @@ fn traverse_type_symbol(id: SymbolId, path: &VarRefPath) -> Vec<VarRefPath> {`
`349`	`350`	`match &symbol.kind {`
`350`	`351`	`SymbolKind::Variable(x) => {`
`351`	`352`	`if let TypeKind::UserDefined(ref x) = x.r#type.kind {`
`352`		`- if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {`
`353`		`- return traverse_type_symbol(symbol.found.id, path);`
	`353`	`+ if let Some(id) = x.symbol {`
	`354`	`+ return traverse_type_symbol(id, path);`
`354`	`355`	`}`
`355`	`356`	`} else {`
`356`	`357`	`return vec![path.clone()];`
`357`	`358`	`}`
`358`	`359`	`}`
`359`	`360`	`SymbolKind::StructMember(x) => {`
`360`	`361`	`if let TypeKind::UserDefined(ref x) = x.r#type.kind {`
`361`		`- if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {`
`362`		`- return traverse_type_symbol(symbol.found.id, path);`
	`362`	`+ if let Some(id) = x.symbol {`
	`363`	`+ return traverse_type_symbol(id, path);`
`363`	`364`	`}`
`364`	`365`	`} else {`
`365`	`366`	`return vec![path.clone()];`
`366`	`367`	`}`
`367`	`368`	`}`
`368`	`369`	`SymbolKind::UnionMember(x) => {`
`369`	`370`	`if let TypeKind::UserDefined(ref x) = x.r#type.kind {`
`370`		`- if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {`
`371`		`- return traverse_type_symbol(symbol.found.id, path);`
	`371`	`+ if let Some(id) = x.symbol {`
	`372`	`+ return traverse_type_symbol(id, path);`
`372`	`373`	`}`
`373`	`374`	`} else {`
`374`	`375`	`return vec![path.clone()];`
`375`	`376`	`}`
`376`	`377`	`}`
`377`	`378`	`SymbolKind::TypeDef(x) => {`
`378`	`379`	`if let TypeKind::UserDefined(ref x) = x.r#type.kind {`
`379`		`- if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {`
`380`		`- return traverse_type_symbol(symbol.found.id, path);`
	`380`	`+ if let Some(id) = x.symbol {`
	`381`	`+ return traverse_type_symbol(id, path);`
`381`	`382`	`}`
`382`	`383`	`} else {`
`383`	`384`	`return vec![path.clone()];`
`@@ -387,8 +388,8 @@ fn traverse_type_symbol(id: SymbolId, path: &VarRefPath) -> Vec<VarRefPath> {`
`387`	`388`	`let r#type: Result<crate::symbol::Type, ()> = (&x.value).try_into();`
`388`	`389`	`if let Ok(r#type) = r#type {`
`389`	`390`	`if let TypeKind::UserDefined(ref x) = r#type.kind {`
`390`		`- if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {`
`391`		`- return traverse_type_symbol(symbol.found.id, path);`
	`391`	`+ if let Some(id) = x.symbol {`
	`392`	`+ return traverse_type_symbol(id, path);`
`392`	`393`	`}`
`393`	`394`	`} else {`
`394`	`395`	`return vec![path.clone()];`
`@@ -451,8 +452,8 @@ fn traverse_assignable_symbol(id: SymbolId, path: &VarRefPath) -> Vec<VarRefPath`
`451`	`452`	`SymbolKind::Port(x) if is_assignable(&x.direction) && !x.is_proto => {`
`452`	`453`	`if let Some(ref x) = x.r#type {`
`453`	`454`	`if let TypeKind::UserDefined(ref x) = x.kind {`
`454`		`- if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {`
`455`		`- return traverse_type_symbol(symbol.found.id, path);`
	`455`	`+ if let Some(id) = x.symbol {`
	`456`	`+ return traverse_type_symbol(id, path);`
`456`	`457`	`}`
`457`	`458`	`} else {`
`458`	`459`	`return vec![path.clone()];`
`@@ -465,8 +466,8 @@ fn traverse_assignable_symbol(id: SymbolId, path: &VarRefPath) -> Vec<VarRefPath`
`465`	`466`	`\|\| x.affiliation == VariableAffiliation::StatementBlock =>`
`466`	`467`	`{`
`467`	`468`	`if let TypeKind::UserDefined(ref x) = x.r#type.kind {`
`468`		`- if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) {`
`469`		`- return traverse_type_symbol(symbol.found.id, path);`
	`469`	`+ if let Some(id) = x.symbol {`
	`470`	`+ return traverse_type_symbol(id, path);`
`470`	`471`	`}`
`471`	`472`	`} else {`
`472`	`473`	`return vec![path.clone()];`
Original file line number	Diff line number	Diff line change
`@@ -912,16 +912,18 @@ fn completion_member(url: &Url, line: usize, column: usize, text: &str) -> Vec<C`
`912`	`912`	`VerylSymbolKind::Port(x) => {`
`913`	`913`	`if let Some(ref x) = x.r#type {`
`914`	`914`	`if let TypeKind::UserDefined(ref x) = x.kind {`
`915`		`- if let Ok(symbol) = symbol_table::resolve((x, &namespace)) {`
`916`		`- items.append(&mut get_member(&symbol.found));`
	`915`	`+ if let Some(id) = x.symbol {`
	`916`	`+ let symbol = symbol_table::get(id).unwrap();`
	`917`	`+ items.append(&mut get_member(&symbol));`
`917`	`918`	`}`
`918`	`919`	`}`
`919`	`920`	`}`
`920`	`921`	`}`
`921`	`922`	`VerylSymbolKind::Variable(x) => {`
`922`	`923`	`if let TypeKind::UserDefined(ref x) = x.r#type.kind {`
`923`		`- if let Ok(symbol) = symbol_table::resolve((x, &namespace)) {`
`924`		`- items.append(&mut get_member(&symbol.found));`
	`924`	`+ if let Some(id) = x.symbol {`
	`925`	`+ let symbol = symbol_table::get(id).unwrap();`
	`926`	`+ items.append(&mut get_member(&symbol));`
`925`	`927`	`}`
`926`	`928`	`}`
`927`	`929`	`}`