Add anonymous designator for labels and implicit operators

Author: kraigher

vhdl_lang/src/analysis/concurrent.rs

@@ -20,11 +20,28 @@ impl<'a> AnalyzeContext<'a> {
     pub fn analyze_concurrent_part(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         statements: &mut [LabeledConcurrentStatement],
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
         for statement in statements.iter_mut() {
+            let parent = if statement.statement.can_have_label() {
+                if let Some(id) = statement.label.as_ref().and_then(|label| label.decl) {
+                    self.arena.get(id)
+                } else {
+                    // Generate an anonymous label if it is not explicitly defined
+                    self.arena.alloc(
+                        Designator::Anonymous(scope.next_anonymous()),
+                        Some(parent),
+                        Related::None,
+                        AnyEntKind::Label,
+                        None,
+                    )
+                }
+            } else {
+                parent
+            };
+
             self.analyze_concurrent_statement(scope, parent, statement, diagnostics)?;
         }
 
@@ -34,7 +51,7 @@ impl<'a> AnalyzeContext<'a> {
     pub fn define_labels_for_concurrent_part(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         statements: &mut [LabeledConcurrentStatement],
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
@@ -53,17 +70,10 @@ impl<'a> AnalyzeContext<'a> {
     fn analyze_concurrent_statement(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         statement: &mut LabeledConcurrentStatement,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
-        // @TODO without label use orginal parent, should unlabeled statements be implicitly declared?
-        let parent = if let Some(id) = statement.label.as_ref().and_then(|label| label.decl) {
-            Some(self.arena.get(id))
-        } else {
-            parent
-        };
-
         match statement.statement {
             ConcurrentStatement::Block(ref mut block) => {
                 if let Some(ref mut guard_condition) = block.guard_condition {
@@ -204,7 +214,7 @@ impl<'a> AnalyzeContext<'a> {
     fn analyze_generate_body(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         body: &mut GenerateBody,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
@@ -219,7 +229,7 @@ impl<'a> AnalyzeContext<'a> {
         if let Some(label) = alternative_label {
             let ent = label.define(self.arena, parent, AnyEntKind::Label);
             scope.add(ent, diagnostics);
-            inner_parent = Some(ent);
+            inner_parent = ent;
         }
 
         // Pre-declare labels

vhdl_lang/src/analysis/declarative.rs

@@ -23,7 +23,7 @@ impl<'a> AnalyzeContext<'a> {
     pub fn analyze_declarative_part(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         declarations: &mut [Declaration],
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
@@ -116,7 +116,7 @@ impl<'a> AnalyzeContext<'a> {
     fn analyze_alias_declaration(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         alias: &mut AliasDeclaration,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> EvalResult<EntRef<'a>> {
@@ -220,7 +220,7 @@ impl<'a> AnalyzeContext<'a> {
     pub(crate) fn analyze_declaration(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         decl: &mut Declaration,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
@@ -302,7 +302,7 @@ impl<'a> AnalyzeContext<'a> {
 
                         let object_ent = self.arena.alloc(
                             object_decl.ident.tree.item.clone().into(),
-                            parent,
+                            Some(parent),
                             if let Some(declared_by) = declared_by {
                                 Related::DeclaredBy(declared_by)
                             } else {
@@ -358,16 +358,11 @@ impl<'a> AnalyzeContext<'a> {
                 );
                 self.analyze_interface_list(
                     &nested,
-                    Some(ent),
+                    ent,
                     &mut component.generic_list,
                     diagnostics,
                 )?;
-                self.analyze_interface_list(
-                    &nested,
-                    Some(ent),
-                    &mut component.port_list,
-                    diagnostics,
-                )?;
+                self.analyze_interface_list(&nested, ent, &mut component.port_list, diagnostics)?;
 
                 let kind = AnyEntKind::Component(nested.into_region());
                 unsafe {
@@ -509,20 +504,20 @@ impl<'a> AnalyzeContext<'a> {
 
                 self.define_labels_for_sequential_part(
                     &subpgm_region,
-                    Some(subpgm_ent.into()),
+                    subpgm_ent.into(),
                     &mut body.statements,
                     diagnostics,
                 )?;
                 self.analyze_declarative_part(
                     &subpgm_region,
-                    Some(subpgm_ent.into()),
+                    subpgm_ent.into(),
                     &mut body.declarations,
                     diagnostics,
                 )?;
 
                 self.analyze_sequential_part(
                     &subpgm_region,
-                    Some(subpgm_ent.into()),
+                    subpgm_ent.into(),
                     &sroot,
                     &mut body.statements,
                     diagnostics,
@@ -608,7 +603,7 @@ impl<'a> AnalyzeContext<'a> {
     pub(crate) fn analyze_type_declaration(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         type_decl: &mut TypeDeclaration,
         // Is the full type declaration of an incomplete type
         // Overwrite id when defining full type
@@ -639,7 +634,7 @@ impl<'a> AnalyzeContext<'a> {
                 for literal in enumeration.iter_mut() {
                     let literal_ent = self.arena.explicit(
                         literal.tree.item.clone().into_designator(),
-                        Some(enum_type.into()),
+                        enum_type.into(),
                         AnyEntKind::Overloaded(Overloaded::EnumLiteral(signature.clone())),
                         Some(&literal.tree.pos),
                     );
@@ -692,7 +687,7 @@ impl<'a> AnalyzeContext<'a> {
                                         let region = Scope::extend(ptype_region, Some(scope));
                                         self.analyze_declarative_part(
                                             &region,
-                                            Some(ptype_body),
+                                            ptype_body,
                                             &mut body.decl,
                                             diagnostics,
                                         )?;
@@ -749,7 +744,7 @@ impl<'a> AnalyzeContext<'a> {
                         ProtectedTypeDeclarativeItem::Subprogram(ref mut subprogram) => {
                             match self.subprogram_declaration(
                                 scope,
-                                Some(ptype),
+                                ptype,
                                 subprogram,
                                 Overloaded::SubprogramDecl,
                                 diagnostics,
@@ -800,7 +795,7 @@ impl<'a> AnalyzeContext<'a> {
                         Ok(subtype) => {
                             let elem = self.arena.define(
                                 &mut elem_decl.ident,
-                                Some(type_ent.into()),
+                                type_ent.into(),
                                 AnyEntKind::ElementDeclaration(subtype),
                             );
                             region.add(elem, diagnostics);
@@ -1112,7 +1107,7 @@ impl<'a> AnalyzeContext<'a> {
     fn analyze_interface_declaration(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         decl: &mut InterfaceDeclaration,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> AnalysisResult<EntRef<'a>> {
@@ -1213,7 +1208,7 @@ impl<'a> AnalyzeContext<'a> {
     pub fn analyze_interface_list(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         declarations: &mut [InterfaceDeclaration],
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
@@ -1233,7 +1228,7 @@ impl<'a> AnalyzeContext<'a> {
     pub fn analyze_parameter_list(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         declarations: &mut [InterfaceDeclaration],
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult<FormalRegion<'a>> {
@@ -1425,7 +1420,7 @@ impl<'a> AnalyzeContext<'a> {
     fn subprogram_declaration(
         &self,
         scope: &Scope<'a>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         subprogram: &mut SubprogramDeclaration,
         to_kind: impl Fn(Signature<'a>) -> Overloaded<'a>,
         diagnostics: &mut dyn DiagnosticHandler,
@@ -1446,7 +1441,7 @@ impl<'a> AnalyzeContext<'a> {
             SubprogramDeclaration::Function(fun) => {
                 let params = self.analyze_parameter_list(
                     &subpgm_region,
-                    Some(ent),
+                    ent,
                     &mut fun.parameter_list,
                     diagnostics,
                 );
@@ -1456,7 +1451,7 @@ impl<'a> AnalyzeContext<'a> {
             SubprogramDeclaration::Procedure(procedure) => {
                 let params = self.analyze_parameter_list(
                     &subpgm_region,
-                    Some(ent),
+                    ent,
                     &mut procedure.parameter_list,
                     diagnostics,
                 );

vhdl_lang/src/analysis/design_unit.rs

@@ -57,19 +57,19 @@ impl<'a> AnalyzeContext<'a> {
         primary_scope.make_potentially_visible(Some(unit.pos()), ent);
 
         if let Some(ref mut list) = unit.generic_clause {
-            self.analyze_interface_list(&primary_scope, Some(ent), list, diagnostics)?;
+            self.analyze_interface_list(&primary_scope, ent, list, diagnostics)?;
         }
         if let Some(ref mut list) = unit.port_clause {
-            self.analyze_interface_list(&primary_scope, Some(ent), list, diagnostics)?;
+            self.analyze_interface_list(&primary_scope, ent, list, diagnostics)?;
         }
         self.define_labels_for_concurrent_part(
             &primary_scope,
-            Some(ent),
+            ent,
             &mut unit.statements,
             diagnostics,
         )?;
-        self.analyze_declarative_part(&primary_scope, Some(ent), &mut unit.decl, diagnostics)?;
-        self.analyze_concurrent_part(&primary_scope, Some(ent), &mut unit.statements, diagnostics)?;
+        self.analyze_declarative_part(&primary_scope, ent, &mut unit.decl, diagnostics)?;
+        self.analyze_concurrent_part(&primary_scope, ent, &mut unit.statements, diagnostics)?;
 
         let region = primary_scope.into_region();
         let visibility = root_scope.into_visibility();
@@ -118,7 +118,7 @@ impl<'a> AnalyzeContext<'a> {
 
         self.arena.define(
             &mut unit.ident,
-            Some(self.work_library()),
+            self.work_library(),
             AnyEntKind::Design(Design::Configuration),
         );
 
@@ -143,9 +143,9 @@ impl<'a> AnalyzeContext<'a> {
         scope.make_potentially_visible(Some(unit.pos()), ent);
 
         if let Some(ref mut list) = unit.generic_clause {
-            self.analyze_interface_list(&scope, Some(ent), list, diagnostics)?;
+            self.analyze_interface_list(&scope, ent, list, diagnostics)?;
         }
-        self.analyze_declarative_part(&scope, Some(ent), &mut unit.decl, diagnostics)?;
+        self.analyze_declarative_part(&scope, ent, &mut unit.decl, diagnostics)?;
 
         if !self.has_package_body() {
             scope.close(diagnostics);
@@ -204,7 +204,7 @@ impl<'a> AnalyzeContext<'a> {
 
         self.arena.define(
             &mut unit.ident,
-            Some(self.work_library()),
+            self.work_library(),
             AnyEntKind::Design(Design::Context(scope.into_region())),
         );
 
@@ -249,21 +249,16 @@ impl<'a> AnalyzeContext<'a> {
 
         let arch = self.arena.define(
             &mut unit.ident,
-            Some(primary.into()),
+            primary.into(),
             AnyEntKind::Design(Design::Architecture(primary)),
         );
 
         // Architecture name is visible
         scope.make_potentially_visible(Some(unit.pos()), arch);
 
-        self.define_labels_for_concurrent_part(
-            &scope,
-            Some(arch),
-            &mut unit.statements,
-            diagnostics,
-        )?;
-        self.analyze_declarative_part(&scope, Some(arch), &mut unit.decl, diagnostics)?;
-        self.analyze_concurrent_part(&scope, Some(arch), &mut unit.statements, diagnostics)?;
+        self.define_labels_for_concurrent_part(&scope, arch, &mut unit.statements, diagnostics)?;
+        self.analyze_declarative_part(&scope, arch, &mut unit.decl, diagnostics)?;
+        self.analyze_concurrent_part(&scope, arch, &mut unit.statements, diagnostics)?;
         scope.close(diagnostics);
         Ok(())
     }
@@ -308,7 +303,7 @@ impl<'a> AnalyzeContext<'a> {
 
         let scope = Scope::extend(region, Some(&root_scope));
 
-        self.analyze_declarative_part(&scope, Some(primary.into()), &mut unit.decl, diagnostics)?;
+        self.analyze_declarative_part(&scope, primary.into(), &mut unit.decl, diagnostics)?;
         scope.close(diagnostics);
         Ok(())
     }

vhdl_lang/src/analysis/named_entity.rs

@@ -191,7 +191,7 @@ impl Arena {
     pub fn define<'a, T: HasIdent>(
         &'a self,
         decl: &mut WithDecl<T>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         kind: AnyEntKind<'a>,
     ) -> EntRef<'a> {
         let ent = self.explicit(
@@ -207,13 +207,13 @@ impl Arena {
     pub fn explicit<'a>(
         &'a self,
         designator: impl Into<Designator>,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         kind: AnyEntKind<'a>,
         decl_pos: Option<&SrcPos>,
     ) -> EntRef<'a> {
         self.alloc(
             designator.into(),
-            parent,
+            Some(parent),
             Related::None,
             kind,
             decl_pos.cloned(),
@@ -445,7 +445,7 @@ impl WithDecl<Ident> {
     pub fn define<'a>(
         &mut self,
         arena: &'a Arena,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         kind: AnyEntKind<'a>,
     ) -> EntRef<'a> {
         let ent = arena.explicit(
@@ -463,7 +463,7 @@ impl WithDecl<WithPos<Designator>> {
     pub fn define<'a>(
         &mut self,
         arena: &'a Arena,
-        parent: Option<EntRef<'a>>,
+        parent: EntRef<'a>,
         kind: AnyEntKind<'a>,
     ) -> EntRef<'a> {
         let ent = arena.explicit(self.tree.item.clone(), parent, kind, Some(&self.tree.pos));