Fix: Track interface package map kind to avoid incorrect package association instance flagging

Author: luscheller

vhdl_lang/src/analysis/association.rs

@@ -662,7 +662,7 @@ impl<'a> AnalyzeContext<'a, '_> {
                                 if let ResolvedName::Design(actual_pkg) = resolved {
                                     let actual_region = match actual_pkg.kind() {
                                         Design::PackageInstance(r)
-                                        | Design::InterfacePackageInstance(r) => Some(r),
+                                        | Design::InterfacePackageInstance(_, r) => Some(r),
                                         _ => None,
                                     };
                                     if let Some(actual_region) = actual_region {

vhdl_lang/src/analysis/declarative.rs

@@ -968,10 +968,16 @@ impl<'a> AnalyzeContext<'a, '_> {
                     diagnostics,
                 )?;
 
+                let map_kind = match instance.generic_map.item {
+                    InterfacePackageGenericMapAspect::Map(_) => InterfacePackageMapKind::Map,
+                    InterfacePackageGenericMapAspect::Box => InterfacePackageMapKind::Box,
+                    InterfacePackageGenericMapAspect::Default => InterfacePackageMapKind::Default,
+                };
+
                 vec![self.define(
                     &mut instance.ident,
                     parent,
-                    AnyEntKind::Design(Design::InterfacePackageInstance(package_region)),
+                    AnyEntKind::Design(Design::InterfacePackageInstance(map_kind, package_region)),
                     span,
                 )]
             }
@@ -1284,7 +1290,7 @@ fn get_entity_class(ent: EntRef<'_>) -> Option<EntityClass> {
             Design::PackageBody(..) => None,
             Design::UninstPackage(_, _) => None,
             Design::PackageInstance(_) => None,
-            Design::InterfacePackageInstance(_) => None,
+            Design::InterfacePackageInstance(..) => None,
             Design::Context(_) => None,
         },
         AnyEntKind::View(_) => None,

vhdl_lang/src/analysis/design_unit.rs

@@ -679,7 +679,7 @@ impl<'a> AnalyzeContext<'a, '_> {
                         }
                         Design::Package(_, ref primary_region)
                         | Design::PackageInstance(ref primary_region)
