support generic array types in generic type signature

We can now handle generic array types like `T[][]` in `Foo<T, A extends List<T[][]>>`. Note that a generic array type cannot be a toplevel bound of a generic type, but can only appear as part of the nested type signature.

Signed-off-by: Peter Gafert <peter.gafert@tngtech.com>

Author: codecholeric

archunit/src/main/java/com/tngtech/archunit/core/domain/DomainObjectCreationContext.java

@@ -48,6 +48,8 @@
 import com.tngtech.archunit.core.importer.DomainBuilders.JavaWildcardTypeBuilder;
 import com.tngtech.archunit.core.importer.DomainBuilders.MethodCallTargetBuilder;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
 /**
  * Together with {@link DomainBuilders}, this class is the link to create domain objects from the import
  * context. To make the API clear, we try to keep only those methods public, which are really meant to be used.
@@ -160,6 +162,12 @@ public static void completeTypeVariable(JavaTypeVariable variable, List<JavaType
         variable.setUpperBounds(upperBounds);
     }
 
+    public static JavaGenericArrayType createGenericArrayType(JavaType componentType, JavaClass erasure) {
+        checkArgument(componentType instanceof JavaTypeVariable || componentType instanceof JavaGenericArrayType,
+                "Component type of a generic array type can only be a type variable or a generic array type. This is most likely a bug.");
+        return new JavaGenericArrayType(componentType.getName() + "[]", componentType, erasure);
+    }
+
     public static JavaWildcardType createWildcardType(JavaWildcardTypeBuilder builder) {
         return new JavaWildcardType(builder);
     }

archunit/src/main/java/com/tngtech/archunit/core/domain/JavaClassDescriptor.java

@@ -134,7 +134,7 @@ private static String createObjectComponentType(String componentTypeName) {
             return "L" + componentTypeName + ";";
         }
 
-        static JavaClassDescriptor javaClass(JavaClass javaClass) {
+        public static JavaClassDescriptor javaClass(JavaClass javaClass) {
             return name(javaClass.getName());
         }
 

archunit/src/main/java/com/tngtech/archunit/core/domain/JavaGenericArrayType.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2014-2020 TNG Technology Consulting GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.tngtech.archunit.core.domain;
+
+import com.tngtech.archunit.PublicAPI;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.tngtech.archunit.PublicAPI.Usage.ACCESS;
+
+/**
+ * Represents a generic array type used in signatures of parameterized types.<br>
+ * E.g. for {@code MyClass<A, T extends List<A[]>>} the upper bound {@code List<A[]>}
+ * would have one {@link JavaGenericArrayType} {@code A[]} as its type parameter.<br>
+ * Like its concrete counterpart a {@link JavaGenericArrayType} can be queried for its
+ * {@link #getComponentType() component type}, which will by definition be a
+ * {@link JavaTypeVariable} or a {@link JavaGenericArrayType} corresponding to a lower dimensional array.
+ */
+@PublicAPI(usage = ACCESS)
+public final class JavaGenericArrayType implements JavaType {
+    private final String name;
+    private final JavaType componentType;
+    private final JavaClass erasure;
+
+    JavaGenericArrayType(String name, JavaType componentType, JavaClass erasure) {
+        this.name = checkNotNull(name);
+        this.componentType = checkNotNull(componentType);
+        this.erasure = checkNotNull(erasure);
+    }
+
+    /**
+     * @return The name of this {@link JavaGenericArrayType}, e.g. for {@code A[]} within
+     *         signature {@code MyClass<A, T extends List<A[]>>} the name would be "A[]"
+     */
+    @Override
+    @PublicAPI(usage = ACCESS)
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * @return The component type of this {@link JavaGenericArrayType}, e.g. for {@code A[]} within
+     *         signature {@code MyClass<A, T extends List<A[]>>} the component type would be {@code A},
+     *         while for {@code A[][]} within {@code MyClass<A, T extends List<A[][]>>} the component
+     *         type would be {@code A[]}.
+     */
+    @PublicAPI(usage = ACCESS)
+    public JavaType getComponentType() {
+        return componentType;
+    }
+
+    @Override
+    @PublicAPI(usage = ACCESS)
+    public JavaClass toErasure() {
+        return erasure;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + '{' + getName() + '}';
+    }
+}

