Find references to end-identifiers and end-labels

Author: kraigher

vhdl_lang/src/analysis/concurrent.rs

@@ -80,6 +80,7 @@ impl<'a> AnalyzeContext<'a> {
                     sensitivity_list,
                     decl,
                     statements,
+                    end_label_pos: _,
                 } = process;
                 if let Some(sensitivity_list) = sensitivity_list {
                     match sensitivity_list {
@@ -104,6 +105,7 @@ impl<'a> AnalyzeContext<'a> {
                     index_name,
                     discrete_range,
                     body,
+                    end_label_pos: _,
                 } = gen;
                 let typ = as_fatal(self.drange_type(scope, discrete_range, diagnostics))?;
                 let nested = scope.nested();
@@ -117,7 +119,7 @@ impl<'a> AnalyzeContext<'a> {
                 let Conditionals {
                     conditionals,
                     else_item,
-                } = gen;
+                } = &mut gen.conds;
                 for conditional in conditionals.iter_mut() {
                     let Conditional { condition, item } = conditional;
                     self.boolean_expr(scope, condition, diagnostics)?;
@@ -130,7 +132,7 @@ impl<'a> AnalyzeContext<'a> {
                 }
             }
             ConcurrentStatement::CaseGenerate(ref mut gen) => {
-                for alternative in gen.alternatives.iter_mut() {
+                for alternative in gen.sels.alternatives.iter_mut() {
                     let nested = scope.nested();
                     self.analyze_generate_body(&nested, &mut alternative.item, diagnostics)?;
                 }
@@ -185,6 +187,7 @@ impl<'a> AnalyzeContext<'a> {
             alternative_label,
             decl,
             statements,
+            end_label_pos: _,
         } = body;
         if let Some(label) = alternative_label {
             scope.add(label.define(self.arena, AnyEntKind::Label), diagnostics);

vhdl_lang/src/analysis/named_entity.rs

@@ -210,6 +210,14 @@ impl<'a> AnyEnt<'a> {
         self.id
     }
 
+    pub fn declaration(&'a self) -> EntRef<'a> {
+        if let Related::DeclaredBy(other) = self.related {
+            other
+        } else {
+            self
+        }
+    }
+
     pub fn is_implicit(&self) -> bool {
         match self.related {
             Related::ImplicitOf(_) => true,

vhdl_lang/src/analysis/root.rs

@@ -369,7 +369,8 @@ impl DesignRoot {
         let mut searcher = ItemAtCursor::new(source, cursor);
         let _ = self.search(&mut searcher);
         let id = searcher.result?;
-        Some(self.get_ent(id))
+        let ent = self.get_ent(id);
+        Some(ent)
     }
 
     pub fn find_definition_of<'a>(&'a self, decl: EntRef<'a>) -> Option<EntRef<'a>> {

vhdl_lang/src/analysis/sequential.rs

@@ -29,10 +29,10 @@ impl<'a> AnalyzeContext<'a> {
 
             match statement.statement {
                 SequentialStatement::If(ref mut ifstmt) => {
-                    let IfStatement {
+                    let Conditionals {
                         conditionals,
                         else_item,
-                    } = ifstmt;
+                    } = &mut ifstmt.conds;
 
                     for conditional in conditionals {
                         self.define_labels_for_sequential_part(
@@ -143,30 +143,36 @@ impl<'a> AnalyzeContext<'a> {
             SequentialStatement::Exit(ref mut exit_stmt) => {
                 let ExitStatement {
                     condition,
-                    // @TODO loop label
-                    ..
+                    loop_label,
                 } = exit_stmt;
 
+                if let Some(ref mut loop_label) = loop_label {
+                    self.check_loop_label(scope, loop_label, diagnostics);
+                }
+
                 if let Some(expr) = condition {
                     self.boolean_expr(scope, expr, diagnostics)?;
                 }
             }
             SequentialStatement::Next(ref mut next_stmt) => {
                 let NextStatement {
                     condition,
-                    // @TODO loop label
-                    ..
+                    loop_label,
                 } = next_stmt;
 
+                if let Some(ref mut loop_label) = loop_label {
+                    self.check_loop_label(scope, loop_label, diagnostics);
+                }
+
                 if let Some(expr) = condition {
                     self.boolean_expr(scope, expr, diagnostics)?;
                 }
             }
             SequentialStatement::If(ref mut ifstmt) => {
-                let IfStatement {
+                let Conditionals {
                     conditionals,
                     else_item,
-                } = ifstmt;
+                } = &mut ifstmt.conds;
 
                 // @TODO write generic function for this
                 for conditional in conditionals {
@@ -183,6 +189,7 @@ impl<'a> AnalyzeContext<'a> {
                     is_matching: _,
                     expression,
                     alternatives,
+                    end_label_pos: _,
                 } = case_stmt;
                 let ctyp = as_fatal(self.expr_unambiguous_type(scope, expression, diagnostics))?;
                 for alternative in alternatives.iter_mut() {
@@ -195,6 +202,7 @@ impl<'a> AnalyzeContext<'a> {
                 let LoopStatement {
                     iteration_scheme,
                     statements,
+                    end_label_pos: _,
                 } = loop_stmt;
                 match iteration_scheme {
                     Some(IterationScheme::For(ref mut index, ref mut drange)) => {
@@ -265,6 +273,39 @@ impl<'a> AnalyzeContext<'a> {
         Ok(())
     }
 
+    fn check_loop_label(
+        &self,
+        scope: &Scope<'a>,
+        label: &mut WithRef<Ident>,
+        diagnostics: &mut dyn DiagnosticHandler,
+    ) {
+        match scope.lookup(
+            &label.item.pos,
+            &Designator::Identifier(label.item.item.clone()),
+        ) {
+            Ok(NamedEntities::Single(ent)) => {
+                label.set_unique_reference(ent);
+                if !matches!(ent.kind(), AnyEntKind::Label) {
+                    // @TODO check that is actually a loop label and that we are inside the loop
+                    diagnostics.error(
+                        &label.item.pos,
+                        format!("Expected loop label, got {}", ent.describe()),
+                    );
+                }
+            }
+            Ok(NamedEntities::Overloaded(_)) => diagnostics.error(
+                &label.item.pos,
+                format!(
+                    "Expected loop label, got overloaded name {}",
+                    &label.item.item
+                ),
+            ),
+            Err(diag) => {
+                diagnostics.push(diag);
+            }
+        }
+    }
+
     pub fn analyze_sequential_part(
         &self,
         scope: &Scope<'a>,

vhdl_lang/src/analysis/tests/resolves_names.rs

@@ -516,6 +516,9 @@ package body pkg is
 
          proc2(i); -- Index is defined
          missing;
+
+         exit missing;
+         next missing;
        end loop;
        
 
@@ -1900,3 +1903,133 @@ end architecture;
         Some(&code.s("a2", 1).pos())
     );
 }
+
+#[test]
+fn find_end_identifier_references_of_declarations() {
+    for name in [
+        "ent1", "a1", "rec_t", "prot_t", "phys_t", "fun1", "proc1", "comp1", "pkg", "cfg1", "ctx1",
+    ] {
+        check_search_reference_with_name(
+            name,
+            "
+entity ent1 is
+end entity ent1;
+
+architecture a1 of ent1 is
+
+    type rec_t is record
+       field: natural;
+    end record rec_t;
+
+    type prot_t is protected
+    end protected prot_t;
+
+    type prot_t is protected body
+    end protected body prot_t;
+
+    type phys_t is range 0 to 10
+    units
+       bangs;
+       bugs = 10 bangs;
+    end units phys_t;
+
+    function fun1 return integer is
+    begin
+    end function fun1;
+
+    procedure proc1 is
+    begin
+    end procedure proc1;
+
+    component comp1 is
+    end component comp1;
+begin
+end architecture a1;
+
+package pkg is
+end package pkg;
+
+package body pkg is
+end package body pkg;
+
+configuration cfg1 of ent1 is
+  for rtl(0)
+  end for;
+end configuration cfg1;
+
+context ctx1 is
+end context ctx1;
+      ",
+        );
+    }
+}
+
+#[test]
+fn find_end_identifier_references_of_concurrent() {
+    for name in ["b1", "p1", "fg1", "ig1", "ialt1", "cg1", "cgalt1"] {
+        check_search_reference_with_name(
+            name,
+            "
+entity ent1 is
+end entity ent1;
+
+architecture a1 of ent1 is
+begin
+  b1: block
+  begin
+  end block b1;
+
+  p1: process
+  begin
+  end process p1;
+
+  fg1: for i in 0 to 10 generate
+  end generate fg1;
+
+  ig1: if true generate
+  else ialt1: generate
+  end ialt1;
+  end generate ig1;
+
+  cg1: case 0 generate
+    when cgalt1: 0 => 
+      assert false;
+    end cgalt1;
+  end generate cg1;
+
+end architecture;
+      ",
+        );
+    }
+}
+
+#[test]
+fn find_end_identifier_references_of_sequential() {
+    for name in ["if0", "loop0", "c0"] {
+        check_search_reference_with_name(
+            name,
+            "
+entity ent1 is
+end entity ent1;
+
+architecture a1 of ent1 is
+begin
+  process
+  begin
+    if0: if true then
+    end if if0;
+
+    loop0: for i in 0 to 1 loop
+      next loop0;
+      exit loop0;
+    end loop loop0;
+
+    c0: case 0 is
+      when others =>
+    end case c0;
+  end process;
+end architecture;
+      ",
+        );
+    }
+}

vhdl_lang/src/analysis/tests/util.rs

@@ -224,9 +224,10 @@ pub fn check_search_reference_with_name(decl_name: &str, contents: &str) {
     let mut references = Vec::new();
     for idx in 1..=occurences {
         assert_eq!(
-            root.search_reference_pos(code.source(), code.s(decl_name, idx).end()),
+            root.search_reference(code.source(), code.s(decl_name, idx).end())
+                .and_then(|ent| ent.declaration().decl_pos().cloned()),
             Some(code.s(decl_name, 1).pos()),
-            "{}",
+            "{decl_name}, occurence {}",
             idx
         );
         references.push(code.s(decl_name, idx).pos());