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 2019/11/15 10:37:30 UTC
[groovy] branch master updated (4fb4dff -> 1cd9c49)
This is an automated email from the ASF dual-hosted git repository.
sunlan pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git.
from 4fb4dff GROOVY-8310: STC: check closure return type when method type has generic
new abf7dda Trivial refactoring: Remove redundant type arguments
new 102ceaa Trivial refactoring: Remove redundant type cast
new 1cd9c49 Trivial refactoring: Remove redundant `if` statement
The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../transform/stc/StaticTypeCheckingVisitor.java | 47 +++++++++++-----------
1 file changed, 23 insertions(+), 24 deletions(-)
[groovy] 02/03: Trivial refactoring: Remove redundant type cast
Posted by su...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
sunlan pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git
commit 102ceaa5171b4136ba5395962208ac1805acb6ed
Author: Daniel.Sun <re...@hotmail.com>
AuthorDate: Fri Nov 15 15:49:58 2019 +0800
Trivial refactoring: Remove redundant type cast
---
.../transform/stc/StaticTypeCheckingVisitor.java | 28 +++++++++++-----------
1 file changed, 14 insertions(+), 14 deletions(-)
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
index a64a53e..e29b5c4 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -484,7 +484,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
@Override
public void visitClassExpression(final ClassExpression expression) {
super.visitClassExpression(expression);
- ClassNode cn = (ClassNode) expression.getNodeMetaData(INFERRED_TYPE);
+ ClassNode cn = expression.getNodeMetaData(INFERRED_TYPE);
if (cn == null) {
storeType(expression, getType(expression));
}
@@ -636,7 +636,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// IMPLICIT_RECEIVER is handled elsewhere
// however other access needs to be fixed for private access
if (vexp.getNodeMetaData(IMPLICIT_RECEIVER) == null) {
- ClassNode owner = (ClassNode) vexp.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER);
+ ClassNode owner = vexp.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER);
if (owner != null) {
FieldNode veFieldNode = owner.getField(vexp.getName());
if (veFieldNode != null) {
@@ -836,7 +836,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (op == KEYWORD_IN || op == COMPARE_NOT_IN) {
// in case of the "in" operator, the receiver and the arguments are reversed
// so we use the reversedExpression and get the target method from it
- storeTargetMethod(expression, (MethodNode) reversedBinaryExpression.getNodeMetaData(DIRECT_METHOD_CALL_TARGET));
+ storeTargetMethod(expression, reversedBinaryExpression.getNodeMetaData(DIRECT_METHOD_CALL_TARGET));
} else if (op == LEFT_SQUARE_BRACKET
&& leftExpression instanceof VariableExpression
&& leftExpression.getNodeMetaData(INFERRED_TYPE) == null) {
@@ -2179,7 +2179,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
varX("{source}", source)
);
virtualDecl.visit(this);
- ClassNode newlyInferred = (ClassNode) virtualDecl.getNodeMetaData(INFERRED_TYPE);
+ ClassNode newlyInferred = virtualDecl.getNodeMetaData(INFERRED_TYPE);
return !missesGenericsTypes(newlyInferred) ? newlyInferred : null;
}
@@ -2469,7 +2469,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
return;
}
if (!extension.beforeVisitMethod(node)) {
- ErrorCollector collector = (ErrorCollector) node.getNodeMetaData(ERROR_COLLECTOR);
+ ErrorCollector collector = node.getNodeMetaData(ERROR_COLLECTOR);
if (collector != null) {
typeCheckingContext.getErrorCollector().addCollectorContents(collector);
} else {
@@ -2625,7 +2625,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
addAmbiguousErrorMessage(mn, name, args, call);
}
if (!callArgsVisited) {
- visitMethodCallArguments(receiver, argumentList, true, (MethodNode) call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET));
+ visitMethodCallArguments(receiver, argumentList, true, call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET));
}
}
} finally {
@@ -2853,7 +2853,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// to the corresponding parameters of the SAM type method
MethodNode methodForSAM = findSAM(classForSAM);
ClassNode[] parameterTypesForSAM = extractTypesFromParameters(methodForSAM.getParameters());
- ClassNode[] blockParameterTypes = (ClassNode[]) openBlock.getNodeMetaData(CLOSURE_ARGUMENTS);
+ ClassNode[] blockParameterTypes = openBlock.getNodeMetaData(CLOSURE_ARGUMENTS);
if (blockParameterTypes == null) {
Parameter[] p = openBlock.getParameters();
if (p == null) {
@@ -3310,7 +3310,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
listNode.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(subcallReturnType))});
storeType(call, listNode);
// store target method
- storeTargetMethod(call, (MethodNode) subcall.getNodeMetaData(DIRECT_METHOD_CALL_TARGET));
+ storeTargetMethod(call, subcall.getNodeMetaData(DIRECT_METHOD_CALL_TARGET));
typeCheckingContext.popEnclosingMethodCall();
return;
}
@@ -3528,7 +3528,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
// now that a method has been chosen, we are allowed to visit the closures
- MethodNode target = (MethodNode) call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
+ MethodNode target = call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
if (!callArgsVisited) {
visitMethodCallArguments(receiver, argumentList, true, target);
}
@@ -4197,7 +4197,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// o = new Object() // and eventually an object !
// in that case, the INFERRED_TYPE corresponds to the current inferred type, while
// DECLARATION_INFERRED_TYPE is the type which should be used for the initial type declaration
- ClassNode oldDIT = (ClassNode) exp.getNodeMetaData(DECLARATION_INFERRED_TYPE);
+ ClassNode oldDIT = exp.getNodeMetaData(DECLARATION_INFERRED_TYPE);
if (oldDIT != null) {
exp.putNodeMetaData(DECLARATION_INFERRED_TYPE, cn == null ? oldDIT : lowestUpperBound(oldDIT, cn));
} else {
@@ -4902,7 +4902,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
return result;
}
} else if (exp instanceof MethodCall) {
- MethodNode target = (MethodNode) exp.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
+ MethodNode target = exp.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
if (target != null) {
return getType(target);
}
@@ -4912,7 +4912,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private ClassNode getTypeFromClosureArguments(Parameter parameter, TypeCheckingContext.EnclosingClosure enclosingClosure) {
ClosureExpression closureExpression = enclosingClosure.getClosureExpression();
- ClassNode[] closureParamTypes = (ClassNode[]) closureExpression.getNodeMetaData(CLOSURE_ARGUMENTS);
+ ClassNode[] closureParamTypes = closureExpression.getNodeMetaData(CLOSURE_ARGUMENTS);
if (closureParamTypes == null) return null;
final Parameter[] parameters = closureExpression.getParameters();
String name = parameter.getName();
@@ -5570,7 +5570,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
List<ClassNode> classNodes = typeCheckingContext.closureSharedVariablesAssignmentTypes.get(var);
if (classNodes != null && classNodes.size() > 1) {
ClassNode lub = lowestUpperBound(classNodes);
- MethodNode methodNode = (MethodNode) call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
+ MethodNode methodNode = call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
// we must check that such a method exists on the LUB
Parameter[] parameters = methodNode.getParameters();
ClassNode[] params = extractTypesFromParameters(parameters);
@@ -5639,7 +5639,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
Variable var = findTargetVariable(expression);
if (var instanceof VariableExpression) {
VariableExpression ve = (VariableExpression) var;
- varOrigType.put(ve, (ClassNode) ve.getNodeMetaData(INFERRED_TYPE));
+ varOrigType.put(ve, ve.getNodeMetaData(INFERRED_TYPE));
}
}
}
[groovy] 01/03: Trivial refactoring: Remove redundant type arguments
Posted by su...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
sunlan pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git
commit abf7dda3a5b3626e3ce3de1e4703f8aa9ccebcf6
Author: Daniel.Sun <re...@hotmail.com>
AuthorDate: Fri Nov 15 15:48:43 2019 +0800
Trivial refactoring: Remove redundant type arguments
---
.../groovy/transform/stc/StaticTypeCheckingVisitor.java | 16 ++++++++--------
1 file changed, 8 insertions(+), 8 deletions(-)
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
index 5b803f0..a64a53e 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -3705,27 +3705,27 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
protected List<Receiver<String>> makeOwnerList(final Expression objectExpression) {
final ClassNode receiver = getType(objectExpression);
List<Receiver<String>> owners = new LinkedList<>();
- owners.add(Receiver.<String>make(receiver));
+ owners.add(Receiver.make(receiver));
if (isClassClassNodeWrappingConcreteType(receiver)) {
GenericsType clazzGT = receiver.getGenericsTypes()[0];
- owners.add(0, Receiver.<String>make(clazzGT.getType()));
+ owners.add(0, Receiver.make(clazzGT.getType()));
}
if (receiver.isInterface()) {
- owners.add(Receiver.<String>make(OBJECT_TYPE));
+ owners.add(Receiver.make(OBJECT_TYPE));
}
addSelfTypes(receiver, owners);
if (!typeCheckingContext.temporaryIfBranchTypeInformation.empty()) {
List<ClassNode> potentialReceiverType = getTemporaryTypesForExpression(objectExpression);
if (potentialReceiverType != null) {
for (ClassNode node : potentialReceiverType) {
- owners.add(Receiver.<String>make(node));
+ owners.add(Receiver.make(node));
}
}
}
if (typeCheckingContext.lastImplicitItType != null
&& objectExpression instanceof VariableExpression
&& ((VariableExpression) objectExpression).getName().equals("it")) {
- owners.add(Receiver.<String>make(typeCheckingContext.lastImplicitItType));
+ owners.add(Receiver.make(typeCheckingContext.lastImplicitItType));
}
if (typeCheckingContext.delegationMetadata != null
&& objectExpression instanceof VariableExpression
@@ -3733,7 +3733,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
&& /*isNested:*/typeCheckingContext.delegationMetadata.getParent() != null) {
owners.clear();
List<Receiver<String>> enclosingClass = Collections.singletonList(
- Receiver.<String>make(typeCheckingContext.getEnclosingClassNode()));
+ Receiver.make(typeCheckingContext.getEnclosingClassNode()));
addReceivers(owners, enclosingClass, typeCheckingContext.delegationMetadata.getParent(), "owner.");
}
return owners;
@@ -3742,7 +3742,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private static void addSelfTypes(final ClassNode receiver, final List<Receiver<String>> owners) {
LinkedHashSet<ClassNode> selfTypes = new LinkedHashSet<>();
for (ClassNode selfType : Traits.collectSelfTypes(receiver, selfTypes)) {
- owners.add(Receiver.<String>make(selfType));
+ owners.add(Receiver.make(selfType));
}
}
@@ -5751,6 +5751,6 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
}
- return variable.getOriginType();
+ return originType;
}
}
[groovy] 03/03: Trivial refactoring: Remove redundant `if` statement
Posted by su...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
sunlan pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git
commit 1cd9c49e2a62b89a08f150c46cc3ceeb22153f25
Author: Daniel.Sun <re...@hotmail.com>
AuthorDate: Fri Nov 15 16:13:43 2019 +0800
Trivial refactoring: Remove redundant `if` statement
---
.../org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
index e29b5c4..0725829 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -427,8 +427,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
protected boolean shouldSkipClassNode(final ClassNode node) {
- if (isSkipMode(node)) return true;
- return false;
+ return isSkipMode(node);
}
/**