Pre-defined labels in previuos declarative part

Author: kraigher

vhdl_lang/src/analysis/concurrent.rs

@@ -30,16 +30,27 @@ impl<'a> AnalyzeContext<'a> {
         Ok(())
     }
 
-    fn analyze_concurrent_statement(
+    pub fn define_labels_for_concurrent_part(
         &self,
         scope: &Scope<'a>,
-        statement: &mut LabeledConcurrentStatement,
+        statements: &mut [LabeledConcurrentStatement],
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
-        if let Some(ref mut label) = statement.label {
-            scope.add(label.define(self.arena, AnyEntKind::Label), diagnostics);
+        for statement in statements.iter_mut() {
+            if let Some(ref mut label) = statement.label {
+                scope.add(label.define(self.arena, AnyEntKind::Label), diagnostics);
+            }
         }
 
+        Ok(())
+    }
+
+    fn analyze_concurrent_statement(
+        &self,
+        scope: &Scope<'a>,
+        statement: &mut LabeledConcurrentStatement,
+        diagnostics: &mut dyn DiagnosticHandler,
+    ) -> FatalResult {
         match statement.statement {
             ConcurrentStatement::Block(ref mut block) => {
                 if let Some(ref mut guard_condition) = block.guard_condition {
@@ -58,6 +69,8 @@ impl<'a> AnalyzeContext<'a> {
                 if let Some(ref mut list) = block.header.port_map {
                     self.analyze_assoc_elems(scope, list, diagnostics)?;
                 }
+
+                self.define_labels_for_concurrent_part(scope, &mut block.statements, diagnostics)?;
                 self.analyze_declarative_part(&nested, &mut block.decl, diagnostics)?;
                 self.analyze_concurrent_part(&nested, &mut block.statements, diagnostics)?;
             }
@@ -77,6 +90,7 @@ impl<'a> AnalyzeContext<'a> {
                     }
                 }
                 let nested = scope.nested();
+                self.define_labels_for_sequential_part(scope, statements, diagnostics)?;
                 self.analyze_declarative_part(&nested, decl, diagnostics)?;
                 self.analyze_sequential_part(
                     &nested,
@@ -175,6 +189,10 @@ impl<'a> AnalyzeContext<'a> {
         if let Some(label) = alternative_label {
             scope.add(label.define(self.arena, AnyEntKind::Label), diagnostics);
         }
+
+        // Pre-declare labels
+        self.define_labels_for_concurrent_part(scope, statements, diagnostics)?;
+
         if let Some(ref mut decl) = decl {
             self.analyze_declarative_part(scope, decl, diagnostics)?;
         }

vhdl_lang/src/analysis/declarative.rs

@@ -493,6 +493,11 @@ impl<'a> AnalyzeContext<'a> {
                 };
                 let subpgm_region = subpgm_region.with_parent(scope);
 
+                self.define_labels_for_sequential_part(
+                    &subpgm_region,
+                    &mut body.statements,
+                    diagnostics,
+                )?;
                 self.analyze_declarative_part(&subpgm_region, &mut body.declarations, diagnostics)?;
 
                 self.analyze_sequential_part(

vhdl_lang/src/analysis/design_unit.rs

@@ -61,6 +61,7 @@ impl<'a> AnalyzeContext<'a> {
         if let Some(ref mut list) = unit.port_clause {
             self.analyze_interface_list(&primary_scope, list, diagnostics)?;
         }
+        self.define_labels_for_concurrent_part(&primary_scope, &mut unit.statements, diagnostics)?;
         self.analyze_declarative_part(&primary_scope, &mut unit.decl, diagnostics)?;
         self.analyze_concurrent_part(&primary_scope, &mut unit.statements, diagnostics)?;
 
@@ -239,6 +240,7 @@ impl<'a> AnalyzeContext<'a> {
                 .explicit(unit.name().clone(), AnyEntKind::Label, Some(unit.pos())),
         );
 
+        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)?;
         scope.close(diagnostics);

vhdl_lang/src/analysis/sequential.rs

@@ -16,17 +16,68 @@ use region::*;
 use target::AssignmentType;
 
 impl<'a> AnalyzeContext<'a> {
+    pub fn define_labels_for_sequential_part(
+        &self,
+        scope: &Scope<'a>,
+        statements: &mut [LabeledSequentialStatement],
+        diagnostics: &mut dyn DiagnosticHandler,
+    ) -> FatalResult {
+        for statement in statements.iter_mut() {
+            if let Some(ref mut label) = statement.label {
+                scope.add(label.define(self.arena, AnyEntKind::Label), diagnostics);
+            }
+
+            match statement.statement {
+                SequentialStatement::If(ref mut ifstmt) => {
+                    let IfStatement {
+                        conditionals,
+                        else_item,
+                    } = ifstmt;
+
+                    for conditional in conditionals {
+                        self.define_labels_for_sequential_part(
+                            scope,
+                            &mut conditional.item,
+                            diagnostics,
+                        )?;
+                    }
+                    if let Some(else_item) = else_item {
+                        self.define_labels_for_sequential_part(scope, else_item, diagnostics)?;
+                    }
+                }
+
+                SequentialStatement::Case(ref mut case_stmt) => {
+                    for alternative in case_stmt.alternatives.iter_mut() {
+                        self.define_labels_for_sequential_part(
+                            scope,
+                            &mut alternative.item,
+                            diagnostics,
+                        )?;
+                    }
+                }
+                SequentialStatement::Loop(ref mut loop_stmt) => {
+                    self.define_labels_for_sequential_part(
+                        scope,
+                        &mut loop_stmt.statements,
+                        diagnostics,
+                    )?;
+                }
+                _ => {
+                    // Does not have sequential part
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     fn analyze_sequential_statement(
         &self,
         scope: &Scope<'a>,
         sroot: &SequentialRoot<'a>,
         statement: &mut LabeledSequentialStatement,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
-        if let Some(ref mut label) = statement.label {
-            scope.add(self.arena.define(label, AnyEntKind::Label), diagnostics);
-        }
-
         match statement.statement {
             SequentialStatement::Return(ref mut ret) => {
                 let ReturnStatement { ref mut expression } = ret.item;

vhdl_lang/src/analysis/tests/homographs.rs

@@ -850,7 +850,13 @@ end architecture;
     );
 
     let diagnostics = builder.analyze();
-    check_diagnostics(diagnostics, duplicates(&code, &["lab1", "lab2"]));
+    check_diagnostics(
+        diagnostics,
+        vec![
+            duplicate(&code, "lab1", 2, 1),
+            duplicate(&code, "lab2", 2, 1),
+        ],
+    );
 }
 
 #[test]

vhdl_lang/src/analysis/tests/visibility.rs

@@ -698,3 +698,62 @@ end function;
         Some(code.s("theproc", 2).pos())
     );
 }
+
+#[test]
+fn labels_are_visible_in_declarative_region() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.code(
+        "libname",
+        "
+entity ent is
+end entity;
+
+architecture a of ent is
+  attribute debug : boolean;
+  attribute debug of main : label is true;
+begin
+  main: process
+  begin
+      wait;
+  end process;
+end architecture;
+
+",
+    );
+    let (root, diagnostics) = builder.get_analyzed_root();
+    check_no_diagnostics(&diagnostics);
+    let label = root
+        .search_reference(code.source(), code.sa("debug of ", "main").start())
+        .unwrap();
+    assert_eq!(label.decl_pos(), Some(&code.sb("main", ": process").pos()));
+}
+
+#[test]
+fn sequential_labels_are_visible_in_declarative_region() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.code(
+        "libname",
+        "
+entity ent is
+end entity;
+
+architecture a of ent is
+begin
+  process
+    attribute debug : boolean;
+    attribute debug of main : label is true;
+  begin
+    main: for i in 0 to 1 loop
+    end loop;
+    wait;
+  end process;
+end architecture;
+",
+    );
+    let (root, diagnostics) = builder.get_analyzed_root();
+    check_no_diagnostics(&diagnostics);
+    let label = root
+        .search_reference(code.source(), code.sa("debug of ", "main").start())
+        .unwrap();
+    assert_eq!(label.decl_pos(), Some(&code.sb("main", ": for i ").pos()));
+}

vhdl_lang/src/syntax/test.rs

@@ -125,6 +125,12 @@ impl Code {
         self.in_range(range)
     }
 
+    // Creates a code from the first occurence for before + substr at the
+    // position of substr
+    pub fn sb(&self, substr: &str, after: &str) -> Code {
+        self.s1(&format!("{substr}{after}")).s1(substr)
+    }
+
     pub fn pos(&self) -> SrcPos {
         self.pos.clone()
     }