Fix parsing errors on anonymous methods with routine directives

cirras · cirras · commit bf56f6415d62 · 2024-10-08T17:31:43.000+11:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,9 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- **API:** `AnonymousMethodNode::getAnonymousMethodHeading` method.
+- **API:** `AnonymousMethodNode::getDirectives` method.
+- **API:** `AnonymousMethodNode::hasDirective` method.
+- **API:** `AnonymousMethodHeadingNode` node type.
+- **API:** `DelphiTokenType.ANONYMOUS_METHOD` token type.
+- **API:** `DelphiTokenType.ANONYMOUS_METHOD_HEADING` token type.
+
 ### Fixed
 
 - Parsing errors on `implementation` keywords nested in conditional branches.
+- Parsing errors on anonymous methods with routine directives (like calling conventions).
 
 ## [1.10.0] - 2024-10-01
 
diff --git a/delphi-frontend/src/main/antlr3/au/com/integradev/delphi/antlr/Delphi.g b/delphi-frontend/src/main/antlr3/au/com/integradev/delphi/antlr/Delphi.g
@@ -69,6 +69,8 @@ tokens {
   TkArrayConstructor;
   TkArrayIndices;
   TkArgument;
+  TkAnonymousMethod;
+  TkAnonymousMethodHeading;
 }
 
 @header
@@ -907,8 +909,12 @@ argumentExpression           : expression writeArguments?
                              ;
 writeArguments               : ':'! expression (':'! expression)? // See: https://docwiki.embarcadero.com/Libraries/en/System.Write
                              ;
-anonymousMethod              : PROCEDURE<AnonymousMethodNodeImpl>^ routineParameters? block
-                             | FUNCTION<AnonymousMethodNodeImpl>^ routineParameters? routineReturnType block
+anonymousMethod              : anonymousMethodHeading block -> ^(TkAnonymousMethod<AnonymousMethodNodeImpl> anonymousMethodHeading block)
+                             ;
+anonymousMethodHeading       : PROCEDURE routineParameters? ((';')? interfaceDirective)*
+                             -> ^(TkAnonymousMethodHeading<AnonymousMethodHeadingNodeImpl> PROCEDURE routineParameters? ((';')? interfaceDirective)*)
+                             | FUNCTION routineParameters? routineReturnType ((';')? interfaceDirective)*
+                             -> ^(TkAnonymousMethodHeading<AnonymousMethodHeadingNodeImpl> FUNCTION routineParameters? routineReturnType ((';')? interfaceDirective)*)
                              ;
 expressionOrRange            : expression ('..'<RangeExpressionNodeImpl>^ expression)?
                              ;
diff --git a/delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/node/AnonymousMethodHeadingNodeImpl.java b/delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/node/AnonymousMethodHeadingNodeImpl.java
@@ -0,0 +1,84 @@
+/*
+ * Sonar Delphi Plugin
+ * Copyright (C) 2024 Integrated Application Development
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02
+ */
+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 org.antlr.runtime.Token;
+import org.sonar.plugins.communitydelphi.api.ast.AnonymousMethodHeadingNode;
+import org.sonar.plugins.communitydelphi.api.ast.DelphiNode;
+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.symbol.declaration.RoutineKind;
+import org.sonar.plugins.communitydelphi.api.token.DelphiToken;
+
+public final class AnonymousMethodHeadingNodeImpl extends DelphiNodeImpl
+    implements AnonymousMethodHeadingNode {
+  private RoutineKind routineKind;
+  private Set<RoutineDirective> directives;
+
+  public AnonymousMethodHeadingNodeImpl(Token token) {
+    super(token);
+  }
+
+  public AnonymousMethodHeadingNodeImpl(int tokenType) {
+    super(tokenType);
+  }
+
+  @Override
+  public <T> T accept(DelphiParserVisitor<T> visitor, T data) {
+    return visitor.visit(this, data);
+  }
+
+  @Override
+  public RoutineParametersNode getRoutineParametersNode() {
+    return getFirstChildOfType(RoutineParametersNode.class);
+  }
+
+  @Override
+  public RoutineReturnTypeNode getReturnTypeNode() {
+    return getFirstChildOfType(RoutineReturnTypeNode.class);
+  }
+
+  @Override
+  public RoutineKind getRoutineKind() {
+    if (routineKind == null) {
+      routineKind = RoutineKind.fromTokenType(getChild(0).getTokenType());
+    }
+    return routineKind;
+  }
+
+  @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;
+  }
+}
diff --git a/delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/node/AnonymousMethodNodeImpl.java b/delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/node/AnonymousMethodNodeImpl.java
@@ -22,38 +22,50 @@
 import au.com.integradev.delphi.type.factory.TypeFactoryImpl;
 import au.com.integradev.delphi.type.parameter.FormalParameter;
 import java.util.Collections;
