Support slicing of formal inside formal conversion

Author: kraigher

vhdl_lang/src/analysis/association.rs

@@ -66,6 +66,14 @@ impl<'a> ResolvedFormal<'a> {
             ResolvedFormal::Converted(idx, _, _) => idx,
         }
     }
+
+    fn formal(&self) -> InterfaceEnt<'a> {
+        *match self {
+            ResolvedFormal::Basic(_, ent) => ent,
+            ResolvedFormal::Selected(_, ent, _) => ent,
+            ResolvedFormal::Converted(_, ent, _) => ent,
+        }
+    }
 }
 
 impl<'a> AnalyzeContext<'a> {
@@ -135,12 +143,19 @@ impl<'a> AnalyzeContext<'a> {
                     // The prefix of the name was not found in the formal region
                     // it must be a type conversion or a single parameter function call
 
-                    let (idx, pos, formal_ent) = if let Some((pos, designator)) =
+                    let (pos, resolved_formal) = if let Some((inner_pos, inner_name)) =
                         to_formal_conversion_argument(&mut fcall.parameters)
                     {
-                        let (idx, ent) = formal_region.lookup(name_pos, designator.designator())?;
-                        designator.set_unique_reference(ent.inner());
-                        (idx, pos, ent)
+                        (
+                            inner_pos,
+                            self.resolve_formal(
+                                formal_region,
+                                scope,
+                                inner_pos,
+                                inner_name,
+                                diagnostics,
+                            )?,
+                        )
                     } else {
                         return Err(Diagnostic::error(name_pos, "Invalid formal conversion").into());
                     };
@@ -152,7 +167,7 @@ impl<'a> AnalyzeContext<'a> {
                         diagnostics,
                     ))? {
                         Some(ResolvedName::Type(typ)) => {
-                            let ctyp = formal_ent.type_mark().base();
+                            let ctyp = resolved_formal.type_mark().base();
                             if !typ.base().is_closely_related(ctyp) {
                                 return Err(Diagnostic::error(
                                     pos,
@@ -171,9 +186,9 @@ impl<'a> AnalyzeContext<'a> {
 
                             for ent in overloaded.entities() {
                                 if ent.is_function()
-                                    && ent
-                                        .signature()
-                                        .can_be_called_with_single_parameter(formal_ent.type_mark())
+                                    && ent.signature().can_be_called_with_single_parameter(
+                                        resolved_formal.type_mark(),
+                                    )
                                 {
                                     candidates.push(ent);
                                 }
@@ -199,7 +214,7 @@ impl<'a> AnalyzeContext<'a> {
                                     format!(
                                         "No function '{}' accepting {}",
                                         fcall.name,
-                                        formal_ent.type_mark().describe()
+                                        resolved_formal.type_mark().describe()
                                     ),
                                 )
                                 .into());
@@ -212,7 +227,11 @@ impl<'a> AnalyzeContext<'a> {
                         }
                     };
 
-                    Ok(ResolvedFormal::Converted(idx, formal_ent, converted_typ))
+                    Ok(ResolvedFormal::Converted(
+                        resolved_formal.idx(),
+                        resolved_formal.formal(),
+                        converted_typ,
+                    ))
                 } else if let Some(mut indexed_name) = fcall.as_indexed() {
                     let resolved_prefix = self.resolve_formal(
                         formal_region,
@@ -361,7 +380,7 @@ impl<'a> AnalyzeContext<'a> {
 
 fn to_formal_conversion_argument(
     parameters: &mut [AssociationElement],
-) -> Option<(&SrcPos, &mut WithRef<Designator>)> {
+) -> Option<(&SrcPos, &mut Box<Name>)> {
     if let &mut [AssociationElement {
         ref formal,
         ref mut actual,
@@ -370,9 +389,7 @@ fn to_formal_conversion_argument(
         if formal.is_some() {
             return None;
         } else if let ActualPart::Expression(Expression::Name(ref mut actual_name)) = actual.item {
-            if let Name::Designator(designator) = actual_name.as_mut() {
-                return Some((&actual.pos, designator));
-            }
+            return Some((&actual.pos, actual_name));
         }
     }
     None

vhdl_lang/src/analysis/tests/association_formal.rs

@@ -418,6 +418,56 @@ end architecture;
     );
 }
 
+#[test]
+fn conversion_of_sliced_formal() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.code(
+        "libname",
+        "
+entity module is
+  port (
+    theport : out bit_vector(0 to 5)
+  );
+end;
+
+architecture a of module is
+begin
+end architecture;
+
+entity ent is
+end;
+
+architecture behav of ent is
+    signal data0 : bit_vector(0 to 5);
+    signal data1 : bit_vector(0 to 5);
+  begin
+
+  inst0: entity work.module
+    port map (
+      bit_vector(theport(data0'range)) => data0
+    );
+
+  inst1: entity work.module
+    port map (
+      bit_vector(theport(0 to 5)) => data1
+    );
+end;",
+    );
+
+    let (root, diagnostics) = builder.get_analyzed_root();
+    check_no_diagnostics(&diagnostics);
+
+    assert_eq!(
+        root.search_reference_pos(code.source(), code.s("theport", 2).end()),
+        Some(code.s1("theport").pos())
+    );
+
+    assert_eq!(
+        root.search_reference_pos(code.source(), code.s("theport", 3).end()),
+        Some(code.s1("theport").pos())
+    );
+}
+
 #[test]
 fn output_ports_may_be_left_open() {
     let mut builder = LibraryBuilder::new();