Fix implicit generic specialization of open array types

Previously, our implicit specialization required **exact** mappings of
types to top-level type parameters, but open arrays can go one level
deep with the type parameter as the element type.

Author: cirras

CHANGELOG.md

@@ -35,6 +35,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - False positives on enumerator method `MoveNext` in `UnusedRoutine`.
 - False positives on enumerator property `Current` in `UnusedProperty`.
 - Name resolution failures in legacy initialization sections referencing the implementation section.
+- Name resolution failures on invocations of methods with generic open array parameters.
 - Incorrect file position calculation for multiline string tokens.
 
 ## [1.15.0] - 2025-04-03

delphi-frontend/src/main/java/au/com/integradev/delphi/symbol/resolve/InvocationCandidate.java

@@ -32,6 +32,7 @@
 import org.sonar.plugins.communitydelphi.api.type.IntrinsicType;
 import org.sonar.plugins.communitydelphi.api.type.Parameter;
 import org.sonar.plugins.communitydelphi.api.type.Type;
+import org.sonar.plugins.communitydelphi.api.type.Type.CollectionType;
 
 /**
  * Stores information about an invocation candidate, used for overload resolution. Based directly
@@ -197,11 +198,17 @@ public static InvocationCandidate implicitSpecialization(
     Map<Type, Type> argumentsByTypeParameters = new HashMap<>();
     for (int i = 0; i < argumentTypes.size(); ++i) {
       Type parameterType = routineDeclaration.getParameter(i).getType();
+      Type argumentType = argumentTypes.get(i);
+
+      if (parameterType.isOpenArray() && argumentType.isArray()) {
+        parameterType = ((CollectionType) parameterType).elementType();
+        argumentType = ((CollectionType) argumentType).elementType();
+      }
+
       if (!parameterType.isTypeParameter()) {
         continue;
       }
 
-      Type argumentType = argumentTypes.get(i);
       Type existingMapping = argumentsByTypeParameters.get(parameterType);
 
       if (existingMapping != null && !existingMapping.is(argumentType)) {

delphi-frontend/src/test/java/au/com/integradev/delphi/executor/DelphiSymbolTableExecutorTest.java

@@ -1046,7 +1046,8 @@ void testGenericParameterizedMethods() {
   @Test
   void testGenericImplicitSpecializations() {
     execute("generics/ImplicitSpecialization.pas");
-    verifyUsages(14, 14, reference(19, 20), reference(26, 2), reference(27, 2), reference(28, 2));
+    verifyUsages(15, 14, reference(21, 20), reference(37, 2), reference(38, 2), reference(39, 2));
+    verifyUsages(16, 14, reference(26, 20), reference(48, 2), reference(49, 2), reference(50, 2));
   }
 
   @Test

delphi-frontend/src/test/resources/au/com/integradev/delphi/symbol/generics/ImplicitSpecialization.pas

@@ -4,14 +4,16 @@ interface
 
 type
   TConsumable = class
-    constructor Create; override;
+    constructor Create;
     procedure GetEaten;
     class function Pizza: TConsumable;
   end;
 
   TConsumer = class
-    procedure Test(Consumable: TConsumable);
-    procedure Consume<T: TConsumable>(Tasty: T);
+    procedure Test(Consumable: TConsumable); overload;
+    procedure Test(Consumables: array of TConsumable); overload;
+    procedure Consume<T: TConsumable>(Consumable: T); overload;
+    procedure Consume<T: TConsumable>(Consumables: array of T); overload;
   end;
 
 implementation
@@ -21,11 +23,31 @@ procedure TConsumer.Consume<T>(Consumable: T);
   Consumable.GetEaten;
 end;
 
+procedure TConsumer.Consume<T>(Consumables: array of T);
+var
+  Consumable: T;
+begin
+  for Consumable in Consumables do begin
+    Consume(Consumable);
+  end;
+end;
+
 procedure TConsumer.Test(Consumable: TConsumable);
 begin
   Consume(Consumable);
   Consume(TConsumable.Pizza);
   Consume(TConsumable.Create);
 end;
 
+procedure TConsumer.Test(Consumables: array of TConsumable);
+var
+  DynamicConsumables: TArray<TConsumable>;
+begin
+  DynamicConsumables := [TConsumable.Create];
+
+  Consume(Consumables);
+  Consume(DynamicConsumables);
+  Consume([TConsumable.Pizza]);
+end;
+
 end.