Persist routine directives into ProceduralType

This was prompted by the realization that `varargs` weren't consistently
persisted into procedural type data, causing non-routine procedural
types to never be recognized as variadic.

Now we simply persist all of the directives, which will also make it
easier to factor calling conventions when comparing procedural types
for overload resolution.

Author: cirras

CHANGELOG.md

@@ -9,6 +9,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **API:** `ProceduralType::directives` method.
+- **API:** `ProceduralTypeNode::getDirectives` method.
+- **API:** `ProceduralTypeNode::hasDirective` method.
+- **API:** `ProceduralTypeHeadingNode::getDirectives` method.
 - **API:** `AnonymousMethodNode::getAnonymousMethodHeading` method.
 - **API:** `AnonymousMethodNode::getDirectives` method.
 - **API:** `AnonymousMethodNode::hasDirective` method.
@@ -20,6 +24,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Parsing errors on `implementation` keywords nested in conditional branches.
 - Parsing errors on anonymous methods with routine directives (like calling conventions).
+- `IndexOutOfBoundsException` errors around procedural types declared with `varargs` in
+  `VariableInitialization`.
 
 ## [1.10.0] - 2024-10-01
 

delphi-checks/src/test/java/au/com/integradev/delphi/checks/VariableInitializationCheckTest.java

@@ -1237,6 +1237,25 @@ void testOutParameterInitializedInNestedRoutineShouldNotAddIssue() {
         .verifyNoIssues();
   }
 
+  // See: https://github.com/integrated-application-development/sonar-delphi/issues/297
+  @Test
+  void testIssue297ShouldAddIssue() {
+    CheckVerifier.newVerifier()
+        .withCheck(new VariableInitializationCheck())
+        .onFile(
+            new DelphiTestUnitBuilder()
+                .appendImpl("var")
+                .appendImpl("  SetValues: procedure(Values: Integer); cdecl varargs;")
+                .appendImpl("")
+                .appendImpl("procedure MyProcedure;")
+                .appendImpl("var")
+                .appendImpl("  Value: Integer;")
+                .appendImpl("begin")
+                .appendImpl("  SetValues(Value, Value); // Noncompliant")
+                .appendImpl("end;"))
+        .verifyIssues();
+  }
+
   private static DelphiTestUnitBuilder createSysUtils() {
     return new DelphiTestUnitBuilder()
         .unitName("System.SysUtils")

delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/node/AnonymousMethodNodeImpl.java

@@ -123,14 +123,16 @@ protected Type createType() {
     RoutineReturnTypeNode returnTypeNode = getReturnTypeNode();
 
     return ((TypeFactoryImpl) getTypeFactory())
-        .anonymous(
+        .createProcedural(
+            ProceduralKind.ANONYMOUS,
             parameters == null
                 ? Collections.emptyList()
                 : parameters.getParameters().stream()
                     .map(FormalParameter::create)
                     .collect(Collectors.toUnmodifiableList()),
             returnTypeNode == null
                 ? TypeFactory.voidType()
-                : returnTypeNode.getTypeNode().getType());
+                : returnTypeNode.getTypeNode().getType(),
+            getDirectives());
   }
 }

delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/node/ProceduralTypeNodeImpl.java

@@ -20,12 +20,14 @@
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 import org.antlr.runtime.Token;
 import org.sonar.plugins.communitydelphi.api.ast.FormalParameterNode.FormalParameterData;
 import org.sonar.plugins.communitydelphi.api.ast.ProceduralTypeNode;
 import org.sonar.plugins.communitydelphi.api.ast.ProcedureTypeHeadingNode;
 import org.sonar.plugins.communitydelphi.api.ast.RoutineParametersNode;
 import org.sonar.plugins.communitydelphi.api.ast.RoutineReturnTypeNode;
+import org.sonar.plugins.communitydelphi.api.symbol.declaration.RoutineDirective;
 import org.sonar.plugins.communitydelphi.api.type.Type;
 import org.sonar.plugins.communitydelphi.api.type.TypeFactory;
 
@@ -53,4 +55,14 @@ public List<FormalParameterData> getParameters() {
     RoutineParametersNode parametersNode = getHeading().getRoutineParametersNode();
     return parametersNode == null ? Collections.emptyList() : parametersNode.getParameters();
   }
+
+  @Override
+  public Set<RoutineDirective> getDirectives() {
+    return getHeading().getDirectives();
+  }
+
+  @Override
+  public boolean hasDirective(RoutineDirective directive) {
+    return getDirectives().contains(directive);
+  }
 }

delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/node/ProcedureOfObjectTypeNodeImpl.java