-                        | Design::InterfacePackageInstance(ref primary_region) => {
+                        | Design::InterfacePackageInstance(_, ref primary_region) => {
                             scope.make_all_potentially_visible(
                                 Some(&name.pos(self.ctx)),
                                 primary_region,

vhdl_lang/src/analysis/package_instance.rs

@@ -207,8 +207,9 @@ impl<'a> AnalyzeContext<'a, '_> {
                 Design::PackageInstance(region) => AnyEntKind::Design(Design::PackageInstance(
                     self.map_region(parent, mapping, region, scope)?,
                 )),
-                Design::InterfacePackageInstance(region) => {
+                Design::InterfacePackageInstance(map_kind, region) => {
                     AnyEntKind::Design(Design::InterfacePackageInstance(
+                        *map_kind,
                         self.map_region(parent, mapping, region, scope)?,
                     ))
                 }

vhdl_lang/src/analysis/tests/package_instance.rs

@@ -869,3 +869,38 @@ end architecture;
     let diagnostics = builder.analyze();
     check_no_diagnostics(&diagnostics);
 }
+
+// Regression test for https://github.com/VHDL-LS/rust_hdl/issues/460
+#[test]
+fn interface_package_with_explicit_generic_map_does_not_require_association() {
+    let mut builder = LibraryBuilder::new();
+    builder.code(
+        "libname",
+        "
+package example_pkg is
+    generic (
+        G_GENERIC   : integer
+    );
+end package;
+
+entity example is
+    generic (
+        package example_pkg is new work.example_pkg
+        generic map (
+            G_GENERIC   => 1
+        )
+    );
+end entity;
+
+architecture rtl of example is
+begin
+
+    inst: entity work.example;
+
+end architecture;
+",
+    );
+
+    let diagnostics = builder.analyze();
+    check_no_diagnostics(&diagnostics);
+}

vhdl_lang/src/completion/generic.rs

@@ -131,7 +131,7 @@ fn visible_entities_from<'a>(
             completion_items_from_visibility(root, visibility),
         )
         .collect_vec(),
-        PackageInstance(region) | InterfacePackageInstance(region) | Context(region) => {
+        PackageInstance(region) | InterfacePackageInstance(_, region) | Context(region) => {
             completion_items_from_region(root, region).collect_vec()
         }
         Configuration => vec![],

vhdl_lang/src/completion/selected.rs

@@ -61,7 +61,7 @@ fn completions_for_design<'a>(
 ) -> Vec<CompletionItem<'a>> {
     use crate::named_entity::Design::*;
     match design {
-        Package(_, region) | PackageInstance(region) | InterfacePackageInstance(region) => {
+        Package(_, region) | PackageInstance(region) | InterfacePackageInstance(_, region) => {
             completion_items_from_region(root, region)
                 .chain(once(CompletionItem::Keyword(All)))
                 .collect()

vhdl_lang/src/named_entity.rs

@@ -20,7 +20,7 @@ pub use overloaded::{Overloaded, OverloadedEnt, Signature, SignatureKey, Subprog
 mod object;
 pub use object::{InterfaceMode, Object, ObjectEnt, ObjectInterface, ViewEnt};
 mod design;
-pub use design::{Design, DesignEnt};
+pub use design::{Design, DesignEnt, InterfacePackageMapKind};
 mod attribute;
 pub use attribute::AttributeEnt;
 mod arena;

vhdl_lang/src/named_entity/design.rs

@@ -13,6 +13,31 @@ use crate::ast::WithRef;
 use crate::named_entity::visibility::Visibility;
 use crate::Diagnostic;
 
+/// LRM 6.5.5: Discriminates the three forms an interface-package's
+/// `generic_map_aspect` may take.
+/// [`crate::ast::InterfacePackageGenericMapAspect`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum InterfacePackageMapKind {
+    /// `generic map (a => x, ...)` - fully bound at declaration; the enclosing
+    /// generic clause is the only place the package's generics are associated.
+    Map,
+    /// `generic map (<>)` - unbound; the enclosing entity/package/subprogram's
+    /// instantiation must associate this interface package.
+    Box,
+    /// `generic map (default)` - bound via the named package's default values
+    /// for its generics.
+    Default,
+}
+
+impl InterfacePackageMapKind {
+    /// Returns whether the enclosing instantiation is *not* required to
+    /// associate this interface package - i.e., it is fully bound at the
+    /// declaration site.
+    pub fn has_default(self) -> bool {
+        matches!(self, Self::Map | Self::Default)
+    }
+}
+
 #[derive(Clone)]
 pub enum Design<'a> {
     Entity(Visibility<'a>, Region<'a>),
@@ -34,7 +59,10 @@ pub enum Design<'a> {
     ///     package foo is new bar generic map (<>)
     /// )
     /// ```
-    InterfacePackageInstance(Region<'a>),
+    /// The [`InterfacePackageMapKind`] records which of the three forms of
+    /// `generic_map_aspect` was used; this drives whether the enclosing
+    /// instantiation must associate the interface package.
+    InterfacePackageInstance(InterfacePackageMapKind, Region<'a>),
     Context(Region<'a>),
 }
 
@@ -48,7 +76,7 @@ impl Design<'_> {
             Package(..) => "package",
             PackageBody(..) => "package body",
             UninstPackage(..) => "uninstantiated package",
-            PackageInstance(_) | InterfacePackageInstance(_) => "package instance",
+            PackageInstance(_) | InterfacePackageInstance(..) => "package instance",
             Context(..) => "context",
         }
     }
@@ -88,7 +116,7 @@ impl<'a> DesignEnt<'a> {
         match self.kind() {
             Design::Package(_, ref region)
             | Design::PackageInstance(ref region)
-            | Design::InterfacePackageInstance(ref region) => {
+            | Design::InterfacePackageInstance(_, ref region) => {
                 if let Some(decl) = region.lookup_immediate(suffix.designator()) {
                     Ok(decl.clone())
                 } else {

vhdl_lang/src/named_entity/formal_region.rs

@@ -40,7 +40,7 @@ impl<'a> InterfaceEnt<'a> {
             AnyEntKind::InterfaceFile(_) => {
                 Some(InterfaceEnt::File(FileEnt::from_any(ent).unwrap()))
             }
-            AnyEntKind::Design(Design::InterfacePackageInstance(_)) => {
+            AnyEntKind::Design(Design::InterfacePackageInstance(..)) => {
                 Some(InterfaceEnt::Package(DesignEnt::from_any(ent).unwrap()))
             }
             AnyEntKind::Type(Type::Interface) => {
@@ -56,6 +56,10 @@ impl<'a> InterfaceEnt<'a> {
     pub fn has_default(&self) -> bool {
         match self {
             InterfaceEnt::Object(o) => o.kind().has_default,
+            InterfaceEnt::Package(pkg) => match pkg.kind() {
+                Design::InterfacePackageInstance(map_kind, _) => map_kind.has_default(),
+                _ => false,
+            },
             _ => false,
         }
     }
@@ -124,7 +128,7 @@ impl<'a> GpkgInterfaceEnt<'a> {
             AnyEntKind::Overloaded(Overloaded::InterfaceSubprogram(_)) => Some(
                 GpkgInterfaceEnt::Subprogram(OverloadedEnt::from_any(ent).unwrap()),
             ),
-            AnyEntKind::Design(Design::InterfacePackageInstance(_)) => {
+            AnyEntKind::Design(Design::InterfacePackageInstance(..)) => {
                 Some(GpkgInterfaceEnt::Package(DesignEnt::from_any(ent).unwrap()))
             }
             _ => None,