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 2023/11/25 20:25:32 UTC
(groovy) branch GROOVY-11229 updated: Refine AST
This is an automated email from the ASF dual-hosted git repository.
sunlan pushed a commit to branch GROOVY-11229
in repository https://gitbox.apache.org/repos/asf/groovy.git
The following commit(s) were added to refs/heads/GROOVY-11229 by this push:
new 9011babe24 Refine AST
9011babe24 is described below
commit 9011babe24a37c410d177285978fc1d4f6fe83d9
Author: Daniel Sun <su...@apache.org>
AuthorDate: Sun Nov 26 04:25:09 2023 +0800
Refine AST
---
src/antlr/GroovyParser.g4 | 4 +-
.../apache/groovy/parser/antlr4/AstBuilder.java | 23 ++++---
.../codehaus/groovy/ast/expr/ClassExpression.java | 10 ++--
.../groovy/ast/expr/PatternClassExpression.java | 70 ++++++++++++++++++++++
.../groovy/ast/expr/PatternVariableExpression.java | 70 ----------------------
5 files changed, 87 insertions(+), 90 deletions(-)
diff --git a/src/antlr/GroovyParser.g4 b/src/antlr/GroovyParser.g4
index bfa6751f56..609dcf4f7b 100644
--- a/src/antlr/GroovyParser.g4
+++ b/src/antlr/GroovyParser.g4
@@ -343,7 +343,7 @@ options { baseContext = type; }
emptyDimsOpt
;
-patternVariableDeclaration
+patternType
: type variableDeclaratorId? // TODO support destructing
;
@@ -819,7 +819,7 @@ expression
right=expression #shiftExprAlt
// boolean relational expressions (level 7)
- | left=expression nls op=INSTANCEOF nls patternVariableDeclaration #relationalExprAlt
+ | left=expression nls op=INSTANCEOF nls patternType #relationalExprAlt
| left=expression nls op=(AS | NOT_INSTANCEOF) nls type #relationalExprAlt
| left=expression nls op=(LE | GE | GT | LT | IN | NOT_IN) nls right=expression #relationalExprAlt
diff --git a/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java b/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
index f871a99c44..2f972bbfd9 100644
--- a/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
+++ b/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
@@ -91,7 +91,7 @@ import org.codehaus.groovy.ast.expr.MethodPointerExpression;
import org.codehaus.groovy.ast.expr.MethodReferenceExpression;
import org.codehaus.groovy.ast.expr.NamedArgumentListExpression;
import org.codehaus.groovy.ast.expr.NotExpression;
-import org.codehaus.groovy.ast.expr.PatternVariableExpression;
+import org.codehaus.groovy.ast.expr.PatternClassExpression;
import org.codehaus.groovy.ast.expr.PostfixExpression;
import org.codehaus.groovy.ast.expr.PrefixExpression;
import org.codehaus.groovy.ast.expr.PropertyExpression;
@@ -3067,16 +3067,13 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
return configureAST(cast, ctx);
case INSTANCEOF:
- ctx.patternVariableDeclaration().putNodeMetaData(IS_INSIDE_INSTANCEOF_EXPR, Boolean.TRUE);
- PatternVariableExpression patternVariableExpression = this.visitPatternVariableDeclaration(ctx.patternVariableDeclaration());
- ClassNode type = patternVariableExpression.getOriginType();
- ClassExpression classExpression = configureAST(new ClassExpression(type), type);
- classExpression.setPatternVariableExpression(patternVariableExpression);
+ ctx.patternType().putNodeMetaData(IS_INSIDE_INSTANCEOF_EXPR, Boolean.TRUE);
+ PatternClassExpression patternClassExpression = this.visitPatternType(ctx.patternType());
return configureAST(
new BinaryExpression(
(Expression) this.visit(ctx.left),
this.createGroovyToken(ctx.op),
- classExpression),
+ patternClassExpression),
ctx);
case NOT_INSTANCEOF:
ctx.type().putNodeMetaData(IS_INSIDE_INSTANCEOF_EXPR, Boolean.TRUE);
@@ -4017,20 +4014,20 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- public PatternVariableExpression visitPatternVariableDeclaration(PatternVariableDeclarationContext ctx) {
+ public PatternClassExpression visitPatternType(PatternTypeContext ctx) {
if (isTrue(ctx, IS_INSIDE_INSTANCEOF_EXPR)) {
ctx.type().putNodeMetaData(IS_INSIDE_INSTANCEOF_EXPR, Boolean.TRUE);
}
ClassNode type = this.visitType(ctx.type());
- PatternVariableExpression patternVariableExpression;
+ PatternClassExpression patternClassExpression;
if (asBoolean(ctx.variableDeclaratorId())) {
VariableExpression variable = this.visitVariableDeclaratorId(ctx.variableDeclaratorId());
- patternVariableExpression = new PatternVariableExpression(variable.getName(), type);
- return configureAST(patternVariableExpression, variable);
+ patternClassExpression = new PatternClassExpression(variable, type);
} else {
- patternVariableExpression = new PatternVariableExpression(type);
- return configureAST(patternVariableExpression, ctx);
+ patternClassExpression = new PatternClassExpression(type);
}
+
+ return configureAST(patternClassExpression, ctx);
}
// type { ------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/ast/expr/ClassExpression.java b/src/main/java/org/codehaus/groovy/ast/expr/ClassExpression.java
index 315c704710..46223fff93 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/ClassExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/ClassExpression.java
@@ -26,7 +26,7 @@ import org.codehaus.groovy.ast.GroovyCodeVisitor;
* as when invoking a static method or accessing a static type
*/
public class ClassExpression extends Expression {
- private PatternVariableExpression patternVariableExpression;
+ private PatternClassExpression patternClassExpression;
public ClassExpression(ClassNode type) {
super.setType(type);
@@ -47,12 +47,12 @@ public class ClassExpression extends Expression {
return getType().getName();
}
- public PatternVariableExpression getPatternVariableExpression() {
- return patternVariableExpression;
+ public PatternClassExpression getPatternVariableExpression() {
+ return patternClassExpression;
}
- public void setPatternVariableExpression(PatternVariableExpression patternVariableExpression) {
- this.patternVariableExpression = patternVariableExpression;
+ public void setPatternVariableExpression(PatternClassExpression patternClassExpression) {
+ this.patternClassExpression = patternClassExpression;
}
@Override
diff --git a/src/main/java/org/codehaus/groovy/ast/expr/PatternClassExpression.java b/src/main/java/org/codehaus/groovy/ast/expr/PatternClassExpression.java
new file mode 100644
index 0000000000..cbd4bd468d
--- /dev/null
+++ b/src/main/java/org/codehaus/groovy/ast/expr/PatternClassExpression.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.codehaus.groovy.ast.expr;
+
+import org.codehaus.groovy.ast.ClassNode;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Represents class expression with pattern variable.
+ * <p>
+ * <pre><code>
+ * // for `someVar instanceof Person(String name, int age) p`,
+ * // the structure of `PatternClassExpression` is shown as follows:
+ * PatternClassExpression("p", Person).destructedPatternClassExpressionList =
+ * [PatternClassExpression("name", String), PatternClassExpression("age", int)]
+ *
+ * </code></pre>
+ *
+ * @since 5.0.0
+ */
+public class PatternClassExpression extends ClassExpression {
+ private static final VariableExpression DUMMY = new VariableExpression("<dummy>");
+ private final List<PatternClassExpression> destructedPatternClassExpressionList = new LinkedList<>();
+
+ private final VariableExpression patternVariable;
+
+ public PatternClassExpression(VariableExpression patternVariable, ClassNode type) {
+ super(type);
+ this.patternVariable = patternVariable;
+ }
+
+ public PatternClassExpression(ClassNode type) {
+ this(DUMMY, type);
+ }
+
+ public boolean isDummy() {
+ return DUMMY == patternVariable;
+ }
+
+ public void addDestructedPatternClassExpression(PatternClassExpression destructedPatternClassExpression) {
+ destructedPatternClassExpressionList.add(destructedPatternClassExpression);
+ }
+
+ public List<PatternClassExpression> getDestructedPatternClassExpressionList() {
+ return destructedPatternClassExpressionList;
+ }
+
+ @Override
+ public String toString() {
+ return super.toString() + "[patternType: " + getType().getName() + (isDummy() ? "" : " " + patternVariable.getName()) + "]";
+ }
+}
diff --git a/src/main/java/org/codehaus/groovy/ast/expr/PatternVariableExpression.java b/src/main/java/org/codehaus/groovy/ast/expr/PatternVariableExpression.java
deleted file mode 100644
index fbfe5a345f..0000000000
--- a/src/main/java/org/codehaus/groovy/ast/expr/PatternVariableExpression.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.codehaus.groovy.ast.expr;
-
-import org.codehaus.groovy.ast.ClassNode;
-
-import java.util.LinkedList;
-import java.util.List;
-
-/**
- * Represents pattern variable.
- * <p>
- * <pre><code>
- * // for `someVar instanceof Person(String name, int age) p`,
- * // the structure of `PatternVariableExpression` is shown as follows:
- * PatternVariableExpression("p", Person).destructedPatternVariableExpressionList =
- * [PatternVariableExpression("name", String), PatternVariableExpression("age", int)]
- *
- * </code></pre>
- *
- * @since 5.0.0
- */
-public class PatternVariableExpression extends VariableExpression {
- private static final String DUMMY = "<dummy>";
- private final List<PatternVariableExpression> destructedPatternVariableExpressionList = new LinkedList<>();
-
- public PatternVariableExpression(String name, ClassNode type) {
- super(name, type);
- }
-
- public PatternVariableExpression(ClassNode type) {
- this(DUMMY, type);
- }
-
- public boolean isDummy() {
- return DUMMY.equals(this.getName());
- }
-
- public void addDestructedPatternVariableExpression(PatternVariableExpression destructedPatternVariableExpression) {
- destructedPatternVariableExpressionList.add(destructedPatternVariableExpression);
- }
-
- public List<PatternVariableExpression> getDestructedPatternVariableExpressionList() {
- return destructedPatternVariableExpressionList;
- }
-
- @Override
- public String toString() {
- return super.toString() + "[pattern variable: " + this.getName() + (this.isDynamicTyped() ? "" : " type: " + getType())
- + (destructedPatternVariableExpressionList.isEmpty()
- ? ""
- : "(destructedPatternVariableExpressionList: " + destructedPatternVariableExpressionList + ")") + "]";
- }
-}