AnyEntKind::Entity does not need library name

Author: kraigher

vhdl_lang/src/analysis/concurrent.rs

@@ -261,22 +261,22 @@ impl<'a> AnalyzeContext<'a> {
                                 expected,
                             )?;
 
-                            if let AnyEntKind::Design(Design::Entity(library_name, _, ent_region)) =
-                                ent.kind()
-                            {
+                            if let AnyEntKind::Design(Design::Entity(_, 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()?);
+                                    if let Some(library_name) = ent.library_name() {
+                                        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()?);
+                                                }
                                             }
                                         }
                                     }

vhdl_lang/src/analysis/design_unit.rs

@@ -74,11 +74,7 @@ impl<'a> AnalyzeContext<'a> {
         let region = primary_scope.into_region();
         let visibility = root_scope.into_visibility();
 
-        let kind = AnyEntKind::Design(Design::Entity(
-            self.work_library_name().clone(),
-            visibility,
-            region,
-        ));
+        let kind = AnyEntKind::Design(Design::Entity(visibility, region));
         unsafe { ent.set_kind(kind) }
 
         Ok(())
@@ -231,7 +227,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");

vhdl_lang/src/analysis/named_entity/design.rs

@@ -15,13 +15,12 @@ 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(Symbol, Visibility<'a>, Region<'a>),
+    Entity(Visibility<'a>, Region<'a>),
     Architecture(DesignEnt<'a>),
     Configuration,
     Package(Visibility<'a>, Region<'a>),