You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by pa...@apache.org on 2021/05/16 13:38:37 UTC
[groovy] branch master updated: GROOVY-9632: Java 8 Type Param
Annotation Not Generated in Byte Code (additional refactoring)
This is an automated email from the ASF dual-hosted git repository.
paulk 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 1cee6da GROOVY-9632: Java 8 Type Param Annotation Not Generated in Byte Code (additional refactoring)
1cee6da is described below
commit 1cee6da12349e500a30cca6c892000fbf87ccf5e
Author: Paul King <pa...@asert.com.au>
AuthorDate: Sun May 16 21:05:28 2021 +1000
GROOVY-9632: Java 8 Type Param Annotation Not Generated in Byte Code (additional refactoring)
---
.../apache/groovy/ast/tools/ClassNodeUtils.java | 4 +-
.../apache/groovy/ast/tools/ExpressionUtils.java | 22 +++--
.../apache/groovy/ast/tools/MethodNodeUtils.java | 2 +-
.../java/org/codehaus/groovy/ast/ClassHelper.java | 26 ++++--
.../java/org/codehaus/groovy/ast/ClassNode.java | 3 +-
.../java/org/codehaus/groovy/ast/GenericsType.java | 7 +-
.../java/org/codehaus/groovy/ast/ModuleNode.java | 5 +-
.../codehaus/groovy/ast/tools/GeneralUtils.java | 9 +-
.../groovy/ast/tools/WideningCategories.java | 17 ++--
.../groovy/classgen/AnnotationVisitor.java | 10 ++-
.../groovy/classgen/AsmClassGenerator.java | 24 +++---
.../codehaus/groovy/classgen/ExtendedVerifier.java | 4 +-
.../groovy/classgen/InnerClassVisitorHelper.java | 3 +-
.../groovy/classgen/VariableScopeVisitor.java | 3 +-
.../org/codehaus/groovy/classgen/Verifier.java | 10 ++-
.../groovy/classgen/asm/BytecodeHelper.java | 3 +-
.../groovy/classgen/asm/InvocationWriter.java | 11 ++-
.../classgen/asm/OptimizingStatementWriter.java | 3 +-
.../classgen/asm/indy/InvokeDynamicWriter.java | 3 +-
.../classgen/asm/sc/StaticInvocationWriter.java | 11 ++-
.../classgen/asm/sc/StaticTypesCallSiteWriter.java | 22 ++---
.../groovy/classgen/asm/util/TypeUtil.java | 80 ++++++++++++++++++
.../groovy/control/AnnotationConstantsVisitor.java | 24 ++++--
.../codehaus/groovy/control/OptimizerVisitor.java | 6 +-
.../codehaus/groovy/control/ResolveVisitor.java | 7 +-
.../groovy/runtime/ProxyGeneratorAdapter.java | 2 +-
.../groovy/tools/javac/JavaStubGenerator.java | 6 +-
.../transform/AbstractASTTransformation.java | 5 +-
.../transform/AutoCloneASTTransformation.java | 5 +-
.../transform/AutoImplementASTTransformation.java | 6 +-
.../transform/DelegateASTTransformation.java | 4 +-
.../TupleConstructorASTTransformation.java | 3 +-
.../transform/sc/StaticCompilationVisitor.java | 6 +-
.../transformers/BinaryExpressionTransformer.java | 24 ++++--
.../transformers/BooleanExpressionTransformer.java | 6 +-
.../MethodCallExpressionTransformer.java | 3 +-
.../transformers/RangeExpressionTransformer.java | 4 +-
.../transform/stc/StaticTypeCheckingSupport.java | 45 +++++-----
.../transform/stc/StaticTypeCheckingVisitor.java | 96 ++++++++++++----------
.../transform/trait/SuperCallTraitTransformer.java | 9 +-
.../transform/trait/TraitASTTransformation.java | 3 +-
.../groovy/transform/trait/TraitComposer.java | 6 +-
.../transform/trait/TraitReceiverTransformer.java | 5 +-
.../codehaus/groovy/transform/trait/Traits.java | 4 +-
44 files changed, 370 insertions(+), 191 deletions(-)
diff --git a/src/main/java/org/apache/groovy/ast/tools/ClassNodeUtils.java b/src/main/java/org/apache/groovy/ast/tools/ClassNodeUtils.java
index 887ee8d..6fd4e0b 100644
--- a/src/main/java/org/apache/groovy/ast/tools/ClassNodeUtils.java
+++ b/src/main/java/org/apache/groovy/ast/tools/ClassNodeUtils.java
@@ -19,7 +19,6 @@
package org.apache.groovy.ast.tools;
import org.apache.groovy.util.BeanUtils;
-import org.codehaus.groovy.ast.ClassHelper;
import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.ConstructorNode;
import org.codehaus.groovy.ast.FieldNode;
@@ -49,6 +48,7 @@ import java.util.function.Predicate;
import static org.apache.groovy.ast.tools.AnnotatedNodeUtils.isGenerated;
import static org.apache.groovy.ast.tools.AnnotatedNodeUtils.markAsGenerated;
import static org.codehaus.groovy.ast.ClassHelper.isPrimitiveType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
import static org.codehaus.groovy.runtime.ArrayTypeUtils.dimension;
import static org.codehaus.groovy.runtime.ArrayTypeUtils.elementType;
@@ -211,7 +211,7 @@ public class ClassNodeUtils {
public static void addDeclaredMethodsFromAllInterfaces(final ClassNode cNode, final Map<String, MethodNode> methodsMap) {
List<?> cnInterfaces = Arrays.asList(cNode.getInterfaces());
ClassNode parent = cNode.getSuperClass();
- while (parent != null && !parent.equals(ClassHelper.OBJECT_TYPE)) {
+ while (parent != null && !isObjectType(parent)) {
ClassNode[] interfaces = parent.getInterfaces();
for (ClassNode iface : interfaces) {
if (!cnInterfaces.contains(iface)) {
diff --git a/src/main/java/org/apache/groovy/ast/tools/ExpressionUtils.java b/src/main/java/org/apache/groovy/ast/tools/ExpressionUtils.java
index e5483ce..1080716 100644
--- a/src/main/java/org/apache/groovy/ast/tools/ExpressionUtils.java
+++ b/src/main/java/org/apache/groovy/ast/tools/ExpressionUtils.java
@@ -35,6 +35,14 @@ import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Arrays;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperByte;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperCharacter;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperDouble;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperFloat;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperInteger;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperLong;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperShort;
import static org.codehaus.groovy.syntax.Types.BITWISE_AND;
import static org.codehaus.groovy.syntax.Types.BITWISE_OR;
import static org.codehaus.groovy.syntax.Types.BITWISE_XOR;
@@ -126,22 +134,22 @@ public final class ExpressionUtils {
break;
}
if (result != null) {
- if (ClassHelper.Byte_TYPE.equals(wrapperType)) {
+ if (isWrapperByte(wrapperType)) {
return configure(be, new ConstantExpression(result.byteValue(), true));
}
- if (ClassHelper.Short_TYPE.equals(wrapperType)) {
+ if (isWrapperShort(wrapperType)) {
return configure(be, new ConstantExpression(result.shortValue(), true));
}
- if (ClassHelper.Long_TYPE.equals(wrapperType)) {
+ if (isWrapperLong(wrapperType)) {
return configure(be, new ConstantExpression(result.longValue(), true));
}
- if (ClassHelper.Integer_TYPE.equals(wrapperType) || ClassHelper.Character_TYPE.equals(wrapperType)) {
+ if (isWrapperInteger(wrapperType) || isWrapperCharacter(wrapperType)) {
return configure(be, new ConstantExpression(result.intValue(), true));
}
- if (ClassHelper.Float_TYPE.equals(wrapperType)) {
+ if (isWrapperFloat(wrapperType)) {
return configure(be, new ConstantExpression(result.floatValue(), true));
}
- if (ClassHelper.Double_TYPE.equals(wrapperType)) {
+ if (isWrapperDouble(wrapperType)) {
return configure(be, new ConstantExpression(result.doubleValue(), true));
}
return configure(be, new ConstantExpression(result, true));
@@ -312,7 +320,7 @@ public final class ExpressionUtils {
Expression lhs = transformInlineConstants(be.getLeftExpression());
Expression rhs = transformInlineConstants(be.getRightExpression());
if (be.getOperation().getType() == PLUS && lhs instanceof ConstantExpression && rhs instanceof ConstantExpression &&
- lhs.getType().equals(ClassHelper.STRING_TYPE) && rhs.getType().equals(ClassHelper.STRING_TYPE)) {
+ isStringType(lhs.getType()) && isStringType(rhs.getType())) {
// GROOVY-9855: inline string concat
return configure(be, new ConstantExpression(lhs.getText() + rhs.getText()));
}
diff --git a/src/main/java/org/apache/groovy/ast/tools/MethodNodeUtils.java b/src/main/java/org/apache/groovy/ast/tools/MethodNodeUtils.java
index f49400d..8a9dfa9 100644
--- a/src/main/java/org/apache/groovy/ast/tools/MethodNodeUtils.java
+++ b/src/main/java/org/apache/groovy/ast/tools/MethodNodeUtils.java
@@ -96,7 +96,7 @@ public class MethodNodeUtils {
}
break;
case 'i':
- if (name.charAt(1) == 's' && mNode.getParameters().length == 0 && (isPrimitiveBoolean(mNode.getReturnType()) /*|| mNode.getReturnType().equals(ClassHelper.Boolean_TYPE)*/)) {
+ if (name.charAt(1) == 's' && mNode.getParameters().length == 0 && (isPrimitiveBoolean(mNode.getReturnType()) /*|| isWrapperBoolean(mNode.getReturnType())*/)) {
return decapitalize(name.substring(2));
}
break;
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassHelper.java b/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
index 869e9f1..46597d0 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
@@ -71,6 +71,7 @@ import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveByte;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveChar;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveDouble;
@@ -78,6 +79,13 @@ import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveFloat;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveInt;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveLong;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveShort;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperByte;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperDouble;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperFloat;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperInteger;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperLong;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperShort;
/**
* Helper for {@link ClassNode} and classes handling them. Contains a set of
@@ -388,7 +396,7 @@ public class ClassHelper {
isPrimitiveFloat(cn) ||
isPrimitiveLong(cn) ||
isPrimitiveDouble(cn) ||
- cn.equals(STRING_TYPE) ||
+ isStringType(cn) ||
// the next items require conversion to int when initializing
isPrimitiveByte(cn) ||
isPrimitiveChar(cn) ||
@@ -397,12 +405,12 @@ public class ClassHelper {
public static boolean isNumberType(ClassNode cn) {
cn = cn.redirect();
- return cn.equals(Byte_TYPE) ||
- cn.equals(Short_TYPE) ||
- cn.equals(Integer_TYPE) ||
- cn.equals(Long_TYPE) ||
- cn.equals(Float_TYPE) ||
- cn.equals(Double_TYPE) ||
+ return isWrapperByte(cn) ||
+ isWrapperShort(cn) ||
+ isWrapperInteger(cn) ||
+ isWrapperLong(cn) ||
+ isWrapperFloat(cn) ||
+ isWrapperDouble(cn) ||
isPrimitiveByte(cn) ||
isPrimitiveShort(cn) ||
isPrimitiveInt(cn) ||
@@ -468,7 +476,7 @@ public class ClassHelper {
if (!Modifier.isAbstract(mi.getModifiers())) continue;
// ignore trait methods which have a default implementation
if (Traits.hasDefaultImplementation(mi)) continue;
- if (mi.getDeclaringClass().equals(OBJECT_TYPE)) continue;
+ if (isObjectType(mi.getDeclaringClass())) continue;
if (OBJECT_TYPE.getDeclaredMethod(mi.getName(), mi.getParameters()) != null) continue;
// we have two methods, so no SAM
@@ -496,7 +504,7 @@ public class ClassHelper {
int asp = found.getModifiers() & ABSTRACT_STATIC_PRIVATE;
int visible = found.getModifiers() & VISIBILITY;
if (visible != 0 && asp == 0) return true;
- if (c.equals(OBJECT_TYPE)) return false;
+ if (isObjectType(c)) return false;
return hasUsableImplementation(c.getSuperClass(), m);
}
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassNode.java b/src/main/java/org/codehaus/groovy/ast/ClassNode.java
index 22d0e70..57228a4 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassNode.java
@@ -50,6 +50,7 @@ import java.util.stream.Collectors;
import static java.util.Arrays.stream;
import static org.apache.groovy.ast.tools.MethodNodeUtils.getCodeAsBlock;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveVoid;
import static org.objectweb.asm.Opcodes.ACC_ABSTRACT;
import static org.objectweb.asm.Opcodes.ACC_ANNOTATION;
@@ -914,7 +915,7 @@ public class ClassNode extends AnnotatedNode {
if (isPrimitiveVoid(this)) {
return isPrimitiveVoid(type);
}
- if (type.equals(ClassHelper.OBJECT_TYPE)) {
+ if (isObjectType(type)) {
return true;
}
ClassNode node = this;
diff --git a/src/main/java/org/codehaus/groovy/ast/GenericsType.java b/src/main/java/org/codehaus/groovy/ast/GenericsType.java
index f2ea4e0..806c04d 100644
--- a/src/main/java/org/codehaus/groovy/ast/GenericsType.java
+++ b/src/main/java/org/codehaus/groovy/ast/GenericsType.java
@@ -28,6 +28,9 @@ import java.util.Map;
import java.util.Objects;
import java.util.Set;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isGroovyObjectType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
+
/**
* This class is used to describe generic type signatures for ClassNodes.
*
@@ -269,7 +272,7 @@ public class GenericsType extends ASTNode {
|| type.implementsInterface(superOrInterface)) {
return true;
}
- if (ClassHelper.GROOVY_OBJECT_TYPE.equals(superOrInterface) && type.getCompileUnit() != null) {
+ if (isGroovyObjectType(superOrInterface) && type.getCompileUnit() != null) {
// type is being compiled so it will implement GroovyObject later
return true;
}
@@ -355,7 +358,7 @@ public class GenericsType extends ASTNode {
return true;
}
}
- if (classNode.equals(ClassHelper.OBJECT_TYPE)) {
+ if (isObjectType(classNode)) {
return false;
}
ClassNode superClass = classNode.getUnresolvedSuperClass();
diff --git a/src/main/java/org/codehaus/groovy/ast/ModuleNode.java b/src/main/java/org/codehaus/groovy/ast/ModuleNode.java
index 6fcdaec..3f83395 100644
--- a/src/main/java/org/codehaus/groovy/ast/ModuleNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/ModuleNode.java
@@ -46,6 +46,7 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.param;
import static org.codehaus.groovy.ast.tools.GeneralUtils.params;
import static org.codehaus.groovy.ast.tools.GeneralUtils.stmt;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveVoid;
import static org.objectweb.asm.Opcodes.ACC_ABSTRACT;
import static org.objectweb.asm.Opcodes.ACC_FINAL;
@@ -412,8 +413,8 @@ public class ModuleNode extends ASTNode {
ClassNode argType = node.getParameters()[0].getType();
ClassNode retType = node.getReturnType();
- argTypeMatches = (argType.equals(ClassHelper.OBJECT_TYPE) || argType.getName().contains("String[]"));
- retTypeMatches = (isPrimitiveVoid(retType) || retType.equals(ClassHelper.OBJECT_TYPE));
+ argTypeMatches = (isObjectType(argType) || argType.getName().contains("String[]"));
+ retTypeMatches = (isPrimitiveVoid(retType) || isObjectType(retType));
if (retTypeMatches && argTypeMatches) {
if (found) {
throw new RuntimeException("Repetitive main method found.");
diff --git a/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java b/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java
index 1673b4a..cbed640 100644
--- a/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java
+++ b/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java
@@ -83,6 +83,7 @@ import java.util.Set;
import java.util.function.Consumer;
import static org.codehaus.groovy.antlr.PrimitiveHelper.getDefaultValueForPrimitive;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
/**
* Handy methods when working with the Groovy AST
@@ -465,7 +466,7 @@ public class GeneralUtils {
public static List<FieldNode> getSuperNonPropertyFields(final ClassNode cNode) {
List<FieldNode> result;
- if (cNode.equals(ClassHelper.OBJECT_TYPE)) {
+ if (isObjectType(cNode)) {
result = new ArrayList<>();
} else {
result = getSuperNonPropertyFields(cNode.getSuperClass());
@@ -480,7 +481,7 @@ public class GeneralUtils {
public static List<FieldNode> getSuperPropertyFields(final ClassNode cNode) {
List<FieldNode> result;
- if (cNode.equals(ClassHelper.OBJECT_TYPE)) {
+ if (isObjectType(cNode)) {
result = new ArrayList<>();
} else {
result = getSuperPropertyFields(cNode.getSuperClass());
@@ -505,7 +506,7 @@ public class GeneralUtils {
final boolean includeFields, final boolean includePseudoGetters, final boolean includePseudoSetters,
final boolean traverseSuperClasses, final boolean skipReadonly, final boolean reverse, final boolean allNames, final boolean includeStatic) {
List<PropertyNode> result = new ArrayList<>();
- if (!(cNode.equals(ClassHelper.OBJECT_TYPE)) && traverseSuperClasses && !reverse) {
+ if (!(isObjectType(cNode)) && traverseSuperClasses && !reverse) {
result.addAll(getAllProperties(names, origType, cNode.getSuperClass(), includeProperties, includeFields, includePseudoGetters, includePseudoSetters, true, skipReadonly));
}
if (includeProperties) {
@@ -540,7 +541,7 @@ public class GeneralUtils {
names.add(fNode.getName());
}
}
- if (!(cNode.equals(ClassHelper.OBJECT_TYPE)) && traverseSuperClasses && reverse) {
+ if (!(isObjectType(cNode)) && traverseSuperClasses && reverse) {
result.addAll(getAllProperties(names, origType, cNode.getSuperClass(), includeProperties, includeFields, includePseudoGetters, includePseudoSetters, true, skipReadonly));
}
return result;
diff --git a/src/main/java/org/codehaus/groovy/ast/tools/WideningCategories.java b/src/main/java/org/codehaus/groovy/ast/tools/WideningCategories.java
index 608cced..58d157f 100644
--- a/src/main/java/org/codehaus/groovy/ast/tools/WideningCategories.java
+++ b/src/main/java/org/codehaus/groovy/ast/tools/WideningCategories.java
@@ -36,8 +36,6 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
-import static org.codehaus.groovy.ast.ClassHelper.BigDecimal_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.BigInteger_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Number_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.OBJECT_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.VOID_TYPE;
@@ -45,6 +43,9 @@ import static org.codehaus.groovy.ast.ClassHelper.getUnwrapper;
import static org.codehaus.groovy.ast.ClassHelper.getWrapper;
import static org.codehaus.groovy.ast.ClassHelper.isNumberType;
import static org.codehaus.groovy.ast.ClassHelper.isPrimitiveType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigDecimalType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigIntegerType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveByte;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveChar;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveDouble;
@@ -149,7 +150,7 @@ public class WideningCategories {
* long category or a BigInteger.
*/
public static boolean isBigIntCategory(ClassNode type) {
- return type.equals(BigInteger_TYPE) || isLongCategory(type);
+ return isBigIntegerType(type) || isLongCategory(type);
}
/**
@@ -157,7 +158,7 @@ public class WideningCategories {
* BigInteger category or a BigDecimal.
*/
public static boolean isBigDecCategory(ClassNode type) {
- return type.equals(BigDecimal_TYPE) || isBigIntCategory(type);
+ return isBigDecimalType(type) || isBigIntCategory(type);
}
/**
@@ -334,7 +335,7 @@ public class WideningCategories {
if (a.isArray() && b.isArray()) {
return lowestUpperBound(a.getComponentType(), b.getComponentType(), interfacesImplementedByA, interfacesImplementedByB).makeArray();
}
- if (a.equals(OBJECT_TYPE) || b.equals(OBJECT_TYPE)) {
+ if (isObjectType(a) || isObjectType(b)) {
// one of the objects is at the top of the hierarchy
GenericsType[] gta = a.getGenericsTypes();
GenericsType[] gtb = b.getGenericsTypes();
@@ -613,7 +614,7 @@ public class WideningCategories {
this.interfaces = interfaces;
boolean usesGenerics;
Arrays.sort(interfaces, CLASS_NODE_COMPARATOR);
- compileTimeClassNode = upper.equals(OBJECT_TYPE) && interfaces.length>0?interfaces[0]:upper;
+ compileTimeClassNode = isObjectType(upper) && interfaces.length > 0 ? interfaces[0] : upper;
this.name = name;
usesGenerics = upper.isUsingGenerics();
List<GenericsType[]> genericsTypesList = new LinkedList<>();
@@ -637,7 +638,7 @@ public class WideningCategories {
setGenericsTypes(asArrayList.toArray(GenericsType.EMPTY_ARRAY));
}
StringBuilder sb = new StringBuilder();
- if (!upper.equals(OBJECT_TYPE)) sb.append(upper.getName());
+ if (!isObjectType(upper)) sb.append(upper.getName());
for (ClassNode anInterface : interfaces) {
if (sb.length()>0) {
sb.append(" or ");
@@ -676,7 +677,7 @@ public class WideningCategories {
@Override
public GenericsType asGenericsType() {
ClassNode[] ubs;
- if (upper.equals(OBJECT_TYPE)) {
+ if (isObjectType(upper)) {
ubs = interfaces; // Object is implicit
} else {
ubs = new ClassNode[interfaces.length + 1]; ubs[0] = upper;
diff --git a/src/main/java/org/codehaus/groovy/classgen/AnnotationVisitor.java b/src/main/java/org/codehaus/groovy/classgen/AnnotationVisitor.java
index 3974262..63b5075 100644
--- a/src/main/java/org/codehaus/groovy/classgen/AnnotationVisitor.java
+++ b/src/main/java/org/codehaus/groovy/classgen/AnnotationVisitor.java
@@ -43,6 +43,8 @@ import java.util.List;
import java.util.Map;
import static org.apache.groovy.ast.tools.ExpressionUtils.transformInlineConstants;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
/**
* An Annotation visitor responsible for:
@@ -184,9 +186,9 @@ public class AnnotationVisitor {
}
} else if (ClassHelper.isPrimitiveType(attrType)) {
visitConstantExpression(attrName, getConstantExpression(attrExp, attrType), ClassHelper.getWrapper(attrType));
- } else if (ClassHelper.STRING_TYPE.equals(attrType)) {
+ } else if (isStringType(attrType)) {
visitConstantExpression(attrName, getConstantExpression(attrExp, attrType), ClassHelper.STRING_TYPE);
- } else if (ClassHelper.CLASS_Type.equals(attrType)) {
+ } else if (isClassType(attrType)) {
if (!(attrExp instanceof ClassExpression || attrExp instanceof ClosureExpression)) {
addError("Only classes and closures can be used for attribute '" + attrName + "'", attrExp);
}
@@ -211,8 +213,8 @@ public class AnnotationVisitor {
if (attrType.isArray()) {
checkReturnType(attrType.getComponentType(), node);
} else if (ClassHelper.isPrimitiveType(attrType)) {
- } else if (ClassHelper.STRING_TYPE.equals(attrType)) {
- } else if (ClassHelper.CLASS_Type.equals(attrType)) {
+ } else if (isStringType(attrType)) {
+ } else if (isClassType(attrType)) {
} else if (attrType.isDerivedFrom(ClassHelper.Enum_Type)) {
} else if (isValidAnnotationClass(attrType)) {
} else {
diff --git a/src/main/java/org/codehaus/groovy/classgen/AsmClassGenerator.java b/src/main/java/org/codehaus/groovy/classgen/AsmClassGenerator.java
index 90d3d0a..cd8d6ad 100644
--- a/src/main/java/org/codehaus/groovy/classgen/AsmClassGenerator.java
+++ b/src/main/java/org/codehaus/groovy/classgen/AsmClassGenerator.java
@@ -129,6 +129,7 @@ import java.util.Optional;
import static org.apache.groovy.ast.tools.ClassNodeUtils.getField;
import static org.apache.groovy.ast.tools.ExpressionUtils.isThisOrSuper;
+import static org.codehaus.groovy.ast.ClassHelper.isPrimitiveType;
import static org.codehaus.groovy.ast.tools.GeneralUtils.attrX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.callX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.classX;
@@ -137,6 +138,8 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.getGetterName;
import static org.codehaus.groovy.ast.tools.GeneralUtils.getSetterName;
import static org.codehaus.groovy.ast.tools.GeneralUtils.propX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.thisPropX;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveByte;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveChar;
@@ -145,6 +148,7 @@ import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveFloat;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveInt;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveLong;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveShort;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.PROPERTY_OWNER;
import static org.objectweb.asm.Opcodes.AASTORE;
import static org.objectweb.asm.Opcodes.ACC_ENUM;
@@ -569,7 +573,7 @@ public class AsmClassGenerator extends ClassGenerator {
mv.visitInsn(RETURN);
} else {
ClassNode type = node.getReturnType();
- if (ClassHelper.isPrimitiveType(type)) {
+ if (isPrimitiveType(type)) {
mv.visitLdcInsn(Integer.valueOf(0));
controller.getOperandStack().push(ClassHelper.int_TYPE);
controller.getOperandStack().doGroovyCast(type);
@@ -616,10 +620,10 @@ public class AsmClassGenerator extends ClassGenerator {
} else {
visitAnnotationDefaultExpression(avl, componentType, exp);
}
- } else if (ClassHelper.isPrimitiveType(type) || type.equals(ClassHelper.STRING_TYPE)) {
+ } else if (isPrimitiveType(type) || isStringType(type)) {
ConstantExpression constExp = (ConstantExpression) exp;
av.visit(null, constExp.getValue());
- } else if (ClassHelper.CLASS_Type.equals(type)) {
+ } else if (isClassType(type)) {
ClassNode clazz = exp.getType();
Type t = Type.getType(BytecodeHelper.getTypeDescription(clazz));
av.visit(null, t);
@@ -910,16 +914,16 @@ public class AsmClassGenerator extends ClassGenerator {
ClassNode type = castExpression.getType();
Expression subExpression = castExpression.getExpression();
subExpression.visit(this);
- if (ClassHelper.OBJECT_TYPE.equals(type)) return;
+ if (isObjectType(type)) return;
if (castExpression.isCoerce()) {
controller.getOperandStack().doAsType(type);
} else {
- if (ExpressionUtils.isNullConstant(subExpression) && !ClassHelper.isPrimitiveType(type)) {
+ if (ExpressionUtils.isNullConstant(subExpression) && !isPrimitiveType(type)) {
controller.getOperandStack().replace(type);
} else {
ClassNode subExprType = controller.getTypeChooser().resolveType(subExpression, controller.getClassNode());
if (castExpression.isStrict() ||
- (!ClassHelper.isPrimitiveType(type) && WideningCategories.implementsInterfaceOrSubclassOf(subExprType, type))) {
+ (!isPrimitiveType(type) && WideningCategories.implementsInterfaceOrSubclassOf(subExprType, type))) {
BytecodeHelper.doCast(controller.getMethodVisitor(), type);
controller.getOperandStack().replace(type);
} else {
@@ -1175,7 +1179,7 @@ public class AsmClassGenerator extends ClassGenerator {
if (objectExpression instanceof ClassExpression) return false;
ClassNode objectExpressionType = controller.getTypeChooser().resolveType(objectExpression, controller.getClassNode());
- if (objectExpressionType.equals(ClassHelper.OBJECT_TYPE)) objectExpressionType = objectExpression.getType();
+ if (isObjectType(objectExpressionType)) objectExpressionType = objectExpression.getType();
return objectExpressionType.isDerivedFromGroovyObject();
}
@@ -1438,7 +1442,7 @@ public class AsmClassGenerator extends ClassGenerator {
if (controller.isInGeneratedFunction() && !controller.getCompileStack().isImplicitThis()) {
mv.visitMethodInsn(INVOKEVIRTUAL, "groovy/lang/Closure", "getThisObject", "()Ljava/lang/Object;", false);
ClassNode expectedType = controller.getTypeChooser().resolveType(thisOrSuper, controller.getOutermostClass());
- if (!ClassHelper.OBJECT_TYPE.equals(expectedType) && !ClassHelper.isPrimitiveType(expectedType)) {
+ if (!isObjectType(expectedType) && !isPrimitiveType(expectedType)) {
BytecodeHelper.doCast(mv, expectedType);
controller.getOperandStack().push(expectedType);
} else {
@@ -1484,7 +1488,7 @@ public class AsmClassGenerator extends ClassGenerator {
// generate a field node
FieldNode fn = controller.getClassNode().getDeclaredField(staticFieldName);
if (fn != null) {
- boolean type = fn.getType().equals(ClassHelper.CLASS_Type);
+ boolean type = isClassType(fn.getType());
boolean modifiers = fn.getModifiers() == ACC_STATIC + ACC_SYNTHETIC;
if (!type || !modifiers) {
String text = "";
@@ -1714,7 +1718,7 @@ public class AsmClassGenerator extends ClassGenerator {
int storeIns = AASTORE;
if (!elementType.isArray() || expression.hasInitializer()) {
- if (ClassHelper.isPrimitiveType(elementType)) {
+ if (isPrimitiveType(elementType)) {
int primType = 0;
if (isPrimitiveBoolean(elementType)) {
primType = T_BOOLEAN;
diff --git a/src/main/java/org/codehaus/groovy/classgen/ExtendedVerifier.java b/src/main/java/org/codehaus/groovy/classgen/ExtendedVerifier.java
index d5bb759..8be2836 100644
--- a/src/main/java/org/codehaus/groovy/classgen/ExtendedVerifier.java
+++ b/src/main/java/org/codehaus/groovy/classgen/ExtendedVerifier.java
@@ -21,7 +21,6 @@ package org.codehaus.groovy.classgen;
import org.codehaus.groovy.ast.AnnotatedNode;
import org.codehaus.groovy.ast.AnnotationNode;
import org.codehaus.groovy.ast.ClassCodeVisitorSupport;
-import org.codehaus.groovy.ast.ClassHelper;
import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.ConstructorNode;
import org.codehaus.groovy.ast.FieldNode;
@@ -68,6 +67,7 @@ import static org.codehaus.groovy.ast.AnnotationNode.TYPE_USE_TARGET;
import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpec;
import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpecRecurse;
import static org.codehaus.groovy.ast.tools.GenericsUtils.createGenericsSpec;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.evaluateExpression;
/**
@@ -411,7 +411,7 @@ public class ExtendedVerifier extends ClassCodeVisitorSupport {
List<ClassNode> ifaces = new ArrayList<>(Arrays.asList(next.getInterfaces()));
while (!ifaces.isEmpty()) {
ClassNode origInterface = ifaces.remove(0);
- if (!origInterface.equals(ClassHelper.OBJECT_TYPE)) {
+ if (!isObjectType(origInterface)) {
genericsSpec = createGenericsSpec(origInterface, genericsSpec);
ClassNode iNode = correctToGenericsSpecRecurse(genericsSpec, origInterface);
MethodNode found2 = getDeclaredMethodCorrected(genericsSpec, mn, iNode);
diff --git a/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitorHelper.java b/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitorHelper.java
index 12a9382..2a38402 100644
--- a/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitorHelper.java
+++ b/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitorHelper.java
@@ -43,6 +43,7 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.propX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.returnS;
import static org.codehaus.groovy.ast.tools.GeneralUtils.stmt;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
public abstract class InnerClassVisitorHelper extends ClassCodeVisitorSupport {
@@ -108,7 +109,7 @@ public abstract class InnerClassVisitorHelper extends ClassCodeVisitorSupport {
protected static int getObjectDistance(ClassNode cn) {
int count = 0;
- while (cn != null && !cn.equals(ClassHelper.OBJECT_TYPE)) {
+ while (cn != null && !isObjectType(cn)) {
cn = cn.getSuperClass();
count += 1;
}
diff --git a/src/main/java/org/codehaus/groovy/classgen/VariableScopeVisitor.java b/src/main/java/org/codehaus/groovy/classgen/VariableScopeVisitor.java
index 7513f60..e8ad0e3 100644
--- a/src/main/java/org/codehaus/groovy/classgen/VariableScopeVisitor.java
+++ b/src/main/java/org/codehaus/groovy/classgen/VariableScopeVisitor.java
@@ -58,6 +58,7 @@ import java.util.function.BiConsumer;
import static java.lang.reflect.Modifier.isFinal;
import static java.lang.reflect.Modifier.isStatic;
import static org.apache.groovy.ast.tools.MethodNodeUtils.getPropertyName;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
/**
* Initializes the variable scopes for an AST.
@@ -169,7 +170,7 @@ public class VariableScopeVisitor extends ClassCodeVisitorSupport {
private Variable findClassMember(final ClassNode node, final String name) {
final boolean abstractType = node.isAbstract();
- for (ClassNode cn = node; cn != null && !cn.equals(ClassHelper.OBJECT_TYPE); cn = cn.getSuperClass()) {
+ for (ClassNode cn = node; cn != null && !isObjectType(cn); cn = cn.getSuperClass()) {
if (cn.isScript()) {
return new DynamicVariable(name, false);
}
diff --git a/src/main/java/org/codehaus/groovy/classgen/Verifier.java b/src/main/java/org/codehaus/groovy/classgen/Verifier.java
index ddf8fab..1ff531a 100644
--- a/src/main/java/org/codehaus/groovy/classgen/Verifier.java
+++ b/src/main/java/org/codehaus/groovy/classgen/Verifier.java
@@ -114,9 +114,11 @@ import static org.codehaus.groovy.ast.tools.GenericsUtils.addMethodGenerics;
import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpec;
import static org.codehaus.groovy.ast.tools.GenericsUtils.createGenericsSpec;
import static org.codehaus.groovy.ast.tools.PropertyNodeUtils.adjustPropertyModifiersForMethod;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveDouble;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveLong;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperBoolean;
/**
* Verifies the AST node and adds any default AST code before bytecode generation occurs.
@@ -196,7 +198,7 @@ public class Verifier implements GroovyClassVisitor, Opcodes {
return ret;
}
ClassNode current = node;
- while (!(current.equals(ClassHelper.OBJECT_TYPE))) {
+ while (!(isObjectType(current))) {
current = current.getSuperClass();
if (current == null) break;
ret = current.getDeclaredField("metaClass");
@@ -647,10 +649,10 @@ public class Verifier implements GroovyClassVisitor, Opcodes {
Parameter[] params = node.getParameters();
if (params.length == 1) {
Parameter param = params[0];
- if (param.getType() == null || param.getType().equals(ClassHelper.OBJECT_TYPE)) {
+ if (param.getType() == null || isObjectType(param.getType())) {
param.setType(ClassHelper.STRING_TYPE.makeArray());
ClassNode returnType = node.getReturnType();
- if (returnType.equals(ClassHelper.OBJECT_TYPE)) {
+ if (isObjectType(returnType)) {
node.setReturnType(ClassHelper.VOID_TYPE);
}
}
@@ -718,7 +720,7 @@ public class Verifier implements GroovyClassVisitor, Opcodes {
if (getterBlock != null) {
visitGetter(node, field, getterBlock, getterModifiers, getterName);
- if (node.getGetterName() == null && getterName.startsWith("get") && (isPrimitiveBoolean(node.getType()) || node.getType().equals(ClassHelper.Boolean_TYPE))) {
+ if (node.getGetterName() == null && getterName.startsWith("get") && (isPrimitiveBoolean(node.getType()) || isWrapperBoolean(node.getType()))) {
String altGetterName = "is" + capitalize(name);
MethodNode altGetter = classNode.getGetterMethod(altGetterName, !node.isStatic());
if (methodNeedsReplacement(altGetter)) {
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java b/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java
index 0435716..b91431e 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java
@@ -33,6 +33,7 @@ import org.objectweb.asm.MethodVisitor;
import java.lang.reflect.Modifier;
import static org.codehaus.groovy.ast.ClassHelper.isPrimitiveType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveByte;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveChar;
@@ -464,7 +465,7 @@ public class BytecodeHelper {
}
public static void doCast(MethodVisitor mv, ClassNode type) {
- if (type.equals(ClassHelper.OBJECT_TYPE)) return;
+ if (isObjectType(type)) return;
if (isPrimitiveType(type) && !isPrimitiveVoid(type)) {
unbox(mv, type);
} else {
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/InvocationWriter.java b/src/main/java/org/codehaus/groovy/classgen/asm/InvocationWriter.java
index 497cfbf..f16fdd7 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/InvocationWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/InvocationWriter.java
@@ -57,7 +57,10 @@ import static org.apache.groovy.ast.tools.ExpressionUtils.isSuperExpression;
import static org.apache.groovy.ast.tools.ExpressionUtils.isThisExpression;
import static org.codehaus.groovy.ast.ClassHelper.isFunctionalInterface;
import static org.codehaus.groovy.ast.ClassHelper.isPrimitiveType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveVoid;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.isClassClassNodeWrappingConcreteType;
import static org.objectweb.asm.Opcodes.AALOAD;
import static org.objectweb.asm.Opcodes.ACC_FINAL;
@@ -180,7 +183,7 @@ public class InvocationWriter {
int stackLen = operandStack.getStackLength();
String owner = BytecodeHelper.getClassInternalName(declaringClass);
- if (opcode == INVOKEVIRTUAL && declaringClass.equals(ClassHelper.OBJECT_TYPE)) {
+ if (opcode == INVOKEVIRTUAL && isObjectType(declaringClass)) {
// avoid using a narrowed type if the method is defined on object because it can interfere
// with delegate type inference in static compilation mode and trigger a ClassCastException
receiverType = declaringClass;
@@ -430,7 +433,7 @@ public class InvocationWriter {
String methodName = null;
if (message instanceof CastExpression) {
CastExpression msg = (CastExpression) message;
- if (msg.getType().equals(ClassHelper.STRING_TYPE)) {
+ if (isStringType(msg.getType())) {
final Expression methodExpr = msg.getExpression();
if (methodExpr instanceof ConstantExpression) {
methodName = methodExpr.getText();
@@ -863,9 +866,9 @@ public class InvocationWriter {
ClassNode boxedType = os.box();
if (WideningCategories.implementsInterfaceOrSubclassOf(boxedType, targetType)) return;
MethodVisitor mv = controller.getMethodVisitor();
- if (ClassHelper.CLASS_Type.equals(targetType)) {
+ if (isClassType(targetType)) {
castToClassMethod.call(mv);
- } else if (ClassHelper.STRING_TYPE.equals(targetType)) {
+ } else if (isStringType(targetType)) {
castToStringMethod.call(mv);
} else if (targetType.isDerivedFrom(ClassHelper.Enum_Type)) {
(new ClassExpression(targetType)).visit(controller.getAcg());
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/OptimizingStatementWriter.java b/src/main/java/org/codehaus/groovy/classgen/asm/OptimizingStatementWriter.java
index 59c9087..8de50a9 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/OptimizingStatementWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/OptimizingStatementWriter.java
@@ -80,6 +80,7 @@ import static org.codehaus.groovy.ast.tools.WideningCategories.isIntCategory;
import static org.codehaus.groovy.ast.tools.WideningCategories.isLongCategory;
import static org.codehaus.groovy.classgen.asm.BinaryExpressionMultiTypeDispatcher.typeMap;
import static org.codehaus.groovy.classgen.asm.BinaryExpressionMultiTypeDispatcher.typeMapKeyNames;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigDecimalType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
import static org.objectweb.asm.Opcodes.ACC_FINAL;
import static org.objectweb.asm.Opcodes.GETSTATIC;
@@ -867,7 +868,7 @@ public class OptimizingStatementWriter extends StatementWriter {
if (op != Types.DIVIDE && op != Types.DIVIDE_EQUAL) return null;
ClassNode originalResultType = typeChooser.resolveType(binExp, node);
- if (!originalResultType.equals(BigDecimal_TYPE)
+ if (!isBigDecimalType(originalResultType)
|| !(isLongCategory(assignmentTartgetType) || isFloatingCategory(assignmentTartgetType))) {
return null;
}
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/indy/InvokeDynamicWriter.java b/src/main/java/org/codehaus/groovy/classgen/asm/indy/InvokeDynamicWriter.java
index d2735ac..e67b060 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/indy/InvokeDynamicWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/indy/InvokeDynamicWriter.java
@@ -45,6 +45,7 @@ import java.lang.invoke.MethodType;
import static org.codehaus.groovy.classgen.asm.BytecodeHelper.getTypeDescription;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperBoolean;
import static org.codehaus.groovy.vmplugin.v8.IndyInterface.CallType.CAST;
import static org.codehaus.groovy.vmplugin.v8.IndyInterface.CallType.GET;
import static org.codehaus.groovy.vmplugin.v8.IndyInterface.CallType.INIT;
@@ -195,7 +196,7 @@ public class InvokeDynamicWriter extends InvocationWriter {
public void coerce(ClassNode from, ClassNode target) {
ClassNode wrapper = ClassHelper.getWrapper(target);
makeIndyCall(invokeMethod, EmptyExpression.INSTANCE, false, false, "asType", new ClassExpression(wrapper));
- if (isPrimitiveBoolean(target) || ClassHelper.Boolean_TYPE.equals(target)) {
+ if (isPrimitiveBoolean(target) || isWrapperBoolean(target)) {
writeIndyCast(ClassHelper.OBJECT_TYPE,target);
} else {
BytecodeHelper.doCast(controller.getMethodVisitor(), wrapper);
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticInvocationWriter.java b/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticInvocationWriter.java
index 4b770da..13d30a8 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticInvocationWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticInvocationWriter.java
@@ -84,7 +84,10 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.nullX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.propX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.stmt;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isGStringType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveVoid;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
import static org.codehaus.groovy.transform.trait.Traits.isTrait;
import static org.objectweb.asm.Opcodes.ACONST_NULL;
import static org.objectweb.asm.Opcodes.ALOAD;
@@ -438,7 +441,7 @@ public class StaticInvocationWriter extends InvocationWriter {
if (lastPrmType.isArray() && (nArgs > nPrms || nArgs == nPrms - 1
|| (nArgs == nPrms && !lastArgType.isArray()
&& (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(lastArgType, lastPrmType.getComponentType())
- || ClassHelper.GSTRING_TYPE.equals(lastArgType) && ClassHelper.STRING_TYPE.equals(lastPrmType.getComponentType())))
+ || isGStringType(lastArgType) && isStringType(lastPrmType.getComponentType())))
)) {
OperandStack operandStack = controller.getOperandStack();
int stackLength = operandStack.getStackLength() + nArgs;
@@ -705,7 +708,7 @@ public class StaticInvocationWriter extends InvocationWriter {
if (visitor instanceof AsmClassGenerator) {
ClassNode topOperand = controller.getOperandStack().getTopOperand();
ClassNode type = getType();
- if (ClassHelper.GSTRING_TYPE.equals(topOperand) && ClassHelper.STRING_TYPE.equals(type)) {
+ if (isGStringType(topOperand) && isStringType(type)) {
// perform regular type conversion
controller.getOperandStack().doGroovyCast(type);
return;
@@ -740,12 +743,12 @@ public class StaticInvocationWriter extends InvocationWriter {
&& type.getClass() != DecompiledClassNode.class) {
type = declaringClass; // ex: LUB type
}
- if (ClassHelper.OBJECT_TYPE.equals(declaringClass)) {
+ if (isObjectType(declaringClass)) {
// checkcast not necessary because Object never evolves
// and it prevents a potential ClassCastException if the
// delegate of a closure is changed in a SC closure
type = ClassHelper.OBJECT_TYPE;
- } else if (ClassHelper.OBJECT_TYPE.equals(type)) {
+ } else if (isObjectType(type)) {
// can happen for compiler rewritten code, where type information is missing
type = declaringClass;
}
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesCallSiteWriter.java b/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesCallSiteWriter.java
index 0bfcde8..e9d5384 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesCallSiteWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesCallSiteWriter.java
@@ -58,16 +58,12 @@ import java.util.Map;
import static org.apache.groovy.ast.tools.ClassNodeUtils.getField;
import static org.apache.groovy.ast.tools.ExpressionUtils.isThisExpression;
import static org.apache.groovy.util.BeanUtils.capitalize;
-import static org.codehaus.groovy.ast.ClassHelper.BigDecimal_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.BigInteger_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Boolean_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.CLASS_Type;
import static org.codehaus.groovy.ast.ClassHelper.CLOSURE_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.GROOVY_OBJECT_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.Integer_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Iterator_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.LIST_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.Long_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.MAP_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Number_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.OBJECT_TYPE;
@@ -88,7 +84,13 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.isOrImplements;
import static org.codehaus.groovy.ast.tools.GeneralUtils.nullX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.propX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigDecimalType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigIntegerType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperInteger;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperLong;
import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.chooseBestMethod;
import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.findDGMMethodsByNameAndArguments;
import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf;
@@ -471,7 +473,7 @@ public class StaticTypesCallSiteWriter extends CallSiteWriter {
getterName = "is" + capitalize(propertyName);
getterNode = receiverType.getGetterMethod(getterName);
}
- if (getterNode != null && receiver instanceof ClassExpression && !CLASS_Type.equals(receiverType) && !getterNode.isStatic()) {
+ if (getterNode != null && receiver instanceof ClassExpression && !isClassType(receiverType) && !getterNode.isStatic()) {
return false;
}
@@ -623,7 +625,7 @@ public class StaticTypesCallSiteWriter extends CallSiteWriter {
writeOperatorCall(receiver, arguments, message);
return true;
}
- } else if (STRING_TYPE.equals(rType) && "plus".equals(message)) {
+ } else if (isStringType(rType) && "plus".equals(message)) {
writeStringPlusCall(receiver, message, arguments);
return true;
} else if ("getAt".equals(message)) {
@@ -746,13 +748,13 @@ public class StaticTypesCallSiteWriter extends CallSiteWriter {
operandStack.doGroovyCast(getWrapper(aType));
int m2 = operandStack.getStackLength();
MethodVisitor mv = controller.getMethodVisitor();
- if (BigDecimal_TYPE.equals(rType) && Integer_TYPE.equals(getWrapper(aType))) {
+ if (isBigDecimalType(rType) && isWrapperInteger(getWrapper(aType))) {
mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/runtime/DefaultGroovyMethods", "power", "(Ljava/math/BigDecimal;Ljava/lang/Integer;)Ljava/lang/Number;", false);
- } else if (BigInteger_TYPE.equals(rType) && Integer_TYPE.equals(getWrapper(aType))) {
+ } else if (isBigIntegerType(rType) && isWrapperInteger(getWrapper(aType))) {
mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/runtime/DefaultGroovyMethods", "power", "(Ljava/math/BigInteger;Ljava/lang/Integer;)Ljava/lang/Number;", false);
- } else if (Long_TYPE.equals(getWrapper(rType)) && Integer_TYPE.equals(getWrapper(aType))) {
+ } else if (isWrapperLong(getWrapper(rType)) && isWrapperInteger(getWrapper(aType))) {
mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/runtime/DefaultGroovyMethods", "power", "(Ljava/lang/Long;Ljava/lang/Integer;)Ljava/lang/Number;", false);
- } else if (Integer_TYPE.equals(getWrapper(rType)) && Integer_TYPE.equals(getWrapper(aType))) {
+ } else if (isWrapperInteger(getWrapper(rType)) && isWrapperInteger(getWrapper(aType))) {
mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/runtime/DefaultGroovyMethods", "power", "(Ljava/lang/Integer;Ljava/lang/Integer;)Ljava/lang/Number;", false);
} else {
mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/runtime/DefaultGroovyMethods", "power", "(Ljava/lang/Number;Ljava/lang/Number;)Ljava/lang/Number;", false);
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/util/TypeUtil.java b/src/main/java/org/codehaus/groovy/classgen/asm/util/TypeUtil.java
index b7f0b86..606ce64 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/util/TypeUtil.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/util/TypeUtil.java
@@ -26,7 +26,22 @@ import org.objectweb.asm.Type;
import java.util.Map;
+import static org.codehaus.groovy.ast.ClassHelper.BigDecimal_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.BigInteger_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.Boolean_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.Byte_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.CLASS_Type;
+import static org.codehaus.groovy.ast.ClassHelper.Character_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.DYNAMIC_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.Double_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.Float_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.GROOVY_OBJECT_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.GSTRING_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.Integer_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.Long_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.OBJECT_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.STRING_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.Short_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.VOID_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.boolean_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.byte_TYPE;
@@ -36,6 +51,7 @@ import static org.codehaus.groovy.ast.ClassHelper.float_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.int_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.long_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.short_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.void_WRAPPER_TYPE;
import static org.objectweb.asm.Opcodes.ALOAD;
import static org.objectweb.asm.Opcodes.ARETURN;
import static org.objectweb.asm.Opcodes.DLOAD;
@@ -140,6 +156,70 @@ public abstract class TypeUtil {
return type.redirect() == VOID_TYPE;
}
+ public static boolean isWrapperBoolean(ClassNode type) {
+ return type != null && type.redirect() == Boolean_TYPE;
+ }
+
+ public static boolean isWrapperCharacter(ClassNode type) {
+ return type != null && type.redirect() == Character_TYPE;
+ }
+
+ public static boolean isWrapperByte(ClassNode type) {
+ return type != null && type.redirect() == Byte_TYPE;
+ }
+
+ public static boolean isWrapperInteger(ClassNode type) {
+ return type != null && type.redirect() == Integer_TYPE;
+ }
+
+ public static boolean isWrapperLong(ClassNode type) {
+ return type != null && type.redirect() == Long_TYPE;
+ }
+
+ public static boolean isWrapperShort(ClassNode type) {
+ return type != null && type.redirect() == Short_TYPE;
+ }
+
+ public static boolean isWrapperDouble(ClassNode type) {
+ return type != null && type.redirect() == Double_TYPE;
+ }
+
+ public static boolean isWrapperFloat(ClassNode type) {
+ return type != null && type.redirect() == Float_TYPE;
+ }
+
+ public static boolean isWrapperVoid(ClassNode type) {
+ return type != null && type.redirect() == void_WRAPPER_TYPE;
+ }
+
+ public static boolean isBigIntegerType(ClassNode type) {
+ return type != null && type.redirect() == BigInteger_TYPE;
+ }
+
+ public static boolean isBigDecimalType(ClassNode type) {
+ return type != null && type.redirect() == BigDecimal_TYPE;
+ }
+
+ public static boolean isStringType(ClassNode type) {
+ return type != null && type.redirect() == STRING_TYPE;
+ }
+
+ public static boolean isGStringType(ClassNode type) {
+ return type != null && type.redirect() == GSTRING_TYPE;
+ }
+
+ public static boolean isObjectType(ClassNode type) {
+ return OBJECT_TYPE.equals(type);
+ }
+
+ public static boolean isGroovyObjectType(ClassNode type) {
+ return GROOVY_OBJECT_TYPE.equals(type);
+ }
+
+ public static boolean isClassType(ClassNode type) {
+ return CLASS_Type.equals(type);
+ }
+
public static String getDescriptionByType(ClassNode type) {
String desc = PRIMITIVE_TYPE_TO_DESCRIPTION_MAP.get(type);
diff --git a/src/main/java/org/codehaus/groovy/control/AnnotationConstantsVisitor.java b/src/main/java/org/codehaus/groovy/control/AnnotationConstantsVisitor.java
index a471a77..203db2c 100644
--- a/src/main/java/org/codehaus/groovy/control/AnnotationConstantsVisitor.java
+++ b/src/main/java/org/codehaus/groovy/control/AnnotationConstantsVisitor.java
@@ -33,6 +33,14 @@ import org.codehaus.groovy.classgen.Verifier;
import java.math.BigDecimal;
import static org.apache.groovy.ast.tools.ExpressionUtils.transformInlineConstants;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigDecimalType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperByte;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperCharacter;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperDouble;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperFloat;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperInteger;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperShort;
/**
* Visitor to resolve constants in annotation definitions.
@@ -94,28 +102,28 @@ public class AnnotationConstantsVisitor extends ClassCodeVisitorSupport {
private static Expression revertType(Expression val, ClassNode returnWrapperType) {
ConstantExpression ce = (ConstantExpression) val;
- if (ClassHelper.Character_TYPE.equals(returnWrapperType) && ClassHelper.STRING_TYPE.equals(val.getType())) {
+ if (isWrapperCharacter(returnWrapperType) && isStringType(val.getType())) {
return configure(val, Verifier.transformToPrimitiveConstantIfPossible((ConstantExpression) val));
}
ClassNode valWrapperType = ClassHelper.getWrapper(val.getType());
- if (ClassHelper.Integer_TYPE.equals(valWrapperType)) {
+ if (isWrapperInteger(valWrapperType)) {
Integer i = (Integer) ce.getValue();
- if (ClassHelper.Character_TYPE.equals(returnWrapperType)) {
+ if (isWrapperCharacter(returnWrapperType)) {
return configure(val, new ConstantExpression((char) i.intValue(), true));
}
- if (ClassHelper.Short_TYPE.equals(returnWrapperType)) {
+ if (isWrapperShort(returnWrapperType)) {
return configure(val, new ConstantExpression(i.shortValue(), true));
}
- if (ClassHelper.Byte_TYPE.equals(returnWrapperType)) {
+ if (isWrapperByte(returnWrapperType)) {
return configure(val, new ConstantExpression(i.byteValue(), true));
}
}
- if (ClassHelper.BigDecimal_TYPE.equals(valWrapperType)) {
+ if (isBigDecimalType(valWrapperType)) {
BigDecimal bd = (BigDecimal) ce.getValue();
- if (ClassHelper.Float_TYPE.equals(returnWrapperType)) {
+ if (isWrapperFloat(returnWrapperType)) {
return configure(val, new ConstantExpression(bd.floatValue(), true));
}
- if (ClassHelper.Double_TYPE.equals(returnWrapperType)) {
+ if (isWrapperDouble(returnWrapperType)) {
return configure(val, new ConstantExpression(bd.doubleValue(), true));
}
}
diff --git a/src/main/java/org/codehaus/groovy/control/OptimizerVisitor.java b/src/main/java/org/codehaus/groovy/control/OptimizerVisitor.java
index 33ed1da..5d5300a 100644
--- a/src/main/java/org/codehaus/groovy/control/OptimizerVisitor.java
+++ b/src/main/java/org/codehaus/groovy/control/OptimizerVisitor.java
@@ -19,7 +19,6 @@
package org.codehaus.groovy.control;
import org.codehaus.groovy.ast.ClassCodeExpressionTransformer;
-import org.codehaus.groovy.ast.ClassHelper;
import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.FieldNode;
import org.codehaus.groovy.ast.expr.ClosureExpression;
@@ -34,6 +33,7 @@ import java.util.List;
import java.util.Map;
import static org.codehaus.groovy.ast.ClassHelper.isPrimitiveType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isGroovyObjectType;
/**
* Visitor to produce several optimizations:
@@ -74,7 +74,7 @@ public class OptimizerVisitor extends ClassCodeExpressionTransformer {
ClassNode[] interfaces = node.getInterfaces();
boolean needsFix = false;
for (ClassNode classNode : interfaces) {
- if (classNode.equals(ClassHelper.GROOVY_OBJECT_TYPE)) {
+ if (isGroovyObjectType(classNode)) {
needsFix = true;
break;
}
@@ -82,7 +82,7 @@ public class OptimizerVisitor extends ClassCodeExpressionTransformer {
if (needsFix) {
List<ClassNode> newInterfaces = new ArrayList<ClassNode>(interfaces.length);
for (ClassNode classNode : interfaces) {
- if (!classNode.equals(ClassHelper.GROOVY_OBJECT_TYPE)) {
+ if (!isGroovyObjectType(classNode)) {
newInterfaces.add(classNode);
}
}
diff --git a/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java b/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
index 1cc1bf7..77a31ce 100644
--- a/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
+++ b/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
@@ -84,6 +84,7 @@ import java.util.function.Predicate;
import static groovy.lang.Tuple.tuple;
import static org.codehaus.groovy.ast.tools.ClosureUtils.getParametersSafe;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
/**
* Visitor to resolve Types and convert VariableExpression to
@@ -423,7 +424,7 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
// GROOVY-9243
toResolveFurther = false;
if (typeName.indexOf('.') == -1) {
- for (ClassNode cn = currentClass; cn != null && !cn.equals(ClassHelper.OBJECT_TYPE); cn = cn.getSuperClass()) {
+ for (ClassNode cn = currentClass; cn != null && !isObjectType(cn); cn = cn.getSuperClass()) {
ConstructedOuterNestedClassNode constructedOuterNestedClassNode =
tryToConstructOuterNestedClassNodeForBaseType(compileUnit, typeName, cn, setRedirectListener);
if (constructedOuterNestedClassNode != null) {
@@ -522,7 +523,7 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
ClassNode cn = currentClass;
Set<ClassNode> cycleCheck = new HashSet<>();
// GROOVY-4043: for type "X", try "A$X" with each type in the class hierarchy (except for Object)
- for (; cn != null && cycleCheck.add(cn) && !cn.equals(ClassHelper.OBJECT_TYPE); cn = cn.getSuperClass()) {
+ for (; cn != null && cycleCheck.add(cn) && !isObjectType(cn); cn = cn.getSuperClass()) {
if (setRedirect(type, cn)) return true;
// GROOVY-9866: unresolvable interfaces
}
@@ -1535,7 +1536,7 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
}
}
}
- if (parentToCompare.equals(ClassHelper.OBJECT_TYPE)) return;
+ if (isObjectType(parentToCompare)) return;
checkCyclicInheritance(originalNode, parentToCompare.getUnresolvedSuperClass(), null);
} else {
if (interfacesToCompare != null && interfacesToCompare.length > 0) {
diff --git a/src/main/java/org/codehaus/groovy/runtime/ProxyGeneratorAdapter.java b/src/main/java/org/codehaus/groovy/runtime/ProxyGeneratorAdapter.java
index de33450..422ab8a 100644
--- a/src/main/java/org/codehaus/groovy/runtime/ProxyGeneratorAdapter.java
+++ b/src/main/java/org/codehaus/groovy/runtime/ProxyGeneratorAdapter.java
@@ -565,7 +565,7 @@ public class ProxyGeneratorAdapter extends ClassVisitor {
Type[] args = Type.getArgumentTypes(desc);
if (emptyBody) {
Type returnType = Type.getReturnType(desc);
- if (returnType.equals(Type.VOID_TYPE)) {
+ if (returnType == Type.VOID_TYPE) {
mv.visitInsn(RETURN);
} else {
int loadIns = getLoadInsn(returnType);
diff --git a/src/main/java/org/codehaus/groovy/tools/javac/JavaStubGenerator.java b/src/main/java/org/codehaus/groovy/tools/javac/JavaStubGenerator.java
index f1cbcec..e274a44 100644
--- a/src/main/java/org/codehaus/groovy/tools/javac/JavaStubGenerator.java
+++ b/src/main/java/org/codehaus/groovy/tools/javac/JavaStubGenerator.java
@@ -79,6 +79,7 @@ import java.util.stream.Stream;
import static org.apache.groovy.ast.tools.ConstructorNodeUtils.getFirstIfSpecialConstructorCall;
import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpec;
import static org.codehaus.groovy.ast.tools.GenericsUtils.createGenericsSpec;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveByte;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveChar;
@@ -88,6 +89,7 @@ import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveInt;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveLong;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveShort;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveVoid;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
public class JavaStubGenerator {
private final boolean java5;
@@ -395,7 +397,7 @@ public class JavaStubGenerator {
if (params.length == 0 && name.equals("values")) continue;
if (params.length == 1
&& name.equals("valueOf")
- && params[0].getType().equals(ClassHelper.STRING_TYPE)) {
+ && isStringType(params[0].getType())) {
continue;
}
}
@@ -744,7 +746,7 @@ public class JavaStubGenerator {
Expression re = es.getExpression();
out.print(" default ");
ClassNode rt = methodNode.getReturnType();
- boolean classReturn = ClassHelper.CLASS_Type.equals(rt) || (rt.isArray() && ClassHelper.CLASS_Type.equals(rt.getComponentType()));
+ boolean classReturn = isClassType(rt) || (rt.isArray() && isClassType(rt.getComponentType()));
if (re instanceof ListExpression) {
out.print("{ ");
ListExpression le = (ListExpression) re;
diff --git a/src/main/java/org/codehaus/groovy/transform/AbstractASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/AbstractASTTransformation.java
index 8d4ff7c..0fcbd5a 100644
--- a/src/main/java/org/codehaus/groovy/transform/AbstractASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/AbstractASTTransformation.java
@@ -51,6 +51,7 @@ import java.util.Map;
import static groovy.transform.Undefined.isUndefined;
import static org.codehaus.groovy.ast.tools.GeneralUtils.getInstanceNonPropertyFieldNames;
import static org.codehaus.groovy.ast.tools.GeneralUtils.getSuperNonPropertyFields;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
public abstract class AbstractASTTransformation implements ASTTransformation, ErrorCollecting {
public static final ClassNode RETENTION_CLASSNODE = ClassHelper.makeWithoutCaching(Retention.class);
@@ -280,7 +281,7 @@ public abstract class AbstractASTTransformation implements ASTTransformation, Er
Map updatedGenericsSpec = new HashMap(genericsSpec);
while (!remaining.isEmpty()) {
ClassNode next = remaining.remove(0);
- if (!next.equals(ClassHelper.OBJECT_TYPE)) {
+ if (!isObjectType(next)) {
updatedGenericsSpec = GenericsUtils.createGenericsSpec(next, updatedGenericsSpec);
for (MethodNode mn : next.getMethods()) {
MethodNode correctedMethodNode = GenericsUtils.correctToGenericsSpec(updatedGenericsSpec, mn);
@@ -304,7 +305,7 @@ public abstract class AbstractASTTransformation implements ASTTransformation, Er
Map updatedGenericsSpec = new HashMap(genericsSpec);
while (!remaining.isEmpty()) {
ClassNode next = remaining.remove(0);
- if (!next.equals(ClassHelper.OBJECT_TYPE)) {
+ if (!isObjectType(next)) {
updatedGenericsSpec = GenericsUtils.createGenericsSpec(next, updatedGenericsSpec);
for (MethodNode mn : next.getMethods()) {
MethodNode correctedMethodNode = GenericsUtils.correctToGenericsSpec(updatedGenericsSpec, mn);
diff --git a/src/main/java/org/codehaus/groovy/transform/AutoCloneASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/AutoCloneASTTransformation.java
index 2b64793..4528a0e 100644
--- a/src/main/java/org/codehaus/groovy/transform/AutoCloneASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/AutoCloneASTTransformation.java
@@ -80,6 +80,7 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.returnS;
import static org.codehaus.groovy.ast.tools.GeneralUtils.stmt;
import static org.codehaus.groovy.ast.tools.GeneralUtils.ternaryX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.objectweb.asm.Opcodes.ACC_FINAL;
import static org.objectweb.asm.Opcodes.ACC_PROTECTED;
import static org.objectweb.asm.Opcodes.ACC_PUBLIC;
@@ -184,7 +185,7 @@ public class AutoCloneASTTransformation extends AbstractASTTransformation {
BlockStatement initBody = new BlockStatement();
Parameter initParam = param(GenericsUtils.nonGeneric(cNode), "other");
final Expression other = varX(initParam);
- boolean hasParent = !cNode.getSuperClass().equals(ClassHelper.OBJECT_TYPE);
+ boolean hasParent = !isObjectType(cNode.getSuperClass());
if (hasParent) {
initBody.addStatement(stmt(ctorX(ClassNode.SUPER, other)));
}
@@ -244,7 +245,7 @@ public class AutoCloneASTTransformation extends AbstractASTTransformation {
private static void addSimpleCloneHelperMethod(ClassNode cNode, List<FieldNode> fieldNodes, List<String> excludes) {
Parameter methodParam = new Parameter(GenericsUtils.nonGeneric(cNode), "other");
final Expression other = varX(methodParam);
- boolean hasParent = !cNode.getSuperClass().equals(ClassHelper.OBJECT_TYPE);
+ boolean hasParent = !isObjectType(cNode.getSuperClass());
BlockStatement methodBody = new BlockStatement();
if (hasParent) {
methodBody.addStatement(stmt(callSuperX("cloneOrCopyMembers", args(other))));
diff --git a/src/main/java/org/codehaus/groovy/transform/AutoImplementASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/AutoImplementASTTransformation.java
index 501ab4a..cd3080f 100644
--- a/src/main/java/org/codehaus/groovy/transform/AutoImplementASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/AutoImplementASTTransformation.java
@@ -57,6 +57,8 @@ import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpec;
import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpecRecurse;
import static org.codehaus.groovy.ast.tools.GenericsUtils.createGenericsSpec;
import static org.codehaus.groovy.ast.tools.ParameterUtils.parametersEqual;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isGroovyObjectType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
/**
@@ -172,7 +174,7 @@ public class AutoImplementASTTransformation extends AbstractASTTransformation {
while (!interfaces.isEmpty()) {
ClassNode origInterface = interfaces.remove(0);
// ignore java.lang.Object; also methods added by Verifier for GroovyObject are already good enough
- if (!origInterface.equals(ClassHelper.OBJECT_TYPE) && !origInterface.equals(ClassHelper.GROOVY_OBJECT_TYPE)) {
+ if (!isObjectType(origInterface) && !isGroovyObjectType(origInterface)) {
updatedGenericsSpec = createGenericsSpec(origInterface, updatedGenericsSpec);
ClassNode correctedInterface = correctToGenericsSpecRecurse(updatedGenericsSpec, origInterface);
for (MethodNode nextMethod : correctedInterface.getMethods()) {
@@ -197,7 +199,7 @@ public class AutoImplementASTTransformation extends AbstractASTTransformation {
}
// GROOVY-9816: remove entries for to-be-generated property access and mutate methods
- for (ClassNode cn = cNode; cn != null && !cn.equals(ClassHelper.OBJECT_TYPE); cn = cn.getSuperClass()) {
+ for (ClassNode cn = cNode; cn != null && !isObjectType(cn); cn = cn.getSuperClass()) {
for (PropertyNode pn : cn.getProperties()) {
if (!pn.getField().isFinal()) {
result.remove(pn.getSetterNameOrDefault() + ":" + pn.getType().getText() + ",");
diff --git a/src/main/java/org/codehaus/groovy/transform/DelegateASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/DelegateASTTransformation.java
index 7d01e19..ab6e1ee 100644
--- a/src/main/java/org/codehaus/groovy/transform/DelegateASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/DelegateASTTransformation.java
@@ -67,6 +67,8 @@ import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpec;
import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpecRecurse;
import static org.codehaus.groovy.ast.tools.GenericsUtils.createGenericsSpec;
import static org.codehaus.groovy.ast.tools.GenericsUtils.extractSuperClassGenerics;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isGroovyObjectType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
import static org.objectweb.asm.Opcodes.ACC_ABSTRACT;
import static org.objectweb.asm.Opcodes.ACC_FINAL;
@@ -136,7 +138,7 @@ public class DelegateASTTransformation extends AbstractASTTransformation {
}
if (delegate != null) {
- if (delegate.type.equals(ClassHelper.OBJECT_TYPE) || delegate.type.equals(ClassHelper.GROOVY_OBJECT_TYPE)) {
+ if (isObjectType(delegate.type) || isGroovyObjectType(delegate.type)) {
addError(MY_TYPE_NAME + " " + delegate.origin + " '" + delegate.name + "' has an inappropriate type: " + delegate.type.getName() +
". Please add an explicit type but not java.lang.Object or groovy.lang.GroovyObject.", parent);
return;
diff --git a/src/main/java/org/codehaus/groovy/transform/TupleConstructorASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/TupleConstructorASTTransformation.java
index fe87d0f..849b21f 100644
--- a/src/main/java/org/codehaus/groovy/transform/TupleConstructorASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/TupleConstructorASTTransformation.java
@@ -78,6 +78,7 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.propX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.stmt;
import static org.codehaus.groovy.ast.tools.GeneralUtils.throwS;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.transform.ImmutableASTTransformation.makeImmutable;
import static org.objectweb.asm.Opcodes.ACC_PUBLIC;
@@ -272,7 +273,7 @@ public class TupleConstructorASTTransformation extends AbstractASTTransformation
// or if there is already a @MapConstructor annotation
if (!params.isEmpty() && defaults && !hasMapCons && specialNamedArgCase) {
ClassNode firstParamType = params.get(0).getType();
- if (params.size() > 1 || firstParamType.equals(ClassHelper.OBJECT_TYPE)) {
+ if (params.size() > 1 || isObjectType(firstParamType)) {
String message = "The class " + cNode.getName() + " was incorrectly initialized via the map constructor with null.";
addSpecialMapConstructors(modifiers, cNode, message, false);
}
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java b/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
index 0351a7b..003a02b 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
@@ -66,10 +66,8 @@ import java.util.Map;
import java.util.Optional;
import java.util.Set;
-import static org.codehaus.groovy.ast.ClassHelper.Character_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.LIST_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.OBJECT_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.STRING_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.int_TYPE;
import static org.codehaus.groovy.ast.tools.GeneralUtils.args;
import static org.codehaus.groovy.ast.tools.GeneralUtils.assignS;
@@ -85,6 +83,8 @@ import static org.codehaus.groovy.ast.tools.GenericsUtils.applyGenericsContextTo
import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpecRecurse;
import static org.codehaus.groovy.ast.tools.GenericsUtils.createGenericsSpec;
import static org.codehaus.groovy.ast.tools.GenericsUtils.extractSuperClassGenerics;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperCharacter;
import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.BINARY_EXP_TARGET;
import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.COMPONENT_TYPE;
import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.DYNAMIC_OUTER_NODE_CALLBACK;
@@ -458,7 +458,7 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
ClassNode forLoopVariableType = statement.getVariableType();
ClassNode collectionType = getType(collectionExpression);
ClassNode componentType;
- if (Character_TYPE.equals(ClassHelper.getWrapper(forLoopVariableType)) && STRING_TYPE.equals(collectionType)) {
+ if (isWrapperCharacter(ClassHelper.getWrapper(forLoopVariableType)) && isStringType(collectionType)) {
// we allow auto-coercion here
componentType = forLoopVariableType;
} else {
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/transformers/BinaryExpressionTransformer.java b/src/main/java/org/codehaus/groovy/transform/sc/transformers/BinaryExpressionTransformer.java
index f49fc6d..0b88959 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/transformers/BinaryExpressionTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/transformers/BinaryExpressionTransformer.java
@@ -60,6 +60,14 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.isOrImplements;
import static org.codehaus.groovy.ast.tools.GeneralUtils.nullX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.ternaryX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigDecimalType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigIntegerType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperByte;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperDouble;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperFloat;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperInteger;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperLong;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperShort;
public class BinaryExpressionTransformer {
private static final MethodNode COMPARE_TO_METHOD = ClassHelper.COMPARABLE_TYPE.getMethods("compareTo").get(0);
@@ -371,28 +379,28 @@ public class BinaryExpressionTransformer {
}
private static Object convertConstant(final Number source, final ClassNode target) {
- if (ClassHelper.Byte_TYPE.equals(target)) {
+ if (isWrapperByte(target)) {
return source.byteValue();
}
- if (ClassHelper.Short_TYPE.equals(target)) {
+ if (isWrapperShort(target)) {
return source.shortValue();
}
- if (ClassHelper.Integer_TYPE.equals(target)) {
+ if (isWrapperInteger(target)) {
return source.intValue();
}
- if (ClassHelper.Long_TYPE.equals(target)) {
+ if (isWrapperLong(target)) {
return source.longValue();
}
- if (ClassHelper.Float_TYPE.equals(target)) {
+ if (isWrapperFloat(target)) {
return source.floatValue();
}
- if (ClassHelper.Double_TYPE.equals(target)) {
+ if (isWrapperDouble(target)) {
return source.doubleValue();
}
- if (ClassHelper.BigInteger_TYPE.equals(target)) {
+ if (isBigIntegerType(target)) {
return DefaultGroovyMethods.asType(source, BigInteger.class);
}
- if (ClassHelper.BigDecimal_TYPE.equals(target)) {
+ if (isBigDecimalType(target)) {
return DefaultGroovyMethods.asType(source, BigDecimal.class);
}
throw new IllegalArgumentException("Unsupported conversion");
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/transformers/BooleanExpressionTransformer.java b/src/main/java/org/codehaus/groovy/transform/sc/transformers/BooleanExpressionTransformer.java
index 412a014..7df844a 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/transformers/BooleanExpressionTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/transformers/BooleanExpressionTransformer.java
@@ -41,7 +41,9 @@ import java.lang.reflect.Modifier;
import java.util.Iterator;
import java.util.List;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperBoolean;
import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.findDGMMethodsByNameAndArguments;
import static org.objectweb.asm.Opcodes.DUP;
import static org.objectweb.asm.Opcodes.GOTO;
@@ -116,7 +118,7 @@ public class BooleanExpressionTransformer {
os.doGroovyCast(ClassHelper.boolean_TYPE);
return;
}
- if (type.equals(ClassHelper.Boolean_TYPE)) {
+ if (isWrapperBoolean(type)) {
MethodVisitor mv = controller.getMethodVisitor();
expression.visit(visitor);
Label unbox = new Label();
@@ -154,7 +156,7 @@ public class BooleanExpressionTransformer {
if (node instanceof ExtensionMethodNode) {
MethodNode dgmNode = ((ExtensionMethodNode) node).getExtensionMethodNode();
ClassNode owner = dgmNode.getParameters()[0].getType();
- if (ClassHelper.OBJECT_TYPE.equals(owner)) {
+ if (isObjectType(owner)) {
// we may inline a var!=null check instead of calling a helper method iff
// (1) the class doesn't define an asBoolean method (already tested)
// (2) no subclass defines an asBoolean method
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/transformers/MethodCallExpressionTransformer.java b/src/main/java/org/codehaus/groovy/transform/sc/transformers/MethodCallExpressionTransformer.java
index 356ea77..7c6fdb5 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/transformers/MethodCallExpressionTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/transformers/MethodCallExpressionTransformer.java
@@ -38,6 +38,7 @@ import org.codehaus.groovy.transform.stc.StaticTypesMarker;
import java.util.List;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperInteger;
import static org.objectweb.asm.Opcodes.ACC_PUBLIC;
import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC;
@@ -94,7 +95,7 @@ public class MethodCallExpressionTransformer {
// workaround for generated code in enums which use .next() returning a Number
indexType = ClassHelper.Integer_TYPE;
}
- if (argType != null && ClassHelper.Integer_TYPE.equals(indexType)) {
+ if (argType != null && isWrapperInteger(indexType)) {
BinaryExpression binaryExpression = new BinaryExpression(
objectExpression,
Token.newSymbol("[", indexExpr.getLineNumber(), indexExpr.getColumnNumber()),
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/transformers/RangeExpressionTransformer.java b/src/main/java/org/codehaus/groovy/transform/sc/transformers/RangeExpressionTransformer.java
index 9ff6d17..33564ad 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/transformers/RangeExpressionTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/transformers/RangeExpressionTransformer.java
@@ -33,6 +33,8 @@ import org.codehaus.groovy.transform.stc.StaticTypesMarker;
import java.util.List;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
+
/**
* This transformer focuses on ranges to produce optimized bytecode.
*/
@@ -45,7 +47,7 @@ public class RangeExpressionTransformer {
ConstructorNode target = null;
for (ConstructorNode constructor : declaredConstructors) {
final Parameter[] parameters = constructor.getParameters();
- if (parameters.length==3 && ClassHelper.boolean_TYPE.equals(parameters[0].getOriginType())) {
+ if (parameters.length==3 && isPrimitiveBoolean(parameters[0].getOriginType())) {
target = constructor;
break;
}
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
index 21b40c0..294d73d 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
@@ -77,9 +77,7 @@ import static org.apache.groovy.ast.tools.ClassNodeUtils.samePackageName;
import static org.apache.groovy.ast.tools.ExpressionUtils.isNullConstant;
import static org.codehaus.groovy.ast.ClassHelper.BigDecimal_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.BigInteger_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.Boolean_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Byte_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.CLASS_Type;
import static org.codehaus.groovy.ast.ClassHelper.CLOSURE_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.COLLECTION_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Character_TYPE;
@@ -112,7 +110,14 @@ import static org.codehaus.groovy.ast.ClassHelper.make;
import static org.codehaus.groovy.ast.ClassHelper.makeWithoutCaching;
import static org.codehaus.groovy.ast.ClassHelper.short_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.void_WRAPPER_TYPE;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigDecimalType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isGStringType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isGroovyObjectType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperBoolean;
import static org.codehaus.groovy.runtime.DefaultGroovyMethods.asBoolean;
import static org.codehaus.groovy.runtime.DefaultGroovyMethodsSupport.closeQuietly;
import static org.codehaus.groovy.syntax.Types.BITWISE_AND;
@@ -327,7 +332,7 @@ public abstract class StaticTypeCheckingSupport {
}
if (clazz.isArray()) {
ClassNode componentClass = clazz.getComponentType();
- if (!componentClass.equals(OBJECT_TYPE) && !isPrimitiveType(componentClass)) {
+ if (!isObjectType(componentClass) && !isPrimitiveType(componentClass)) {
if (componentClass.isInterface()) {
findDGMMethodsForClassNode(loader, OBJECT_TYPE.makeArray(), name, accumulator);
} else {
@@ -337,7 +342,7 @@ public abstract class StaticTypeCheckingSupport {
}
if (clazz.getSuperClass() != null) {
findDGMMethodsForClassNode(loader, clazz.getSuperClass(), name, accumulator);
- } else if (!clazz.equals(OBJECT_TYPE)) {
+ } else if (!isObjectType(clazz)) {
findDGMMethodsForClassNode(loader, OBJECT_TYPE, name, accumulator);
}
}
@@ -459,10 +464,10 @@ public abstract class StaticTypeCheckingSupport {
if (type.isArray() && toBeAssignedTo.isArray()) {
return isAssignableTo(type.getComponentType(), toBeAssignedTo.getComponentType());
}
- if (type.isDerivedFrom(GSTRING_TYPE) && STRING_TYPE.equals(toBeAssignedTo)) {
+ if (type.isDerivedFrom(GSTRING_TYPE) && isStringType(toBeAssignedTo)) {
return true;
}
- if (STRING_TYPE.equals(type) && toBeAssignedTo.isDerivedFrom(GSTRING_TYPE)) {
+ if (isStringType(type) && toBeAssignedTo.isDerivedFrom(GSTRING_TYPE)) {
return true;
}
if (implementsInterfaceOrIsSubclassOf(type, toBeAssignedTo)) {
@@ -675,7 +680,7 @@ public abstract class StaticTypeCheckingSupport {
}
if (GeneralUtils.isOrImplements(right, BaseStream_TYPE)) {
GenericsType elementType = GenericsUtils.parameterizeType(right, BaseStream_TYPE).getGenericsTypes()[0];
- return OBJECT_TYPE.equals(left.getComponentType()) // Object[] can accept any stream API element type(s)
+ return isObjectType(left.getComponentType()) // Object[] can accept any stream API element type(s)
|| (elementType.getLowerBound() == null && isCovariant(extractType(elementType), getWrapper(left.getComponentType())));
}
}
@@ -733,11 +738,11 @@ public abstract class StaticTypeCheckingSupport {
if (isNumberType(leftRedirect) && isNumberType(rightRedirect)) return true;
// left is a float/double and right is a BigDecimal
- if (WideningCategories.isFloatingCategory(leftRedirect) && BigDecimal_TYPE.equals(rightRedirect)) {
+ if (WideningCategories.isFloatingCategory(leftRedirect) && isBigDecimalType(rightRedirect)) {
return true;
}
- if (GROOVY_OBJECT_TYPE.equals(leftRedirect) && isBeingCompiled(right)) {
+ if (isGroovyObjectType(leftRedirect) && isBeingCompiled(right)) {
return true;
}
@@ -759,11 +764,11 @@ public abstract class StaticTypeCheckingSupport {
* @return true if it's an Object, String, boolean, Boolean or Class.
*/
public static boolean isWildcardLeftHandSide(final ClassNode node) {
- return (OBJECT_TYPE.equals(node)
- || STRING_TYPE.equals(node)
+ return (isObjectType(node)
+ || isStringType(node)
|| isPrimitiveBoolean(node)
- || Boolean_TYPE.equals(node)
- || CLASS_Type.equals(node));
+ || isWrapperBoolean(node)
+ || isClassType(node));
}
public static boolean isBeingCompiled(final ClassNode node) {
@@ -899,7 +904,7 @@ public abstract class StaticTypeCheckingSupport {
if (type.isArray() && superOrInterface.isArray()) {
return implementsInterfaceOrIsSubclassOf(type.getComponentType(), superOrInterface.getComponentType());
}
- if (GROOVY_OBJECT_TYPE.equals(superOrInterface) && !type.isInterface() && isBeingCompiled(type)) {
+ if (isGroovyObjectType(superOrInterface) && !type.isInterface() && isBeingCompiled(type)) {
return true;
}
return false;
@@ -948,7 +953,7 @@ public abstract class StaticTypeCheckingSupport {
while (cn != null && !cn.equals(compare)) {
cn = cn.getSuperClass();
dist += 1;
- if (OBJECT_TYPE.equals(cn))
+ if (isObjectType(cn))
dist += 1;
dist = (dist + 1) << 1;
}
@@ -1399,8 +1404,8 @@ public abstract class StaticTypeCheckingSupport {
}
if (receiver.isUsingGenerics()
- && receiver.equals(CLASS_Type)
- && !candidateMethod.getDeclaringClass().equals(CLASS_Type)) {
+ && isClassType(receiver)
+ && !isClassType(candidateMethod.getDeclaringClass())) {
return typeCheckMethodsWithGenerics(receiver.getGenericsTypes()[0].getType(), argumentTypes, candidateMethod);
}
@@ -1966,7 +1971,7 @@ public abstract class StaticTypeCheckingSupport {
if (gt.isWildcard() && gt.getLowerBound() == null) {
ClassNode[] upperBounds = gt.getUpperBounds();
return (upperBounds == null || upperBounds.length == 0 || (upperBounds.length == 1
- && upperBounds[0].equals(OBJECT_TYPE) && !upperBounds[0].isGenericsPlaceHolder()));
+ && isObjectType(upperBounds[0]) && !upperBounds[0].isGenericsPlaceHolder()));
}
return false;
}
@@ -2077,7 +2082,7 @@ public abstract class StaticTypeCheckingSupport {
* @return true if the class node is either a GString or the LUB of String and GString.
*/
public static boolean isGStringOrGStringStringLUB(final ClassNode node) {
- return GSTRING_TYPE.equals(node) || GSTRING_STRING_CLASSNODE.equals(node);
+ return isGStringType(node) || GSTRING_STRING_CLASSNODE.equals(node);
}
/**
@@ -2197,7 +2202,7 @@ public abstract class StaticTypeCheckingSupport {
*/
public static boolean isClassClassNodeWrappingConcreteType(final ClassNode classNode) {
GenericsType[] genericsTypes = classNode.getGenericsTypes();
- return CLASS_Type.equals(classNode)
+ return isClassType(classNode)
&& classNode.isUsingGenerics()
&& genericsTypes != null
&& !genericsTypes[0].isPlaceholder()
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 0cf11a7..101ad5e 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -154,7 +154,6 @@ import static org.codehaus.groovy.ast.ClassHelper.DYNAMIC_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Double_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Float_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.GROOVY_OBJECT_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.GSTRING_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Integer_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Iterator_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.LIST_TYPE;
@@ -184,7 +183,6 @@ import static org.codehaus.groovy.ast.ClassHelper.isPrimitiveType;
import static org.codehaus.groovy.ast.ClassHelper.isSAMType;
import static org.codehaus.groovy.ast.ClassHelper.long_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.short_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.void_WRAPPER_TYPE;
import static org.codehaus.groovy.ast.tools.ClosureUtils.getParametersSafe;
import static org.codehaus.groovy.ast.tools.ClosureUtils.getResolveStrategyName;
import static org.codehaus.groovy.ast.tools.ClosureUtils.hasImplicitParameter;
@@ -211,6 +209,11 @@ import static org.codehaus.groovy.ast.tools.WideningCategories.isLongCategory;
import static org.codehaus.groovy.ast.tools.WideningCategories.isNumberCategory;
import static org.codehaus.groovy.ast.tools.WideningCategories.lowestUpperBound;
import static org.codehaus.groovy.classgen.AsmClassGenerator.MINIMUM_BYTECODE_VERSION;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigDecimalType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isBigIntegerType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isGStringType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveByte;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveChar;
@@ -220,6 +223,15 @@ import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveInt;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveLong;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveShort;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveVoid;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isStringType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperByte;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperCharacter;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperDouble;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperFloat;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperInteger;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperLong;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperShort;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperVoid;
import static org.codehaus.groovy.syntax.Types.ASSIGN;
import static org.codehaus.groovy.syntax.Types.COMPARE_EQUAL;
import static org.codehaus.groovy.syntax.Types.COMPARE_NOT_EQUAL;
@@ -624,7 +636,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// GROOVY-9454
ClassNode inferredType = getInferredTypeFromTempInfo(vexp, null);
- if (inferredType != null && !inferredType.equals(OBJECT_TYPE)) {
+ if (inferredType != null && !isObjectType(inferredType)) {
vexp.putNodeMetaData(INFERRED_RETURN_TYPE, inferredType);
} else {
storeType(vexp, getType(vexp));
@@ -656,7 +668,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
ClassNode inferredType = localVariable.getNodeMetaData(INFERRED_TYPE);
inferredType = getInferredTypeFromTempInfo(localVariable, inferredType);
- if (inferredType != null && !inferredType.equals(OBJECT_TYPE)) {
+ if (inferredType != null && !isObjectType(inferredType)) {
vexp.putNodeMetaData(INFERRED_RETURN_TYPE, inferredType);
}
}
@@ -728,7 +740,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
super.visitRangeExpression(expression);
ClassNode fromType = getWrapper(getType(expression.getFrom()));
ClassNode toType = getWrapper(getType(expression.getTo()));
- if (Integer_TYPE.equals(fromType) && Integer_TYPE.equals(toType)) {
+ if (isWrapperInteger(fromType) && isWrapperInteger(toType)) {
storeType(expression, ClassHelper.make(IntRange.class));
} else {
ClassNode rangeType = RANGE_TYPE.getPlainNodeReference();
@@ -1218,7 +1230,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// constructor type : Dimension d = [100,200]
// In that case, more checks can be performed
if (!implementsInterfaceOrIsSubclassOf(LIST_TYPE, leftRedirect)
- && (!leftRedirect.isAbstract() || leftRedirect.isArray()) && !leftRedirect.equals(OBJECT_TYPE)
+ && (!leftRedirect.isAbstract() || leftRedirect.isArray()) && !isObjectType(leftRedirect)
&& !ArrayList_TYPE.isDerivedFrom(leftRedirect) && !LinkedHashSet_TYPE.isDerivedFrom(leftRedirect)) {
ClassNode[] types = getArgumentTypes(args(((ListExpression) rightExpression).getExpressions()));
MethodNode methodNode = checkGroovyStyleConstructor(leftRedirect, types, assignmentExpression);
@@ -1236,7 +1248,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private void addMapAssignmentConstructorErrors(final ClassNode leftRedirect, final Expression leftExpression, final Expression rightExpression) {
if ((leftExpression instanceof VariableExpression && ((VariableExpression) leftExpression).isDynamicTyped())
- || leftRedirect.equals(OBJECT_TYPE) || implementsInterfaceOrIsSubclassOf(leftRedirect, MAP_TYPE)) {
+ || isObjectType(leftRedirect) || implementsInterfaceOrIsSubclassOf(leftRedirect, MAP_TYPE)) {
return;
}
@@ -1385,7 +1397,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
* @param arguments the constructor arguments
*/
protected MethodNode checkGroovyStyleConstructor(final ClassNode node, final ClassNode[] arguments, final ASTNode source) {
- if (node.equals(OBJECT_TYPE) || TypeUtil.isDynamicTyped(node)) {
+ if (isObjectType(node) || TypeUtil.isDynamicTyped(node)) {
// in that case, we are facing a list constructor assigned to a def or object
return null;
}
@@ -1912,7 +1924,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
ClassNode collectionType = getType(collectionExpression);
ClassNode forLoopVariableType = forLoop.getVariableType();
ClassNode componentType;
- if (Character_TYPE.equals(getWrapper(forLoopVariableType)) && STRING_TYPE.equals(collectionType)) {
+ if (isWrapperCharacter(getWrapper(forLoopVariableType)) && isStringType(collectionType)) {
// we allow auto-coercion here
componentType = forLoopVariableType;
} else {
@@ -1961,7 +1973,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
GenericsType[] genericsTypes = intf.getGenericsTypes();
componentType = MAP_ENTRY_TYPE.getPlainNodeReference();
componentType.setGenericsTypes(genericsTypes);
- } else if (STRING_TYPE.equals(collectionType)) {
+ } else if (isStringType(collectionType)) {
componentType = STRING_TYPE;
} else if (ENUMERATION_TYPE.equals(collectionType)) {
// GROOVY-6123
@@ -2005,7 +2017,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (isBigIntCategory(typeRe)) {
// allow any internal number that is not a floating point one
resultType = type;
- } else if (typeRe.equals(STRING_TYPE) || typeRe.equals(GSTRING_TYPE)) {
+ } else if (isStringType(typeRe) || isGStringType(typeRe)) {
resultType = PATTERN_TYPE;
} else if (typeRe.equals(ArrayList_TYPE)) {
resultType = ArrayList_TYPE;
@@ -2107,13 +2119,13 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (isPrimitiveByte(type) || isPrimitiveShort(type) || isPrimitiveInt(type)) {
return int_TYPE;
}
- if (Byte_TYPE.equals(type) || Short_TYPE.equals(type) || Integer_TYPE.equals(type)) {
+ if (isWrapperByte(type) || isWrapperShort(type) || isWrapperInteger(type)) {
return Integer_TYPE;
}
if (isPrimitiveFloat(type)) {
return double_TYPE;
}
- if (Float_TYPE.equals(type)) {
+ if (isWrapperFloat(type)) {
return Double_TYPE;
}
return type;
@@ -2189,7 +2201,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (expression instanceof ConstructorCallExpression) {
inferDiamondType((ConstructorCallExpression) expression, inferredReturnType != null ? inferredReturnType : /*GROOVY-10080:*/DYNAMIC_TYPE);
}
- if (STRING_TYPE.equals(inferredReturnType) && isGStringOrGStringStringLUB(type)) {
+ if (isStringType(inferredReturnType) && isGStringOrGStringStringLUB(type)) {
type = STRING_TYPE; // GROOVY-9971: convert GString to String at point of return
} else if (inferredReturnType != null && !inferredReturnType.isGenericsPlaceHolder()
&& !type.isUsingGenerics() && !type.equals(inferredReturnType) && (inferredReturnType.isInterface()
@@ -2202,7 +2214,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (enclosingMethod != null && !enclosingMethod.isVoidMethod()) {
if (!isNullConstant(expression)
&& !isPrimitiveVoid(type)
- && !type.equals(void_WRAPPER_TYPE)
+ && !isWrapperVoid(type)
&& !checkCompatibleAssignmentTypes(enclosingMethod.getReturnType(), type, null, false)) {
if (!extension.handleIncompatibleReturnType(statement, type)) {
addStaticTypeError("Cannot return value of type " + prettyPrintType(type) + " on method returning type " + prettyPrintType(enclosingMethod.getReturnType()), expression);
@@ -2336,7 +2348,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
List<ClassNode> tempTypes = getTemporaryTypesForExpression(expression);
if (tempTypes != null && !tempTypes.isEmpty()) {
List<ClassNode> types = new ArrayList<>(tempTypes.size() + 1);
- if (expressionType != null && !expressionType.equals(ClassHelper.OBJECT_TYPE) // GROOVY-7333
+ if (expressionType != null && !isObjectType(expressionType) // GROOVY-7333
&& tempTypes.stream().noneMatch(t -> implementsInterfaceOrIsSubclassOf(t, expressionType))) { // GROOVY-9769
types.add(expressionType);
}
@@ -2435,7 +2447,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
super.visitMethodPointerExpression(expression);
Expression nameExpr = expression.getMethodName();
if (nameExpr instanceof ConstantExpression
- && getType(nameExpr).equals(STRING_TYPE)) {
+ && isStringType(getType(nameExpr))) {
String nameText = nameExpr.getText();
if ("new".equals(nameText)) {
@@ -3538,7 +3550,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (call.getNodeMetaData(DYNAMIC_RESOLUTION) == null
&& objectExpression instanceof ClassExpression
&& !directMethodCallCandidate.isStatic()
- && !declaringClass.equals(CLASS_Type)) {
+ && !isClassType(declaringClass)) {
addStaticTypeError("Non static method " + declaringClass.getName() + "#" + directMethodCallCandidate.getName() + " cannot be called from static context", call);
}
if (chosenReceiver == null) {
@@ -4161,10 +4173,10 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
ClassNode expressionType = getType(source);
if (targetType.isArray() && expressionType.isArray()) {
return checkCast(targetType.getComponentType(), varX("foo", expressionType.getComponentType()));
- } else if (isPrimitiveChar(targetType) && expressionType.equals(STRING_TYPE)
+ } else if (isPrimitiveChar(targetType) && isStringType(expressionType)
&& source instanceof ConstantExpression && source.getText().length() == 1) {
// ex: (char) 'c'
- } else if (targetType.equals(Character_TYPE) && (expressionType.equals(STRING_TYPE) || sourceIsNull)
+ } else if (isWrapperCharacter(targetType) && (isStringType(expressionType) || sourceIsNull)
&& (sourceIsNull || source instanceof ConstantExpression && source.getText().length() == 1)) {
// ex : (Character) 'c'
} else if (isNumberCategory(getWrapper(targetType)) && (isNumberCategory(getWrapper(expressionType)) || isPrimitiveChar(expressionType))) {
@@ -4247,7 +4259,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (targetType == null) targetType = sourceType;
inferDiamondType((ConstructorCallExpression) expr, targetType);
} else if (targetType != null && !isPrimitiveType(getUnwrapper(targetType))
- && !targetType.equals(OBJECT_TYPE) && missesGenericsTypes(sourceType)) {
+ && !isObjectType(targetType) && missesGenericsTypes(sourceType)) {
// unchecked assignment with ternary/elvis, like "List<T> list = listOfT ?: []"
// the inferred type is the RHS type "completed" with generics information from LHS
return GenericsUtils.parameterizeType(targetType, sourceType.getPlainNodeReference());
@@ -4391,12 +4403,12 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
// as anything can be assigned to a String, Class or [Bb]oolean, return the left type instead
- if (isWildcardLeftHandSide(initialType) && !initialType.equals(OBJECT_TYPE)) {
+ if (isWildcardLeftHandSide(initialType) && !isObjectType(initialType)) {
return initialType;
}
}
- if (!leftRedirect.equals(OBJECT_TYPE)) {
+ if (!isObjectType(leftRedirect)) {
if (rightExpression instanceof ListExpression) {
if (LIST_TYPE.equals(leftRedirect)
|| ITERABLE_TYPE.equals(leftRedirect)
@@ -4578,25 +4590,25 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
protected static ClassNode getGroupOperationResultType(final ClassNode a, final ClassNode b) {
if (isBigIntCategory(a) && isBigIntCategory(b)) return BigInteger_TYPE;
if (isBigDecCategory(a) && isBigDecCategory(b)) return BigDecimal_TYPE;
- if (BigDecimal_TYPE.equals(a) || BigDecimal_TYPE.equals(b)) return BigDecimal_TYPE;
- if (BigInteger_TYPE.equals(a) || BigInteger_TYPE.equals(b)) {
+ if (isBigDecimalType(a) || isBigDecimalType(b)) return BigDecimal_TYPE;
+ if (isBigIntegerType(a) || isBigIntegerType(b)) {
if (isBigIntCategory(a) && isBigIntCategory(b)) return BigInteger_TYPE;
return BigDecimal_TYPE;
}
if (isPrimitiveDouble(a) || isPrimitiveDouble(b)) return double_TYPE;
- if (Double_TYPE.equals(a) || Double_TYPE.equals(b)) return Double_TYPE;
+ if (isWrapperDouble(a) || isWrapperDouble(b)) return Double_TYPE;
if (isPrimitiveFloat(a) || isPrimitiveFloat(b)) return float_TYPE;
- if (Float_TYPE.equals(a) || Float_TYPE.equals(b)) return Float_TYPE;
+ if (isWrapperFloat(a) || isWrapperFloat(b)) return Float_TYPE;
if (isPrimitiveLong(a) || isPrimitiveLong(b)) return long_TYPE;
- if (Long_TYPE.equals(a) || Long_TYPE.equals(b)) return Long_TYPE;
+ if (isWrapperLong(a) || isWrapperLong(b)) return Long_TYPE;
if (isPrimitiveInt(a) || isPrimitiveInt(b)) return int_TYPE;
- if (Integer_TYPE.equals(a) || Integer_TYPE.equals(b)) return Integer_TYPE;
+ if (isWrapperInteger(a) || isWrapperInteger(b)) return Integer_TYPE;
if (isPrimitiveShort(a) || isPrimitiveShort(b)) return short_TYPE;
- if (Short_TYPE.equals(a) || Short_TYPE.equals(b)) return Short_TYPE;
+ if (isWrapperShort(a) || isWrapperShort(b)) return Short_TYPE;
if (isPrimitiveByte(a) || isPrimitiveByte(b)) return byte_TYPE;
- if (Byte_TYPE.equals(a) || Byte_TYPE.equals(b)) return Byte_TYPE;
+ if (isWrapperByte(a) || isWrapperByte(b)) return Byte_TYPE;
if (isPrimitiveChar(a) || isPrimitiveChar(b)) return char_TYPE;
- if (Character_TYPE.equals(a) || Character_TYPE.equals(b)) return Character_TYPE;
+ if (isWrapperCharacter(a) || isWrapperCharacter(b)) return Character_TYPE;
return Number_TYPE;
}
@@ -4901,12 +4913,12 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
}
- if (receiver.equals(CLASS_Type) && receiver.getGenericsTypes() != null) {
+ if (isClassType(receiver) && receiver.getGenericsTypes() != null) {
List<MethodNode> result = findMethod(receiver.getGenericsTypes()[0].getType(), name, args);
if (!result.isEmpty()) return result;
}
- if (GSTRING_TYPE.equals(receiver)) {
+ if (isGStringType(receiver)) {
return findMethod(STRING_TYPE, name, args);
}
if (isBeingCompiled(receiver)) {
@@ -5162,7 +5174,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
GenericsType[] genericsTypes = listType.getGenericsTypes();
if ((genericsTypes == null
|| genericsTypes.length == 0
- || (genericsTypes.length == 1 && OBJECT_TYPE.equals(genericsTypes[0].getType())))) {
+ || (genericsTypes.length == 1 && isObjectType(genericsTypes[0].getType())))) {
// maybe we can infer the component type
List<ClassNode> nodes = new ArrayList<>(nExpressions);
for (Expression expression : expressions) {
@@ -5203,7 +5215,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
GenericsType[] genericsTypes = mapType.getGenericsTypes();
if (genericsTypes == null
|| genericsTypes.length < 2
- || (genericsTypes.length == 2 && OBJECT_TYPE.equals(genericsTypes[0].getType()) && OBJECT_TYPE.equals(genericsTypes[1].getType()))) {
+ || (genericsTypes.length == 2 && isObjectType(genericsTypes[0].getType()) && isObjectType(genericsTypes[1].getType()))) {
List<ClassNode> keyTypes = new ArrayList<>(nExpressions);
List<ClassNode> valueTypes = new ArrayList<>(nExpressions);
for (MapEntryExpression entryExpression : entryExpressions) {
@@ -5212,7 +5224,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
ClassNode keyType = lowestUpperBound(keyTypes);
ClassNode valueType = lowestUpperBound(valueTypes);
- if (!OBJECT_TYPE.equals(keyType) || !OBJECT_TYPE.equals(valueType)) {
+ if (!isObjectType(keyType) || !isObjectType(valueType)) {
mapType = mapType.getPlainNodeReference();
mapType.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(keyType)), new GenericsType(wrapTypeIfNecessary(valueType))});
}
@@ -5397,7 +5409,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// and unknown generics
if (!GenericsUtils.hasUnresolvedGenerics(at)) continue;
- while (!at.equals(pt) && !at.equals(OBJECT_TYPE)) {
+ while (!at.equals(pt) && !isObjectType(at)) {
ClassNode sc = GenericsUtils.getSuperClass(at, pt);
at = applyGenericsContext(GenericsUtils.extractPlaceholders(at), sc);
}
@@ -5606,10 +5618,10 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private static Map<GenericsTypeName, GenericsType> resolvePlaceHoldersFromDeclaration(final ClassNode receiver, final ClassNode declaration, final MethodNode method, final boolean isStaticTarget) {
Map<GenericsTypeName, GenericsType> resolvedPlaceholders;
if (isStaticTarget
- && CLASS_Type.equals(receiver)
+ && isClassType(receiver)
&& receiver.getGenericsTypes() != null
&& receiver.getGenericsTypes().length > 0
- && !OBJECT_TYPE.equals(receiver.getGenericsTypes()[0].getType())) {
+ && !isObjectType(receiver.getGenericsTypes()[0].getType())) {
return resolvePlaceHoldersFromDeclaration(receiver.getGenericsTypes()[0].getType(), declaration, method, isStaticTarget);
} else {
resolvedPlaceholders = extractPlaceHolders(method, receiver, declaration);
@@ -5618,7 +5630,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
private static Map<GenericsTypeName, GenericsType> extractPlaceHolders(final MethodNode method, ClassNode receiver, final ClassNode declaringClass) {
- if (declaringClass.equals(OBJECT_TYPE)) {
+ if (isObjectType(declaringClass)) {
Map<GenericsTypeName, GenericsType> resolvedPlaceholders = new HashMap<>();
if (method != null) addMethodLevelDeclaredGenerics(method, resolvedPlaceholders);
return resolvedPlaceholders;
@@ -5666,7 +5678,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
boolean isRawType = (current.getGenericsTypes() == null
&& current.redirect().getGenericsTypes() != null);
current = getNextSuperClass(current, declaringClass);
- if (current == null && declaringClass.equals(CLASS_Type)) {
+ if (current == null && isClassType(declaringClass)) {
// this can happen if the receiver is Class<Foo>, then
// the actual receiver is Foo and declaringClass is Class
current = declaringClass;
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/SuperCallTraitTransformer.java b/src/main/java/org/codehaus/groovy/transform/trait/SuperCallTraitTransformer.java
index 1b8b00d..e0be55f 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/SuperCallTraitTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/SuperCallTraitTransformer.java
@@ -42,6 +42,7 @@ import java.util.function.Function;
import static org.codehaus.groovy.ast.tools.GeneralUtils.thisPropX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveVoid;
import static org.objectweb.asm.Opcodes.ACC_ABSTRACT;
@@ -109,7 +110,7 @@ class SuperCallTraitTransformer extends ClassCodeExpressionTransformer {
new ClassExpression(helperType),
setterName,
new ArgumentListExpression(
- parameters[0].getType().equals(ClassHelper.CLASS_Type)
+ isClassType(parameters[0].getType())
? thisPropX(false, "class") : varX("this"),
bin.getRightExpression()
)
@@ -148,7 +149,7 @@ class SuperCallTraitTransformer extends ClassCodeExpressionTransformer {
new ClassExpression(helperType),
methodNode.getName(),
new ArgumentListExpression(
- methodNode.getParameters()[0].getType().equals(ClassHelper.CLASS_Type)
+ isClassType(methodNode.getParameters()[0].getType())
? thisPropX(false, "class") : varX("this")
)
);
@@ -191,7 +192,7 @@ class SuperCallTraitTransformer extends ClassCodeExpressionTransformer {
List<MethodNode> targets = helperType.getMethods(exp.getMethodAsString());
boolean isStatic = !targets.isEmpty() && targets.stream().map(MethodNode::getParameters)
- .allMatch(params -> params.length > 0 && params[0].getType().equals(ClassHelper.CLASS_Type));
+ .allMatch(params -> params.length > 0 && isClassType(params[0].getType()));
ArgumentListExpression newArgs = new ArgumentListExpression(
isStatic ? thisPropX(false, "class") : varX("this"));
@@ -254,7 +255,7 @@ class SuperCallTraitTransformer extends ClassCodeExpressionTransformer {
private static boolean isSelfType(final Parameter parameter, final ClassNode traitType) {
ClassNode paramType = parameter.getType();
if (paramType.equals(traitType)) return true;
- return paramType.equals(ClassHelper.CLASS_Type)
+ return isClassType(paramType)
&& paramType.getGenericsTypes() != null
&& paramType.getGenericsTypes()[0].getType().equals(traitType);
}
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java
index aac32e2..1c9cc74 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java
@@ -76,6 +76,7 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.returnS;
import static org.codehaus.groovy.ast.tools.GeneralUtils.stmt;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isPrimitiveBoolean;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isWrapperBoolean;
import static org.codehaus.groovy.transform.trait.SuperCallTraitTransformer.UNRESOLVED_HELPER_CLASS;
import static org.objectweb.asm.Opcodes.ACC_ABSTRACT;
import static org.objectweb.asm.Opcodes.ACC_FINAL;
@@ -423,7 +424,7 @@ public class TraitASTTransformation extends AbstractASTTransformation implements
getter.setSynthetic(true);
cNode.addMethod(getter);
- if (node.getGetterName() == null && getterName.startsWith("get") && (isPrimitiveBoolean(node.getType()) || node.getType().equals(ClassHelper.Boolean_TYPE))) {
+ if (node.getGetterName() == null && getterName.startsWith("get") && (isPrimitiveBoolean(node.getType()) || isWrapperBoolean(node.getType()))) {
MethodNode secondGetter = new MethodNode("is" + capitalize(name), propNodeModifiers, node.getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock);
if (methodNeedsReplacement(cNode, secondGetter)) {
secondGetter.setSynthetic(true);
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java b/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
index b810a3f..1735a66 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
@@ -76,6 +76,8 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.returnS;
import static org.codehaus.groovy.ast.tools.GeneralUtils.stmt;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpecRecurse;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isObjectType;
/**
* This class contains a static utility method {@link #doExtendTraits(org.codehaus.groovy.ast.ClassNode, org.codehaus.groovy.control.SourceUnit, org.codehaus.groovy.control.CompilationUnit)}
@@ -118,7 +120,7 @@ public abstract class TraitComposer {
private static void checkTraitAllowed(final ClassNode bottomTrait, final SourceUnit unit) {
ClassNode superClass = bottomTrait.getSuperClass();
- if (superClass==null || ClassHelper.OBJECT_TYPE.equals(superClass)) return;
+ if (superClass==null || isObjectType(superClass)) return;
if (!Traits.isTrait(superClass)) {
unit.addError(new SyntaxException("A trait can only inherit from another trait", superClass.getLineNumber(), superClass.getColumnNumber()));
}
@@ -337,7 +339,7 @@ public abstract class TraitComposer {
Expression forwardExpression = noCastRequired ? mce : new CastExpression(fixedReturnType,mce);
// we could rely on the first parameter name ($static$self) but that information is not
// guaranteed to be always present
- boolean isHelperForStaticMethod = helperMethodParams[0].getOriginType().equals(ClassHelper.CLASS_Type);
+ boolean isHelperForStaticMethod = isClassType(helperMethodParams[0].getOriginType());
if (helperMethod.isPrivate() && !isHelperForStaticMethod) {
// GROOVY-7213: do not create forwarder for private methods
return;
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java b/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java
index 0d40134..4febf10 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java
@@ -58,6 +58,7 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.classX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.propX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.ternaryX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
/**
* This expression transformer is used internally by the {@link org.codehaus.groovy.transform.trait.TraitASTTransformation
@@ -258,7 +259,7 @@ class TraitReceiverTransformer extends ClassCodeExpressionTransformer {
private static FieldNode tryGetFieldNode(final ClassNode weavedType, final String fieldName) {
FieldNode fn = weavedType.getDeclaredField(fieldName);
- if (fn == null && ClassHelper.CLASS_Type.equals(weavedType)) {
+ if (fn == null && isClassType(weavedType)) {
GenericsType[] genericsTypes = weavedType.getGenericsTypes();
if (genericsTypes != null && genericsTypes.length == 1) {
// for static properties
@@ -393,6 +394,6 @@ class TraitReceiverTransformer extends ClassCodeExpressionTransformer {
}
private Expression createFieldHelperReceiver() {
- return weaved.getOriginType().equals(ClassHelper.CLASS_Type) ? weaved : castX(fieldHelper, weaved);
+ return isClassType(weaved.getOriginType()) ? weaved : castX(fieldHelper, weaved);
}
}
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/Traits.java b/src/main/java/org/codehaus/groovy/transform/trait/Traits.java
index e051ad2..a9b4b0f 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/Traits.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/Traits.java
@@ -47,6 +47,8 @@ import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
+import static org.codehaus.groovy.classgen.asm.util.TypeUtil.isClassType;
+
/**
* A collection of utility methods used to deal with traits.
*
@@ -108,7 +110,7 @@ public abstract class Traits {
}
private static ClassNode unwrapOwner(ClassNode owner) {
- if (ClassHelper.CLASS_Type.equals(owner) && owner.getGenericsTypes()!=null && owner.getGenericsTypes().length==1) {
+ if (isClassType(owner) && owner.getGenericsTypes() != null && owner.getGenericsTypes().length == 1) {
return owner.getGenericsTypes()[0].getType();
}
return owner;