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

@@ -38,6 +38,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - False positives on enums that are never referenced by name (but have used values) in `UnusedType`.
 - Name resolution failures in legacy initialization sections referencing the implementation section.
 - Name resolution failures whena accessing ancestors of enclosing types from nested type methods.
+- Name resolution failures on invocations of methods with generic open array parameters.
 - Incorrect file position calculation for multiline string tokens.
 - Analysis errors around `type of` type declarations.
 

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

@@ -32,6 +32,8 @@
 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.ArrayConstructorType;
+import org.sonar.plugins.communitydelphi.api.type.Type.CollectionType;
 
 /**
  * Stores information about an invocation candidate, used for overload resolution. Based directly
@@ -197,11 +199,20 @@ 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()) {
+        Type argumentElementType = getArrayElementType(argumentType);
+        if (argumentElementType != null) {
+          parameterType = ((CollectionType) parameterType).elementType();
+          argumentType = argumentElementType;
+        }
+      }
+
       if (!parameterType.isTypeParameter()) {
         continue;
       }
 
-      Type argumentType = argumentTypes.get(i);
       Type existingMapping = argumentsByTypeParameters.get(parameterType);
 
       if (existingMapping != null && !existingMapping.is(argumentType)) {
@@ -230,6 +241,33 @@ public static InvocationCandidate implicitSpecialization(
     return new InvocationCandidate(specialized);
   }
 
+  private static Type getArrayElementType(Type type) {
+    if (type.isArray()) {
+      return ((CollectionType) type).elementType();
+    } else if (type.isArrayConstructor()) {
+      return getHomogeneousElementType((ArrayConstructorType) type);
+    } else {
+      return null;
+    }
+  }
+
+  private static Type getHomogeneousElementType(ArrayConstructorType type) {
+    List<Type> elementTypes = type.elementTypes();
+    if (elementTypes.isEmpty()) {
+      return null;
+    }
+
+    Type result = elementTypes.get(0);
+    for (Type elementType : elementTypes) {
+      if (!elementType.is(result)) {
+        result = null;
+        break;
+      }
+    }
+
+    return result;
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {

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

@@ -1053,7 +1053,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.