Insert mappings for interface packages.

Closes #403

Author: Schottkyc137

vhdl_lang/src/analysis/association.rs

@@ -654,7 +654,29 @@ impl<'a> AnalyzeContext<'a, '_> {
                         },
                         InterfaceEnt::Package(_) => match expr {
                             Expression::Name(name) => {
-                                self.name_resolve(scope, actual.span, name, diagnostics)?;
+                                let resolved =
+                                    self.name_resolve(scope, actual.span, name, diagnostics)?;
+                                // When a formal generic package is mapped to an actual package,
+                                // populate the type mapping so that types from the formal package's
+                                // region resolve to the corresponding types in the actual package.
+                                if let ResolvedName::Design(actual_pkg) = resolved {
+                                    let actual_region = match actual_pkg.kind() {
+                                        Design::PackageInstance(r)
+                                        | Design::InterfacePackageInstance(r) => Some(r),
+                                        _ => None,
+                                    };
+                                    if let Some(actual_region) = actual_region {
+                                        for named_entities in actual_region.entities.values() {
+                                            if let Some(actual_ent) = named_entities.as_unique() {
+                                                if let (Some(actual_type), Related::InstanceOf(uninst)) =
+                                                    (TypeEnt::from_any(actual_ent), &actual_ent.related)
+                                                {
+                                                    mapping.insert(uninst.id(), actual_type);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
                             }
                             _ => diagnostics.add(
                                 actual.pos(self.ctx),

vhdl_lang/src/analysis/tests/package_instance.rs

@@ -822,3 +822,50 @@ end architecture;
     let diagnostics = builder.analyze();
     check_no_diagnostics(&diagnostics);
 }
+
+// Regression test for https://github.com/VHDL-LS/rust_hdl/issues/403
+#[test]
+fn type_from_generic_package_formal_is_compatible_with_actual() {
+    let mut builder = LibraryBuilder::new();
+    builder.code(
+        "libname",
+        "
+package base_pkg is
+  generic(n : natural);
+  type t is range 0 to n;
+end package;
+
+use work.base_pkg;
+package wrapper_pkg is
+  generic(package i_base is new base_pkg generic map(<>));
+  function get return i_base.t;
+end package;
+
+package body wrapper_pkg is
+  function get return i_base.t is
+  begin
+    return 0;
+  end function;
+end package body;
+
+use work.base_pkg;
+use work.wrapper_pkg;
+entity tb is end entity;
+
+architecture arch of tb is
+  package my_base is new base_pkg generic map(10);
+  package my_wrapper is new wrapper_pkg generic map(my_base);
+begin
+  process
+    variable v : my_base.t;
+  begin
+    v := my_wrapper.get;
+    wait;
+  end process;
+end architecture;
+",
+    );
+
+    let diagnostics = builder.analyze();
+    check_no_diagnostics(&diagnostics);
+}