Find references of user defined attribute

Author: kraigher

vhdl_lang/src/analysis/named_entity/attribute.rs

@@ -42,3 +42,9 @@ impl<'a> AttributeEnt<'a> {
         }
     }
 }
+
+impl<'a> From<AttributeEnt<'a>> for EntRef<'a> {
+    fn from(value: AttributeEnt<'a>) -> Self {
+        value.ent
+    }
+}

vhdl_lang/src/analysis/names.rs

@@ -944,9 +944,10 @@ impl<'a> AnalyzeContext<'a> {
                 }
             }
 
-            AttributeDesignator::Ident(ref sym) => {
+            AttributeDesignator::Ident(ref mut sym) => {
                 if let Some(actual) = prefix.as_actual_entity() {
-                    if let Some(attr) = actual.get_attribute(sym) {
+                    if let Some(attr) = actual.get_attribute(&sym.item) {
+                        sym.set_unique_reference(attr.into());
                         Ok(AttrResolveResult::Value(attr.typ().base()))
                     } else {
                         diagnostics.error(

vhdl_lang/src/analysis/tests/custom_attributes.rs

@@ -4,6 +4,8 @@
 //
 // Copyright (c) 2023, Olof Kraigher olof.kraigher@gmail.com
 
+use itertools::Itertools;
+
 use super::*;
 
 #[test]
@@ -126,6 +128,40 @@ end architecture;
     check_no_diagnostics(&diagnostics);
 }
 
+#[test]
+fn finds_references_of_custom_attributes() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.code(
+        "libname",
+        "
+entity ent is
+    attribute myattr : boolean;
+    attribute myattr of ent : entity is false;
+end entity;
+
+architecture a of ent is
+    constant c0 : boolean := ent'myattr;
+begin
+end architecture;
+        ",
+    );
+
+    let (root, diagnostics) = builder.get_analyzed_root();
+    check_no_diagnostics(&diagnostics);
+
+    assert_eq!(
+        root.find_all_references_pos(&code.s1("myattr").pos()),
+        vec![
+            code.s1("attribute myattr : boolean"),
+            code.s1("myattr of ent"),
+            code.s1("ent'myattr"),
+        ]
+        .into_iter()
+        .map(|c| c.s1("myattr").pos())
+        .collect_vec()
+    );
+}
+
 #[test]
 fn invalid_prefix_for_custom_attribute() {
     let mut builder = LibraryBuilder::new();

vhdl_lang/src/ast.rs

@@ -111,7 +111,7 @@ pub enum RangeAttribute {
 pub enum AttributeDesignator {
     Type(TypeAttribute),
     Range(RangeAttribute),
-    Ident(Symbol),
+    Ident(WithRef<Symbol>),
     Ascending,
     Descending,
     Left,
@@ -436,7 +436,7 @@ pub enum Designator {
 pub type Reference = Option<EntityId>;
 
 /// An item which has a reference to a declaration
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub struct WithRef<T> {
     pub item: T,
     pub reference: Reference,

vhdl_lang/src/ast/search.rs

@@ -628,8 +628,17 @@ fn search_pos_name(
         Name::CallOrIndexed(ref mut fcall) => fcall.search(ctx, searcher),
         Name::Attribute(ref mut attr) => {
             // @TODO more
-            let AttributeName { name, expr, .. } = attr.as_mut();
+            let AttributeName {
+                name, expr, attr, ..
+            } = attr.as_mut();
             return_if_found!(name.search(ctx, searcher));
+            if let AttributeDesignator::Ident(ref mut user_attr) = attr.item {
+                return_if_finished!(searcher.search_pos_with_ref(
+                    ctx,
+                    &attr.pos,
+                    &mut user_attr.reference
+                ));
+            }
             if let Some(expr) = expr {
                 return_if_found!(expr.search(ctx, searcher));
             }

vhdl_lang/src/syntax/names.rs

@@ -724,7 +724,7 @@ mod tests {
         let attr = WithPos {
             item: Name::Attribute(Box::new(AttributeName {
                 name: prefix,
-                attr: code.s1("foo").ident().map_into(AttributeDesignator::Ident),
+                attr: code.s1("foo").attr_ident(),
                 signature: None,
                 expr: None,
             })),
@@ -855,7 +855,7 @@ mod tests {
         let attr = WithPos {
             item: Name::Attribute(Box::new(AttributeName {
                 name: prefix,
-                attr: code.s1("foo").ident().map_into(AttributeDesignator::Ident),
+                attr: code.s1("foo").attr_ident(),
                 signature: None,
                 expr: Some(Box::new(code.s1("expr+1").expr())),
             })),
@@ -874,7 +874,7 @@ mod tests {
         let attr = WithPos {
             item: Name::Attribute(Box::new(AttributeName {
                 name: prefix,
-                attr: code.s1("foo").ident().map_into(AttributeDesignator::Ident),
+                attr: code.s1("foo").attr_ident(),
                 signature: Some(code.s1("[return natural]").signature()),
                 expr: Some(Box::new(code.s1("expr+1").expr())),
             })),

vhdl_lang/src/syntax/test.rs

@@ -459,6 +459,11 @@ impl Code {
         self.parse_ok(|stream: &TokenStream| stream.expect_ident())
     }
 
+    pub fn attr_ident(&self) -> WithPos<AttributeDesignator> {
+        self.parse_ok(|stream: &TokenStream| stream.expect_ident())
+            .map_into(|i| AttributeDesignator::Ident(WithRef::new(i)))
+    }
+
     pub fn decl_ident(&self) -> WithDecl<Ident> {
         WithDecl::new(self.parse_ok(|stream: &TokenStream| stream.expect_ident()))
     }

vhdl_lang/src/syntax/tokens/tokenizer.rs

@@ -6,7 +6,7 @@
 
 use fnv::FnvHashMap;
 
-use crate::ast::{self, AttributeDesignator, Operator};
+use crate::ast::{self, AttributeDesignator, Operator, WithRef};
 use crate::ast::{BaseSpecifier, Ident};
 use crate::data::*;
 
@@ -1668,7 +1668,7 @@ impl<'a> Tokenizer<'a> {
             .attributes
             .get(&sym)
             .cloned()
-            .unwrap_or_else(|| AttributeDesignator::Ident(sym))
+            .unwrap_or_else(|| AttributeDesignator::Ident(WithRef::new(sym)))
     }
 
     fn parse_token(&mut self) -> Result<Option<(Kind, Value)>, TokenError> {