Implement references for architecture. #155

Author: kraigher

vhdl_lang/src/analysis/analyze.rs

@@ -153,7 +153,7 @@ pub(super) struct AnalyzeContext<'a> {
     current_unit: UnitId,
     pub(super) arena: &'a Arena,
     uses: RefCell<FnvHashSet<UnitId>>,
-    missing_primary: RefCell<FnvHashSet<(Symbol, Symbol)>>,
+    missing_unit: RefCell<FnvHashSet<(Symbol, Symbol, Option<Symbol>)>>,
     uses_library_all: RefCell<FnvHashSet<Symbol>>,
 }
 
@@ -176,7 +176,7 @@ impl<'a> AnalyzeContext<'a> {
             current_unit: current_unit.clone(),
             arena,
             uses: RefCell::new(FnvHashSet::default()),
-            missing_primary: RefCell::new(FnvHashSet::default()),
+            missing_unit: RefCell::new(FnvHashSet::default()),
             uses_library_all: RefCell::new(FnvHashSet::default()),
         }
     }
@@ -214,13 +214,26 @@ impl<'a> AnalyzeContext<'a> {
         }
     }
 
-    fn make_use_of_missing_primary(&self, library_name: &Symbol, primary_name: &Symbol) {
-        let key = (library_name.clone(), primary_name.clone());
+    fn make_use_of_missing_unit(
+        &self,
+        library_name: &Symbol,
+        primary_name: &Symbol,
+        secondary_name: Option<&Symbol>,
+    ) {
+        let key = (
+            library_name.clone(),
+            primary_name.clone(),
+            secondary_name.cloned(),
+        );
 
         // Check local cache before taking lock
-        if self.missing_primary.borrow_mut().insert(key) {
-            self.root
-                .make_use_of_missing_primary(&self.current_unit, library_name, primary_name);
+        if self.missing_unit.borrow_mut().insert(key) {
+            self.root.make_use_of_missing_unit(
+                &self.current_unit,
+                library_name,
+                primary_name,
+                secondary_name,
+            );
         }
     }
 
@@ -334,16 +347,63 @@ impl<'a> AnalyzeContext<'a> {
 
     fn get_primary_unit(&self, library_name: &Symbol, name: &Symbol) -> Option<&'a LockedUnit> {
         let units = self.root.get_library_units(library_name)?;
-        // @TODO missing library
-
         if let Some(unit) = units.get(&UnitKey::Primary(name.clone())) {
             return Some(unit);
         }
+        self.make_use_of_missing_unit(library_name, name, None);
+        None
+    }
 
-        self.make_use_of_missing_primary(library_name, name);
+    fn get_secondary_unit(
+        &self,
+        library_name: &Symbol,
+        primary: &Symbol,
+        name: &Symbol,
+    ) -> Option<&'a LockedUnit> {
+        let units = self.root.get_library_units(library_name)?;
+        if let Some(unit) = units.get(&UnitKey::Secondary(primary.clone(), name.clone())) {
+            return Some(unit);
+        }
+        self.make_use_of_missing_unit(library_name, primary, Some(name));
         None
     }
 
+    pub(super) fn get_architecture(
+        &self,
+        library_name: &Symbol,
+        pos: &SrcPos,
+        entity_name: &Symbol,
+        architecture_name: &Symbol,
+    ) -> AnalysisResult<DesignEnt<'a>> {
+        if let Some(unit) = self.get_secondary_unit(library_name, entity_name, architecture_name) {
+            let data = self.get_analysis(Some(pos), unit)?;
+            if let AnyDesignUnit::Secondary(AnySecondaryUnit::Architecture(arch)) = data.deref() {
+                if let Some(id) = arch.ident.decl {
+                    let ent = self.arena.get(id);
+                    let design = DesignEnt::from_any(ent).ok_or_else(|| {
+                        // Almost impossible but better not fail silently
+                        Diagnostic::error(
+                            pos,
+                            format!(
+                                "Found non-design {} unit within library {}",
+                                ent.describe(),
+                                library_name
+                            ),
+                        )
+                    })?;
+                    return Ok(design);
+                }
+            }
+        }
+
+        Err(AnalysisError::NotFatal(Diagnostic::error(
+            pos,
+            format!(
+                "No architecture '{architecture_name}' for entity '{library_name}.{entity_name}'"
+            ),
+        )))
+    }
+
     pub fn lookup_in_library(
         &self,
         library_name: &Symbol,

vhdl_lang/src/analysis/concurrent.rs

@@ -208,8 +208,7 @@ impl<'a> AnalyzeContext<'a> {
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
         match instance.unit {
-            // @TODO architecture
-            InstantiatedUnit::Entity(ref mut entity_name, ..) => {
+            InstantiatedUnit::Entity(ref mut entity_name, ref mut architecture_name) => {
                 if let Err(err) =
                     self.resolve_selected_name(scope, entity_name)
                         .and_then(|entities| {
@@ -220,7 +219,27 @@ impl<'a> AnalyzeContext<'a> {
                                 expected,
                             )?;
 
-                            if let AnyEntKind::Design(Design::Entity(_, ent_region)) = ent.kind() {
+                            if let AnyEntKind::Design(Design::Entity(library_name, _, ent_region)) =
+                                ent.kind()
+                            {
+                                if let Designator::Identifier(entity_ident) = ent.designator() {
+                                    if let Some(ref mut architecture_name) = architecture_name {
+                                        match self.get_architecture(
+                                            library_name,
+                                            &architecture_name.item.pos,
+                                            entity_ident,
+                                            &architecture_name.item.item,
+                                        ) {
+                                            Ok(arch) => {
+                                                architecture_name.set_unique_reference(&arch);
+                                            }
+                                            Err(err) => {
+                                                diagnostics.push(err.into_non_fatal()?);
+                                            }
+                                        }
+                                    }
+                                }
+
                                 let (generic_region, port_region) = ent_region.to_entity_formal();
 
                                 self.analyze_assoc_elems_with_formal_region(

vhdl_lang/src/analysis/design_unit.rs

@@ -71,7 +71,11 @@ impl<'a> AnalyzeContext<'a> {
         self.redefine(
             id,
             &mut unit.ident,
-            AnyEntKind::Design(Design::Entity(visibility, region)),
+            AnyEntKind::Design(Design::Entity(
+                self.work_library_name().clone(),
+                visibility,
+                region,
+            )),
         );
 
         Ok(())
@@ -217,7 +221,7 @@ impl<'a> AnalyzeContext<'a> {
         self.check_secondary_before_primary(&primary, unit.pos(), diagnostics);
 
         let (visibility, region) =
-            if let Design::Entity(ref visibility, ref region) = primary.kind() {
+            if let Design::Entity(_, ref visibility, ref region) = primary.kind() {
                 (visibility, region)
             } else {
                 let mut diagnostic = Diagnostic::error(unit.pos(), "Expected an entity");
@@ -233,13 +237,14 @@ impl<'a> AnalyzeContext<'a> {
         self.analyze_context_clause(&root_scope, &mut unit.context_clause, diagnostics)?;
         let scope = Scope::extend(region, Some(&root_scope));
 
-        // Architecture name is visible
-        scope.make_potentially_visible(
-            Some(unit.pos()),
-            self.arena
-                .explicit(unit.name().clone(), AnyEntKind::Label, Some(unit.pos())),
+        let arch = self.arena.define(
+            &mut unit.ident,
+            AnyEntKind::Design(Design::Architecture(primary)),
         );
 
+        // Architecture name is visible
+        scope.make_potentially_visible(Some(unit.pos()), arch);
+
         self.define_labels_for_concurrent_part(&scope, &mut unit.statements, diagnostics)?;
         self.analyze_declarative_part(&scope, &mut unit.decl, diagnostics)?;
         self.analyze_concurrent_part(&scope, &mut unit.statements, diagnostics)?;

vhdl_lang/src/analysis/named_entity/design.rs

@@ -15,12 +15,14 @@ use crate::analysis::visibility::Visibility;
 use crate::ast::Designator;
 use crate::ast::HasDesignator;
 use crate::ast::WithRef;
+use crate::data::Symbol;
 use crate::data::WithPos;
 use crate::Diagnostic;
 use crate::SrcPos;
 
 pub enum Design<'a> {
-    Entity(Visibility<'a>, Region<'a>),
+    Entity(Symbol, Visibility<'a>, Region<'a>),
+    Architecture(DesignEnt<'a>),
     Configuration,
     Package(Visibility<'a>, Region<'a>),
     UninstPackage(Visibility<'a>, Region<'a>),
@@ -33,6 +35,7 @@ impl<'a> Design<'a> {
         use Design::*;
         match self {
             Entity(..) => "entity",
+            Architecture(..) => "architecture",
             Configuration => "configuration",
             Package(..) => "package",
             UninstPackage(..) => "uninstantiated package",

vhdl_lang/src/analysis/root.rs

@@ -267,8 +267,9 @@ pub struct DesignRoot {
     // user  =>  set(users)
     users_of: RwLock<FnvHashMap<UnitId, FnvHashSet<UnitId>>>,
 
-    // missing primary name  =>  set(affected)
-    missing_primary: RwLock<FnvHashMap<(Symbol, Symbol), FnvHashSet<UnitId>>>,
+    // missing unit name  =>  set(affected)
+    #[allow(clippy::type_complexity)]
+    missing_unit: RwLock<FnvHashMap<(Symbol, Symbol, Option<Symbol>), FnvHashSet<UnitId>>>,
 
     // Tracks which units have a "use library.all;" clause.
     // library name  =>  set(affected)
@@ -287,7 +288,7 @@ impl DesignRoot {
             arenas: FinalArena::default(),
             libraries: FnvHashMap::default(),
             users_of: RwLock::new(FnvHashMap::default()),
-            missing_primary: RwLock::new(FnvHashMap::default()),
+            missing_unit: RwLock::new(FnvHashMap::default()),
             users_of_library_all: RwLock::new(FnvHashMap::default()),
         }
     }
@@ -607,16 +608,21 @@ impl DesignRoot {
         }
     }
 
-    /// Make use of a missing primary name. The library unit will be sensitive to adding such a primary unit in the future.
-    pub(super) fn make_use_of_missing_primary(
+    /// Make use of a missing unit name. The library unit will be sensitive to adding such a unit in the future.
+    pub(super) fn make_use_of_missing_unit(
         &self,
         user: &UnitId,
         library_name: &Symbol,
         primary_name: &Symbol,
+        secondary_name: Option<&Symbol>,
     ) {
-        let mut missing_primary = self.missing_primary.write();
-        let key = (library_name.clone(), primary_name.clone());
-        match missing_primary.entry(key) {
+        let mut missing_unit = self.missing_unit.write();
+        let key = (
+            library_name.clone(),
+            primary_name.clone(),
+            secondary_name.cloned(),
+        );
+        match missing_unit.entry(key) {
             Entry::Occupied(mut entry) => {
                 entry.get_mut().insert(user.clone());
             }
@@ -659,10 +665,12 @@ impl DesignRoot {
                 }
             }
         }
-        let missing_primary = self.missing_primary.read();
-        for ((library_name, primary_name), unit_ids) in missing_primary.iter() {
+        let missing_unit = self.missing_unit.read();
+        for ((library_name, primary_name, secondary_name), unit_ids) in missing_unit.iter() {
             let was_added = added.iter().any(|added_id| {
-                added_id.library_name() == library_name && added_id.primary_name() == primary_name
+                added_id.library_name() == library_name
+                    && added_id.primary_name() == primary_name
+                    && added_id.secondary_name() == secondary_name.as_ref()
             });
 
             if was_added {
@@ -686,11 +694,11 @@ impl DesignRoot {
         self.reset_affected(get_all_affected(&users_of, affected));
         drop(users_of);
         drop(users_of_library_all);
-        drop(missing_primary);
+        drop(missing_unit);
 
         let mut users_of = self.users_of.write();
         let mut users_of_library_all = self.users_of_library_all.write();
-        let mut missing_primary = self.missing_primary.write();
+        let mut missing_unit = self.missing_unit.write();
 
         // Clean-up after removed units
         for removed_unit in removed.iter() {
@@ -701,7 +709,7 @@ impl DesignRoot {
                 library_all_affected.remove(removed_unit);
             }
 
-            missing_primary.retain(|_, unit_ids| {
+            missing_unit.retain(|_, unit_ids| {
                 unit_ids.remove(removed_unit);
                 !unit_ids.is_empty()
             });

vhdl_lang/src/analysis/tests/resolves_names.rs

@@ -1841,3 +1841,62 @@ end package body;
         Some(&code.s("c0", 2).pos())
     );
 }
+
+#[test]
+fn find_architecture_references() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.code(
+        "libname",
+        "
+entity ent1 is
+end entity;
+
+architecture a1 of ent1 is
+begin
+end architecture;
+
+architecture a2 of ent1 is
+begin
+end architecture;
+
+entity ent2 is
+end entity;
+
+architecture a of ent2 is
+begin
+    good_inst1 : entity work.ent1(a1);
+    good_inst2 : entity work.ent1(a2);
+    bad_inst : entity work.ent1(a3);
+end architecture;
+      ",
+    );
+
+    let (root, diagnostics) = builder.get_analyzed_root();
+    check_diagnostics(
+        diagnostics,
+        vec![Diagnostic::error(
+            code.sa("work.ent1(", "a3"),
+            "No architecture 'a3' for entity 'libname.ent1'",
+        )],
+    );
+
+    assert_eq_unordered(
+        &root.find_all_references_pos(&code.s("a1", 1).pos()),
+        &[code.s("a1", 1).pos(), code.s("a1", 2).pos()],
+    );
+
+    assert_eq_unordered(
+        &root.find_all_references_pos(&code.s("a1", 2).pos()),
+        &[code.s("a1", 1).pos(), code.s("a1", 2).pos()],
+    );
+
+    assert_eq!(
+        root.find_definition_of(
+            root.search_reference(code.source(), code.s("a2", 2).start())
+                .unwrap()
+        )
+        .unwrap()
+        .decl_pos(),
+        Some(&code.s("a2", 1).pos())
+    );
+}

vhdl_lang/src/ast.rs

@@ -1007,7 +1007,7 @@ pub struct ConcurrentSignalAssignment {
 #[derive(PartialEq, Debug, Clone)]
 pub enum InstantiatedUnit {
     Component(WithPos<SelectedName>),
-    Entity(WithPos<SelectedName>, Option<Ident>),
+    Entity(WithPos<SelectedName>, Option<WithRef<Ident>>),
     Configuration(WithPos<SelectedName>),
 }
 
@@ -1204,7 +1204,7 @@ pub struct EntityDeclaration {
 #[derive(PartialEq, Debug, Clone)]
 pub struct ArchitectureBody {
     pub context_clause: ContextClause,
-    pub ident: Ident,
+    pub ident: WithDecl<Ident>,
     pub entity_name: WithRef<Ident>,
     pub decl: Vec<Declaration>,
     pub statements: Vec<LabeledConcurrentStatement>,