You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by su...@apache.org on 2020/12/16 14:55:38 UTC
[groovy] branch GROOVY_3_0_X updated: minor edits(backport to 3.0.X)
This is an automated email from the ASF dual-hosted git repository.
sunlan pushed a commit to branch GROOVY_3_0_X
in repository https://gitbox.apache.org/repos/asf/groovy.git
The following commit(s) were added to refs/heads/GROOVY_3_0_X by this push:
new f72e647 minor edits(backport to 3.0.X)
f72e647 is described below
commit f72e647adc7ddb371684100c1b2f24d57cfc1e42
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Wed Dec 16 22:48:41 2020 +0800
minor edits(backport to 3.0.X)
---
src/antlr/GroovyParser.g4 | 29 +-
.../apache/groovy/parser/antlr4/AstBuilder.java | 900 ++++++++-------------
2 files changed, 363 insertions(+), 566 deletions(-)
diff --git a/src/antlr/GroovyParser.g4 b/src/antlr/GroovyParser.g4
index d318ecb..418778c 100644
--- a/src/antlr/GroovyParser.g4
+++ b/src/antlr/GroovyParser.g4
@@ -458,13 +458,13 @@ gstringPath
// LAMBDA EXPRESSION
lambdaExpression
options { baseContext = standardLambdaExpression; }
- : lambdaParameters nls ARROW nls lambdaBody
- ;
+ : lambdaParameters nls ARROW nls lambdaBody
+ ;
// JAVA STANDARD LAMBDA EXPRESSION
standardLambdaExpression
- : standardLambdaParameters nls ARROW nls lambdaBody
- ;
+ : standardLambdaParameters nls ARROW nls lambdaBody
+ ;
lambdaParameters
options { baseContext = standardLambdaParameters; }
@@ -481,9 +481,9 @@ standardLambdaParameters
;
lambdaBody
- : block
- | statementExpression
- ;
+ : block
+ | statementExpression
+ ;
// CLOSURE
closure
@@ -738,9 +738,10 @@ postfixExpression
;
expression
- // qualified names, array expressions, method invocation, post inc/dec, type casting (level 1)
- // The cast expression must be put before pathExpression to resovle the ambiguities between type casting and call on parentheses expression, e.g. (int)(1 / 2)
+ // must come before postfixExpression to resovle the ambiguities between casting and call on parentheses expression, e.g. (int)(1 / 2)
: castParExpression castOperandExpression #castExprAlt
+
+ // qualified names, array expressions, method invocation, post inc/dec
| postfixExpression #postfixExprAlt
// ~(BNOT)/!(LNOT) (level 1)
@@ -833,16 +834,16 @@ expression
enhancedStatementExpression #assignmentExprAlt
;
-
castOperandExpression
options { baseContext = expression; }
: castParExpression castOperandExpression #castExprAlt
+
| postfixExpression #postfixExprAlt
- // ~(BNOT)/!(LNOT) (level 1)
+ // ~(BNOT)/!(LNOT)
| (BITNOT | NOT) nls castOperandExpression #unaryNotExprAlt
- // ++(prefix)/--(prefix)/+(unary)/-(unary) (level 3)
+ // ++(prefix)/--(prefix)/+(unary)/-(unary)
| op=(INC | DEC | ADD | SUB) castOperandExpression #unaryAddExprAlt
;
@@ -896,7 +897,7 @@ pathExpression returns [int t]
primary
|
// if 'static' followed by DOT, we can treat them as identifiers, e.g. static.unused = { -> }
- { DOT == _input.LT(2).getType() }?
+ { _input.LT(2).getType() == DOT }?
STATIC
) (pathElement { $t = $pathElement.t; })*
;
@@ -1186,7 +1187,7 @@ identifier
| CapitalizedIdentifier
| VAR
| IN
-// | DEF
+// | DEF
| TRAIT
| AS
;
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
index dff4de2..e4051c1 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
@@ -34,6 +34,7 @@ import org.antlr.v4.runtime.misc.Interval;
import org.antlr.v4.runtime.misc.ParseCancellationException;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
+import org.apache.groovy.parser.antlr4.GroovyParser.*;
import org.apache.groovy.parser.antlr4.internal.DescriptiveErrorStrategy;
import org.apache.groovy.parser.antlr4.internal.atnmanager.AtnManager;
import org.apache.groovy.parser.antlr4.util.StringUtils;
@@ -143,193 +144,25 @@ import java.util.stream.Collectors;
import java.util.stream.Stream;
import static groovy.lang.Tuple.tuple;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ADD;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.AS;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.AdditiveExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.AndExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.AnnotatedQualifiedClassNameContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.AnnotationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.AnnotationNameContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.AnnotationsOptContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.AnonymousInnerClassDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ArgumentsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ArrayInitializerContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.AssertStatementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.AssignmentExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.BlockContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.BlockStatementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.BlockStatementsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.BlockStatementsOptContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.BooleanLiteralAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.BreakStatementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.BuiltInTypeContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CASE;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CastExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CastParExpressionContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CatchClauseContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CatchTypeContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClassBodyContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClassBodyDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClassDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClassNameContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClassOrInterfaceModifierContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClassOrInterfaceModifiersContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClassOrInterfaceModifiersOptContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClassOrInterfaceTypeContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClassicalForControlContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClosureContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ClosureOrLambdaExpressionContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CommandArgumentContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CommandExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CommandExpressionContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CompilationUnitContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ConditionalExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ConditionalStatementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ContinueStatementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CreatedNameContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.CreatorContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.DEC;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.DEF;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.DEFAULT;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.DimContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.DoWhileStmtAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.DynamicMemberNameContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ElementValueArrayInitializerContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ElementValueContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ElementValuePairContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ElementValuePairsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ElementValuesContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.EmptyDimsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.EmptyDimsOptContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.EnhancedArgumentListElementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.EnhancedArgumentListInParContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.EnhancedForControlContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.EnhancedStatementExpressionContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.EnumConstantContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.EnumConstantsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.EqualityExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ExclusiveOrExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ExpressionContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ExpressionInParContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ExpressionListContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ExpressionListElementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.FieldDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.FinallyBlockContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.FloatingPointLiteralAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ForControlContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ForInitContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ForStmtAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ForUpdateContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.FormalParameterContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.FormalParameterListContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.FormalParametersContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.GE;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.GT;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.GroovyParserRuleContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.GstringContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.GstringPathContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.GstringValueContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.IN;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.INC;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.INSTANCEOF;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.IdentifierContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.IdentifierPrmrAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.IfElseStatementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ImportDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.InclusiveOrExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.IndexPropertyArgsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.IntegerLiteralAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.KeywordsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.LE;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.LT;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.LabeledStmtAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.LambdaBodyContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ListContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.LocalVariableDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.LogicalAndExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.LogicalOrExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.LoopStmtAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.MapContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.MapEntryContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.MapEntryLabelContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.MapEntryListContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.MemberDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.MethodBodyContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.MethodDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.MethodNameContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ModifierContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ModifiersContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ModifiersOptContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.MultipleAssignmentExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.MultiplicativeExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.NOT_IN;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.NOT_INSTANCEOF;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.NamePartContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.NamedPropertyArgsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.NewPrmrAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.NonWildcardTypeArgumentsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.NullLiteralAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.PRIVATE;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.PackageDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ParExpressionContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.PathElementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.PathExpressionContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.PostfixExpressionContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.PowerExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.PrimitiveTypeContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.QualifiedClassNameContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.QualifiedClassNameListContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.QualifiedNameContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.QualifiedStandardClassNameContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.RegexExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.RelationalExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ResourceContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ResourceListContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ResourcesContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ReturnStmtAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ReturnTypeContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.STATIC;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.SUB;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ScriptStatementsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ShiftExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.StandardLambdaExpressionContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.StandardLambdaParametersContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.StatementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.StringLiteralContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.SuperPrmrAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.SwitchBlockStatementGroupContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.SwitchLabelContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.SwitchStatementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.SynchronizedStmtAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ThisFormalParameterContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ThisPrmrAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.ThrowStmtAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TryCatchStatementContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeArgumentContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeArgumentsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeArgumentsOrDiamondContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeBoundContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeListContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeNamePairContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeNamePairsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeParameterContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.TypeParametersContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.UnaryAddExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.UnaryNotExprAltContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VAR;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VariableDeclarationContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VariableDeclaratorContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VariableDeclaratorIdContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VariableDeclaratorsContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VariableInitializerContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VariableInitializersContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VariableModifierContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VariableModifiersContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VariableModifiersOptContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.VariableNamesContext;
-import static org.apache.groovy.parser.antlr4.GroovyLangParser.WhileStmtAltContext;
+import static org.apache.groovy.parser.antlr4.GroovyParser.ADD;
+import static org.apache.groovy.parser.antlr4.GroovyParser.AS;
+import static org.apache.groovy.parser.antlr4.GroovyParser.CASE;
+import static org.apache.groovy.parser.antlr4.GroovyParser.DEC;
+import static org.apache.groovy.parser.antlr4.GroovyParser.DEF;
+import static org.apache.groovy.parser.antlr4.GroovyParser.DEFAULT;
+import static org.apache.groovy.parser.antlr4.GroovyParser.GE;
+import static org.apache.groovy.parser.antlr4.GroovyParser.GT;
+import static org.apache.groovy.parser.antlr4.GroovyParser.IN;
+import static org.apache.groovy.parser.antlr4.GroovyParser.INC;
+import static org.apache.groovy.parser.antlr4.GroovyParser.INSTANCEOF;
+import static org.apache.groovy.parser.antlr4.GroovyParser.LE;
+import static org.apache.groovy.parser.antlr4.GroovyParser.LT;
+import static org.apache.groovy.parser.antlr4.GroovyParser.NOT_IN;
+import static org.apache.groovy.parser.antlr4.GroovyParser.NOT_INSTANCEOF;
+import static org.apache.groovy.parser.antlr4.GroovyParser.PRIVATE;
+import static org.apache.groovy.parser.antlr4.GroovyParser.STATIC;
+import static org.apache.groovy.parser.antlr4.GroovyParser.SUB;
+import static org.apache.groovy.parser.antlr4.GroovyParser.VAR;
import static org.apache.groovy.parser.antlr4.util.PositionConfigureUtils.configureAST;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveType;
import static org.codehaus.groovy.runtime.DefaultGroovyMethods.asBoolean;
@@ -353,7 +186,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
this.tryWithResourcesASTTransformation = new TryWithResourcesASTTransformation(this);
}
- private CharStream createCharStream(SourceUnit sourceUnit) {
+ private CharStream createCharStream(final SourceUnit sourceUnit) {
CharStream charStream;
try {
@@ -392,7 +225,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return result;
}
- private GroovyParserRuleContext buildCST(PredictionMode predictionMode) {
+ private GroovyParserRuleContext buildCST(final PredictionMode predictionMode) {
parser.getInterpreter().setPredictionMode(predictionMode);
if (PredictionMode.SLL.equals(predictionMode)) {
@@ -405,7 +238,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return parser.compilationUnit();
}
- private CompilationFailedException convertException(Throwable t) {
+ private CompilationFailedException convertException(final Throwable t) {
CompilationFailedException cfe;
if (t instanceof CompilationFailedException) {
@@ -428,7 +261,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ModuleNode visitCompilationUnit(CompilationUnitContext ctx) {
+ public ModuleNode visitCompilationUnit(final CompilationUnitContext ctx) {
this.visit(ctx.packageDeclaration());
for (ASTNode node : this.visitScriptStatements(ctx.scriptStatements())) {
@@ -467,7 +300,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<ASTNode> visitScriptStatements(ScriptStatementsContext ctx) {
+ public List<ASTNode> visitScriptStatements(final ScriptStatementsContext ctx) {
if (!asBoolean(ctx)) {
return Collections.emptyList();
}
@@ -478,7 +311,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public PackageNode visitPackageDeclaration(PackageDeclarationContext ctx) {
+ public PackageNode visitPackageDeclaration(final PackageDeclarationContext ctx) {
String packageName = this.visitQualifiedName(ctx.qualifiedName());
moduleNode.setPackageName(packageName + DOT_STR);
@@ -490,7 +323,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ImportNode visitImportDeclaration(ImportDeclarationContext ctx) {
+ public ImportNode visitImportDeclaration(final ImportDeclarationContext ctx) {
ImportNode importNode;
boolean hasStatic = asBoolean(ctx.STATIC());
@@ -509,7 +342,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
importNode = last(moduleNode.getStaticStarImports().values());
} else { // e.g. import static java.lang.Math.pow
- List<GroovyParserRuleContext> identifierList = new LinkedList<>(ctx.qualifiedName().qualifiedNameElement());
+ List<? extends QualifiedNameElementContext> identifierList = ctx.qualifiedName().qualifiedNameElement();
int identifierListSize = identifierList.size();
String name = identifierList.get(identifierListSize - 1).getText();
ClassNode classNode =
@@ -552,11 +385,11 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return configureAST(importNode, ctx);
}
- // statement { --------------------------------------------------------------------
+ // statement { -------------------------------------------------------------
@Override
- public AssertStatement visitAssertStatement(AssertStatementContext ctx) {
- visitingAssertStatementCnt++;
+ public AssertStatement visitAssertStatement(final AssertStatementContext ctx) {
+ visitingAssertStatementCount += 1;
Expression conditionExpression = (Expression) this.visit(ctx.ce);
@@ -581,13 +414,13 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
(Expression) this.visit(ctx.me)),
ctx);
- visitingAssertStatementCnt--;
+ visitingAssertStatementCount -= 1;
return result;
}
@Override
- public Statement visitConditionalStatement(ConditionalStatementContext ctx) {
+ public Statement visitConditionalStatement(final ConditionalStatementContext ctx) {
if (asBoolean(ctx.ifElseStatement())) {
return configureAST(this.visitIfElseStatement(ctx.ifElseStatement()), ctx);
} else if (asBoolean(ctx.switchStatement())) {
@@ -598,7 +431,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public IfStatement visitIfElseStatement(IfElseStatementContext ctx) {
+ public IfStatement visitIfElseStatement(final IfElseStatementContext ctx) {
Expression conditionExpression = this.visitExpressionInPar(ctx.expressionInPar());
BooleanExpression booleanExpression =
configureAST(
@@ -617,16 +450,16 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Statement visitLoopStmtAlt(LoopStmtAltContext ctx) {
- visitingLoopStatementCnt++;
+ public Statement visitLoopStmtAlt(final LoopStmtAltContext ctx) {
+ visitingLoopStatementCount += 1;
Statement result = configureAST((Statement) this.visit(ctx.loopStatement()), ctx);
- visitingLoopStatementCnt--;
+ visitingLoopStatementCount -= 1;
return result;
}
@Override
- public ForStatement visitForStmtAlt(ForStmtAltContext ctx) {
+ public ForStatement visitForStmtAlt(final ForStmtAltContext ctx) {
Tuple2<Parameter, Expression> controlTuple = this.visitForControl(ctx.forControl());
Statement loopBlock = this.unpackStatement((Statement) this.visit(ctx.statement()));
@@ -637,7 +470,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Tuple2<Parameter, Expression> visitForControl(ForControlContext ctx) {
+ public Tuple2<Parameter, Expression> visitForControl(final ForControlContext ctx) {
if (asBoolean(ctx.enhancedForControl())) { // e.g. for(int i in 0..<10) {}
return this.visitEnhancedForControl(ctx.enhancedForControl());
}
@@ -649,20 +482,20 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
throw createParsingFailedException("Unsupported for control: " + ctx.getText(), ctx);
}
- @Override
- public Expression visitForInit(ForInitContext ctx) {
+ @Override @SuppressWarnings("unchecked")
+ public Expression visitForInit(final ForInitContext ctx) {
if (!asBoolean(ctx)) {
return EmptyExpression.INSTANCE;
}
if (asBoolean(ctx.localVariableDeclaration())) {
DeclarationListStatement declarationListStatement = this.visitLocalVariableDeclaration(ctx.localVariableDeclaration());
- List<? extends Expression> declarationExpressionList = declarationListStatement.getDeclarationExpressions();
+ List<DeclarationExpression> declarationExpressions = declarationListStatement.getDeclarationExpressions();
- if (declarationExpressionList.size() == 1) {
- return configureAST((Expression) declarationExpressionList.get(0), ctx);
+ if (declarationExpressions.size() == 1) {
+ return configureAST((Expression) declarationExpressions.get(0), ctx);
} else {
- return configureAST(new ClosureListExpression((List<Expression>) declarationExpressionList), ctx);
+ return configureAST(new ClosureListExpression(List.class.cast(declarationExpressions)), ctx);
}
}
@@ -674,7 +507,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitForUpdate(ForUpdateContext ctx) {
+ public Expression visitForUpdate(final ForUpdateContext ctx) {
if (!asBoolean(ctx)) {
return EmptyExpression.INSTANCE;
}
@@ -682,7 +515,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return this.translateExpressionList(ctx.expressionList());
}
- private Expression translateExpressionList(ExpressionListContext ctx) {
+ private Expression translateExpressionList(final ExpressionListContext ctx) {
List<Expression> expressionList = this.visitExpressionList(ctx);
if (expressionList.size() == 1) {
@@ -693,7 +526,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Tuple2<Parameter, Expression> visitEnhancedForControl(EnhancedForControlContext ctx) {
+ public Tuple2<Parameter, Expression> visitEnhancedForControl(final EnhancedForControlContext ctx) {
Parameter parameter = configureAST(
new Parameter(this.visitType(ctx.type()), this.visitVariableDeclaratorId(ctx.variableDeclaratorId()).getName()),
ctx.variableDeclaratorId());
@@ -705,7 +538,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Tuple2<Parameter, Expression> visitClassicalForControl(ClassicalForControlContext ctx) {
+ public Tuple2<Parameter, Expression> visitClassicalForControl(final ClassicalForControlContext ctx) {
ClosureListExpression closureListExpression = new ClosureListExpression();
closureListExpression.addExpression(this.visitForInit(ctx.forInit()));
@@ -716,7 +549,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public WhileStatement visitWhileStmtAlt(WhileStmtAltContext ctx) {
+ public WhileStatement visitWhileStmtAlt(final WhileStmtAltContext ctx) {
Tuple2<BooleanExpression, Statement> conditionAndBlock = createLoopConditionExpressionAndBlock(ctx.expressionInPar(), ctx.statement());
return configureAST(
@@ -725,7 +558,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public DoWhileStatement visitDoWhileStmtAlt(DoWhileStmtAltContext ctx) {
+ public DoWhileStatement visitDoWhileStmtAlt(final DoWhileStmtAltContext ctx) {
Tuple2<BooleanExpression, Statement> conditionAndBlock = createLoopConditionExpressionAndBlock(ctx.expressionInPar(), ctx.statement());
return configureAST(
@@ -733,7 +566,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
ctx);
}
- private Tuple2<BooleanExpression, Statement> createLoopConditionExpressionAndBlock(ExpressionInParContext eipc, StatementContext sc) {
+ private Tuple2<BooleanExpression, Statement> createLoopConditionExpressionAndBlock(final ExpressionInParContext eipc, final StatementContext sc) {
Expression conditionExpression = this.visitExpressionInPar(eipc);
BooleanExpression booleanExpression =
@@ -748,7 +581,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Statement visitTryCatchStatement(TryCatchStatementContext ctx) {
+ public Statement visitTryCatchStatement(final TryCatchStatementContext ctx) {
boolean resourcesExists = asBoolean(ctx.resources());
boolean catchExists = asBoolean(ctx.catchClause());
boolean finallyExists = asBoolean(ctx.finallyBlock());
@@ -779,17 +612,17 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<ExpressionStatement> visitResources(ResourcesContext ctx) {
+ public List<ExpressionStatement> visitResources(final ResourcesContext ctx) {
return this.visitResourceList(ctx.resourceList());
}
@Override
- public List<ExpressionStatement> visitResourceList(ResourceListContext ctx) {
+ public List<ExpressionStatement> visitResourceList(final ResourceListContext ctx) {
return ctx.resource().stream().map(this::visitResource).collect(Collectors.toList());
}
@Override
- public ExpressionStatement visitResource(ResourceContext ctx) {
+ public ExpressionStatement visitResource(final ResourceContext ctx) {
if (asBoolean(ctx.localVariableDeclaration())) {
List<ExpressionStatement> declarationStatements = this.visitLocalVariableDeclaration(ctx.localVariableDeclaration()).getDeclarationStatements();
@@ -842,7 +675,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
* @return a list of CatchStatement instances
*/
@Override
- public List<CatchStatement> visitCatchClause(CatchClauseContext ctx) {
+ public List<CatchStatement> visitCatchClause(final CatchClauseContext ctx) {
// FIXME Groovy will ignore variableModifier of parameter in the catch clause
// In order to make the new parser behave same with the old one, we do not process variableModifier*
@@ -860,7 +693,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<ClassNode> visitCatchType(CatchTypeContext ctx) {
+ public List<ClassNode> visitCatchType(final CatchTypeContext ctx) {
if (!asBoolean(ctx)) {
return Collections.singletonList(ClassHelper.OBJECT_TYPE);
}
@@ -871,7 +704,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Statement visitFinallyBlock(FinallyBlockContext ctx) {
+ public Statement visitFinallyBlock(final FinallyBlockContext ctx) {
if (!asBoolean(ctx)) {
return EmptyStatement.INSTANCE;
}
@@ -882,8 +715,8 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public SwitchStatement visitSwitchStatement(SwitchStatementContext ctx) {
- visitingSwitchStatementCnt++;
+ public SwitchStatement visitSwitchStatement(final SwitchStatementContext ctx) {
+ visitingSwitchStatementCount += 1;
List<Statement> statementList =
ctx.switchBlockStatementGroup().stream()
@@ -921,14 +754,13 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
),
ctx);
- visitingSwitchStatementCnt--;
+ visitingSwitchStatementCount -= 1;
return result;
}
- @Override
- @SuppressWarnings("unchecked")
- public List<Statement> visitSwitchBlockStatementGroup(SwitchBlockStatementGroupContext ctx) {
+ @Override @SuppressWarnings("unchecked")
+ public List<Statement> visitSwitchBlockStatementGroup(final SwitchBlockStatementGroupContext ctx) {
int labelCnt = ctx.switchLabel().size();
List<Token> firstLabelHolder = new ArrayList<>(1);
@@ -979,7 +811,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Tuple2<Token, Expression> visitSwitchLabel(SwitchLabelContext ctx) {
+ public Tuple2<Token, Expression> visitSwitchLabel(final SwitchLabelContext ctx) {
if (asBoolean(ctx.CASE())) {
return tuple(ctx.CASE().getSymbol(), (Expression) this.visit(ctx.expression()));
} else if (asBoolean(ctx.DEFAULT())) {
@@ -990,14 +822,14 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public SynchronizedStatement visitSynchronizedStmtAlt(SynchronizedStmtAltContext ctx) {
+ public SynchronizedStatement visitSynchronizedStmtAlt(final SynchronizedStmtAltContext ctx) {
return configureAST(
new SynchronizedStatement(this.visitExpressionInPar(ctx.expressionInPar()), this.visitBlock(ctx.block())),
ctx);
}
@Override
- public ReturnStatement visitReturnStmtAlt(ReturnStmtAltContext ctx) {
+ public ReturnStatement visitReturnStmtAlt(final ReturnStmtAltContext ctx) {
return configureAST(new ReturnStatement(asBoolean(ctx.expression())
? (Expression) this.visit(ctx.expression())
: ConstantExpression.EMPTY_EXPRESSION),
@@ -1005,24 +837,24 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ThrowStatement visitThrowStmtAlt(ThrowStmtAltContext ctx) {
+ public ThrowStatement visitThrowStmtAlt(final ThrowStmtAltContext ctx) {
return configureAST(
new ThrowStatement((Expression) this.visit(ctx.expression())),
ctx);
}
@Override
- public Statement visitLabeledStmtAlt(LabeledStmtAltContext ctx) {
+ public Statement visitLabeledStmtAlt(final LabeledStmtAltContext ctx) {
Statement statement = (Statement) this.visit(ctx.statement());
statement.addStatementLabel(this.visitIdentifier(ctx.identifier()));
- return statement; // this.configureAST(statement, ctx);
+ return statement;
}
@Override
- public BreakStatement visitBreakStatement(BreakStatementContext ctx) {
- if (0 == visitingLoopStatementCnt && 0 == visitingSwitchStatementCnt) {
+ public BreakStatement visitBreakStatement(final BreakStatementContext ctx) {
+ if (0 == visitingLoopStatementCount && 0 == visitingSwitchStatementCount) {
throw createParsingFailedException("break statement is only allowed inside loops or switches", ctx);
}
@@ -1034,8 +866,8 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ContinueStatement visitContinueStatement(ContinueStatementContext ctx) {
- if (0 == visitingLoopStatementCnt) {
+ public ContinueStatement visitContinueStatement(final ContinueStatementContext ctx) {
+ if (visitingLoopStatementCount == 0) {
throw createParsingFailedException("continue statement is only allowed inside loops", ctx);
}
@@ -1047,10 +879,10 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
- // } statement --------------------------------------------------------------------
+ // } statement -------------------------------------------------------------
@Override
- public ClassNode visitTypeDeclaration(TypeDeclarationContext ctx) {
+ public ClassNode visitTypeDeclaration(final TypeDeclarationContext ctx) {
if (asBoolean(ctx.classDeclaration())) { // e.g. class A {}
ctx.classDeclaration().putNodeMetaData(TYPE_DECLARATION_MODIFIERS, this.visitClassOrInterfaceModifiersOpt(ctx.classOrInterfaceModifiersOpt()));
return configureAST(this.visitClassDeclaration(ctx.classDeclaration()), ctx);
@@ -1059,7 +891,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
throw createParsingFailedException("Unsupported type declaration: " + ctx.getText(), ctx);
}
- private void initUsingGenerics(ClassNode classNode) {
+ private void initUsingGenerics(final ClassNode classNode) {
if (classNode.isUsingGenerics()) {
return;
}
@@ -1079,7 +911,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClassNode visitClassDeclaration(ClassDeclarationContext ctx) {
+ public ClassNode visitClassDeclaration(final ClassDeclarationContext ctx) {
String packageName = Optional.ofNullable(moduleNode.getPackageName()).orElse("");
String className = this.visitIdentifier(ctx.identifier());
if (VAR_STR.equals(className)) {
@@ -1226,7 +1058,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@SuppressWarnings("unchecked")
- private boolean containsDefaultMethods(ClassDeclarationContext ctx) {
+ private boolean containsDefaultMethods(final ClassDeclarationContext ctx) {
List<MethodDeclarationContext> methodDeclarationContextList =
(List<MethodDeclarationContext>) ctx.classBody().classBodyDeclaration().stream()
.map(ClassBodyDeclarationContext::memberDeclaration)
@@ -1234,11 +1066,9 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
.map(e -> (Object) e.methodDeclaration())
.filter(Objects::nonNull).reduce(new LinkedList<MethodDeclarationContext>(), (r, e) -> {
MethodDeclarationContext methodDeclarationContext = (MethodDeclarationContext) e;
-
if (createModifierManager(methodDeclarationContext).containsAny(DEFAULT)) {
((List) r).add(methodDeclarationContext);
}
-
return r;
});
@@ -1246,7 +1076,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Void visitClassBody(ClassBodyContext ctx) {
+ public Void visitClassBody(final ClassBodyContext ctx) {
ClassNode classNode = ctx.getNodeMetaData(CLASS_DECLARATION_CLASS_NODE);
Objects.requireNonNull(classNode, "classNode should not be null");
@@ -1264,7 +1094,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<FieldNode> visitEnumConstants(EnumConstantsContext ctx) {
+ public List<FieldNode> visitEnumConstants(final EnumConstantsContext ctx) {
ClassNode classNode = ctx.getNodeMetaData(CLASS_DECLARATION_CLASS_NODE);
Objects.requireNonNull(classNode, "classNode should not be null");
@@ -1277,7 +1107,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public FieldNode visitEnumConstant(EnumConstantContext ctx) {
+ public FieldNode visitEnumConstant(final EnumConstantContext ctx) {
ClassNode classNode = ctx.getNodeMetaData(CLASS_DECLARATION_CLASS_NODE);
Objects.requireNonNull(classNode, "classNode should not be null");
@@ -1300,7 +1130,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return configureAST(enumConstant, ctx);
}
- private Expression createEnumConstantInitExpression(ArgumentsContext ctx, InnerClassNode anonymousInnerClassNode) {
+ private Expression createEnumConstantInitExpression(final ArgumentsContext ctx, final InnerClassNode anonymousInnerClassNode) {
if (!asBoolean(ctx) && !asBoolean(anonymousInnerClassNode)) {
return null;
}
@@ -1378,7 +1208,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Void visitClassBodyDeclaration(ClassBodyDeclarationContext ctx) {
+ public Void visitClassBodyDeclaration(final ClassBodyDeclarationContext ctx) {
ClassNode classNode = ctx.getNodeMetaData(CLASS_DECLARATION_CLASS_NODE);
Objects.requireNonNull(classNode, "classNode should not be null");
@@ -1402,7 +1232,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Void visitMemberDeclaration(MemberDeclarationContext ctx) {
+ public Void visitMemberDeclaration(final MemberDeclarationContext ctx) {
ClassNode classNode = ctx.getNodeMetaData(CLASS_DECLARATION_CLASS_NODE);
Objects.requireNonNull(classNode, "classNode should not be null");
@@ -1422,7 +1252,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public GenericsType[] visitTypeParameters(TypeParametersContext ctx) {
+ public GenericsType[] visitTypeParameters(final TypeParametersContext ctx) {
if (!asBoolean(ctx)) {
return null;
}
@@ -1433,7 +1263,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public GenericsType visitTypeParameter(TypeParameterContext ctx) {
+ public GenericsType visitTypeParameter(final TypeParameterContext ctx) {
return configureAST(
new GenericsType(
configureAST(ClassHelper.make(this.visitClassName(ctx.className())), ctx),
@@ -1444,7 +1274,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClassNode[] visitTypeBound(TypeBoundContext ctx) {
+ public ClassNode[] visitTypeBound(final TypeBoundContext ctx) {
if (!asBoolean(ctx)) {
return null;
}
@@ -1455,7 +1285,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Void visitFieldDeclaration(FieldDeclarationContext ctx) {
+ public Void visitFieldDeclaration(final FieldDeclarationContext ctx) {
ClassNode classNode = ctx.getNodeMetaData(CLASS_DECLARATION_CLASS_NODE);
Objects.requireNonNull(classNode, "classNode should not be null");
@@ -1465,7 +1295,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return null;
}
- private ConstructorCallExpression checkThisAndSuperConstructorCall(Statement statement) {
+ private ConstructorCallExpression checkThisAndSuperConstructorCall(final Statement statement) {
if (!(statement instanceof BlockStatement)) { // method code must be a BlockStatement
return null;
}
@@ -1473,7 +1303,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
BlockStatement blockStatement = (BlockStatement) statement;
List<Statement> statementList = blockStatement.getStatements();
- for (int i = 0, n = statementList.size(); i < n; i++) {
+ for (int i = 0, n = statementList.size(); i < n; i += 1) {
Statement s = statementList.get(i);
if (s instanceof ExpressionStatement) {
Expression expression = ((ExpressionStatement) s).getExpression();
@@ -1486,7 +1316,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return null;
}
- private ModifierManager createModifierManager(MethodDeclarationContext ctx) {
+ private ModifierManager createModifierManager(final MethodDeclarationContext ctx) {
List<ModifierNode> modifierNodeList = Collections.emptyList();
if (asBoolean(ctx.modifiersOpt())) {
@@ -1496,7 +1326,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return new ModifierManager(this, modifierNodeList);
}
- private void validateParametersOfMethodDeclaration(Parameter[] parameters, ClassNode classNode) {
+ private void validateParametersOfMethodDeclaration(final Parameter[] parameters, final ClassNode classNode) {
if (!classNode.isInterface()) {
return;
}
@@ -1509,7 +1339,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public MethodNode visitMethodDeclaration(MethodDeclarationContext ctx) {
+ public MethodNode visitMethodDeclaration(final MethodDeclarationContext ctx) {
ModifierManager modifierManager = createModifierManager(ctx);
if (modifierManager.containsAny(VAR)) {
@@ -1562,7 +1392,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return methodNode;
}
- private void validateMethodDeclaration(MethodDeclarationContext ctx, MethodNode methodNode, ModifierManager modifierManager, ClassNode classNode) {
+ private void validateMethodDeclaration(final MethodDeclarationContext ctx, final MethodNode methodNode, final ModifierManager modifierManager, final ClassNode classNode) {
if (1 == ctx.t || 2 == ctx.t || 3 == ctx.t) { // 1: normal method declaration; 2: abstract method declaration; 3: normal method declaration OR abstract method declaration
if (!(asBoolean(ctx.modifiersOpt().modifiers()) || asBoolean(ctx.returnType()))) {
throw createParsingFailedException("Modifiers or return type is required", ctx);
@@ -1620,22 +1450,20 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
}
- private MethodNode createScriptMethodNode(ModifierManager modifierManager, String methodName, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code) {
- MethodNode methodNode;
- methodNode =
- new MethodNode(
- methodName,
- modifierManager.containsAny(PRIVATE) ? Opcodes.ACC_PRIVATE : Opcodes.ACC_PUBLIC,
- returnType,
- parameters,
- exceptions,
- code);
-
+ private MethodNode createScriptMethodNode(final ModifierManager modifierManager, final String methodName, final ClassNode returnType, final Parameter[] parameters, final ClassNode[] exceptions, final Statement code) {
+ MethodNode methodNode = new MethodNode(
+ methodName,
+ modifierManager.containsAny(PRIVATE) ? Opcodes.ACC_PRIVATE : Opcodes.ACC_PUBLIC,
+ returnType,
+ parameters,
+ exceptions,
+ code
+ );
modifierManager.processMethodNode(methodNode);
return methodNode;
}
- private MethodNode createConstructorOrMethodNodeForClass(MethodDeclarationContext ctx, ModifierManager modifierManager, String methodName, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code, ClassNode classNode) {
+ private MethodNode createConstructorOrMethodNodeForClass(final MethodDeclarationContext ctx, final ModifierManager modifierManager, final String methodName, final ClassNode returnType, final Parameter[] parameters, final ClassNode[] exceptions, final Statement code, final ClassNode classNode) {
MethodNode methodNode;
String className = classNode.getNodeMetaData(CLASS_NAME);
int modifiers = modifierManager.getClassMemberModifiersOpValue();
@@ -1643,16 +1471,12 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
boolean hasReturnType = asBoolean(ctx.returnType());
boolean hasMethodBody = asBoolean(ctx.methodBody());
- if (!hasReturnType
- && hasMethodBody
- && methodName.equals(className)) { // constructor declaration
-
+ if (!hasReturnType && hasMethodBody && methodName.equals(className)) {
methodNode = createConstructorNodeForClass(methodName, parameters, exceptions, code, classNode, modifiers);
- } else { // class member method declaration
+ } else {
if (!hasReturnType && hasMethodBody && (0 == modifierManager.getModifierCount())) {
throw createParsingFailedException("Invalid method declaration: " + methodName, ctx);
}
-
methodNode = createMethodNodeForClass(ctx, modifierManager, methodName, returnType, parameters, exceptions, code, classNode, modifiers);
}
@@ -1660,7 +1484,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return methodNode;
}
- private MethodNode createMethodNodeForClass(MethodDeclarationContext ctx, ModifierManager modifierManager, String methodName, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code, ClassNode classNode, int modifiers) {
+ private MethodNode createMethodNodeForClass(final MethodDeclarationContext ctx, final ModifierManager modifierManager, final String methodName, final ClassNode returnType, final Parameter[] parameters, final ClassNode[] exceptions, Statement code, final ClassNode classNode, int modifiers) {
if (asBoolean(ctx.elementValue())) { // the code of annotation method
code = configureAST(
new ExpressionStatement(
@@ -1677,7 +1501,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return methodNode;
}
- private ConstructorNode createConstructorNodeForClass(String methodName, Parameter[] parameters, ClassNode[] exceptions, Statement code, ClassNode classNode, int modifiers) {
+ private ConstructorNode createConstructorNodeForClass(final String methodName, final Parameter[] parameters, final ClassNode[] exceptions, final Statement code, final ClassNode classNode, final int modifiers) {
ConstructorCallExpression thisOrSuperConstructorCallExpression = this.checkThisAndSuperConstructorCall(code);
if (asBoolean(thisOrSuperConstructorCallExpression)) {
throw createParsingFailedException(thisOrSuperConstructorCallExpression.getText() + " should be the first statement in the constructor[" + methodName + "]", thisOrSuperConstructorCallExpression);
@@ -1691,7 +1515,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public String visitMethodName(MethodNameContext ctx) {
+ public String visitMethodName(final MethodNameContext ctx) {
if (asBoolean(ctx.identifier())) {
return this.visitIdentifier(ctx.identifier());
}
@@ -1704,7 +1528,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClassNode visitReturnType(ReturnTypeContext ctx) {
+ public ClassNode visitReturnType(final ReturnTypeContext ctx) {
if (!asBoolean(ctx)) {
return ClassHelper.OBJECT_TYPE;
}
@@ -1725,7 +1549,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Statement visitMethodBody(MethodBodyContext ctx) {
+ public Statement visitMethodBody(final MethodBodyContext ctx) {
if (!asBoolean(ctx)) {
return null;
}
@@ -1734,11 +1558,11 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public DeclarationListStatement visitLocalVariableDeclaration(LocalVariableDeclarationContext ctx) {
+ public DeclarationListStatement visitLocalVariableDeclaration(final LocalVariableDeclarationContext ctx) {
return configureAST(this.visitVariableDeclaration(ctx.variableDeclaration()), ctx);
}
- private DeclarationListStatement createMultiAssignmentDeclarationListStatement(VariableDeclarationContext ctx, ModifierManager modifierManager) {
+ private DeclarationListStatement createMultiAssignmentDeclarationListStatement(final VariableDeclarationContext ctx, final ModifierManager modifierManager) {
/*
if (!modifierManager.contains(DEF)) {
throw createParsingFailedException("keyword def is required to declare tuple, e.g. def (int a, int b) = [1, 2]", ctx);
@@ -1767,7 +1591,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public DeclarationListStatement visitVariableDeclaration(VariableDeclarationContext ctx) {
+ public DeclarationListStatement visitVariableDeclaration(final VariableDeclarationContext ctx) {
ModifierManager modifierManager =
new ModifierManager(
this,
@@ -1812,7 +1636,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return configureAST(new DeclarationListStatement(declarationExpressionList), ctx);
}
- private DeclarationListStatement createFieldDeclarationListStatement(VariableDeclarationContext ctx, ModifierManager modifierManager, ClassNode variableType, List<DeclarationExpression> declarationExpressionList, ClassNode classNode) {
+ private DeclarationListStatement createFieldDeclarationListStatement(final VariableDeclarationContext ctx, final ModifierManager modifierManager, final ClassNode variableType, final List<DeclarationExpression> declarationExpressionList, final ClassNode classNode) {
for (int i = 0, n = declarationExpressionList.size(); i < n; i += 1) {
DeclarationExpression declarationExpression = declarationExpressionList.get(i);
VariableExpression variableExpression = (VariableExpression) declarationExpression.getLeftExpression();
@@ -1842,7 +1666,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return null;
}
- private void declareProperty(VariableDeclarationContext ctx, ModifierManager modifierManager, ClassNode variableType, ClassNode classNode, int i, VariableExpression variableExpression, String fieldName, int modifiers, Expression initialValue) {
+ private void declareProperty(final VariableDeclarationContext ctx, final ModifierManager modifierManager, final ClassNode variableType, final ClassNode classNode, final int i, final VariableExpression variableExpression, final String fieldName, final int modifiers, final Expression initialValue) {
if (classNode.hasProperty(fieldName)) {
throw createParsingFailedException("The property '" + fieldName + "' is declared multiple times", ctx);
}
@@ -1875,7 +1699,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
groovydocManager.handle(fieldNode, ctx);
groovydocManager.handle(propertyNode, ctx);
- if (0 == i) {
+ if (i == 0) {
configureAST(fieldNode, ctx, initialValue);
configureAST(propertyNode, ctx, initialValue);
} else {
@@ -1884,7 +1708,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
}
- private void declareField(VariableDeclarationContext ctx, ModifierManager modifierManager, ClassNode variableType, ClassNode classNode, int i, VariableExpression variableExpression, String fieldName, int modifiers, Expression initialValue) {
+ private void declareField(final VariableDeclarationContext ctx, final ModifierManager modifierManager, final ClassNode variableType, final ClassNode classNode, final int i, final VariableExpression variableExpression, final String fieldName, final int modifiers, final Expression initialValue) {
FieldNode existingFieldNode = classNode.getDeclaredField(fieldName);
if (null != existingFieldNode && !existingFieldNode.isSynthetic()) {
throw createParsingFailedException("The field '" + fieldName + "' is declared multiple times", ctx);
@@ -1910,24 +1734,24 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
modifierManager.attachAnnotations(fieldNode);
groovydocManager.handle(fieldNode, ctx);
- if (0 == i) {
+ if (i == 0) {
configureAST(fieldNode, ctx, initialValue);
} else {
configureAST(fieldNode, variableExpression, initialValue);
}
}
- private boolean isFieldDeclaration(ModifierManager modifierManager, ClassNode classNode) {
+ private boolean isFieldDeclaration(final ModifierManager modifierManager, final ClassNode classNode) {
return classNode.isInterface() || modifierManager.containsVisibilityModifier();
}
@Override
- public List<Expression> visitTypeNamePairs(TypeNamePairsContext ctx) {
+ public List<Expression> visitTypeNamePairs(final TypeNamePairsContext ctx) {
return ctx.typeNamePair().stream().map(this::visitTypeNamePair).collect(Collectors.toList());
}
@Override
- public VariableExpression visitTypeNamePair(TypeNamePairContext ctx) {
+ public VariableExpression visitTypeNamePair(final TypeNamePairContext ctx) {
return configureAST(
new VariableExpression(
this.visitVariableDeclaratorId(ctx.variableDeclaratorId()).getName(),
@@ -1936,7 +1760,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<DeclarationExpression> visitVariableDeclarators(VariableDeclaratorsContext ctx) {
+ public List<DeclarationExpression> visitVariableDeclarators(final VariableDeclaratorsContext ctx) {
ClassNode variableType = ctx.getNodeMetaData(VARIABLE_DECLARATION_VARIABLE_TYPE);
Objects.requireNonNull(variableType, "variableType should not be null");
@@ -1944,13 +1768,12 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
.map(e -> {
e.putNodeMetaData(VARIABLE_DECLARATION_VARIABLE_TYPE, variableType);
return this.visitVariableDeclarator(e);
-// return this.configureAST(this.visitVariableDeclarator(e), ctx);
})
.collect(Collectors.toList());
}
@Override
- public DeclarationExpression visitVariableDeclarator(VariableDeclaratorContext ctx) {
+ public DeclarationExpression visitVariableDeclarator(final VariableDeclaratorContext ctx) {
ClassNode variableType = ctx.getNodeMetaData(VARIABLE_DECLARATION_VARIABLE_TYPE);
Objects.requireNonNull(variableType, "variableType should not be null");
@@ -1975,7 +1798,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitVariableInitializer(VariableInitializerContext ctx) {
+ public Expression visitVariableInitializer(final VariableInitializerContext ctx) {
if (!asBoolean(ctx)) {
return EmptyExpression.INSTANCE;
}
@@ -1986,7 +1809,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<Expression> visitVariableInitializers(VariableInitializersContext ctx) {
+ public List<Expression> visitVariableInitializers(final VariableInitializersContext ctx) {
if (!asBoolean(ctx)) {
return Collections.emptyList();
}
@@ -1996,24 +1819,22 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
.collect(Collectors.toList());
}
- private int visitingArrayInitializerCnt = 0;
-
@Override
- public List<Expression> visitArrayInitializer(ArrayInitializerContext ctx) {
+ public List<Expression> visitArrayInitializer(final ArrayInitializerContext ctx) {
if (!asBoolean(ctx)) {
return Collections.emptyList();
}
try {
- visitingArrayInitializerCnt++;
+ visitingArrayInitializerCount += 1;
return this.visitVariableInitializers(ctx.variableInitializers());
} finally {
- visitingArrayInitializerCnt--;
+ visitingArrayInitializerCount -= 1;
}
}
@Override
- public Statement visitBlock(BlockContext ctx) {
+ public Statement visitBlock(final BlockContext ctx) {
if (!asBoolean(ctx)) {
return this.createBlockStatement();
}
@@ -2024,16 +1845,16 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ExpressionStatement visitCommandExprAlt(CommandExprAltContext ctx) {
+ public ExpressionStatement visitCommandExprAlt(final CommandExprAltContext ctx) {
return configureAST(new ExpressionStatement(this.visitCommandExpression(ctx.commandExpression())), ctx);
}
@Override
- public Expression visitCommandExpression(CommandExpressionContext ctx) {
+ public Expression visitCommandExpression(final CommandExpressionContext ctx) {
boolean hasArgumentList = asBoolean(ctx.enhancedArgumentListInPar());
boolean hasCommandArgument = asBoolean(ctx.commandArgument());
- if (visitingArrayInitializerCnt > 0 && (hasArgumentList || hasCommandArgument)) {
+ if (visitingArrayInitializerCount > 0 && (hasArgumentList || hasCommandArgument)) {
// To avoid ambiguities, command chain expression should not be used in array initializer
// the old parser does not support either, so no breaking changes
// SEE http://groovy.329449.n5.nabble.com/parrot-Command-expressions-in-array-initializer-tt5752273.html
@@ -2117,7 +1938,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
* Note: if the text of `VariableExpression` does not start with upper case character, e.g. task m() {}
* ,it may be a command expression
*/
- private void validateInvalidMethodDefinition(Expression baseExpr, Expression arguments) {
+ private void validateInvalidMethodDefinition(final Expression baseExpr, final Expression arguments) {
if (baseExpr instanceof VariableExpression) {
if (isBuiltInType(baseExpr) || Character.isUpperCase(baseExpr.getText().codePointAt(0))) {
if (arguments instanceof ArgumentListExpression) {
@@ -2153,7 +1974,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitCommandArgument(CommandArgumentContext ctx) {
+ public Expression visitCommandArgument(final CommandArgumentContext ctx) {
// e.g. x y a b we call "x y" as the base expression
Expression baseExpr = ctx.getNodeMetaData(CMD_EXPRESSION_BASE_EXPR);
@@ -2199,35 +2020,30 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
);
}
- // expression { --------------------------------------------------------------------
+ // expression { ------------------------------------------------------------
@Override
- public ClassNode visitCastParExpression(CastParExpressionContext ctx) {
+ public ClassNode visitCastParExpression(final CastParExpressionContext ctx) {
return this.visitType(ctx.type());
}
@Override
- public Expression visitParExpression(ParExpressionContext ctx) {
+ public Expression visitParExpression(final ParExpressionContext ctx) {
Expression expression = this.visitExpressionInPar(ctx.expressionInPar());
- Integer insideParenLevel = expression.getNodeMetaData(INSIDE_PARENTHESES_LEVEL);
- if (null != insideParenLevel) {
- insideParenLevel++;
- } else {
- insideParenLevel = 1;
- }
- expression.putNodeMetaData(INSIDE_PARENTHESES_LEVEL, insideParenLevel);
+ expression.getNodeMetaData(INSIDE_PARENTHESES_LEVEL,
+ k -> new java.util.concurrent.atomic.AtomicInteger()).getAndAdd(1);
return configureAST(expression, ctx);
}
@Override
- public Expression visitExpressionInPar(ExpressionInParContext ctx) {
+ public Expression visitExpressionInPar(final ExpressionInParContext ctx) {
return this.visitEnhancedStatementExpression(ctx.enhancedStatementExpression());
}
@Override
- public Expression visitEnhancedStatementExpression(EnhancedStatementExpressionContext ctx) {
+ public Expression visitEnhancedStatementExpression(final EnhancedStatementExpressionContext ctx) {
Expression expression;
if (asBoolean(ctx.statementExpression())) {
@@ -2242,7 +2058,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitPathExpression(PathExpressionContext ctx) {
+ public Expression visitPathExpression(final PathExpressionContext ctx) {
final TerminalNode staticTerminalNode = ctx.STATIC();
Expression primaryExpr;
if (asBoolean(staticTerminalNode)) {
@@ -2255,7 +2071,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitPathElement(PathElementContext ctx) {
+ public Expression visitPathElement(final PathElementContext ctx) {
Expression baseExpr = ctx.getNodeMetaData(PATH_EXPRESSION_BASE_EXPR);
Objects.requireNonNull(baseExpr, "baseExpr is required!");
@@ -2317,15 +2133,12 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
configureAST(
new ListExpression(
mapEntryExpressionList.stream()
- .map(
- e -> {
- if (e.getKeyExpression() instanceof SpreadMapExpression) {
- return e.getKeyExpression();
- }
-
- return e;
- }
- )
+ .map(e -> {
+ if (e.getKeyExpression() instanceof SpreadMapExpression) {
+ return e.getKeyExpression();
+ }
+ return e;
+ })
.collect(Collectors.toList())),
ctx.namedPropertyArgs()
);
@@ -2373,7 +2186,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
// so if this and super is inside the closure, it will not be constructor call.
// e.g. src/test/org/codehaus/groovy/transform/MapConstructorTransformTest.groovy:
// @MapConstructor(pre={ super(args?.first, args?.last); args = args ?: [:] }, post = { first = first?.toUpperCase() })
- if (visitingClosureCnt > 0) {
+ if (visitingClosureCount > 0) {
return configureAST(
new MethodCallExpression(
baseExpr,
@@ -2487,7 +2300,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
throw createParsingFailedException("Unsupported path element: " + ctx.getText(), ctx);
}
- private Expression createDotExpression(PathElementContext ctx, Expression baseExpr, Expression namePartExpr, GenericsType[] genericsTypes, boolean safe) {
+ private Expression createDotExpression(final PathElementContext ctx, final Expression baseExpr, final Expression namePartExpr, final GenericsType[] genericsTypes, final boolean safe) {
if (asBoolean(ctx.AT())) { // e.g. obj.@a OR obj?.@a
return configureAST(new AttributeExpression(baseExpr, namePartExpr, safe), ctx);
} else { // e.g. obj.p OR obj?.p
@@ -2497,18 +2310,18 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
}
- private MethodCallExpression createCallMethodCallExpression(Expression baseExpr, Expression argumentsExpr) {
+ private MethodCallExpression createCallMethodCallExpression(final Expression baseExpr, final Expression argumentsExpr) {
return createCallMethodCallExpression(baseExpr, argumentsExpr, false);
}
- private MethodCallExpression createCallMethodCallExpression(Expression baseExpr, Expression argumentsExpr, boolean implicitThis) {
+ private MethodCallExpression createCallMethodCallExpression(final Expression baseExpr, final Expression argumentsExpr, final boolean implicitThis) {
MethodCallExpression methodCallExpression = new MethodCallExpression(baseExpr, CALL_STR, argumentsExpr);
methodCallExpression.setImplicitThis(implicitThis);
return methodCallExpression;
}
@Override
- public GenericsType[] visitNonWildcardTypeArguments(NonWildcardTypeArgumentsContext ctx) {
+ public GenericsType[] visitNonWildcardTypeArguments(final NonWildcardTypeArgumentsContext ctx) {
if (!asBoolean(ctx)) {
return null;
}
@@ -2519,7 +2332,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClassNode[] visitTypeList(TypeListContext ctx) {
+ public ClassNode[] visitTypeList(final TypeListContext ctx) {
if (!asBoolean(ctx)) {
return ClassNode.EMPTY_ARRAY;
}
@@ -2530,7 +2343,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitArguments(ArgumentsContext ctx) {
+ public Expression visitArguments(final ArgumentsContext ctx) {
if (asBoolean(ctx) && asBoolean(ctx.COMMA()) && !asBoolean(ctx.enhancedArgumentListInPar())) {
throw createParsingFailedException("Expression expected", ctx.COMMA());
}
@@ -2543,7 +2356,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitEnhancedArgumentListInPar(EnhancedArgumentListInParContext ctx) {
+ public Expression visitEnhancedArgumentListInPar(final EnhancedArgumentListInParContext ctx) {
if (!asBoolean(ctx)) {
return null;
}
@@ -2589,23 +2402,15 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
throw createParsingFailedException("Unsupported argument list: " + ctx.getText(), ctx);
}
- private void validateDuplicatedNamedParameter(List<MapEntryExpression> mapEntryExpressionList, MapEntryExpression mapEntryExpression) {
+ private void validateDuplicatedNamedParameter(final List<MapEntryExpression> mapEntryExpressionList, final MapEntryExpression mapEntryExpression) {
Expression keyExpression = mapEntryExpression.getKeyExpression();
-
- if (null == keyExpression) {
- return;
- }
-
- if (isInsideParentheses(keyExpression)) {
+ if (keyExpression == null || isInsideParentheses(keyExpression)) {
return;
}
String parameterName = keyExpression.getText();
-
- boolean isDuplicatedNamedParameter =
- mapEntryExpressionList.stream()
- .anyMatch(m -> m.getKeyExpression().getText().equals(parameterName));
-
+ boolean isDuplicatedNamedParameter = mapEntryExpressionList.stream()
+ .anyMatch(m -> m.getKeyExpression().getText().equals(parameterName));
if (!isDuplicatedNamedParameter) {
return;
}
@@ -2614,7 +2419,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitEnhancedArgumentListElement(EnhancedArgumentListElementContext ctx) {
+ public Expression visitEnhancedArgumentListElement(final EnhancedArgumentListElementContext ctx) {
if (asBoolean(ctx.expressionListElement())) {
return configureAST(this.visitExpressionListElement(ctx.expressionListElement()), ctx);
}
@@ -2631,7 +2436,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ConstantExpression visitStringLiteral(StringLiteralContext ctx) {
+ public ConstantExpression visitStringLiteral(final StringLiteralContext ctx) {
String text = parseStringLiteral(ctx.StringLiteral().getText());
ConstantExpression constantExpression = new ConstantExpression(text, true);
@@ -2664,13 +2469,13 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return StringUtils.replaceEscapes(text, slashyType);
}
- private int getSlashyType(String text) {
+ private int getSlashyType(final String text) {
return text.startsWith(SLASH_STR) ? StringUtils.SLASHY :
text.startsWith(DOLLAR_SLASH_STR) ? StringUtils.DOLLAR_SLASHY : StringUtils.NONE_SLASHY;
}
@Override
- public Tuple2<Token, Expression> visitIndexPropertyArgs(IndexPropertyArgsContext ctx) {
+ public Tuple2<Token, Expression> visitIndexPropertyArgs(final IndexPropertyArgsContext ctx) {
List<Expression> expressionList = this.visitExpressionList(ctx.expressionList());
@@ -2698,12 +2503,12 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<MapEntryExpression> visitNamedPropertyArgs(NamedPropertyArgsContext ctx) {
+ public List<MapEntryExpression> visitNamedPropertyArgs(final NamedPropertyArgsContext ctx) {
return this.visitMapEntryList(ctx.mapEntryList());
}
@Override
- public Expression visitNamePart(NamePartContext ctx) {
+ public Expression visitNamePart(final NamePartContext ctx) {
if (asBoolean(ctx.identifier())) {
return configureAST(new ConstantExpression(this.visitIdentifier(ctx.identifier())), ctx);
} else if (asBoolean(ctx.stringLiteral())) {
@@ -2718,7 +2523,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitDynamicMemberName(DynamicMemberNameContext ctx) {
+ public Expression visitDynamicMemberName(final DynamicMemberNameContext ctx) {
if (asBoolean(ctx.parExpression())) {
return configureAST(this.visitParExpression(ctx.parExpression()), ctx);
} else if (asBoolean(ctx.gstring())) {
@@ -2729,13 +2534,13 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitPostfixExpression(PostfixExpressionContext ctx) {
+ public Expression visitPostfixExpression(final PostfixExpressionContext ctx) {
Expression pathExpr = this.visitPathExpression(ctx.pathExpression());
if (asBoolean(ctx.op)) {
PostfixExpression postfixExpression = new PostfixExpression(pathExpr, createGroovyToken(ctx.op));
- if (visitingAssertStatementCnt > 0) {
+ if (visitingAssertStatementCount > 0) {
// powerassert requires different column for values, so we have to copy the location of op
return configureAST(postfixExpression, ctx.op);
} else {
@@ -2747,7 +2552,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitUnaryNotExprAlt(UnaryNotExprAltContext ctx) {
+ public Expression visitUnaryNotExprAlt(final UnaryNotExprAltContext ctx) {
if (asBoolean(ctx.NOT())) {
return configureAST(
new NotExpression((Expression) this.visit(ctx.expression())),
@@ -2764,23 +2569,22 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public CastExpression visitCastExprAlt(CastExprAltContext ctx) {
- return configureAST(
- new CastExpression(
- this.visitCastParExpression(ctx.castParExpression()),
- (Expression) this.visit(ctx.expression())
- ),
- ctx
+ public CastExpression visitCastExprAlt(final CastExprAltContext ctx) {
+ CastExpression cast = new CastExpression(
+ this.visitCastParExpression(ctx.castParExpression()),
+ (Expression) this.visit(ctx.expression())
);
+
+ return configureAST(cast, ctx);
}
@Override
- public BinaryExpression visitPowerExprAlt(PowerExprAltContext ctx) {
+ public BinaryExpression visitPowerExprAlt(final PowerExprAltContext ctx) {
return this.createBinaryExpression(ctx.left, ctx.op, ctx.right, ctx);
}
@Override
- public Expression visitUnaryAddExprAlt(UnaryAddExprAltContext ctx) {
+ public Expression visitUnaryAddExprAlt(final UnaryAddExprAltContext ctx) {
ExpressionContext expressionCtx = ctx.expression();
Expression expression = (Expression) this.visit(expressionCtx);
@@ -2834,24 +2638,24 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
}
- private boolean isNonStringConstantOutsideParentheses(Expression expression) {
+ private boolean isNonStringConstantOutsideParentheses(final Expression expression) {
return expression instanceof ConstantExpression
&& !(((ConstantExpression) expression).getValue() instanceof String)
&& !isInsideParentheses(expression);
}
@Override
- public BinaryExpression visitMultiplicativeExprAlt(MultiplicativeExprAltContext ctx) {
+ public BinaryExpression visitMultiplicativeExprAlt(final MultiplicativeExprAltContext ctx) {
return this.createBinaryExpression(ctx.left, ctx.op, ctx.right, ctx);
}
@Override
- public BinaryExpression visitAdditiveExprAlt(AdditiveExprAltContext ctx) {
+ public BinaryExpression visitAdditiveExprAlt(final AdditiveExprAltContext ctx) {
return this.createBinaryExpression(ctx.left, ctx.op, ctx.right, ctx);
}
@Override
- public Expression visitShiftExprAlt(ShiftExprAltContext ctx) {
+ public Expression visitShiftExprAlt(final ShiftExprAltContext ctx) {
Expression left = (Expression) this.visit(ctx.left);
Expression right = (Expression) this.visit(ctx.right);
@@ -2884,7 +2688,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitRelationalExprAlt(RelationalExprAltContext ctx) {
+ public Expression visitRelationalExprAlt(final RelationalExprAltContext ctx) {
switch (ctx.op.getType()) {
case AS:
return configureAST(
@@ -2921,50 +2725,50 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public BinaryExpression visitEqualityExprAlt(EqualityExprAltContext ctx) {
+ public BinaryExpression visitEqualityExprAlt(final EqualityExprAltContext ctx) {
return configureAST(
this.createBinaryExpression(ctx.left, ctx.op, ctx.right),
ctx);
}
@Override
- public BinaryExpression visitRegexExprAlt(RegexExprAltContext ctx) {
+ public BinaryExpression visitRegexExprAlt(final RegexExprAltContext ctx) {
return configureAST(
this.createBinaryExpression(ctx.left, ctx.op, ctx.right),
ctx);
}
@Override
- public BinaryExpression visitAndExprAlt(AndExprAltContext ctx) {
+ public BinaryExpression visitAndExprAlt(final AndExprAltContext ctx) {
return this.createBinaryExpression(ctx.left, ctx.op, ctx.right, ctx);
}
@Override
- public BinaryExpression visitExclusiveOrExprAlt(ExclusiveOrExprAltContext ctx) {
+ public BinaryExpression visitExclusiveOrExprAlt(final ExclusiveOrExprAltContext ctx) {
return this.createBinaryExpression(ctx.left, ctx.op, ctx.right, ctx);
}
@Override
- public BinaryExpression visitInclusiveOrExprAlt(InclusiveOrExprAltContext ctx) {
+ public BinaryExpression visitInclusiveOrExprAlt(final InclusiveOrExprAltContext ctx) {
return this.createBinaryExpression(ctx.left, ctx.op, ctx.right, ctx);
}
@Override
- public BinaryExpression visitLogicalAndExprAlt(LogicalAndExprAltContext ctx) {
+ public BinaryExpression visitLogicalAndExprAlt(final LogicalAndExprAltContext ctx) {
return configureAST(
this.createBinaryExpression(ctx.left, ctx.op, ctx.right),
ctx);
}
@Override
- public BinaryExpression visitLogicalOrExprAlt(LogicalOrExprAltContext ctx) {
+ public BinaryExpression visitLogicalOrExprAlt(final LogicalOrExprAltContext ctx) {
return configureAST(
this.createBinaryExpression(ctx.left, ctx.op, ctx.right),
ctx);
}
@Override
- public Expression visitConditionalExprAlt(ConditionalExprAltContext ctx) {
+ public Expression visitConditionalExprAlt(final ConditionalExprAltContext ctx) {
ctx.fb.putNodeMetaData(IS_INSIDE_CONDITIONAL_EXPRESSION, true);
if (asBoolean(ctx.ELVIS())) { // e.g. a == 6 ?: 0
@@ -2985,7 +2789,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public BinaryExpression visitMultipleAssignmentExprAlt(MultipleAssignmentExprAltContext ctx) {
+ public BinaryExpression visitMultipleAssignmentExprAlt(final MultipleAssignmentExprAltContext ctx) {
return configureAST(
new BinaryExpression(
this.visitVariableNames(ctx.left),
@@ -2995,13 +2799,13 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public BinaryExpression visitAssignmentExprAlt(AssignmentExprAltContext ctx) {
+ public BinaryExpression visitAssignmentExprAlt(final AssignmentExprAltContext ctx) {
Expression leftExpr = (Expression) this.visit(ctx.left);
if (leftExpr instanceof VariableExpression
&& isInsideParentheses(leftExpr)) { // it is a special multiple assignment whose variable count is only one, e.g. (a) = [1]
- if ((Integer) leftExpr.getNodeMetaData(INSIDE_PARENTHESES_LEVEL) > 1) {
+ if (leftExpr.<Number>getNodeMetaData(INSIDE_PARENTHESES_LEVEL).intValue() > 1) {
throw createParsingFailedException("Nested parenthesis is not allowed in multiple assignment, e.g. ((a)) = b", ctx);
}
@@ -3040,11 +2844,12 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
ctx);
}
- // } expression --------------------------------------------------------------------
+ // } expression ------------------------------------------------------------
+
+ // primary { ---------------------------------------------------------------
- // primary { --------------------------------------------------------------------
@Override
- public Expression visitIdentifierPrmrAlt(IdentifierPrmrAltContext ctx) {
+ public Expression visitIdentifierPrmrAlt(final IdentifierPrmrAltContext ctx) {
if (asBoolean(ctx.typeArguments())) {
ClassNode classNode = ClassHelper.make(ctx.identifier().getText());
@@ -3058,24 +2863,24 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitNewPrmrAlt(NewPrmrAltContext ctx) {
+ public Expression visitNewPrmrAlt(final NewPrmrAltContext ctx) {
return configureAST(this.visitCreator(ctx.creator()), ctx);
}
@Override
- public VariableExpression visitThisPrmrAlt(ThisPrmrAltContext ctx) {
+ public VariableExpression visitThisPrmrAlt(final ThisPrmrAltContext ctx) {
return configureAST(new VariableExpression(ctx.THIS().getText()), ctx);
}
@Override
- public VariableExpression visitSuperPrmrAlt(SuperPrmrAltContext ctx) {
+ public VariableExpression visitSuperPrmrAlt(final SuperPrmrAltContext ctx) {
return configureAST(new VariableExpression(ctx.SUPER().getText()), ctx);
}
- // } primary --------------------------------------------------------------------
+ // } primary ---------------------------------------------------------------
@Override
- public Expression visitCreator(CreatorContext ctx) {
+ public Expression visitCreator(final CreatorContext ctx) {
ClassNode classNode = this.visitCreatedName(ctx.createdName());
if (asBoolean(ctx.arguments())) { // create instance of class
@@ -3200,11 +3005,11 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Tuple3<Expression, List<AnnotationNode>, TerminalNode> visitDim(DimContext ctx) {
+ public Tuple3<Expression, List<AnnotationNode>, TerminalNode> visitDim(final DimContext ctx) {
return tuple((Expression) this.visit(ctx.expression()), this.visitAnnotationsOpt(ctx.annotationsOpt()), ctx.LBRACK());
}
- private static String nextAnonymousClassName(ClassNode outerClass) {
+ private static String nextAnonymousClassName(final ClassNode outerClass) {
int anonymousClassCount = 0;
for (Iterator<InnerClassNode> it = outerClass.getInnerClasses(); it.hasNext();) {
InnerClassNode innerClass = it.next();
@@ -3217,7 +3022,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public InnerClassNode visitAnonymousInnerClassDeclaration(AnonymousInnerClassDeclarationContext ctx) {
+ public InnerClassNode visitAnonymousInnerClassDeclaration(final AnonymousInnerClassDeclarationContext ctx) {
ClassNode superClass = Objects.requireNonNull(ctx.getNodeMetaData(ANONYMOUS_INNER_CLASS_SUPER_CLASS), "superClass should not be null");
ClassNode outerClass = Optional.ofNullable(classNodeStack.peek()).orElse(moduleNode.getScriptClassDummy());
String innerClassName = nextAnonymousClassName(outerClass);
@@ -3247,7 +3052,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClassNode visitCreatedName(CreatedNameContext ctx) {
+ public ClassNode visitCreatedName(final CreatedNameContext ctx) {
ClassNode classNode = null;
if (asBoolean(ctx.qualifiedClassName())) {
@@ -3275,14 +3080,14 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public MapExpression visitMap(MapContext ctx) {
+ public MapExpression visitMap(final MapContext ctx) {
return configureAST(
new MapExpression(this.visitMapEntryList(ctx.mapEntryList())),
ctx);
}
@Override
- public List<MapEntryExpression> visitMapEntryList(MapEntryListContext ctx) {
+ public List<MapEntryExpression> visitMapEntryList(final MapEntryListContext ctx) {
if (!asBoolean(ctx)) {
return Collections.emptyList();
}
@@ -3290,7 +3095,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return this.createMapEntryList(ctx.mapEntry());
}
- private List<MapEntryExpression> createMapEntryList(List<? extends MapEntryContext> mapEntryContextList) {
+ private List<MapEntryExpression> createMapEntryList(final List<? extends MapEntryContext> mapEntryContextList) {
if (!asBoolean(mapEntryContextList)) {
return Collections.emptyList();
}
@@ -3301,7 +3106,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public MapEntryExpression visitMapEntry(MapEntryContext ctx) {
+ public MapEntryExpression visitMapEntry(final MapEntryContext ctx) {
Expression keyExpr;
Expression valueExpr = (Expression) this.visit(ctx.expression());
@@ -3319,7 +3124,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitMapEntryLabel(MapEntryLabelContext ctx) {
+ public Expression visitMapEntryLabel(final MapEntryLabelContext ctx) {
if (asBoolean(ctx.keywords())) {
return configureAST(this.visitKeywords(ctx.keywords()), ctx);
} else if (asBoolean(ctx.primary())) {
@@ -3340,12 +3145,12 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ConstantExpression visitKeywords(KeywordsContext ctx) {
+ public ConstantExpression visitKeywords(final KeywordsContext ctx) {
return configureAST(new ConstantExpression(ctx.getText()), ctx);
}
@Override
- public VariableExpression visitBuiltInType(BuiltInTypeContext ctx) {
+ public VariableExpression visitBuiltInType(final BuiltInTypeContext ctx) {
String text;
if (asBoolean(ctx.VOID())) {
text = ctx.VOID().getText();
@@ -3362,7 +3167,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ListExpression visitList(ListContext ctx) {
+ public ListExpression visitList(final ListContext ctx) {
if (asBoolean(ctx.COMMA()) && !asBoolean(ctx.expressionList())) {
throw createParsingFailedException("Empty list constructor should not contain any comma(,)", ctx.COMMA());
}
@@ -3374,7 +3179,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<Expression> visitExpressionList(ExpressionListContext ctx) {
+ public List<Expression> visitExpressionList(final ExpressionListContext ctx) {
if (!asBoolean(ctx)) {
return Collections.emptyList();
}
@@ -3382,7 +3187,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return this.createExpressionList(ctx.expressionListElement());
}
- private List<Expression> createExpressionList(List<? extends ExpressionListElementContext> expressionListElementContextList) {
+ private List<Expression> createExpressionList(final List<? extends ExpressionListElementContext> expressionListElementContextList) {
if (!asBoolean(expressionListElementContextList)) {
return Collections.emptyList();
}
@@ -3393,7 +3198,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitExpressionListElement(ExpressionListElementContext ctx) {
+ public Expression visitExpressionListElement(final ExpressionListElementContext ctx) {
Expression expression = (Expression) this.visit(ctx.expression());
validateExpressionListElement(ctx, expression);
@@ -3409,7 +3214,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return configureAST(expression, ctx);
}
- private void validateExpressionListElement(ExpressionListElementContext ctx, Expression expression) {
+ private void validateExpressionListElement(final ExpressionListElementContext ctx, final Expression expression) {
if (!(expression instanceof MethodCallExpression && isTrue(expression, IS_COMMAND_EXPRESSION))) {
return;
}
@@ -3422,10 +3227,10 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
}
- // literal { --------------------------------------------------------------------
+ // literal { ---------------------------------------------------------------
@Override
- public ConstantExpression visitIntegerLiteralAlt(IntegerLiteralAltContext ctx) {
+ public ConstantExpression visitIntegerLiteralAlt(final IntegerLiteralAltContext ctx) {
String text = ctx.IntegerLiteral().getText();
Number num = null;
@@ -3436,14 +3241,14 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
ConstantExpression constantExpression = new ConstantExpression(num, !text.startsWith(SUB_STR));
- constantExpression.putNodeMetaData(IS_NUMERIC, true);
+ constantExpression.putNodeMetaData(IS_NUMERIC, Boolean.TRUE);
constantExpression.putNodeMetaData(INTEGER_LITERAL_TEXT, text);
return configureAST(constantExpression, ctx);
}
@Override
- public ConstantExpression visitFloatingPointLiteralAlt(FloatingPointLiteralAltContext ctx) {
+ public ConstantExpression visitFloatingPointLiteralAlt(final FloatingPointLiteralAltContext ctx) {
String text = ctx.FloatingPointLiteral().getText();
Number num = null;
@@ -3454,28 +3259,28 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
ConstantExpression constantExpression = new ConstantExpression(num, !text.startsWith(SUB_STR));
- constantExpression.putNodeMetaData(IS_NUMERIC, true);
+ constantExpression.putNodeMetaData(IS_NUMERIC, Boolean.TRUE);
constantExpression.putNodeMetaData(FLOATING_POINT_LITERAL_TEXT, text);
return configureAST(constantExpression, ctx);
}
@Override
- public ConstantExpression visitBooleanLiteralAlt(BooleanLiteralAltContext ctx) {
+ public ConstantExpression visitBooleanLiteralAlt(final BooleanLiteralAltContext ctx) {
return configureAST(new ConstantExpression("true".equals(ctx.BooleanLiteral().getText()), true), ctx);
}
@Override
- public ConstantExpression visitNullLiteralAlt(NullLiteralAltContext ctx) {
+ public ConstantExpression visitNullLiteralAlt(final NullLiteralAltContext ctx) {
return configureAST(new ConstantExpression(null), ctx);
}
- // } literal --------------------------------------------------------------------
+ // } literal ---------------------------------------------------------------
- // gstring { --------------------------------------------------------------------
+ // gstring { ---------------------------------------------------------------
@Override
- public GStringExpression visitGstring(GstringContext ctx) {
+ public GStringExpression visitGstring(final GstringContext ctx) {
final List<ConstantExpression> stringLiteralList = new LinkedList<>();
final String begin = ctx.GStringBegin().getText();
final String beginQuotation = beginQuotation(begin);
@@ -3494,7 +3299,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
.collect(Collectors.toList());
StringBuilder verbatimText = new StringBuilder(ctx.getText().length());
- for (int i = 0, n = stringLiteralList.size(), s = values.size(); i < n; i++) {
+ for (int i = 0, n = stringLiteralList.size(), s = values.size(); i < n; i += 1) {
verbatimText.append(stringLiteralList.get(i).getValue());
if (i == s) {
@@ -3513,18 +3318,18 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return configureAST(new GStringExpression(verbatimText.toString(), stringLiteralList, values), ctx);
}
- private boolean hasArrow(GstringValueContext e) {
+ private static boolean hasArrow(final GstringValueContext e) {
return asBoolean(e.closure().ARROW());
}
- private String parseGStringEnd(GstringContext ctx, String beginQuotation) {
+ private String parseGStringEnd(final GstringContext ctx, final String beginQuotation) {
StringBuilder text = new StringBuilder(ctx.GStringEnd().getText());
text.insert(0, beginQuotation);
return this.parseStringLiteral(text.toString());
}
- private String parseGStringPart(TerminalNode e, String beginQuotation) {
+ private String parseGStringPart(final TerminalNode e, final String beginQuotation) {
StringBuilder text = new StringBuilder(e.getText());
text.deleteCharAt(text.length() - 1); // remove the tailing $
text.insert(0, beginQuotation).append(QUOTATION_MAP.get(beginQuotation));
@@ -3532,7 +3337,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return this.parseStringLiteral(text.toString());
}
- private String parseGStringBegin(GstringContext ctx, String beginQuotation) {
+ private String parseGStringBegin(final GstringContext ctx, final String beginQuotation) {
StringBuilder text = new StringBuilder(ctx.GStringBegin().getText());
text.deleteCharAt(text.length() - 1); // remove the tailing $
text.append(QUOTATION_MAP.get(beginQuotation));
@@ -3540,7 +3345,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return this.parseStringLiteral(text.toString());
}
- private String beginQuotation(String text) {
+ private static String beginQuotation(final String text) {
if (text.startsWith(TDQ_STR)) {
return TDQ_STR;
} else if (text.startsWith(DQ_STR)) {
@@ -3555,7 +3360,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitGstringValue(GstringValueContext ctx) {
+ public Expression visitGstringValue(final GstringValueContext ctx) {
if (asBoolean(ctx.gstringPath())) {
return configureAST(this.visitGstringPath(ctx.gstringPath()), ctx);
}
@@ -3587,7 +3392,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Expression visitGstringPath(GstringPathContext ctx) {
+ public Expression visitGstringPath(final GstringPathContext ctx) {
VariableExpression variableExpression = new VariableExpression(this.visitIdentifier(ctx.identifier()));
if (asBoolean(ctx.GStringPathPart())) {
@@ -3601,21 +3406,21 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return configureAST(variableExpression, ctx);
}
- // } gstring --------------------------------------------------------------------
+ // } gstring ---------------------------------------------------------------
@Override
- public LambdaExpression visitStandardLambdaExpression(StandardLambdaExpressionContext ctx) {
+ public LambdaExpression visitStandardLambdaExpression(final StandardLambdaExpressionContext ctx) {
return configureAST(this.createLambda(ctx.standardLambdaParameters(), ctx.lambdaBody()), ctx);
}
- private LambdaExpression createLambda(StandardLambdaParametersContext standardLambdaParametersContext, LambdaBodyContext lambdaBodyContext) {
+ private LambdaExpression createLambda(final StandardLambdaParametersContext standardLambdaParametersContext, final LambdaBodyContext lambdaBodyContext) {
return new LambdaExpression(
this.visitStandardLambdaParameters(standardLambdaParametersContext),
this.visitLambdaBody(lambdaBodyContext));
}
@Override
- public Parameter[] visitStandardLambdaParameters(StandardLambdaParametersContext ctx) {
+ public Parameter[] visitStandardLambdaParameters(final StandardLambdaParametersContext ctx) {
if (asBoolean(ctx.variableDeclaratorId())) {
VariableExpression variable = this.visitVariableDeclaratorId(ctx.variableDeclaratorId());
Parameter parameter = new Parameter(ClassHelper.OBJECT_TYPE, variable.getName());
@@ -3628,7 +3433,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Statement visitLambdaBody(LambdaBodyContext ctx) {
+ public Statement visitLambdaBody(final LambdaBodyContext ctx) {
if (asBoolean(ctx.statementExpression())) {
return configureAST((ExpressionStatement) this.visit(ctx.statementExpression()), ctx);
}
@@ -3641,8 +3446,8 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClosureExpression visitClosure(ClosureContext ctx) {
- visitingClosureCnt++;
+ public ClosureExpression visitClosure(final ClosureContext ctx) {
+ visitingClosureCount += 1;
Parameter[] parameters = asBoolean(ctx.formalParameterList())
? this.visitFormalParameterList(ctx.formalParameterList())
@@ -3655,13 +3460,13 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
Statement code = this.visitBlockStatementsOpt(ctx.blockStatementsOpt());
ClosureExpression result = configureAST(new ClosureExpression(parameters, code), ctx);
- visitingClosureCnt--;
+ visitingClosureCount -= 1;
return result;
}
@Override
- public Parameter[] visitFormalParameters(FormalParametersContext ctx) {
+ public Parameter[] visitFormalParameters(final FormalParametersContext ctx) {
if (!asBoolean(ctx)) {
return Parameter.EMPTY_ARRAY;
}
@@ -3670,7 +3475,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Parameter[] visitFormalParameterList(FormalParameterListContext ctx) {
+ public Parameter[] visitFormalParameterList(final FormalParameterListContext ctx) {
if (!asBoolean(ctx)) {
return Parameter.EMPTY_ARRAY;
}
@@ -3696,8 +3501,8 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return parameterList.toArray(Parameter.EMPTY_ARRAY);
}
- private void validateVarArgParameter(List<? extends FormalParameterContext> formalParameterList) {
- for (int i = 0, n = formalParameterList.size(); i < n - 1; i++) {
+ private void validateVarArgParameter(final List<? extends FormalParameterContext> formalParameterList) {
+ for (int i = 0, n = formalParameterList.size(); i < n - 1; i += 1) {
FormalParameterContext formalParameterContext = formalParameterList.get(i);
if (asBoolean(formalParameterContext.ELLIPSIS())) {
throw createParsingFailedException("The var-arg parameter strs must be the last parameter", formalParameterContext);
@@ -3705,8 +3510,8 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
}
- private void validateParameterList(List<Parameter> parameterList) {
- for (int n = parameterList.size(), i = n - 1; i >= 0; i--) {
+ private void validateParameterList(final List<Parameter> parameterList) {
+ for (int n = parameterList.size(), i = n - 1; i >= 0; i -= 1) {
Parameter parameter = parameterList.get(i);
for (Parameter otherParameter : parameterList) {
@@ -3722,17 +3527,17 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Parameter visitFormalParameter(FormalParameterContext ctx) {
+ public Parameter visitFormalParameter(final FormalParameterContext ctx) {
return this.processFormalParameter(ctx, ctx.variableModifiersOpt(), ctx.type(), ctx.ELLIPSIS(), ctx.variableDeclaratorId(), ctx.expression());
}
@Override
- public Parameter visitThisFormalParameter(ThisFormalParameterContext ctx) {
+ public Parameter visitThisFormalParameter(final ThisFormalParameterContext ctx) {
return configureAST(new Parameter(this.visitType(ctx.type()), THIS_STR), ctx);
}
@Override
- public List<ModifierNode> visitClassOrInterfaceModifiersOpt(ClassOrInterfaceModifiersOptContext ctx) {
+ public List<ModifierNode> visitClassOrInterfaceModifiersOpt(final ClassOrInterfaceModifiersOptContext ctx) {
if (asBoolean(ctx.classOrInterfaceModifiers())) {
return this.visitClassOrInterfaceModifiers(ctx.classOrInterfaceModifiers());
}
@@ -3741,14 +3546,14 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<ModifierNode> visitClassOrInterfaceModifiers(ClassOrInterfaceModifiersContext ctx) {
+ public List<ModifierNode> visitClassOrInterfaceModifiers(final ClassOrInterfaceModifiersContext ctx) {
return ctx.classOrInterfaceModifier().stream()
.map(this::visitClassOrInterfaceModifier)
.collect(Collectors.toList());
}
@Override
- public ModifierNode visitClassOrInterfaceModifier(ClassOrInterfaceModifierContext ctx) {
+ public ModifierNode visitClassOrInterfaceModifier(final ClassOrInterfaceModifierContext ctx) {
if (asBoolean(ctx.annotation())) {
return configureAST(new ModifierNode(this.visitAnnotation(ctx.annotation()), ctx.getText()), ctx);
}
@@ -3761,7 +3566,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ModifierNode visitModifier(ModifierContext ctx) {
+ public ModifierNode visitModifier(final ModifierContext ctx) {
if (asBoolean(ctx.classOrInterfaceModifier())) {
return configureAST(this.visitClassOrInterfaceModifier(ctx.classOrInterfaceModifier()), ctx);
}
@@ -3774,14 +3579,14 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<ModifierNode> visitModifiers(ModifiersContext ctx) {
+ public List<ModifierNode> visitModifiers(final ModifiersContext ctx) {
return ctx.modifier().stream()
.map(this::visitModifier)
.collect(Collectors.toList());
}
@Override
- public List<ModifierNode> visitModifiersOpt(ModifiersOptContext ctx) {
+ public List<ModifierNode> visitModifiersOpt(final ModifiersOptContext ctx) {
if (asBoolean(ctx.modifiers())) {
return this.visitModifiers(ctx.modifiers());
}
@@ -3790,7 +3595,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ModifierNode visitVariableModifier(VariableModifierContext ctx) {
+ public ModifierNode visitVariableModifier(final VariableModifierContext ctx) {
if (asBoolean(ctx.annotation())) {
return configureAST(new ModifierNode(this.visitAnnotation(ctx.annotation()), ctx.getText()), ctx);
}
@@ -3803,7 +3608,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<ModifierNode> visitVariableModifiersOpt(VariableModifiersOptContext ctx) {
+ public List<ModifierNode> visitVariableModifiersOpt(final VariableModifiersOptContext ctx) {
if (asBoolean(ctx.variableModifiers())) {
return this.visitVariableModifiers(ctx.variableModifiers());
}
@@ -3812,14 +3617,14 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<ModifierNode> visitVariableModifiers(VariableModifiersContext ctx) {
+ public List<ModifierNode> visitVariableModifiers(final VariableModifiersContext ctx) {
return ctx.variableModifier().stream()
.map(this::visitVariableModifier)
.collect(Collectors.toList());
}
@Override
- public List<List<AnnotationNode>> visitEmptyDims(EmptyDimsContext ctx) {
+ public List<List<AnnotationNode>> visitEmptyDims(final EmptyDimsContext ctx) {
List<List<AnnotationNode>> dimList =
ctx.annotationsOpt().stream()
.map(this::visitAnnotationsOpt)
@@ -3831,7 +3636,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<List<AnnotationNode>> visitEmptyDimsOpt(EmptyDimsOptContext ctx) {
+ public List<List<AnnotationNode>> visitEmptyDimsOpt(final EmptyDimsOptContext ctx) {
if (!asBoolean(ctx.emptyDims())) {
return Collections.emptyList();
}
@@ -3839,10 +3644,10 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return this.visitEmptyDims(ctx.emptyDims());
}
- // type { --------------------------------------------------------------------
+ // type { ------------------------------------------------------------------
@Override
- public ClassNode visitType(TypeContext ctx) {
+ public ClassNode visitType(final TypeContext ctx) {
if (!asBoolean(ctx)) {
return ClassHelper.OBJECT_TYPE;
}
@@ -3875,7 +3680,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClassNode visitClassOrInterfaceType(ClassOrInterfaceTypeContext ctx) {
+ public ClassNode visitClassOrInterfaceType(final ClassOrInterfaceTypeContext ctx) {
ClassNode classNode;
if (asBoolean(ctx.qualifiedClassName())) {
ctx.qualifiedClassName().putNodeMetaData(IS_INSIDE_INSTANCEOF_EXPR, ctx.getNodeMetaData(IS_INSIDE_INSTANCEOF_EXPR));
@@ -3894,7 +3699,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public GenericsType[] visitTypeArgumentsOrDiamond(TypeArgumentsOrDiamondContext ctx) {
+ public GenericsType[] visitTypeArgumentsOrDiamond(final TypeArgumentsOrDiamondContext ctx) {
if (asBoolean(ctx.typeArguments())) {
return this.visitTypeArguments(ctx.typeArguments());
}
@@ -3906,14 +3711,13 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
throw createParsingFailedException("Unsupported type arguments or diamond: " + ctx.getText(), ctx);
}
-
@Override
- public GenericsType[] visitTypeArguments(TypeArgumentsContext ctx) {
+ public GenericsType[] visitTypeArguments(final TypeArgumentsContext ctx) {
return ctx.typeArgument().stream().map(this::visitTypeArgument).toArray(GenericsType[]::new);
}
@Override
- public GenericsType visitTypeArgument(TypeArgumentContext ctx) {
+ public GenericsType visitTypeArgument(final TypeArgumentContext ctx) {
if (asBoolean(ctx.QUESTION())) {
ClassNode baseType = configureAST(ClassHelper.makeWithoutCaching(QUESTION_STR), ctx.QUESTION());
@@ -3952,19 +3756,19 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClassNode visitPrimitiveType(PrimitiveTypeContext ctx) {
+ public ClassNode visitPrimitiveType(final PrimitiveTypeContext ctx) {
return configureAST(ClassHelper.make(ctx.getText()), ctx);
}
- // } type --------------------------------------------------------------------
+ // } type ------------------------------------------------------------------
@Override
- public VariableExpression visitVariableDeclaratorId(VariableDeclaratorIdContext ctx) {
+ public VariableExpression visitVariableDeclaratorId(final VariableDeclaratorIdContext ctx) {
return configureAST(new VariableExpression(this.visitIdentifier(ctx.identifier())), ctx);
}
@Override
- public TupleExpression visitVariableNames(VariableNamesContext ctx) {
+ public TupleExpression visitVariableNames(final VariableNamesContext ctx) {
return configureAST(
new TupleExpression(
ctx.variableDeclaratorId().stream()
@@ -3975,7 +3779,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClosureExpression visitClosureOrLambdaExpression(ClosureOrLambdaExpressionContext ctx) {
+ public ClosureExpression visitClosureOrLambdaExpression(final ClosureOrLambdaExpressionContext ctx) {
// GROOVY-8991: Difference in behaviour with closure and lambda
if (asBoolean(ctx.closure())) {
return configureAST(this.visitClosure(ctx.closure()), ctx);
@@ -3988,7 +3792,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public BlockStatement visitBlockStatementsOpt(BlockStatementsOptContext ctx) {
+ public BlockStatement visitBlockStatementsOpt(final BlockStatementsOptContext ctx) {
if (asBoolean(ctx.blockStatements())) {
return configureAST(this.visitBlockStatements(ctx.blockStatements()), ctx);
}
@@ -3997,7 +3801,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public BlockStatement visitBlockStatements(BlockStatementsContext ctx) {
+ public BlockStatement visitBlockStatements(final BlockStatementsContext ctx) {
return configureAST(
this.createBlockStatement(
ctx.blockStatement().stream()
@@ -4008,7 +3812,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Statement visitBlockStatement(BlockStatementContext ctx) {
+ public Statement visitBlockStatement(final BlockStatementContext ctx) {
if (asBoolean(ctx.localVariableDeclaration())) {
return configureAST(this.visitLocalVariableDeclaration(ctx.localVariableDeclaration()), ctx);
}
@@ -4035,7 +3839,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<AnnotationNode> visitAnnotationsOpt(AnnotationsOptContext ctx) {
+ public List<AnnotationNode> visitAnnotationsOpt(final AnnotationsOptContext ctx) {
if (!asBoolean(ctx)) {
return Collections.emptyList();
}
@@ -4046,7 +3850,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public AnnotationNode visitAnnotation(AnnotationContext ctx) {
+ public AnnotationNode visitAnnotation(final AnnotationContext ctx) {
String annotationName = this.visitAnnotationName(ctx.annotationName());
AnnotationNode annotationNode = new AnnotationNode(ClassHelper.make(annotationName));
List<Tuple2<String, Expression>> annotationElementValues = this.visitElementValues(ctx.elementValues());
@@ -4057,7 +3861,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public List<Tuple2<String, Expression>> visitElementValues(ElementValuesContext ctx) {
+ public List<Tuple2<String, Expression>> visitElementValues(final ElementValuesContext ctx) {
if (!asBoolean(ctx)) {
return Collections.emptyList();
}
@@ -4074,12 +3878,12 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public String visitAnnotationName(AnnotationNameContext ctx) {
+ public String visitAnnotationName(final AnnotationNameContext ctx) {
return this.visitQualifiedClassName(ctx.qualifiedClassName()).getName();
}
@Override
- public Map<String, Expression> visitElementValuePairs(ElementValuePairsContext ctx) {
+ public Map<String, Expression> visitElementValuePairs(final ElementValuePairsContext ctx) {
return ctx.elementValuePair().stream()
.map(this::visitElementValuePair)
.collect(Collectors.toMap(
@@ -4093,12 +3897,12 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public Tuple2<String, Expression> visitElementValuePair(ElementValuePairContext ctx) {
+ public Tuple2<String, Expression> visitElementValuePair(final ElementValuePairContext ctx) {
return tuple(ctx.elementValuePairName().getText(), this.visitElementValue(ctx.elementValue()));
}
@Override
- public Expression visitElementValue(ElementValueContext ctx) {
+ public Expression visitElementValue(final ElementValueContext ctx) {
if (asBoolean(ctx.expression())) {
return configureAST((Expression) this.visit(ctx.expression()), ctx);
}
@@ -4115,29 +3919,29 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ListExpression visitElementValueArrayInitializer(ElementValueArrayInitializerContext ctx) {
+ public ListExpression visitElementValueArrayInitializer(final ElementValueArrayInitializerContext ctx) {
return configureAST(new ListExpression(ctx.elementValue().stream().map(this::visitElementValue).collect(Collectors.toList())), ctx);
}
@Override
- public String visitClassName(ClassNameContext ctx) {
+ public String visitClassName(final ClassNameContext ctx) {
return ctx.getText();
}
@Override
- public String visitIdentifier(IdentifierContext ctx) {
+ public String visitIdentifier(final IdentifierContext ctx) {
return ctx.getText();
}
@Override
- public String visitQualifiedName(QualifiedNameContext ctx) {
+ public String visitQualifiedName(final QualifiedNameContext ctx) {
return ctx.qualifiedNameElement().stream()
.map(ParseTree::getText)
.collect(Collectors.joining(DOT_STR));
}
@Override
- public ClassNode visitAnnotatedQualifiedClassName(AnnotatedQualifiedClassNameContext ctx) {
+ public ClassNode visitAnnotatedQualifiedClassName(final AnnotatedQualifiedClassNameContext ctx) {
ClassNode classNode = this.visitQualifiedClassName(ctx.qualifiedClassName());
classNode.addAnnotations(this.visitAnnotationsOpt(ctx.annotationsOpt()));
@@ -4146,7 +3950,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClassNode[] visitQualifiedClassNameList(QualifiedClassNameListContext ctx) {
+ public ClassNode[] visitQualifiedClassNameList(final QualifiedClassNameListContext ctx) {
if (!asBoolean(ctx)) {
return ClassNode.EMPTY_ARRAY;
}
@@ -4157,16 +3961,16 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public ClassNode visitQualifiedClassName(QualifiedClassNameContext ctx) {
+ public ClassNode visitQualifiedClassName(final QualifiedClassNameContext ctx) {
return this.createClassNode(ctx);
}
@Override
- public ClassNode visitQualifiedStandardClassName(QualifiedStandardClassNameContext ctx) {
+ public ClassNode visitQualifiedStandardClassName(final QualifiedStandardClassNameContext ctx) {
return this.createClassNode(ctx);
}
- private ClassNode createArrayType(ClassNode elementType, List<List<AnnotationNode>> dimAnnotationsList) {
+ private ClassNode createArrayType(final ClassNode elementType, List<List<AnnotationNode>> dimAnnotationsList) {
ClassNode arrayType = elementType;
for (int i = dimAnnotationsList.size() - 1; i >= 0; i -= 1) {
arrayType = this.createArrayType(arrayType);
@@ -4175,14 +3979,14 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return arrayType;
}
- private ClassNode createArrayType(ClassNode elementType) {
+ private ClassNode createArrayType(final ClassNode elementType) {
if (ClassHelper.VOID_TYPE.equals(elementType)) {
throw this.createParsingFailedException("void[] is an invalid type", elementType);
}
return elementType.makeArray();
}
- private ClassNode createClassNode(GroovyParserRuleContext ctx) {
+ private ClassNode createClassNode(final GroovyParserRuleContext ctx) {
ClassNode result = ClassHelper.make(ctx.getText());
if (!isTrue(ctx, IS_INSIDE_INSTANCEOF_EXPR)) { // type in the "instanceof" expression should not have proxy to redirect to it
@@ -4192,7 +3996,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return configureAST(result, ctx);
}
- private ClassNode proxyClassNode(ClassNode classNode) {
+ private ClassNode proxyClassNode(final ClassNode classNode) {
if (!classNode.isUsingGenerics()) {
return classNode;
}
@@ -4210,7 +4014,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
* @return the visiting result
*/
@Override
- public Object visit(ParseTree tree) {
+ public Object visit(final ParseTree tree) {
if (!asBoolean(tree)) {
return null;
}
@@ -4219,7 +4023,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
// e.g. obj.a(1, 2) or obj.a 1, 2
- private MethodCallExpression createMethodCallExpression(PropertyExpression propertyExpression, Expression arguments) {
+ private MethodCallExpression createMethodCallExpression(final PropertyExpression propertyExpression, final Expression arguments) {
MethodCallExpression methodCallExpression =
new MethodCallExpression(
propertyExpression.getObjectExpression(),
@@ -4246,9 +4050,10 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
// e.g. m(1, 2) or m 1, 2
- private MethodCallExpression createMethodCallExpression(Expression baseExpr, Expression arguments) {
+ private MethodCallExpression createMethodCallExpression(final Expression baseExpr, final Expression arguments) {
Expression thisExpr = new VariableExpression("this");
- configureAST(thisExpr, baseExpr);
+ thisExpr.setColumnNumber(baseExpr.getColumnNumber());
+ thisExpr.setLineNumber(baseExpr.getLineNumber());
return new MethodCallExpression(
thisExpr,
@@ -4261,13 +4066,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
);
}
- private Parameter processFormalParameter(GroovyParserRuleContext ctx,
- VariableModifiersOptContext variableModifiersOptContext,
- TypeContext typeContext,
- TerminalNode ellipsis,
- VariableDeclaratorIdContext variableDeclaratorIdContext,
- ExpressionContext expressionContext) {
-
+ private Parameter processFormalParameter(final GroovyParserRuleContext ctx, final VariableModifiersOptContext variableModifiersOptContext, final TypeContext typeContext, final TerminalNode ellipsis, final VariableDeclaratorIdContext variableDeclaratorIdContext, final ExpressionContext expressionContext) {
ClassNode classNode = this.visitType(typeContext);
if (asBoolean(ellipsis)) {
@@ -4298,7 +4097,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return parameter;
}
- private Expression createPathExpression(Expression primaryExpr, List<? extends PathElementContext> pathElementContextList) {
+ private Expression createPathExpression(final Expression primaryExpr, final List<? extends PathElementContext> pathElementContextList) {
return (Expression) pathElementContextList.stream()
.map(e -> (Object) e)
.reduce(primaryExpr,
@@ -4317,11 +4116,11 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
);
}
- private GenericsType createGenericsType(ClassNode classNode) {
+ private GenericsType createGenericsType(final ClassNode classNode) {
return configureAST(new GenericsType(classNode), classNode);
}
- private ConstantExpression createConstantExpression(Expression expression) {
+ private ConstantExpression createConstantExpression(final Expression expression) {
if (expression instanceof ConstantExpression) {
return (ConstantExpression) expression;
}
@@ -4329,11 +4128,11 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return configureAST(new ConstantExpression(expression.getText()), expression);
}
- private BinaryExpression createBinaryExpression(ExpressionContext left, Token op, ExpressionContext right) {
+ private BinaryExpression createBinaryExpression(final ExpressionContext left, final Token op, final ExpressionContext right) {
return new BinaryExpression((Expression) this.visit(left), this.createGroovyToken(op), (Expression) this.visit(right));
}
- private BinaryExpression createBinaryExpression(ExpressionContext left, Token op, ExpressionContext right, ExpressionContext ctx) {
+ private BinaryExpression createBinaryExpression(final ExpressionContext left, final Token op, final ExpressionContext right, final ExpressionContext ctx) {
BinaryExpression binaryExpression = this.createBinaryExpression(left, op, right);
if (isTrue(ctx, IS_INSIDE_CONDITIONAL_EXPRESSION)) {
@@ -4343,7 +4142,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return configureAST(binaryExpression, ctx);
}
- private Statement unpackStatement(Statement statement) {
+ private Statement unpackStatement(final Statement statement) {
if (statement instanceof DeclarationListStatement) {
List<ExpressionStatement> expressionStatementList = ((DeclarationListStatement) statement).getDeclarationStatements();
@@ -4357,19 +4156,19 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return statement;
}
- BlockStatement createBlockStatement(Statement... statements) {
+ BlockStatement createBlockStatement(final Statement... statements) {
return this.createBlockStatement(Arrays.asList(statements));
}
- private BlockStatement createBlockStatement(List<Statement> statementList) {
+ private BlockStatement createBlockStatement(final List<Statement> statementList) {
return this.appendStatementsToBlockStatement(new BlockStatement(), statementList);
}
- public BlockStatement appendStatementsToBlockStatement(BlockStatement bs, Statement... statements) {
+ public BlockStatement appendStatementsToBlockStatement(final BlockStatement bs, final Statement... statements) {
return this.appendStatementsToBlockStatement(bs, Arrays.asList(statements));
}
- private BlockStatement appendStatementsToBlockStatement(BlockStatement bs, List<Statement> statementList) {
+ private BlockStatement appendStatementsToBlockStatement(final BlockStatement bs, final List<Statement> statementList) {
return (BlockStatement) statementList.stream()
.reduce(bs, (r, e) -> {
BlockStatement blockStatement = (BlockStatement) r;
@@ -4384,15 +4183,11 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
});
}
- private boolean isAnnotationDeclaration(ClassNode classNode) {
+ private boolean isAnnotationDeclaration(final ClassNode classNode) {
return asBoolean(classNode) && classNode.isAnnotationDefinition();
}
- private boolean isSyntheticPublic(
- boolean isAnnotationDeclaration,
- boolean isAnonymousInnerEnumDeclaration,
- boolean hasReturnType,
- ModifierManager modifierManager) {
+ private boolean isSyntheticPublic(final boolean isAnnotationDeclaration, final boolean isAnonymousInnerEnumDeclaration, final boolean hasReturnType, final ModifierManager modifierManager) {
if (modifierManager.containsVisibilityModifier()) {
return false;
}
@@ -4413,7 +4208,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
// the mixins of interface and annotation should be null
- private void hackMixins(ClassNode classNode) {
+ private void hackMixins(final ClassNode classNode) {
classNode.setMixins(null);
}
@@ -4428,7 +4223,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
ClassHelper.boolean_TYPE, Boolean.FALSE
);
- private Object findDefaultValueByType(ClassNode type) {
+ private Object findDefaultValueByType(final ClassNode type) {
return TYPE_DEFAULT_VALUE_MAP.get(type);
}
@@ -4441,29 +4236,29 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return moduleNode.getStatementBlock().isEmpty() && moduleNode.getMethods().isEmpty() && moduleNode.getClasses().isEmpty();
}
- private boolean isInsideParentheses(NodeMetaDataHandler nodeMetaDataHandler) {
- Integer insideParenLevel = nodeMetaDataHandler.getNodeMetaData(INSIDE_PARENTHESES_LEVEL);
- return insideParenLevel != null && insideParenLevel > 0;
+ private boolean isInsideParentheses(final NodeMetaDataHandler nodeMetaDataHandler) {
+ Number insideParenLevel = nodeMetaDataHandler.getNodeMetaData(INSIDE_PARENTHESES_LEVEL);
+ return insideParenLevel != null && insideParenLevel.intValue() > 0;
}
- private boolean isBuiltInType(Expression expression) {
+ private boolean isBuiltInType(final Expression expression) {
if (!(expression instanceof VariableExpression)) return false;
return isTrue(expression, IS_BUILT_IN_TYPE);
}
- private org.codehaus.groovy.syntax.Token createGroovyTokenByType(Token token, int type) {
+ private org.codehaus.groovy.syntax.Token createGroovyTokenByType(final Token token, final int type) {
if (token == null) {
throw new IllegalArgumentException("token should not be null");
}
return new org.codehaus.groovy.syntax.Token(type, token.getText(), token.getLine(), token.getCharPositionInLine());
}
- private org.codehaus.groovy.syntax.Token createGroovyToken(Token token) {
+ private org.codehaus.groovy.syntax.Token createGroovyToken(final Token token) {
return this.createGroovyToken(token, 1);
}
- private org.codehaus.groovy.syntax.Token createGroovyToken(Token token, int cardinality) {
+ private org.codehaus.groovy.syntax.Token createGroovyToken(final Token token, final int cardinality) {
String text = StringGroovyMethods.multiply((CharSequence) token.getText(), cardinality);
return new org.codehaus.groovy.syntax.Token(
"..<".equals(token.getText()) || "..".equals(token.getText())
@@ -4496,11 +4291,11 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
}
- private String getOriginalText(ParserRuleContext context) {
+ private String getOriginalText(final ParserRuleContext context) {
return lexer.getInputStream().getText(Interval.of(context.getStart().getStartIndex(), context.getStop().getStopIndex()));
}
- private boolean isTrue(NodeMetaDataHandler nodeMetaDataHandler, String key) {
+ private boolean isTrue(final NodeMetaDataHandler nodeMetaDataHandler, final String key) {
Object nmd = nodeMetaDataHandler.getNodeMetaData(key);
if (null == nmd) {
@@ -4514,7 +4309,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return (Boolean) nmd;
}
- private CompilationFailedException createParsingFailedException(String msg, GroovyParserRuleContext ctx) {
+ private CompilationFailedException createParsingFailedException(final String msg, final GroovyParserRuleContext ctx) {
return createParsingFailedException(
new SyntaxException(msg,
ctx.start.getLine(),
@@ -4523,7 +4318,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
ctx.stop.getCharPositionInLine() + 1 + ctx.stop.getText().length()));
}
- CompilationFailedException createParsingFailedException(String msg, Tuple2<Integer, Integer> start, Tuple2<Integer, Integer> end) {
+ CompilationFailedException createParsingFailedException(final String msg, final Tuple2<Integer, Integer> start, final Tuple2<Integer, Integer> end) {
return createParsingFailedException(
new SyntaxException(msg,
start.getV1(),
@@ -4532,7 +4327,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
end.getV2()));
}
- CompilationFailedException createParsingFailedException(String msg, ASTNode node) {
+ CompilationFailedException createParsingFailedException(final String msg, final ASTNode node) {
Objects.requireNonNull(node, "node passed into createParsingFailedException should not be null");
return createParsingFailedException(
@@ -4543,11 +4338,11 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
node.getLastColumnNumber()));
}
- private CompilationFailedException createParsingFailedException(String msg, TerminalNode node) {
+ private CompilationFailedException createParsingFailedException(final String msg, final TerminalNode node) {
return createParsingFailedException(msg, node.getSymbol());
}
- private CompilationFailedException createParsingFailedException(String msg, Token token) {
+ private CompilationFailedException createParsingFailedException(final String msg, final Token token) {
return createParsingFailedException(
new SyntaxException(msg,
token.getLine(),
@@ -4556,7 +4351,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
token.getCharPositionInLine() + 1 + token.getText().length()));
}
- private CompilationFailedException createParsingFailedException(Throwable t) {
+ private CompilationFailedException createParsingFailedException(final Throwable t) {
if (t instanceof SyntaxException) {
this.collectSyntaxError((SyntaxException) t);
} else if (t instanceof GroovySyntaxError) {
@@ -4578,22 +4373,18 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
t);
}
- private void collectSyntaxError(SyntaxException e) {
+ private void collectSyntaxError(final SyntaxException e) {
sourceUnit.getErrorCollector().addFatalError(new SyntaxErrorMessage(e, sourceUnit));
}
- private void collectException(Exception e) {
+ private void collectException(final Exception e) {
sourceUnit.getErrorCollector().addException(e, this.sourceUnit);
}
private ANTLRErrorListener createANTLRErrorListener() {
return new ANTLRErrorListener() {
@Override
- public void syntaxError(
- Recognizer recognizer,
- Object offendingSymbol, int line, int charPositionInLine,
- String msg, RecognitionException e) {
-
+ public void syntaxError(final Recognizer recognizer, final Object offendingSymbol, final int line, final int charPositionInLine, final String msg, final RecognitionException e) {
collectSyntaxError(new SyntaxException(msg, line, charPositionInLine + 1));
}
};
@@ -4612,7 +4403,10 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
parser.addErrorListener(this.createANTLRErrorListener());
}
+ //--------------------------------------------------------------------------
+
private static class DeclarationListStatement extends Statement {
+
private final List<ExpressionStatement> declarationStatements;
public DeclarationListStatement(DeclarationExpression... declarations) {
@@ -4654,18 +4448,20 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
private final SourceUnit sourceUnit;
private final GroovyLangLexer lexer;
private final GroovyLangParser parser;
- private final TryWithResourcesASTTransformation tryWithResourcesASTTransformation;
private final GroovydocManager groovydocManager;
+ private final TryWithResourcesASTTransformation tryWithResourcesASTTransformation;
+
private final List<ClassNode> classNodeList = new LinkedList<>();
private final Deque<ClassNode> classNodeStack = new ArrayDeque<>();
private final Deque<List<InnerClassNode>> anonymousInnerClassesDefinedInMethodStack = new ArrayDeque<>();
private Tuple2<GroovyParserRuleContext, Exception> numberFormatError;
- private int visitingLoopStatementCnt;
- private int visitingSwitchStatementCnt;
- private int visitingAssertStatementCnt;
- private int visitingClosureCnt;
+ private int visitingClosureCount;
+ private int visitingLoopStatementCount;
+ private int visitingSwitchStatementCount;
+ private int visitingAssertStatementCount;
+ private int visitingArrayInitializerCount;
private static final String QUESTION_STR = "?";
private static final String DOT_STR = ".";