archunit/src/main/java/com/tngtech/archunit/core/domain/JavaType.java

@@ -29,6 +29,9 @@ public interface JavaType extends HasName {
      *     <li>the class itself, if this type is a {@link JavaClass}</li>
      *     <li>the {@link JavaClass} equivalent to {@link Object}, if this type is an unbound {@link JavaTypeVariable}</li>
      *     <li>the {@link JavaClass} equivalent to the erasure of the left most bound, if this type is a bound {@link JavaTypeVariable}</li>
+     *     <li>if this type is a {@link JavaGenericArrayType}, the erasure will be the {@link JavaClass}
+     *     equivalent to the array type that has the erasure of the generic component type of this type as its component type;
+     *     e.g. take the generic array type {@code T[][]} where {@code T} is unbound, then the erasure will be the array type {@code Object[][]}</li>
      * </ul>
      */
     @PublicAPI(usage = ACCESS)

archunit/src/main/java/com/tngtech/archunit/core/importer/JavaGenericTypeImporter.java

@@ -20,6 +20,7 @@
 
 import com.google.common.base.Function;
 import com.google.common.base.Functions;
+import com.tngtech.archunit.core.domain.JavaClass;
 import com.tngtech.archunit.core.domain.JavaClassDescriptor;
 import com.tngtech.archunit.core.domain.JavaType;
 import com.tngtech.archunit.core.domain.JavaTypeVariable;
@@ -36,6 +37,7 @@
 import org.slf4j.LoggerFactory;
 
 import static com.google.common.base.Functions.compose;
+import static com.tngtech.archunit.core.domain.DomainObjectCreationContext.createGenericArrayType;
 import static com.tngtech.archunit.core.importer.ClassFileProcessor.ASM_API_VERSION;
 
 class JavaGenericTypeImporter {
@@ -109,12 +111,12 @@ public void visitTypeArgument() {
             @Override
             public void visitTypeVariable(String name) {
                 log.trace("Encountered upper bound for {}: Type variable {}", currentType.getName(), name);
-                currentType.addBound(new ReferenceCreationProcess(name));
+                currentType.addBound(new ReferenceCreationProcess(name, ReferenceCreationProcess.JavaTypeVariableFinisher.IDENTITY));
             }
 
             @Override
             public SignatureVisitor visitTypeArgument(char wildcard) {
-                return TypeArgumentProcessor.create(wildcard, currentBound, Functions.<JavaClassDescriptor>identity());
+                return TypeArgumentProcessor.create(wildcard, currentBound, Functions.<JavaClassDescriptor>identity(), ReferenceCreationProcess.JavaTypeVariableFinisher.IDENTITY);
             }
         }
     }
@@ -134,13 +136,19 @@ public JavaType finish(Iterable<JavaTypeVariable> allTypeParametersInContext, Cl
 
     private static class ReferenceCreationProcess implements JavaTypeCreationProcess {
         private final String typeVariableName;
+        private final JavaTypeVariableFinisher finisher;
 
-        ReferenceCreationProcess(String typeVariableName) {
+        ReferenceCreationProcess(String typeVariableName, JavaTypeVariableFinisher finisher) {
             this.typeVariableName = typeVariableName;
+            this.finisher = finisher;
         }
 
         @Override
         public JavaType finish(Iterable<JavaTypeVariable> allTypeParametersInContext, ClassesByTypeName classes) {
+            return finisher.finish(createTypeVariable(allTypeParametersInContext, classes), classes);
+        }
+
+        private JavaType createTypeVariable(Iterable<JavaTypeVariable> allTypeParametersInContext, ClassesByTypeName classes) {
             for (JavaTypeVariable existingTypeVariable : allTypeParametersInContext) {
                 if (existingTypeVariable.getName().equals(typeVariableName)) {
                     return existingTypeVariable;
@@ -149,6 +157,38 @@ public JavaType finish(Iterable<JavaTypeVariable> allTypeParametersInContext, Cl
             // type variables can be missing from the import context -> create a simple unbound type variable since we have no more information
             return new JavaTypeParameterBuilder(typeVariableName).build(classes);
         }
+
+        abstract static class JavaTypeVariableFinisher {
+            abstract JavaType finish(JavaType input, ClassesByTypeName classes);
+
+            abstract String getFinishedName(String name);
+
+            JavaTypeVariableFinisher after(final JavaTypeVariableFinisher other) {
+                return new JavaTypeVariableFinisher() {
+                    @Override
+                    JavaType finish(JavaType input, ClassesByTypeName classes) {
+                        return JavaTypeVariableFinisher.this.finish(other.finish(input, classes), classes);
+                    }
+
+                    @Override
+                    String getFinishedName(String name) {
+                        return JavaTypeVariableFinisher.this.getFinishedName(other.getFinishedName(name));
+                    }
+                };
+            }
+
+            static JavaTypeVariableFinisher IDENTITY = new JavaTypeVariableFinisher() {
+                @Override
+                JavaType finish(JavaType input, ClassesByTypeName classes) {
+                    return input;
+                }
+
+                @Override
+                String getFinishedName(String name) {
+                    return name;
+                }
+            };
+        }
     }
 
     private static class TypeArgumentProcessor extends SignatureVisitor {
@@ -158,18 +198,37 @@ public JavaClassDescriptor apply(JavaClassDescriptor input) {
                 return input.toArrayDescriptor();
             }
         };
+        private static final ReferenceCreationProcess.JavaTypeVariableFinisher GENERIC_ARRAY_CREATOR = new ReferenceCreationProcess.JavaTypeVariableFinisher() {
+            @Override
+            public JavaType finish(JavaType componentType, ClassesByTypeName classes) {
+                JavaClassDescriptor erasureType = JavaClassDescriptor.From.javaClass(componentType.toErasure()).toArrayDescriptor();
+                JavaClass erasure = classes.get(erasureType.getFullyQualifiedClassName());
+                return createGenericArrayType(componentType, erasure);
+            }
+
+            @Override
+            String getFinishedName(String name) {
+                return name + "[]";
+            }
+        };
 
         private final TypeArgumentType typeArgumentType;
         private final JavaParameterizedTypeBuilder parameterizedType;
         private final Function<JavaClassDescriptor, JavaClassDescriptor> typeMapping;
+        private final ReferenceCreationProcess.JavaTypeVariableFinisher typeVariableFinisher;
 
         private JavaParameterizedTypeBuilder currentTypeArgument;
 
-        TypeArgumentProcessor(TypeArgumentType typeArgumentType, JavaParameterizedTypeBuilder parameterizedType, Function<JavaClassDescriptor, JavaClassDescriptor> typeMapping) {
+        TypeArgumentProcessor(
+                TypeArgumentType typeArgumentType,
+                JavaParameterizedTypeBuilder parameterizedType,
+                Function<JavaClassDescriptor, JavaClassDescriptor> typeMapping,
+                ReferenceCreationProcess.JavaTypeVariableFinisher typeVariableFinisher) {
             super(ASM_API_VERSION);
             this.typeArgumentType = typeArgumentType;
             this.parameterizedType = parameterizedType;
             this.typeMapping = typeMapping;
+            this.typeVariableFinisher = typeVariableFinisher;
         }
 
         @Override
@@ -188,28 +247,35 @@ public void visitTypeArgument() {
 
         @Override
         public void visitTypeVariable(String name) {
-            log.trace("Encountered {} for {}: Type variable {}", typeArgumentType.description, parameterizedType.getTypeName(), name);
-            typeArgumentType.addTypeArgumentToBuilder(parameterizedType, new ReferenceCreationProcess(name));
+            if (log.isTraceEnabled()) {
+                log.trace("Encountered {} for {}: Type variable {}", typeArgumentType.description, parameterizedType.getTypeName(), typeVariableFinisher.getFinishedName(name));
+            }
+            typeArgumentType.addTypeArgumentToBuilder(parameterizedType, new ReferenceCreationProcess(name, typeVariableFinisher));
         }
 
         @Override
         public SignatureVisitor visitTypeArgument(char wildcard) {
-            return TypeArgumentProcessor.create(wildcard, currentTypeArgument, typeMapping);
+            return TypeArgumentProcessor.create(wildcard, currentTypeArgument, typeMapping, typeVariableFinisher);
         }
 
         @Override
         public SignatureVisitor visitArrayType() {
-            return new TypeArgumentProcessor(typeArgumentType, parameterizedType, compose(typeMapping, TO_ARRAY_TYPE));
+            return new TypeArgumentProcessor(typeArgumentType, parameterizedType, compose(typeMapping, TO_ARRAY_TYPE), typeVariableFinisher.after(GENERIC_ARRAY_CREATOR));
         }
 
-        static TypeArgumentProcessor create(char identifier, JavaParameterizedTypeBuilder parameterizedType, Function<JavaClassDescriptor, JavaClassDescriptor> typeMapping) {
+        static TypeArgumentProcessor create(
+                char identifier,
+                JavaParameterizedTypeBuilder parameterizedType,
+                Function<JavaClassDescriptor, JavaClassDescriptor> typeMapping,
+                ReferenceCreationProcess.JavaTypeVariableFinisher typeVariableFinisher) {
+
             switch (identifier) {
                 case '=':
-                    return new TypeArgumentProcessor(PARAMETERIZED_TYPE, parameterizedType, typeMapping);
+                    return new TypeArgumentProcessor(PARAMETERIZED_TYPE, parameterizedType, typeMapping, typeVariableFinisher);
                 case '+':
-                    return new TypeArgumentProcessor(WILDCARD_WITH_UPPER_BOUND, parameterizedType, typeMapping);
+                    return new TypeArgumentProcessor(WILDCARD_WITH_UPPER_BOUND, parameterizedType, typeMapping, typeVariableFinisher);
                 case '-':
-                    return new TypeArgumentProcessor(WILDCARD_WITH_LOWER_BOUND, parameterizedType, typeMapping);
+                    return new TypeArgumentProcessor(WILDCARD_WITH_LOWER_BOUND, parameterizedType, typeMapping, typeVariableFinisher);
                 default:
                     throw new IllegalStateException(String.format("Cannot handle asm type argument identifier '%s'", identifier));
             }

archunit/src/test/java/com/tngtech/archunit/core/domain/JavaTypeTest.java

@@ -56,6 +56,15 @@ public void erased_type_parameter_of_concrete_array_type_is_array_type() {
         assertThatType(getTypeArgumentOfFirstBound(typeParameters.get(2)).toErasure()).matches(List[][][].class);
     }
 
+    @Test
+    public void erased_type_parameter_of_generic_array_type_is_array_type() {
+        List<JavaTypeVariable> typeParameters = new ClassFileImporter().importClass(ClassWithBoundTypeParameterWithGenericArrayBounds.class).getTypeParameters();
+
+        assertThatType(getTypeArgumentOfFirstBound(typeParameters.get(3)).toErasure()).matches(Object[].class);
+        assertThatType(getTypeArgumentOfFirstBound(typeParameters.get(4)).toErasure()).matches(String[][].class);
+        assertThatType(getTypeArgumentOfFirstBound(typeParameters.get(5)).toErasure()).matches(List[][][].class);
+    }
+
     private static JavaType getTypeArgumentOfFirstBound(JavaTypeVariable typeParameter) {
         JavaParameterizedType firstBound = (JavaParameterizedType) typeParameter.getBounds().get(0);
         return firstBound.getActualTypeArguments().get(0);
@@ -80,6 +89,10 @@ private static class ClassWithBoundTypeParameterWithSingleGenericClassBound<T ex
     private static class ClassWithBoundTypeParameterWithSingleGenericArrayBound<T extends List<Object[]>, U extends List<String[][]>, V extends List<List<?>[][][]>> {
     }
 
+    @SuppressWarnings("unused")
+    private static class ClassWithBoundTypeParameterWithGenericArrayBounds<A, B extends String, C extends List<?>, T extends List<A[]>, U extends List<B[][]>, V extends List<C[][][]>> {
+    }
+
     @SuppressWarnings("unused")
     private static class ClassWithBoundTypeParameterWithMultipleGenericClassAndInterfaceBounds<T extends HashMap<String, String> & Iterable<String> & Serializable> {
     }