Ensure disambiguated overloaded name has reference set

Author: kraigher

vhdl_lang/src/analysis/names.rs

@@ -319,6 +319,8 @@ impl<'a> AnalyzeContext<'a> {
     fn name_to_type(
         &self,
         pos: &SrcPos,
+        // Reference to set if overloaded name was disambiguated
+        reference: Option<&mut Reference>,
         name: ResolvedName<'a>,
     ) -> Result<Option<DisambiguatedType<'a>>, Diagnostic> {
         match name {
@@ -344,6 +346,11 @@ impl<'a> AnalyzeContext<'a> {
             },
             ResolvedName::Overloaded(des, overloaded) => {
                 if let Some(disamb) = self.disambiguate_no_actuals(&des, None, &overloaded)? {
+                    if let Disambiguated::Unambiguous(ref ent) = disamb {
+                        if let Some(reference) = reference {
+                            *reference = Some(ent.id());
+                        }
+                    }
                     Ok(Some(disamb.into_type()))
                 } else {
                     Ok(None)
@@ -1157,7 +1164,7 @@ impl<'a> AnalyzeContext<'a> {
     ) -> EvalResult<DisambiguatedType<'a>> {
         let resolved =
             self.name_resolve_with_suffixes(scope, expr_pos, name, None, false, diagnostics)?;
-        match self.name_to_type(expr_pos, resolved) {
+        match self.name_to_type(expr_pos, name.suffix_reference_mut(), resolved) {
             Ok(Some(typ)) => Ok(typ),
             Ok(None) => Err(EvalError::Unknown),
             Err(diag) => {

vhdl_lang/src/analysis/tests/typecheck_expression.rs

@@ -1277,6 +1277,26 @@ end;
     );
 }
 
+#[test]
+fn resolves_unambiguous_boolean_reference() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.in_declarative_region(
+        "
+procedure wrapper is
+begin
+   assert true;
+end;
+",
+    );
+
+    let (root, diagnostics) = builder.get_analyzed_root();
+    check_no_diagnostics(&diagnostics);
+
+    assert!(root
+        .search_reference(code.source(), code.s1("assert true;").s1("true").start())
+        .is_some());
+}
+
 #[test]
 fn ambiguous_boolean_conversion_favors_boolean() {
     let mut builder = LibraryBuilder::new();