Java, typeres: fix PR comments

pmd-java/src/main/java/net/sourceforge/pmd/lang/java/typeresolution/typedefinition/JavaTypeDefinition.java

@@ -37,7 +37,7 @@ public abstract class JavaTypeDefinition implements TypeDefinition {
         case UPPER_BOUND:
         case UPPER_WILDCARD:
         case LOWER_WILDCARD:
-            return new JavaTypeDefinitionIntersection(type, intersectionTypes);
+            return new JavaTypeDefinitionSpecial(type, intersectionTypes);
         default:
             throw new IllegalStateException("Unknow type");
         }
@@ -125,9 +125,7 @@ public abstract class JavaTypeDefinition implements TypeDefinition {
     /**
      * @return true if clazz is generic and had not been parameterized
      */
-    public final boolean isRawType() {
-        return !isIntersectionType() && isGeneric() && CLASS_EXACT_TYPE_DEF_CACHE.containsKey(getType());
-    }
+    public abstract boolean isRawType();
 
     public abstract JavaTypeDefinition getAsSuper(Class<?> superClazz);
 
@@ -144,9 +142,7 @@ public abstract class JavaTypeDefinition implements TypeDefinition {
         return definitionType == TypeDefinitionType.LOWER_WILDCARD;
     }
 
-    public final boolean isIntersectionType() {
-        return getJavaTypeCount() != 1;
-    }
+    public abstract boolean isIntersectionType();
 
     public final boolean isWildcard() {
         return definitionType == TypeDefinitionType.LOWER_WILDCARD

pmd-java/src/main/java/net/sourceforge/pmd/lang/java/typeresolution/typedefinition/JavaTypeDefinitionSimple.java

@@ -21,6 +21,7 @@ import java.util.Set;
     // cached because calling clazz.getTypeParameters().length create a new array every time
     private final int typeParameterCount;
     private final boolean isGeneric;
+    private final boolean isRawType;
     private final JavaTypeDefinition enclosingClass;
 
     protected JavaTypeDefinitionSimple(Class<?> clazz, JavaTypeDefinition... boundGenerics) {
@@ -42,6 +43,7 @@ import java.util.Set;
 
         typeParameterCount = typeParameters.length;
         isGeneric = typeParameters.length != 0;
+        isRawType = isGeneric && boundGenerics.length == 0;
 
         if (isGeneric) {
             // Generics will be lazily loaded
@@ -330,4 +332,14 @@ import java.util.Set;
     public int getJavaTypeCount() {
         return 1;
     }
+
+    @Override
+    public boolean isRawType() {
+        return isRawType;
+    }
+
+    @Override
+    public boolean isIntersectionType() {
+        return false;
+    }
 }

pmd-java/src/main/java/net/sourceforge/pmd/lang/java/typeresolution/typedefinition/JavaTypeDefinitionSpecial.java

@@ -11,87 +11,95 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
-public class JavaTypeDefinitionIntersection extends JavaTypeDefinition {
-    private List<JavaTypeDefinition> intersectionTypes;
+/* default */ class JavaTypeDefinitionSpecial extends JavaTypeDefinition {
+    private List<JavaTypeDefinition> typeList;
 
-    protected JavaTypeDefinitionIntersection(TypeDefinitionType defType, List<JavaTypeDefinition> intersectionTypes) {
+    protected JavaTypeDefinitionSpecial(TypeDefinitionType defType, List<JavaTypeDefinition> typeList) {
         super(defType);
 
-        if (intersectionTypes.isEmpty()) {
+        if (typeList.isEmpty()) {
             throw new IllegalArgumentException("Intersection type list can't be empty");
         }
 
-        this.intersectionTypes = Collections.unmodifiableList(new ArrayList<>(intersectionTypes));
+        this.typeList = Collections.unmodifiableList(new ArrayList<>(typeList));
+    }
+
+    /**
+     * All the calls to this method are to delegate JavaTypeDefinition method calls to the first
+     * JavaTypeDefinition in the 'typeList' list.
+     */
+    private JavaTypeDefinition firstJavaType() {
+        return typeList.get(0);
     }
 
     @Override
     public Class<?> getType() {
-        return intersectionTypes.get(0).getType();
+        return firstJavaType().getType();
     }
 
     @Override
     public JavaTypeDefinition getEnclosingClass() {
-        return intersectionTypes.get(0).getEnclosingClass();
+        return firstJavaType().getEnclosingClass();
     }
 
     @Override
     public boolean isGeneric() {
-        return intersectionTypes.get(0).isGeneric();
+        return firstJavaType().isGeneric();
     }
 
     @Override
     public JavaTypeDefinition getGenericType(String parameterName) {
-        return intersectionTypes.get(0).getGenericType(parameterName);
+        return firstJavaType().getGenericType(parameterName);
     }
 
     @Override
     public JavaTypeDefinition getGenericType(int index) {
-        return intersectionTypes.get(0).getGenericType(index);
+        return firstJavaType().getGenericType(index);
     }
 
     @Override
     public JavaTypeDefinition resolveTypeDefinition(Type type) {
-        return intersectionTypes.get(0).resolveTypeDefinition(type);
+        return firstJavaType().resolveTypeDefinition(type);
     }
 
     @Override
     public JavaTypeDefinition resolveTypeDefinition(Type type, Method method, List<JavaTypeDefinition> methodTypeArgs) {
-        return intersectionTypes.get(0).resolveTypeDefinition(type, method, methodTypeArgs);
+        return firstJavaType().resolveTypeDefinition(type, method, methodTypeArgs);
     }
 
     @Override
     public JavaTypeDefinition getComponentType() {
-        return intersectionTypes.get(0).getComponentType();
+        return firstJavaType().getComponentType();
     }
 
     @Override
     public boolean isClassOrInterface() {
-        return intersectionTypes.get(0).isClassOrInterface();
+        return firstJavaType().isClassOrInterface();
     }
 
     @Override
     public boolean isNullType() {
-        return intersectionTypes.get(0).isNullType();
+        return firstJavaType().isNullType();
     }
 
     @Override
     public boolean isPrimitive() {
-        return intersectionTypes.get(0).isPrimitive();
+        return firstJavaType().isPrimitive();
     }
 
     @Override
     public boolean hasSameErasureAs(JavaTypeDefinition def) {
-        return intersectionTypes.get(0).hasSameErasureAs(def);
+        return firstJavaType().hasSameErasureAs(def);
     }
 
     @Override
     public int getTypeParameterCount() {
-        return intersectionTypes.get(0).getTypeParameterCount();
+        return firstJavaType().getTypeParameterCount();
     }
 
     @Override
     public boolean isArrayType() {
-        return intersectionTypes.get(0).isArrayType();
+        return firstJavaType().isArrayType();
     }
 
     @Override
@@ -100,17 +108,17 @@ public class JavaTypeDefinitionIntersection extends JavaTypeDefinition {
                 .append("JavaTypeDefinition ")
                 .append(getDefinitionType().toString())
                 .append(" [")
-                .append(intersectionTypes.get(0));
-        for (int index = 1; index < intersectionTypes.size(); ++index) {
+                .append(firstJavaType());
+        for (int index = 1; index < typeList.size(); ++index) {
             builder.append(" && ");
-            builder.append(intersectionTypes.get(index));
+            builder.append(typeList.get(index));
         }
         return builder.append("]").toString();
     }
 
     @Override
     public boolean equals(Object obj) {
-        if (obj == null || !(obj instanceof JavaTypeDefinitionIntersection)) {
+        if (obj == null || !(obj instanceof JavaTypeDefinitionSpecial)) {
             return false;
         }
 
@@ -118,17 +126,17 @@ public class JavaTypeDefinitionIntersection extends JavaTypeDefinition {
             return true;
         }
 
-        JavaTypeDefinitionIntersection otherTypeDef = (JavaTypeDefinitionIntersection) obj;
+        JavaTypeDefinitionSpecial otherTypeDef = (JavaTypeDefinitionSpecial) obj;
 
         if (otherTypeDef.getJavaTypeCount() != getJavaTypeCount()
                 || getDefinitionType() != otherTypeDef.getDefinitionType()) {
             return false;
         }
 
-        // we assume that the intersectionTypes list cannot contain duplicates, then indeed, this will prove equality
+        // we assume that the typeList list cannot contain duplicates, then indeed, this will prove equality
         outer:
-        for (JavaTypeDefinition intersectionTypeDef : intersectionTypes) {
-            for (JavaTypeDefinition otherIntersectionTypeDef : otherTypeDef.intersectionTypes) {
+        for (JavaTypeDefinition intersectionTypeDef : typeList) {
+            for (JavaTypeDefinition otherIntersectionTypeDef : otherTypeDef.typeList) {
                 if (intersectionTypeDef.equals(otherIntersectionTypeDef)) {
                     continue outer;
                 }
@@ -144,7 +152,7 @@ public class JavaTypeDefinitionIntersection extends JavaTypeDefinition {
     public int hashCode() {
         int result = 31;
 
-        for (JavaTypeDefinition typeDef : intersectionTypes) {
+        for (JavaTypeDefinition typeDef : typeList) {
             result *= typeDef.hashCode();
         }
 
@@ -153,31 +161,41 @@ public class JavaTypeDefinitionIntersection extends JavaTypeDefinition {
 
     @Override
     public Set<JavaTypeDefinition> getSuperTypeSet() {
-        return intersectionTypes.get(0).getSuperTypeSet();
+        return firstJavaType().getSuperTypeSet();
     }
 
     @Override
     protected Set<JavaTypeDefinition> getSuperTypeSet(Set<JavaTypeDefinition> destinationSet) {
-        return intersectionTypes.get(0).getSuperTypeSet(destinationSet);
+        return firstJavaType().getSuperTypeSet(destinationSet);
     }
 
     @Override
     public Set<Class<?>> getErasedSuperTypeSet() {
-        return intersectionTypes.get(0).getErasedSuperTypeSet();
+        return firstJavaType().getErasedSuperTypeSet();
     }
 
     @Override
     public JavaTypeDefinition getAsSuper(Class<?> superClazz) {
-        return intersectionTypes.get(0).getAsSuper(superClazz);
+        return firstJavaType().getAsSuper(superClazz);
     }
 
     @Override
     public JavaTypeDefinition getJavaType(int index) {
-        return intersectionTypes.get(0);
+        return firstJavaType();
     }
 
     @Override
     public int getJavaTypeCount() {
-        return intersectionTypes.size();
+        return typeList.size();
+    }
+
+    @Override
+    public boolean isRawType() {
+        return typeList.size() == 1 && firstJavaType().isRawType();
+    }
+
+    @Override
+    public boolean isIntersectionType() {
+        return typeList.size() == 1;
     }
 }