Enable ports to lookup the types from generics

Author: Schottkyc137

vhdl_lang/src/analysis/association.rs

@@ -499,18 +499,26 @@ impl<'a> AnalyzeContext<'a, '_> {
         self.check_missing_and_duplicates(error_pos, resolved_pairs, formal_region, diagnostics)
     }
 
+    /// Checks associations irrelevant of the actual kind (i.e., can analyzes generic maps,
+    /// port maps and subprogram calls).
+    ///
+    /// * `error_pos` Position of the instance or call site
+    /// * `formal_region` The formals, i.e., the declared elements
+    /// * `mapping` Maps generic types to their actual values. This is a mutable reference so that
+    ///   generic maps can populate the content appropriately while port maps and parameters will
+    ///   only read from it.
     pub fn check_association<'e>(
         &self,
-        error_pos: &SrcPos, // The position of the instance/call-site
+        error_pos: &SrcPos,
         formal_region: &FormalRegion<'a>,
+        mapping: &mut FnvHashMap<EntityId, TypeEnt<'a>>,
         scope: &Scope<'a>,
         elems: &'e mut [AssociationElement],
         diagnostics: &mut dyn DiagnosticHandler,
-    ) -> EvalResult<FnvHashMap<EntityId, TypeEnt<'a>>> {
+    ) -> EvalResult {
         let resolved_pairs =
             self.combine_formal_with_actuals(formal_region, scope, elems, diagnostics)?;
 
-        let mut mapping = FnvHashMap::default();
         for (resolved_formal, actual) in resolved_pairs
             .iter()
             .map(|(_, resolved_formal)| resolved_formal)
@@ -673,7 +681,7 @@ impl<'a> AnalyzeContext<'a, '_> {
             }
         }
         self.check_missing_and_duplicates(error_pos, resolved_pairs, formal_region, diagnostics)?;
-        Ok(mapping)
+        Ok(())
     }
 
     // LRM 4.2.2.1: In a subprogram, the interface mode must match the mode of the actual designator

vhdl_lang/src/analysis/concurrent.rs

@@ -13,6 +13,7 @@ use crate::data::*;
 use crate::named_entity::*;
 use crate::{HasTokenSpan, TokenSpan};
 use analyze::*;
+use fnv::FnvHashMap;
 
 impl<'a> AnalyzeContext<'a, '_> {
     pub fn analyze_concurrent_part(
@@ -408,10 +409,12 @@ impl<'a> AnalyzeContext<'a, '_> {
     ) -> FatalResult {
         let (generic_region, port_region) = ent_region.to_entity_formal();
 
+        let mut mapping = FnvHashMap::default();
         as_fatal(
             self.check_association(
                 &entity_name.pos(self.ctx),
                 &generic_region,
+                &mut mapping,
                 scope,
                 generic_map_aspect
                     .map(|it| it.list.items.as_mut_slice())
@@ -423,6 +426,7 @@ impl<'a> AnalyzeContext<'a, '_> {
             self.check_association(
                 &entity_name.pos(self.ctx),
                 &port_region,
+                &mut mapping,
                 scope,
                 port_map_aspect
                     .map(|it| it.list.items.as_mut_slice())

vhdl_lang/src/analysis/overloaded.rs

@@ -4,7 +4,7 @@
 //
 // Copyright (c) 2023, Olof Kraigher [email protected]
 
-use fnv::FnvHashSet;
+use fnv::{FnvHashMap, FnvHashSet};
 use vhdl_lang::TokenAccess;
 
 use super::analyze::*;
@@ -198,6 +198,7 @@ impl<'a> AnalyzeContext<'a, '_> {
         as_fatal(self.check_association(
             error_pos,
             FormalRegion::ref_from_param_ref(ent.formals()),
+            &mut FnvHashMap::default(),
             scope,
             assocs,
             diagnostics,

vhdl_lang/src/analysis/package_instance.rs

@@ -56,17 +56,17 @@ impl<'a> AnalyzeContext<'a, '_> {
         let nested = scope.nested().in_package_declaration();
         let (generics, other) = uninst_region.to_package_generic();
 
-        let mapping = if let Some(generic_map) = generic_map {
+        let mut mapping = FnvHashMap::default();
+        if let Some(generic_map) = generic_map {
             self.check_association(
                 decl_pos,
                 &generics,
+                &mut mapping,
                 &nested,
                 generic_map.list.items.as_mut_slice(),
                 diagnostics,
-            )?
-        } else {
-            FnvHashMap::default()
-        };
+            )?;
+        }
 
         for uninst in other {
             match self.instantiate(Some(ent), &mapping, uninst, &nested) {

vhdl_lang/src/analysis/tests/association_formal.rs

@@ -787,7 +787,6 @@ end architecture;
 }
 
 #[test]
-#[ignore]
 fn generic_type_from_port_in_map() {
     let mut builder = LibraryBuilder::new();
     builder.code(
@@ -809,7 +808,7 @@ end architecture;
 entity test is
 end entity test;
 
-architecture rtl of te is
+architecture rtl of test is
 begin
     foo_inst: entity work.foo
     generic map(