support embed component path

(refs: #1751)

Author: taichi-ishitani

crates/analyzer/src/handlers/create_symbol_table.rs

@@ -2255,15 +2255,23 @@ impl VerylGrammarTrait for CreateSymbolTable {
                 }
             }
 
-            let content = &arg.embed_content.embed_content_token.token;
+            let content = &arg.embed_content;
+            let content_source = content
+                .embed_triple_l_brace
+                .embed_triple_l_brace_token
+                .token
+                .source;
             let r#type = match way.as_str() {
                 "inline" => Some(TestType::Inline),
-                "cocotb" => Some(TestType::CocotbEmbed(content.text)),
+                "cocotb" => Some(TestType::CocotbEmbed(
+                    content.as_ref().clone(),
+                    self.namespace.clone(),
+                )),
                 _ => None,
             };
 
             if let (Some((token, top)), Some(r#type)) = (test_attr, r#type) {
-                let path = if let TokenSource::File { path, .. } = content.source {
+                let path = if let TokenSource::File { path, .. } = content_source {
                     path
                 } else {
                     unreachable!()

crates/analyzer/src/symbol.rs

@@ -2176,7 +2176,7 @@ pub struct GenericInstanceProperty {
 #[derive(Debug, Clone)]
 pub enum TestType {
     Inline,
-    CocotbEmbed(StrId),
+    CocotbEmbed(syntax_tree::EmbedContent, Namespace),
     CocotbInclude(StrId),
 }
 

crates/analyzer/src/symbol_path.rs

@@ -1,7 +1,7 @@
 use crate::namespace::Namespace;
 use crate::namespace_table;
 use crate::symbol::{DocComment, GenericInstanceProperty, GenericMap, Symbol, SymbolKind};
-use crate::symbol_table;
+use crate::symbol_table::{self, ResolveError, ResolveResult};
 use crate::{SVec, svec};
 use std::cmp::Ordering;
 use std::fmt;
@@ -460,6 +460,66 @@ impl GenericSymbolPath {
         }
     }
 
+    pub fn resolve_path(
+        &self,
+        namespace: &Namespace,
+        generic_maps: Option<&Vec<GenericMap>>,
+    ) -> (Result<ResolveResult, ResolveError>, GenericSymbolPath) {
+        let mut path = self.clone();
+        path.resolve_imported(namespace, generic_maps);
+
+        for i in 0..path.len() {
+            let base = path.base_path(i);
+            if let Ok(symbol) = symbol_table::resolve((&base, namespace)) {
+                if !symbol.found.kind.is_generic() {
+                    continue;
+                }
+
+                let params = symbol.found.generic_parameters();
+                let n_args = path.paths[i].arguments.len();
+
+                for param in params.iter().skip(n_args) {
+                    path.paths[i]
+                        .arguments
+                        .push(param.1.default_value.as_ref().unwrap().clone());
+                }
+
+                for arg in &mut path.paths[i].arguments {
+                    if let Ok(symbol) = symbol_table::resolve((&arg.mangled_path(), namespace)) {
+                        if let Some(target) = symbol.found.alias_target() {
+                            if let (Ok(_), path) =
+                                target.resolve_path(&symbol.found.namespace, generic_maps)
+                            {
+                                *arg = path;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if let Some(maps) = generic_maps {
+            path.apply_map(maps);
+        }
+
+        let result = symbol_table::resolve((&path.mangled_path(), namespace));
+        if let Ok(symbol) = &result {
+            if let Some(target) = symbol.found.alias_target() {
+                if let Some(parent) = symbol.found.get_parent() {
+                    if matches!(parent.kind, SymbolKind::GenericInstance(_)) {
+                        // Alias target may be a generic parameter if it is defined in a generic package.
+                        // Need to apply parent's generic map to resolve a generic parameter.
+                        let map = parent.generic_maps();
+                        return target.resolve_path(&symbol.found.namespace, Some(&map));
+                    }
+                }
+                return target.resolve_path(&symbol.found.namespace, generic_maps);
+            }
+        }
+
+        (result, path)
+    }
+
     /// Resolve and expand path if the path is imported at declaration
     pub fn resolve_imported(
         &mut self,

crates/analyzer/src/tests.rs

@@ -3770,6 +3770,20 @@ fn undefined_identifier() {
         errors[1],
         AnalyzerError::UndefinedIdentifier { .. }
     ));
+
+    let code = r#"
+    module ModuleA {
+        embed(inline) sv {{{
+            \((( ModuleB ))) u_monitor();
+        }}}
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(matches!(
+        errors[0],
+        AnalyzerError::UndefinedIdentifier { .. }
+    ));
 }
 
 #[test]

crates/emitter/src/emitter.rs

@@ -60,6 +60,7 @@ pub struct Emitter {
     single_line: Vec<()>,
     multi_line: Vec<()>,
     adjust_line: bool,
+    keep_tail_newline: bool,
     in_always_ff: bool,
     in_direction_modport: bool,
     in_direction_with_var: bool,
@@ -108,6 +109,7 @@ impl Default for Emitter {
             single_line: Vec::new(),
             multi_line: Vec::new(),
             adjust_line: false,
+            keep_tail_newline: false,
             in_always_ff: false,
             in_direction_modport: false,
             in_direction_with_var: false,
@@ -328,7 +330,7 @@ impl Emitter {
     fn push_token(&mut self, x: &Token) {
         self.consume_adjust_line(x);
         let text = resource_table::get_str_value(x.text).unwrap();
-        let text = if text.ends_with('\n') {
+        let text = if !self.keep_tail_newline && text.ends_with('\n') {
             self.consumed_next_newline = true;
             text.trim_end()
         } else {
@@ -1559,8 +1561,7 @@ impl Emitter {
             }
 
             let user_defined = r#type.unwrap().get_user_defined()?;
-            let (type_symbol, _) =
-                resolve_generic_path(&user_defined.path, &symbol.namespace, Some(map));
+            let (type_symbol, _) = user_defined.path.resolve_path(&symbol.namespace, Some(map));
             type_symbol
                 .ok()
                 .map(|x| (x.found, x.full_path, x.generic_tables))
@@ -1796,10 +1797,10 @@ impl Emitter {
     ) -> (Result<ResolveResult, ResolveError>, GenericSymbolPath) {
         let generic_map = self.generic_map.last();
         if let Some(namespace) = namespace {
-            resolve_generic_path(path, namespace, generic_map)
+            path.resolve_path(namespace, generic_map)
         } else {
             let namespace = namespace_table::get(path.paths[0].base.id).unwrap();
-            resolve_generic_path(path, &namespace, generic_map)
+            path.resolve_path(&namespace, generic_map)
         }
     }
 
@@ -2007,6 +2008,11 @@ impl VerylWalker for Emitter {
         }
     }
 
+    /// Semantic action for non-terminal 'EscapedBackslash'
+    fn escaped_backslash(&mut self, arg: &EscapedBackslash) {
+        self.token(&arg.escaped_backslash_token.replace("\\"));
+    }
+
     /// Semantic action for non-terminal 'Bool'
     fn bool(&mut self, arg: &Bool) {
         self.veryl_token(&arg.bool_token.replace("logic"));
@@ -5268,21 +5274,39 @@ impl VerylWalker for Emitter {
     /// Semantic action for non-terminal 'EmbedDeclaration'
     fn embed_declaration(&mut self, arg: &EmbedDeclaration) {
         if arg.identifier.identifier_token.to_string() == "inline" {
-            let text = arg.embed_content.embed_content_token.to_string();
-            let text = if arg.identifier0.identifier_token.to_string() == "sv" {
-                &text
-                    .replace("{{{", "`ifndef SYNTHESIS")
-                    .replace("}}}", "`endif")
-            } else {
-                text.strip_prefix("{{{")
-                    .unwrap()
-                    .strip_prefix("}}}")
-                    .unwrap()
-            };
-            self.veryl_token(&arg.embed_content.embed_content_token.replace(text));
+            let is_sv = arg.identifier0.identifier_token.to_string() == "sv";
+
+            if is_sv {
+                self.token(
+                    &arg.embed_content
+                        .embed_triple_l_brace
+                        .embed_triple_l_brace_token
+                        .replace("`ifndef SYNTHESIS"),
+                );
+            }
+
+            self.keep_tail_newline = true;
+            for x in &arg.embed_content.embed_content_list {
+                self.embed_item(&x.embed_item);
+            }
+            self.keep_tail_newline = false;
+
+            if is_sv {
+                self.token(
+                    &arg.embed_content
+                        .embed_triple_r_brace
+                        .embed_triple_r_brace_token
+                        .replace("`endif"),
+                );
+            }
         }
     }
 
+    /// Semantic action for non-terminal 'EmbedIdentifier'
+    fn embed_identifier(&mut self, arg: &EmbedIdentifier) {
+        self.scoped_identifier(&arg.scoped_identifier);
+    }
+
     /// Semantic action for non-terminal 'IncludeDeclaration'
     fn include_declaration(&mut self, arg: &IncludeDeclaration) {
         if arg.identifier.identifier_token.to_string() == "inline" {
@@ -5724,63 +5748,3 @@ pub fn emitting_identifier(arg: &Identifier) -> Identifier {
     };
     identifier_with_prefix_suffix(arg, &prefix, &suffix)
 }
-
-pub fn resolve_generic_path(
-    path: &GenericSymbolPath,
-    namespace: &Namespace,
-    generic_maps: Option<&Vec<GenericMap>>,
-) -> (Result<ResolveResult, ResolveError>, GenericSymbolPath) {
-    let mut path = path.clone();
-    path.resolve_imported(namespace, generic_maps);
-
-    for i in 0..path.len() {
-        let base = path.base_path(i);
-        if let Ok(symbol) = symbol_table::resolve((&base, namespace)) {
-            if !symbol.found.kind.is_generic() {
-                continue;
-            }
-
-            let params = symbol.found.generic_parameters();
-            let n_args = path.paths[i].arguments.len();
-
-            for param in params.iter().skip(n_args) {
-                path.paths[i]
-                    .arguments
-                    .push(param.1.default_value.as_ref().unwrap().clone());
-            }
-
-            for arg in &mut path.paths[i].arguments {
-                if let Ok(symbol) = symbol_table::resolve((&arg.mangled_path(), namespace)) {
-                    if let Some(target) = symbol.found.alias_target() {
-                        if let (Ok(_), path) =
-                            resolve_generic_path(&target, &symbol.found.namespace, generic_maps)
-                        {
-                            *arg = path;
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    if let Some(maps) = generic_maps {
-        path.apply_map(maps);
-    }
-
-    let result = symbol_table::resolve((&path.mangled_path(), namespace));
-    if let Ok(symbol) = &result {
-        if let Some(target) = symbol.found.alias_target() {
-            if let Some(parent) = symbol.found.get_parent() {
-                if matches!(parent.kind, SymbolKind::GenericInstance(_)) {
-                    // Alias target may be a generic parameter if it is defined in a generic package.
-                    // Need to apply parent's generic map to resolve a generic parameter.
-                    let map = parent.generic_maps();
-                    return resolve_generic_path(&target, &symbol.found.namespace, Some(&map));
-                }
-            }
-            return resolve_generic_path(&target, &symbol.found.namespace, generic_maps);
-        }
-    }
-
-    (result, path)
-}

crates/emitter/src/expaneded_modport.rs

@@ -1,4 +1,4 @@
-use crate::emitter::{SymbolContext, resolve_generic_path, symbol_string};
+use crate::emitter::{SymbolContext, symbol_string};
 use std::collections::HashMap;
 use veryl_analyzer::attribute::ExpandItem;
 use veryl_analyzer::attribute_table;
@@ -497,7 +497,7 @@ fn resolve_interface(
     let mut path = user_defined.get_user_defined()?.path.clone();
     path.paths.pop(); // remove modport path
 
-    let (result, _) = resolve_generic_path(&path, namespace, Some(&generic_map.to_vec()));
+    let (result, _) = path.resolve_path(namespace, Some(&generic_map.to_vec()));
     result
         .ok()
         .map(|x| (x.found, x.full_path, x.generic_tables))

crates/formatter/src/formatter.rs

@@ -32,6 +32,7 @@ pub struct Formatter {
     single_line: Vec<()>,
     multi_line: Vec<()>,
     adjust_line: bool,
+    keep_tail_newline: bool,
     in_scalar_type: bool,
     in_expression: Vec<()>,
     in_attribute: bool,
@@ -53,6 +54,7 @@ impl Default for Formatter {
             single_line: Vec::new(),
             multi_line: Vec::new(),
             adjust_line: false,
+            keep_tail_newline: false,
             in_scalar_type: false,
             in_expression: Vec::new(),
             in_attribute: false,
@@ -214,7 +216,7 @@ impl Formatter {
     fn push_token(&mut self, x: &Token) {
         self.consume_adjust_line(x);
         let text = resource_table::get_str_value(x.text).unwrap();
-        let text = if text.ends_with('\n') {
+        let text = if !self.keep_tail_newline && text.ends_with('\n') {
             self.consumed_next_newline = true;
             text.trim_end()
         } else {
@@ -2780,6 +2782,37 @@ impl VerylWalker for Formatter {
         self.embed_content(&arg.embed_content);
     }
 
+    /// Semantic action for non-terminal 'EmbedContent'
+    fn embed_content(&mut self, arg: &EmbedContent) {
+        self.embed_triple_l_brace(&arg.embed_triple_l_brace);
+        self.keep_tail_newline = true;
+        for x in &arg.embed_content_list {
+            self.embed_item(&x.embed_item);
+        }
+        self.keep_tail_newline = false;
+        if !self
+            .string
+            .chars()
+            .last()
+            .map(|c| c.is_ascii_whitespace())
+            .unwrap_or(false)
+        {
+            self.newline();
+        }
+        self.embed_triple_r_brace(&arg.embed_triple_r_brace);
+    }
+
+    /// Semantic action for non-terminal 'EmbedIdentifier'
+    fn embed_identifier(&mut self, arg: &EmbedIdentifier) {
+        self.escaped_l_paren(&arg.escaped_l_paren);
+        self.embed_l_paren(&arg.embed_l_paren);
+        self.embed_l_paren(&arg.embed_l_paren0);
+        self.scoped_identifier(&arg.scoped_identifier);
+        self.embed_r_paren(&arg.embed_r_paren);
+        self.embed_r_paren(&arg.embed_r_paren0);
+        self.embed_r_paren(&arg.embed_r_paren1);
+    }
+
     /// Semantic action for non-terminal 'IncludeDeclaration'
     fn include_declaration(&mut self, arg: &IncludeDeclaration) {
         self.include(&arg.include);