+import java.util.Set;
 import java.util.stream.Collectors;
 import javax.annotation.Nonnull;
 import org.antlr.runtime.Token;
+import org.sonar.plugins.communitydelphi.api.ast.AnonymousMethodHeadingNode;
 import org.sonar.plugins.communitydelphi.api.ast.AnonymousMethodNode;
 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.symbol.declaration.RoutineKind;
 import org.sonar.plugins.communitydelphi.api.type.Type;
+import org.sonar.plugins.communitydelphi.api.type.Type.ProceduralType.ProceduralKind;
 import org.sonar.plugins.communitydelphi.api.type.TypeFactory;
 
 public final class AnonymousMethodNodeImpl extends ExpressionNodeImpl
     implements AnonymousMethodNode {
   private String image;
-  private RoutineKind routineKind;
 
   public AnonymousMethodNodeImpl(Token token) {
     super(token);
   }
 
+  public AnonymousMethodNodeImpl(int tokenType) {
+    super(tokenType);
+  }
+
   @Override
   public <T> T accept(DelphiParserVisitor<T> visitor, T data) {
     return visitor.visit(this, data);
   }
 
+  @Override
+  public AnonymousMethodHeadingNode getAnonymousMethodHeading() {
+    return (AnonymousMethodHeadingNode) getChild(0);
+  }
+
   @Override
   public RoutineParametersNode getRoutineParametersNode() {
-    return getFirstChildOfType(RoutineParametersNode.class);
+    return getAnonymousMethodHeading().getRoutineParametersNode();
   }
 
   @Override
   public RoutineReturnTypeNode getReturnTypeNode() {
-    return getFirstChildOfType(RoutineReturnTypeNode.class);
+    return getAnonymousMethodHeading().getReturnTypeNode();
   }
 
   @Override
@@ -63,10 +75,17 @@ public Type getReturnType() {
 
   @Override
   public RoutineKind getRoutineKind() {
-    if (routineKind == null) {
-      routineKind = RoutineKind.fromTokenType(getTokenType());
-    }
-    return routineKind;
+    return getAnonymousMethodHeading().getRoutineKind();
+  }
+
+  @Override
+  public Set<RoutineDirective> getDirectives() {
+    return getAnonymousMethodHeading().getDirectives();
+  }
+
+  @Override
+  public boolean hasDirective(RoutineDirective directive) {
+    return getDirectives().contains(directive);
   }
 
   @Override
diff --git a/delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/visitors/DelphiParserVisitor.java b/delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/visitors/DelphiParserVisitor.java
@@ -23,6 +23,7 @@
 package au.com.integradev.delphi.antlr.ast.visitors;
 
 import org.sonar.plugins.communitydelphi.api.ast.AncestorListNode;
+import org.sonar.plugins.communitydelphi.api.ast.AnonymousMethodHeadingNode;
 import org.sonar.plugins.communitydelphi.api.ast.AnonymousMethodNode;
 import org.sonar.plugins.communitydelphi.api.ast.ArgumentListNode;
 import org.sonar.plugins.communitydelphi.api.ast.ArgumentNode;
@@ -185,6 +186,10 @@ default void visitToken(DelphiToken token, T data) {
     // Do nothing
   }
 
+  default T visit(AnonymousMethodHeadingNode node, T data) {
+    return visit((DelphiNode) node, data);
+  }
+
   default T visit(ArgumentListNode node, T data) {
     return visit((DelphiNode) node, data);
   }
diff --git a/delphi-frontend/src/main/java/org/sonar/plugins/communitydelphi/api/ast/AnonymousMethodHeadingNode.java b/delphi-frontend/src/main/java/org/sonar/plugins/communitydelphi/api/ast/AnonymousMethodHeadingNode.java
@@ -0,0 +1,33 @@
+/*
+ * Sonar Delphi Plugin
+ * Copyright (C) 2024 Integrated Application Development
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02
+ */
+package org.sonar.plugins.communitydelphi.api.ast;
+
+import java.util.Set;
+import org.sonar.plugins.communitydelphi.api.symbol.declaration.RoutineDirective;
+import org.sonar.plugins.communitydelphi.api.symbol.declaration.RoutineKind;
+
+public interface AnonymousMethodHeadingNode extends DelphiNode {
+  RoutineParametersNode getRoutineParametersNode();
+
+  RoutineReturnTypeNode getReturnTypeNode();
+
+  RoutineKind getRoutineKind();
+
+  Set<RoutineDirective> getDirectives();
+}
diff --git a/delphi-frontend/src/main/java/org/sonar/plugins/communitydelphi/api/ast/AnonymousMethodNode.java b/delphi-frontend/src/main/java/org/sonar/plugins/communitydelphi/api/ast/AnonymousMethodNode.java
@@ -18,10 +18,14 @@
  */
 package org.sonar.plugins.communitydelphi.api.ast;
 
+import java.util.Set;
+import org.sonar.plugins.communitydelphi.api.symbol.declaration.RoutineDirective;
 import org.sonar.plugins.communitydelphi.api.symbol.declaration.RoutineKind;
 import org.sonar.plugins.communitydelphi.api.type.Type;
 
 public interface AnonymousMethodNode extends ExpressionNode {
+  AnonymousMethodHeadingNode getAnonymousMethodHeading();
+
   RoutineParametersNode getRoutineParametersNode();
 
   RoutineReturnTypeNode getReturnTypeNode();
@@ -30,6 +34,10 @@ public interface AnonymousMethodNode extends ExpressionNode {
 
   RoutineKind getRoutineKind();
 
+  Set<RoutineDirective> getDirectives();
+
+  boolean hasDirective(RoutineDirective directive);
+
   boolean isFunction();
 
   boolean isProcedure();
diff --git a/delphi-frontend/src/test/resources/au/com/integradev/delphi/grammar/AnonymousMethods.pas b/delphi-frontend/src/test/resources/au/com/integradev/delphi/grammar/AnonymousMethods.pas
@@ -32,4 +32,13 @@ function IsStringEmptyImmediateInvocation(const aValue : string) : Boolean;
     end)(aValue);
 end;
 
+function IsStringEmptyWithCallingConvention(const aValue : string) : Boolean;
+begin
+  Result := StringMatches(aValue,
+    function(const aValue : string) : Boolean register
+    begin
+      Result := aValue = '';
+    end);
+end;
+
 end.

Original file line number	Diff line number	Diff line change
`@@ -69,6 +69,8 @@ tokens {`
`69`	`69`	`TkArrayConstructor;`
`70`	`70`	`TkArrayIndices;`
`71`	`71`	`TkArgument;`
	`72`	`+ TkAnonymousMethod;`
	`73`	`+ TkAnonymousMethodHeading;`
`72`	`74`	`}`
`73`	`75`
`74`	`76`	`@header`
`@@ -907,8 +909,12 @@ argumentExpression : expression writeArguments?`
`907`	`909`	`;`
`908`	`910`	`writeArguments : ':'! expression (':'! expression)? // See: https://docwiki.embarcadero.com/Libraries/en/System.Write`
`909`	`911`	`;`
`910`		`-anonymousMethod : PROCEDURE<AnonymousMethodNodeImpl>^ routineParameters? block`
`911`		`- \| FUNCTION<AnonymousMethodNodeImpl>^ routineParameters? routineReturnType block`
	`912`	`+anonymousMethod : anonymousMethodHeading block -> ^(TkAnonymousMethod<AnonymousMethodNodeImpl> anonymousMethodHeading block)`
	`913`	`+ ;`
	`914`	`+anonymousMethodHeading : PROCEDURE routineParameters? ((';')? interfaceDirective)*`
	`915`	`+ -> ^(TkAnonymousMethodHeading<AnonymousMethodHeadingNodeImpl> PROCEDURE routineParameters? ((';')? interfaceDirective)*)`
	`916`	`+ \| FUNCTION routineParameters? routineReturnType ((';')? interfaceDirective)*`
	`917`	`+ -> ^(TkAnonymousMethodHeading<AnonymousMethodHeadingNodeImpl> FUNCTION routineParameters? routineReturnType ((';')? interfaceDirective)*)`
`912`	`918`	`;`
`913`	`919`	`expressionOrRange : expression ('..'<RangeExpressionNodeImpl>^ expression)?`
`914`	`920`	`;`