Refactor map aspects (#382)

* Separate port formal regions from generic formal regions

* Remove the GpkgRegion in favor of the FormalRegion

* Modify generic map to use already existing infrastructure

* Enable generic functions, types and packages in entity and component instantiations

* Restructure generic_map into association.rs

* Enable ports to lookup the types from generics

Author: Schottkyc137

vhdl_lang/src/analysis/association.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(
@@ -303,29 +304,13 @@ impl<'a> AnalyzeContext<'a, '_> {
                                 }
                             }
 
-                            let (generic_region, port_region) = ent_region.to_entity_formal();
-
-                            self.check_association(
-                                &entity_name.pos(self.ctx),
-                                &generic_region,
+                            self.analyze_generics_and_ports(
                                 scope,
-                                instance
-                                    .generic_map
-                                    .as_mut()
-                                    .map(|it| it.list.items.as_mut_slice())
-                                    .unwrap_or(&mut []),
-                                diagnostics,
-                            )?;
-                            self.check_association(
-                                &entity_name.pos(self.ctx),
-                                &port_region,
-                                scope,
-                                instance
-                                    .port_map
-                                    .as_mut()
-                                    .map(|it| it.list.items.as_mut_slice())
-                                    .unwrap_or(&mut []),
+                                instance.generic_map.as_mut(),
+                                instance.port_map.as_mut(),
                                 diagnostics,
+                                entity_name,
+                                ent_region,
                             )?;
                             Ok(())
                         }
@@ -368,28 +353,13 @@ impl<'a> AnalyzeContext<'a, '_> {
                 };
 
                 if let AnyEntKind::Component(ent_region) = ent.kind() {
-                    let (generic_region, port_region) = ent_region.to_entity_formal();
-                    self.check_association(
-                        &component_name.pos(self.ctx),
-                        &generic_region,
-                        scope,
-                        instance
-                            .generic_map
-                            .as_mut()
-                            .map(|it| it.list.items.as_mut_slice())
-                            .unwrap_or(&mut []),
-                        diagnostics,
-                    )?;
-                    self.check_association(
-                        &component_name.pos(self.ctx),
-                        &port_region,
+                    self.analyze_generics_and_ports(
                         scope,
-                        instance
-                            .port_map
-                            .as_mut()
-                            .map(|it| it.list.items.as_mut_slice())
-                            .unwrap_or(&mut []),
+                        instance.generic_map.as_mut(),
+                        instance.port_map.as_mut(),
                         diagnostics,
+                        component_name,
+                        ent_region,
                     )?;
                     Ok(())
                 } else {
@@ -428,6 +398,45 @@ impl<'a> AnalyzeContext<'a, '_> {
         }
     }
 
+    pub fn analyze_generics_and_ports(
+        &self,
+        scope: &Scope<'a>,
+        generic_map_aspect: Option<&mut MapAspect>,
+        port_map_aspect: Option<&mut MapAspect>,
+        diagnostics: &mut dyn DiagnosticHandler,
+        entity_name: &mut WithTokenSpan<Name>,
+        ent_region: &Region<'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())
+                    .unwrap_or(&mut []),
+                diagnostics,
+            ),
+        )?;
+        as_fatal(
+            self.check_association(
+                &entity_name.pos(self.ctx),
+                &port_region,
+                &mut mapping,
+                scope,
+                port_map_aspect
+                    .map(|it| it.list.items.as_mut_slice())
+                    .unwrap_or(&mut []),
+                diagnostics,
+            ),
+        )?;
+        Ok(())
+    }
+
     pub fn analyze_map_aspect(
         &self,
         scope: &Scope<'a>,

vhdl_lang/src/analysis/concurrent.rs

@@ -564,7 +564,7 @@ impl<'a> AnalyzeContext<'a, '_> {
                     &mut instance.ident,
                     parent,
                     AnyEntKind::Overloaded(Overloaded::Subprogram(Signature::new(
-                        FormalRegion::new_params(),
+                        ParameterRegion::default(),
                         None,
                     ))),
                     src_span,

vhdl_lang/src/analysis/declarative.rs

@@ -4,13 +4,12 @@
 //
 // Copyright (c) 2023, Olof Kraigher olof.kraigher@gmail.com
 
-use fnv::FnvHashSet;
+use fnv::{FnvHashMap, FnvHashSet};
 use vhdl_lang::TokenAccess;
 
 use super::analyze::*;
 use super::expression::ExpressionType;
 use super::scope::*;
-use crate::ast::search::clear_references;
 use crate::ast::token_range::WithToken;
 use crate::ast::*;
 use crate::data::error_codes::ErrorCode;
@@ -44,7 +43,7 @@ enum Rejection<'a> {
     Procedure,
 
     // The amount of actuals or named actuals do not match formals
-    MissingFormals(Vec<InterfaceEnt<'a>>),
+    MissingFormals(Vec<ParameterEnt<'a>>),
 }
 
 struct Candidate<'a> {
@@ -196,7 +195,14 @@ impl<'a> AnalyzeContext<'a, '_> {
         assocs: &mut [AssociationElement],
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
-        self.check_association(error_pos, ent.formals(), scope, assocs, diagnostics)?;
+        as_fatal(self.check_association(
+            error_pos,
+            ent.formals().as_formal_region(),
+            &mut FnvHashMap::default(),
+            scope,
+            assocs,
+            diagnostics,
+        ))?;
         Ok(())
     }
 
@@ -218,20 +224,25 @@ impl<'a> AnalyzeContext<'a, '_> {
         for ent in candidates.iter() {
             if let Some(resolved) = as_fatal(self.resolve_association_formals(
                 call_pos,
-                ent.formals(),
+                ent.formals().as_formal_region(),
                 scope,
                 assocs,
                 &mut NullDiagnostics,
             ))? {
+                // Since we are in a ParameterRegion, we should only get back Parameter Entities
+                // that are all convertible to types.
+                let resolved = resolved
+                    .into_iter()
+                    .map(|ent| {
+                        ent.require_type_mark()
+                            .expect("Resolved formal should have type")
+                    })
+                    .collect();
                 result.push(ResolvedCall {
                     subpgm: *ent,
                     formals: resolved,
                 });
             }
-
-            for elem in assocs.iter_mut() {
-                clear_references(elem, self.ctx);
-            }
         }
 
         Ok(result)