@@ -26,6 +26,7 @@
 import org.antlr.runtime.Token;
 import org.sonar.plugins.communitydelphi.api.ast.ProcedureOfObjectTypeNode;
 import org.sonar.plugins.communitydelphi.api.type.Type;
+import org.sonar.plugins.communitydelphi.api.type.Type.ProceduralType.ProceduralKind;
 
 public final class ProcedureOfObjectTypeNodeImpl extends ProceduralTypeNodeImpl
     implements ProcedureOfObjectTypeNode {
@@ -42,10 +43,12 @@ public <T> T accept(DelphiParserVisitor<T> visitor, T data) {
   @Nonnull
   protected Type createType() {
     return ((TypeFactoryImpl) getTypeFactory())
-        .ofObject(
+        .createProcedural(
+            ProceduralKind.PROCEDURE_OF_OBJECT,
             getParameters().stream()
                 .map(FormalParameter::create)
                 .collect(Collectors.toUnmodifiableList()),
-            getReturnType());
+            getReturnType(),
+            getDirectives());
   }
 }

delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/node/ProcedureReferenceTypeNodeImpl.java

@@ -26,6 +26,7 @@
 import org.antlr.runtime.Token;
 import org.sonar.plugins.communitydelphi.api.ast.ProcedureReferenceTypeNode;
 import org.sonar.plugins.communitydelphi.api.type.Type;
+import org.sonar.plugins.communitydelphi.api.type.Type.ProceduralType.ProceduralKind;
 
 public final class ProcedureReferenceTypeNodeImpl extends ProceduralTypeNodeImpl
     implements ProcedureReferenceTypeNode {
@@ -42,10 +43,12 @@ public <T> T accept(DelphiParserVisitor<T> visitor, T data) {
   @Nonnull
   protected Type createType() {
     return ((TypeFactoryImpl) getTypeFactory())
-        .reference(
+        .createProcedural(
+            ProceduralKind.REFERENCE,
             getParameters().stream()
                 .map(FormalParameter::create)
                 .collect(Collectors.toUnmodifiableList()),
-            getReturnType());
+            getReturnType(),
+            getDirectives());
   }
 }

delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/node/ProcedureTypeHeadingNodeImpl.java

@@ -19,15 +19,21 @@
 package au.com.integradev.delphi.antlr.ast.node;
 
 import au.com.integradev.delphi.antlr.ast.visitors.DelphiParserVisitor;
+import com.google.common.collect.ImmutableSet;
+import java.util.Set;
 import javax.annotation.Nullable;
 import org.antlr.runtime.Token;
 import org.sonar.plugins.communitydelphi.api.ast.DelphiNode;
 import org.sonar.plugins.communitydelphi.api.ast.ProcedureTypeHeadingNode;
 import org.sonar.plugins.communitydelphi.api.ast.RoutineParametersNode;
 import org.sonar.plugins.communitydelphi.api.ast.RoutineReturnTypeNode;
+import org.sonar.plugins.communitydelphi.api.symbol.declaration.RoutineDirective;
+import org.sonar.plugins.communitydelphi.api.token.DelphiToken;
 
 public final class ProcedureTypeHeadingNodeImpl extends DelphiNodeImpl
     implements ProcedureTypeHeadingNode {
+  private Set<RoutineDirective> directives;
+
   public ProcedureTypeHeadingNodeImpl(Token token) {
     super(token);
   }
@@ -61,6 +67,22 @@ public RoutineReturnTypeNode getRoutineReturnTypeNode() {
     return (node instanceof RoutineReturnTypeNode) ? (RoutineReturnTypeNode) node : null;
   }
 
+  @Override
+  public Set<RoutineDirective> getDirectives() {
+    if (directives == null) {
+      var builder = new ImmutableSet.Builder<RoutineDirective>();
+      for (DelphiNode child : getChildren()) {
+        DelphiToken token = child.getToken();
+        RoutineDirective directive = RoutineDirective.fromToken(token);
+        if (directive != null) {
+          builder.add(directive);
+        }
+      }
+      directives = builder.build();
+    }
+    return directives;
+  }
+
   private boolean hasRoutineParametersNode() {
     return getRoutineParametersNode() != null;
   }

delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/node/ProcedureTypeNodeImpl.java

@@ -26,6 +26,7 @@
 import org.antlr.runtime.Token;
 import org.sonar.plugins.communitydelphi.api.ast.ProcedureTypeNode;
 import org.sonar.plugins.communitydelphi.api.type.Type;
+import org.sonar.plugins.communitydelphi.api.type.Type.ProceduralType.ProceduralKind;
 
 public final class ProcedureTypeNodeImpl extends ProceduralTypeNodeImpl
     implements ProcedureTypeNode {
@@ -46,10 +47,12 @@ public <T> T accept(DelphiParserVisitor<T> visitor, T data) {
   @Nonnull
   protected Type createType() {
     return ((TypeFactoryImpl) getTypeFactory())
-        .procedure(
+        .createProcedural(
+            ProceduralKind.PROCEDURE,
             getParameters().stream()
                 .map(FormalParameter::create)
                 .collect(Collectors.toUnmodifiableList()),
-            getReturnType());
+            getReturnType(),
+            getDirectives());
   }
 }

delphi-frontend/src/main/java/au/com/integradev/delphi/symbol/declaration/RoutineNameDeclarationImpl.java

@@ -52,6 +52,7 @@
 import org.sonar.plugins.communitydelphi.api.type.Parameter;
 import org.sonar.plugins.communitydelphi.api.type.Type;
 import org.sonar.plugins.communitydelphi.api.type.Type.ProceduralType;
+import org.sonar.plugins.communitydelphi.api.type.Type.ProceduralType.ProceduralKind;
 import org.sonar.plugins.communitydelphi.api.type.TypeFactory;
 import org.sonar.plugins.communitydelphi.api.type.TypeSpecializationContext;
 
@@ -112,7 +113,11 @@ public static RoutineNameDeclaration create(
         true,
         data.getRoutineKind(),
         ((TypeFactoryImpl) typeFactory)
-            .routine(createParameters(data), data.getReturnType(), data.isVariadic()),
+            .createProcedural(
+                ProceduralKind.ROUTINE,
+                createParameters(data),
+                data.getReturnType(),
+                data.isVariadic() ? Set.of(RoutineDirective.VARARGS) : Collections.emptySet()),
         null,
         VisibilityType.PUBLIC,
         Collections.emptyList(),
@@ -147,7 +152,12 @@ public static RoutineNameDeclarationImpl create(RoutineNode routine, TypeFactory
         routine.isClassMethod(),
         isCallable,
         routine.getRoutineKind(),
-        ((TypeFactoryImpl) typeFactory).routine(createParameters(routine), routine.getReturnType()),
+        ((TypeFactoryImpl) typeFactory)
+            .createProcedural(
+                ProceduralKind.ROUTINE,
+                createParameters(routine),
+                routine.getReturnType(),
+                routine.getDirectives()),
         routine.getTypeDeclaration(),
         routine.getVisibility(),
         extractGenericTypeParameters(routine),

delphi-frontend/src/main/java/au/com/integradev/delphi/type/factory/ProceduralTypeImpl.java

@@ -21,7 +21,9 @@
 import au.com.integradev.delphi.type.generic.GenerifiableTypeImpl;
 import com.google.common.collect.Iterables;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
+import org.sonar.plugins.communitydelphi.api.symbol.declaration.RoutineDirective;
 import org.sonar.plugins.communitydelphi.api.type.Parameter;
 import org.sonar.plugins.communitydelphi.api.type.Type;
 import org.sonar.plugins.communitydelphi.api.type.Type.ProceduralType;
@@ -32,19 +34,19 @@ public final class ProceduralTypeImpl extends GenerifiableTypeImpl implements Pr
   private final ProceduralKind kind;
   private final List<Parameter> parameters;
   private final Type returnType;
-  private final boolean variadic;
+  private final Set<RoutineDirective> directives;
 
   ProceduralTypeImpl(
       int size,
       ProceduralKind kind,
       List<Parameter> parameters,
       Type returnType,
-      boolean variadic) {
+      Set<RoutineDirective> directives) {
     this.size = size;
     this.kind = kind;
     this.parameters = List.copyOf(parameters);
     this.returnType = returnType;
-    this.variadic = variadic;
+    this.directives = directives;
   }
 
   @Override
@@ -93,14 +95,14 @@ public List<Parameter> parameters() {
 
   @Override
   public int parametersCount() {
-    return variadic ? 255 : parameters().size();
+    return directives.contains(RoutineDirective.VARARGS) ? 255 : parameters().size();
   }
 
   @Override
   public Parameter getParameter(int index) {
     if (index < parameters().size()) {
       return parameters().get(index);
-    } else if (variadic) {
+    } else if (directives.contains(RoutineDirective.VARARGS)) {
       return Iterables.getLast(parameters());
     }
 
@@ -122,6 +124,11 @@ public ProceduralKind kind() {
     return kind;
   }
 
+  @Override
+  public Set<RoutineDirective> directives() {
+    return directives;
+  }
+
   @Override
   public boolean isProcedural() {
     return true;
@@ -151,6 +158,6 @@ public GenerifiableTypeImpl doSpecialization(TypeSpecializationContext context)
             .map(parameter -> parameter.specialize(context))
             .collect(Collectors.toUnmodifiableList()),
         returnType.specialize(context),
-        variadic);
+        directives);
   }
 }