You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by em...@apache.org on 2022/08/02 20:51:15 UTC
[groovy] branch master updated: GROOVY-10713: update visits for closure/lambda and `try`-with-resources
This is an automated email from the ASF dual-hosted git repository.
emilles pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git
The following commit(s) were added to refs/heads/master by this push:
new 39ec4d17d3 GROOVY-10713: update visits for closure/lambda and `try`-with-resources
39ec4d17d3 is described below
commit 39ec4d17d3d6700f34b15303a59f33828eb6a1fd
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Tue Aug 2 15:47:58 2022 -0500
GROOVY-10713: update visits for closure/lambda and `try`-with-resources
---
.../groovy/ast/ClassCodeExpressionTransformer.java | 90 ++++++++++++----------
.../groovy/ast/ClassCodeVisitorSupport.java | 28 ++++---
.../codehaus/groovy/ast/CodeVisitorSupport.java | 63 ++++++++-------
3 files changed, 104 insertions(+), 77 deletions(-)
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassCodeExpressionTransformer.java b/src/main/java/org/codehaus/groovy/ast/ClassCodeExpressionTransformer.java
index 4e17a10384..0073c54823 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassCodeExpressionTransformer.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassCodeExpressionTransformer.java
@@ -19,6 +19,7 @@
package org.codehaus.groovy.ast;
import org.codehaus.groovy.ast.expr.BooleanExpression;
+import org.codehaus.groovy.ast.expr.ClosureExpression;
import org.codehaus.groovy.ast.expr.Expression;
import org.codehaus.groovy.ast.expr.ExpressionTransformer;
import org.codehaus.groovy.ast.expr.PropertyExpression;
@@ -29,7 +30,6 @@ import org.codehaus.groovy.ast.stmt.ExpressionStatement;
import org.codehaus.groovy.ast.stmt.ForStatement;
import org.codehaus.groovy.ast.stmt.IfStatement;
import org.codehaus.groovy.ast.stmt.ReturnStatement;
-import org.codehaus.groovy.ast.stmt.Statement;
import org.codehaus.groovy.ast.stmt.SwitchStatement;
import org.codehaus.groovy.ast.stmt.SynchronizedStatement;
import org.codehaus.groovy.ast.stmt.ThrowStatement;
@@ -43,93 +43,105 @@ import java.util.Map;
public abstract class ClassCodeExpressionTransformer extends ClassCodeVisitorSupport implements ExpressionTransformer {
@Override
- public Expression transform(Expression expr) {
+ public Expression transform(final Expression expr) {
if (expr == null) return null;
return expr.transformExpression(this);
}
@Override
- protected void visitAnnotation(AnnotationNode node) {
+ protected void visitAnnotation(final AnnotationNode node) {
for (Map.Entry<String, Expression> entry : node.getMembers().entrySet()) {
entry.setValue(transform(entry.getValue()));
}
}
@Override
- protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) {
+ protected void visitConstructorOrMethod(final MethodNode node, final boolean isConstructor) {
for (Parameter p : node.getParameters()) {
- if (p.hasInitialExpression()) {
+ Expression init = p.getInitialExpression();
+ if (init != null) p.setInitialExpression(transform(init));
+ }
+ super.visitConstructorOrMethod(node, isConstructor);
+ }
+
+ @Override
+ public void visitClosureExpression(final ClosureExpression expr) {
+ if (expr.isParameterSpecified()) {
+ for (Parameter p : expr.getParameters()) {
Expression init = p.getInitialExpression();
- p.setInitialExpression(transform(init));
+ if (init != null) p.setInitialExpression(transform(init));
}
}
- super.visitConstructorOrMethod(node, isConstructor);
+ super.visitClosureExpression(expr);
}
@Override
- public void visitField(FieldNode node) {
+ public void visitField(final FieldNode node) {
visitAnnotations(node);
Expression init = node.getInitialExpression();
- node.setInitialValueExpression(transform(init));
+ if (init != null) node.setInitialValueExpression(transform(init));
}
@Override
- public void visitProperty(PropertyNode node) {
+ public void visitProperty(final PropertyNode node) {
visitAnnotations(node);
- Statement statement = node.getGetterBlock();
- visitClassCodeContainer(statement);
-
- statement = node.getSetterBlock();
- visitClassCodeContainer(statement);
+ visitClassCodeContainer(node.getGetterBlock());
+ visitClassCodeContainer(node.getSetterBlock());
}
// statements:
@Override
- public void visitAssertStatement(AssertStatement stmt) {
+ public void visitAssertStatement(final AssertStatement stmt) {
stmt.setBooleanExpression((BooleanExpression) transform(stmt.getBooleanExpression()));
stmt.setMessageExpression(transform(stmt.getMessageExpression()));
}
@Override
- public void visitCaseStatement(CaseStatement stmt) {
+ public void visitCaseStatement(final CaseStatement stmt) {
stmt.setExpression(transform(stmt.getExpression()));
stmt.getCode().visit(this);
}
@Override
- public void visitDoWhileLoop(DoWhileStatement stmt) {
+ public void visitDoWhileLoop(final DoWhileStatement stmt) {
+ stmt.getLoopBlock().visit(this);
stmt.setBooleanExpression((BooleanExpression) transform(stmt.getBooleanExpression()));
- super.visitDoWhileLoop(stmt);
}
@Override
- public void visitExpressionStatement(ExpressionStatement stmt) {
+ public void visitExpressionStatement(final ExpressionStatement stmt) {
stmt.setExpression(transform(stmt.getExpression()));
}
@Override
- public void visitForLoop(ForStatement stmt) {
+ public void visitForLoop(final ForStatement stmt) {
+ Parameter variable = stmt.getVariable();
+ visitAnnotations(variable);
+ Expression init = variable.getInitialExpression();
+ if (init != null) variable.setInitialExpression(transform(init));
+
stmt.setCollectionExpression(transform(stmt.getCollectionExpression()));
- super.visitForLoop(stmt);
+ stmt.getLoopBlock().visit(this);
}
@Override
- public void visitIfElse(IfStatement stmt) {
+ public void visitIfElse(final IfStatement stmt) {
stmt.setBooleanExpression((BooleanExpression) transform(stmt.getBooleanExpression()));
stmt.getIfBlock().visit(this);
stmt.getElseBlock().visit(this);
}
@Override
- public void visitReturnStatement(ReturnStatement stmt) {
+ public void visitReturnStatement(final ReturnStatement stmt) {
stmt.setExpression(transform(stmt.getExpression()));
}
@Override
- public void visitSwitch(SwitchStatement stmt) {
- Expression exp = stmt.getExpression();
- stmt.setExpression(transform(exp));
+ public void visitSwitch(final SwitchStatement stmt) {
+ stmt.setExpression(transform(stmt.getExpression()));
+ afterSwitchConditionExpressionVisited(stmt);
+
for (CaseStatement caseStatement : stmt.getCaseStatements()) {
caseStatement.visit(this);
}
@@ -137,32 +149,32 @@ public abstract class ClassCodeExpressionTransformer extends ClassCodeVisitorSup
}
@Override
- public void visitSynchronizedStatement(SynchronizedStatement stmt) {
+ public void visitSynchronizedStatement(final SynchronizedStatement stmt) {
stmt.setExpression(transform(stmt.getExpression()));
- super.visitSynchronizedStatement(stmt);
+ stmt.getCode().visit(this);
}
@Override
- public void visitThrowStatement(ThrowStatement stmt) {
+ public void visitThrowStatement(final ThrowStatement stmt) {
stmt.setExpression(transform(stmt.getExpression()));
}
@Override
- public void visitWhileLoop(WhileStatement stmt) {
+ public void visitWhileLoop(final WhileStatement stmt) {
stmt.setBooleanExpression((BooleanExpression) transform(stmt.getBooleanExpression()));
- super.visitWhileLoop(stmt);
+ stmt.getLoopBlock().visit(this);
}
/**
- * Set the source position of toSet including its property expression if it has one.
+ * Transfers the source position to target including its property expression if it has one.
*
- * @param toSet resulting node
- * @param origNode original node
+ * @param target resulting node
+ * @param source original node
*/
- protected static void setSourcePosition(Expression toSet, Expression origNode) {
- toSet.setSourcePosition(origNode);
- if (toSet instanceof PropertyExpression) {
- ((PropertyExpression) toSet).getProperty().setSourcePosition(origNode);
+ protected static void setSourcePosition(final Expression target, final Expression source) {
+ target.setSourcePosition(source);
+ if (target instanceof PropertyExpression) {
+ ((PropertyExpression) target).getProperty().setSourcePosition(source);
}
}
}
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java b/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
index 8b09b01664..e6938f172d 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
@@ -18,6 +18,7 @@
*/
package org.codehaus.groovy.ast;
+import org.codehaus.groovy.ast.expr.ClosureExpression;
import org.codehaus.groovy.ast.expr.DeclarationExpression;
import org.codehaus.groovy.ast.expr.Expression;
import org.codehaus.groovy.ast.stmt.AssertStatement;
@@ -112,10 +113,10 @@ public abstract class ClassCodeVisitorSupport extends CodeVisitorSupport impleme
protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) {
visitAnnotations(node);
- visitClassCodeContainer(node.getCode());
- for (Parameter param : node.getParameters()) {
- visitAnnotations(param);
+ for (Parameter parameter : node.getParameters()) {
+ visitAnnotations(parameter);
}
+ visitClassCodeContainer(node.getCode());
}
@Override
@@ -128,14 +129,11 @@ public abstract class ClassCodeVisitorSupport extends CodeVisitorSupport impleme
@Override
public void visitProperty(PropertyNode node) {
visitAnnotations(node);
- Statement statement = node.getGetterBlock();
- visitClassCodeContainer(statement);
-
- statement = node.getSetterBlock();
- visitClassCodeContainer(statement);
-
Expression init = node.getInitialExpression();
if (init != null) init.visit(this);
+
+ visitClassCodeContainer(node.getGetterBlock());
+ visitClassCodeContainer(node.getSetterBlock());
}
protected void visitClassCodeContainer(Statement code) {
@@ -148,6 +146,16 @@ public abstract class ClassCodeVisitorSupport extends CodeVisitorSupport impleme
}
}
+ @Override
+ public void visitClosureExpression(ClosureExpression expression) {
+ if (expression.isParameterSpecified()) {
+ for (Parameter parameter : expression.getParameters()) {
+ visitAnnotations(parameter);
+ }
+ }
+ super.visitClosureExpression(expression);
+ }
+
@Override
public void visitDeclarationExpression(DeclarationExpression expression) {
visitAnnotations(expression);
@@ -207,8 +215,8 @@ public abstract class ClassCodeVisitorSupport extends CodeVisitorSupport impleme
@Override
public void visitForLoop(ForStatement statement) {
visitStatement(statement);
- super.visitForLoop(statement);
visitAnnotations(statement.getVariable());
+ super.visitForLoop(statement);
}
@Override
diff --git a/src/main/java/org/codehaus/groovy/ast/CodeVisitorSupport.java b/src/main/java/org/codehaus/groovy/ast/CodeVisitorSupport.java
index 0500137006..542864e9ce 100644
--- a/src/main/java/org/codehaus/groovy/ast/CodeVisitorSupport.java
+++ b/src/main/java/org/codehaus/groovy/ast/CodeVisitorSupport.java
@@ -81,104 +81,111 @@ import org.codehaus.groovy.classgen.BytecodeExpression;
public abstract class CodeVisitorSupport implements GroovyCodeVisitor {
@Override
- public void visitBlockStatement(BlockStatement block) {
+ public void visitBlockStatement(final BlockStatement block) {
for (Statement statement : block.getStatements()) {
statement.visit(this);
}
}
@Override
- public void visitForLoop(ForStatement forLoop) {
- forLoop.getCollectionExpression().visit(this);
- forLoop.getLoopBlock().visit(this);
+ public void visitForLoop(final ForStatement statement) {
+ statement.getCollectionExpression().visit(this);
+ statement.getLoopBlock().visit(this);
}
@Override
- public void visitWhileLoop(WhileStatement loop) {
- loop.getBooleanExpression().visit(this);
- loop.getLoopBlock().visit(this);
+ public void visitWhileLoop(final WhileStatement statement) {
+ statement.getBooleanExpression().visit(this);
+ statement.getLoopBlock().visit(this);
}
@Override
- public void visitDoWhileLoop(DoWhileStatement loop) {
- loop.getLoopBlock().visit(this);
- loop.getBooleanExpression().visit(this);
+ public void visitDoWhileLoop(final DoWhileStatement statement) {
+ statement.getLoopBlock().visit(this);
+ statement.getBooleanExpression().visit(this);
}
@Override
- public void visitIfElse(IfStatement ifElse) {
- ifElse.getBooleanExpression().visit(this);
- ifElse.getIfBlock().visit(this);
- ifElse.getElseBlock().visit(this);
+ public void visitIfElse(final IfStatement statement) {
+ statement.getBooleanExpression().visit(this);
+ statement.getIfBlock().visit(this);
+ statement.getElseBlock().visit(this);
}
@Override
- public void visitExpressionStatement(ExpressionStatement statement) {
+ public void visitExpressionStatement(final ExpressionStatement statement) {
statement.getExpression().visit(this);
}
@Override
- public void visitReturnStatement(ReturnStatement statement) {
+ public void visitReturnStatement(final ReturnStatement statement) {
statement.getExpression().visit(this);
}
@Override
- public void visitAssertStatement(AssertStatement statement) {
+ public void visitAssertStatement(final AssertStatement statement) {
statement.getBooleanExpression().visit(this);
statement.getMessageExpression().visit(this);
}
@Override
- public void visitTryCatchFinally(TryCatchStatement statement) {
+ public void visitTryCatchFinally(final TryCatchStatement statement) {
+ for (Statement resource : statement.getResourceStatements()) {
+ resource.visit(this);
+ }
statement.getTryStatement().visit(this);
- for (CatchStatement catchStatement : statement.getCatchStatements()) {
+ for (Statement catchStatement : statement.getCatchStatements()) {
catchStatement.visit(this);
}
statement.getFinallyStatement().visit(this);
}
@Override
- public void visitEmptyStatement(EmptyStatement statement) {
+ public void visitEmptyStatement(final EmptyStatement statement) {
// noop
}
@Override
- public void visitSwitch(SwitchStatement statement) {
+ public void visitSwitch(final SwitchStatement statement) {
statement.getExpression().visit(this);
afterSwitchConditionExpressionVisited(statement);
- for (CaseStatement caseStatement : statement.getCaseStatements()) {
+ for (Statement caseStatement : statement.getCaseStatements()) {
caseStatement.visit(this);
}
statement.getDefaultStatement().visit(this);
}
- protected void afterSwitchConditionExpressionVisited(SwitchStatement statement) {}
+ protected void afterSwitchConditionExpressionVisited(final SwitchStatement statement) {
+ // hook for subclass to do something after switch condition, but before case(s)
+ }
@Override
- public void visitCaseStatement(CaseStatement statement) {
+ public void visitCaseStatement(final CaseStatement statement) {
statement.getExpression().visit(this);
statement.getCode().visit(this);
}
@Override
- public void visitBreakStatement(BreakStatement statement) {
+ public void visitBreakStatement(final BreakStatement statement) {
}
@Override
- public void visitContinueStatement(ContinueStatement statement) {
+ public void visitContinueStatement(final ContinueStatement statement) {
}
@Override
- public void visitSynchronizedStatement(SynchronizedStatement statement) {
+ public void visitSynchronizedStatement(final SynchronizedStatement statement) {
statement.getExpression().visit(this);
statement.getCode().visit(this);
}
@Override
- public void visitThrowStatement(ThrowStatement statement) {
+ public void visitThrowStatement(final ThrowStatement statement) {
statement.getExpression().visit(this);
}
+ //--------------------------------------------------------------------------
+
@Override
public void visitMethodCallExpression(MethodCallExpression call) {
call.getObjectExpression().visit(this);