add type parameter dependencies from self

Now that we have the full type parameter info for any `JavaClass` (e.g. `class Foo<T extends Set<? super Bar>>`), we can add type parameter dependencies to `JavaClass.getDirectDependenciesFromSelf()`. In particular any other class that appears within the type signature should count as a dependency of the class, e.g. in the former example `Foo` should report type parameter dependencies on `Set` and `Bar`.
I decided to deviate a little bit from the common pattern by making each `JavaTypeVariable` aware of its own dependencies. This way we only need to calculate the dependencies once and can easily reuse them in the next step to register the "toSelf" direction, i.e. all the type parameter dependencies that depend on a specific class.
I also did consider to add some sort of visitor API to the type signature, but in the end I went with a simple instanceof chain in this one place. I could not come up with a generic, yet easy and use-/meaningful visitor interface that I would consider a good addition to the public API. Since within ArchUnit there is also only one use case so far, I decided that this part of the domain model will likely be stable enough to not cause any maintainability issues (after all I can't think of any other `JavaType` to be added in the near future and we have the Reflection API to peek into which sorts of `JavaType` came up in the wider context over the last decades).

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

Author: codecholeric

archunit-example/example-plain/src/main/java/com/tngtech/archunit/example/layers/service/ServiceHelper.java

@@ -1,11 +1,20 @@
 package com.tngtech.archunit.example.layers.service;
 
+import java.util.Map;
+import java.util.Set;
+
+import com.tngtech.archunit.example.layers.controller.SomeUtility;
+import com.tngtech.archunit.example.layers.controller.one.SomeEnum;
 import com.tngtech.archunit.example.layers.security.Secured;
 
 /**
  * Well modelled code always has lots of 'helpers' ;-)
  */
-public class ServiceHelper {
+@SuppressWarnings("unused")
+public class ServiceHelper<
+        TYPE_PARAMETER_VIOLATING_LAYER_RULE extends SomeUtility,
+        ANOTHER_TYPE_PARAMETER_VIOLATING_LAYER_RULE extends Map<?, Set<? super SomeEnum>>> {
+
     public Object insecure = new Object();
     @Secured
     public Object properlySecured = new Object();

archunit-integration-test/src/test/java/com/tngtech/archunit/integration/ExamplesIntegrationTest.java

@@ -165,6 +165,7 @@
 import static com.tngtech.archunit.testutils.ExpectedDependency.field;
 import static com.tngtech.archunit.testutils.ExpectedDependency.inheritanceFrom;
 import static com.tngtech.archunit.testutils.ExpectedDependency.method;
+import static com.tngtech.archunit.testutils.ExpectedDependency.typeParameter;
 import static com.tngtech.archunit.testutils.ExpectedLocation.javaClass;
 import static com.tngtech.archunit.testutils.ExpectedNaming.simpleNameOf;
 import static com.tngtech.archunit.testutils.ExpectedNaming.simpleNameOfAnonymousClassOf;
@@ -738,6 +739,8 @@ Stream<DynamicTest> LayerDependencyRulesTest() {
                 .by(callFromMethod(ServiceViolatingLayerRules.class, illegalAccessToController)
                         .toMethod(UseCaseTwoController.class, doSomethingTwo)
                         .inLine(27).asDependency())
+                .by(typeParameter(ServiceHelper.class, "TYPE_PARAMETER_VIOLATING_LAYER_RULE").dependingOn(SomeUtility.class))
+                .by(typeParameter(ServiceHelper.class, "ANOTHER_TYPE_PARAMETER_VIOLATING_LAYER_RULE").dependingOn(SomeEnum.class))
                 .by(method(ServiceViolatingLayerRules.class, dependentMethod).withParameter(UseCaseTwoController.class))
                 .by(method(ServiceViolatingLayerRules.class, dependentMethod).withReturnType(SomeGuiController.class))
                 .by(annotatedClass(ServiceViolatingLayerRules.class).withAnnotationParameterType(ComplexControllerAnnotation.class))
@@ -790,16 +793,13 @@ Stream<DynamicTest> LayerDependencyRulesTest() {
                 .by(callFromMethod(ServiceViolatingLayerRules.class, illegalAccessToController)
                         .toMethod(UseCaseTwoController.class, doSomethingTwo)
                         .inLine(27).asDependency())
-                .by(method(ServiceViolatingLayerRules.class, dependentMethod)
-                        .withParameter(UseCaseTwoController.class))
-                .by(method(ServiceViolatingLayerRules.class, dependentMethod)
-                        .withReturnType(SomeGuiController.class))
-                .by(field(ServiceHelper.class, "properlySecured")
-                        .withAnnotationType(Secured.class))
-                .by(method(ServiceViolatingLayerRules.class, "properlySecured")
-                        .withAnnotationType(Secured.class))
-                .by(constructor(ServiceHelper.class)
-                        .withAnnotationType(Secured.class))
+                .by(typeParameter(ServiceHelper.class, "TYPE_PARAMETER_VIOLATING_LAYER_RULE").dependingOn(SomeUtility.class))
+                .by(typeParameter(ServiceHelper.class, "ANOTHER_TYPE_PARAMETER_VIOLATING_LAYER_RULE").dependingOn(SomeEnum.class))
+                .by(method(ServiceViolatingLayerRules.class, dependentMethod).withParameter(UseCaseTwoController.class))
+                .by(method(ServiceViolatingLayerRules.class, dependentMethod).withReturnType(SomeGuiController.class))
+                .by(field(ServiceHelper.class, "properlySecured").withAnnotationType(Secured.class))
+                .by(method(ServiceViolatingLayerRules.class, "properlySecured").withAnnotationType(Secured.class))
+                .by(constructor(ServiceHelper.class).withAnnotationType(Secured.class))
                 .by(annotatedClass(ServiceViolatingDaoRules.class).annotatedWith(MyService.class))
                 .by(annotatedClass(ServiceViolatingLayerRules.class).annotatedWith(MyService.class))
                 .by(annotatedClass(ServiceImplementation.class).annotatedWith(MyService.class))

archunit-integration-test/src/test/java/com/tngtech/archunit/testutils/ExpectedDependency.java

@@ -25,6 +25,10 @@ public static InheritanceCreator inheritanceFrom(Class<?> clazz) {
         return new InheritanceCreator(clazz);
     }
 
+    public static TypeParameterCreator typeParameter(Class<?> clazz, String typeParameterName) {
+        return new TypeParameterCreator(clazz, typeParameterName);
+    }
+
     public static AnnotationDependencyCreator annotatedClass(Class<?> clazz) {
         return new AnnotationDependencyCreator(clazz);
     }
@@ -85,6 +89,21 @@ public ExpectedDependency implementing(Class<?> anInterface) {
         }
     }
 
+    public static class TypeParameterCreator {
+        private final Class<?> clazz;
+        private final String typeParameterName;
+
+        private TypeParameterCreator(Class<?> clazz, String typeParameterName) {
+            this.clazz = clazz;
+            this.typeParameterName = typeParameterName;
+        }
+
+        public ExpectedDependency dependingOn(Class<?> typeParameterDependency) {
+            return new ExpectedDependency(clazz, typeParameterDependency,
+                    getDependencyPattern(clazz.getName(), "has type parameter '" + typeParameterName + "' depending on", typeParameterDependency.getName(), 0));
+        }
+    }
+
     public static class AccessCreator {
         private final Class<?> originClass;
 

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

@@ -108,26 +108,31 @@ static Optional<Dependency> tryCreateFromInstanceofCheck(InstanceofCheck instanc
     }
 
     static Optional<Dependency> tryCreateFromAnnotation(JavaAnnotation<?> target) {
-        Origin origin = findSuitableOrigin(target);
+        Origin origin = findSuitableOrigin(target, target.getAnnotatedElement());
         return tryCreateDependency(origin.originClass, origin.originDescription, "is annotated with", target.getRawType());
     }
 
     static Optional<Dependency> tryCreateFromAnnotationMember(JavaAnnotation<?> annotation, JavaClass memberType) {
-        Origin origin = findSuitableOrigin(annotation);
+        Origin origin = findSuitableOrigin(annotation, annotation.getAnnotatedElement());
         return tryCreateDependency(origin.originClass, origin.originDescription, "has annotation member of type", memberType);
     }
 
-    private static Origin findSuitableOrigin(JavaAnnotation<?> annotation) {
-        Object annotatedElement = annotation.getAnnotatedElement();
-        if (annotatedElement instanceof JavaMember) {
-            JavaMember member = (JavaMember) annotatedElement;
+    static Optional<Dependency> tryCreateFromTypeParameter(JavaTypeVariable<?> typeParameter, JavaClass typeParameterDependency) {
+        String dependencyType = "has type parameter '" + typeParameter.getName() + "' depending on";
+        Origin origin = findSuitableOrigin(typeParameter, typeParameter.getOwner());
+        return tryCreateDependency(origin.originClass, origin.originDescription, dependencyType, typeParameterDependency);
+    }
+
+    private static Origin findSuitableOrigin(Object dependencyCause, Object originCandidate) {
+        if (originCandidate instanceof JavaMember) {
+            JavaMember member = (JavaMember) originCandidate;
             return new Origin(member.getOwner(), member.getDescription());
         }
-        if (annotatedElement instanceof JavaClass) {
-            JavaClass clazz = (JavaClass) annotatedElement;
+        if (originCandidate instanceof JavaClass) {
+            JavaClass clazz = (JavaClass) originCandidate;
             return new Origin(clazz, clazz.getDescription());
         }
-        throw new IllegalStateException("Could not find suitable dependency origin for " + annotation);
+        throw new IllegalStateException("Could not find suitable dependency origin for " + dependencyCause);
     }
 
     private static Optional<Dependency> tryCreateDependencyFromJavaMember(JavaMember origin, String dependencyType, JavaClass target) {

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

@@ -575,7 +575,7 @@ public Optional<JavaAnnotation<JavaClass>> tryGetAnnotationOfType(String typeNam
     }
 
     @PublicAPI(usage = ACCESS)
-    public List<JavaTypeVariable<JavaClass>> getTypeParameters() {
+    public JavaTypeParameters<JavaClass> getTypeParameters() {
         return typeParameters;
     }
 

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

@@ -71,6 +71,7 @@ public Set<Dependency> get() {
                 result.addAll(constructorParameterDependenciesFromSelf());
                 result.addAll(annotationDependenciesFromSelf());
                 result.addAll(instanceofCheckDependenciesFromSelf());
+                result.addAll(typeParameterDependenciesFromSelf());
                 return result.build();
             }
         });
@@ -220,6 +221,10 @@ private Set<Dependency> instanceofCheckDependenciesFromSelf() {
         return result.build();
     }
 
+    private Set<Dependency> typeParameterDependenciesFromSelf() {
+        return javaClass.getTypeParameters().getDependenciesFromSelf();
+    }
+
     private <T extends HasDescription & HasAnnotations<?>> Set<Dependency> annotationDependencies(Set<T> annotatedObjects) {
         ImmutableSet.Builder<Dependency> result = ImmutableSet.builder();
         for (T annotated : annotatedObjects) {

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

@@ -16,8 +16,10 @@
 package com.tngtech.archunit.core.domain;
 
 import java.util.List;
+import java.util.Set;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import com.tngtech.archunit.PublicAPI;
 import com.tngtech.archunit.base.ForwardingList;
 import com.tngtech.archunit.base.HasDescription;
@@ -40,4 +42,12 @@ public final class JavaTypeParameters<OWNER extends HasDescription> extends Forw
     protected List<JavaTypeVariable<OWNER>> delegate() {
         return typeParameters;
     }
+
+    Set<Dependency> getDependenciesFromSelf() {
+        ImmutableSet.Builder<Dependency> result = ImmutableSet.builder();
+        for (JavaTypeVariable<?> typeVariable : typeParameters) {
+            result.addAll(typeVariable.getDependenciesFromSelf());
+        }
+        return result.build();
+    }
 }

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

@@ -17,19 +17,23 @@
 
 import java.lang.reflect.TypeVariable;
 import java.util.List;
+import java.util.Set;
 
 import com.google.common.base.Joiner;
 import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableSet;
 import com.tngtech.archunit.PublicAPI;
 import com.tngtech.archunit.base.HasDescription;
 import com.tngtech.archunit.core.domain.properties.HasOwner;
 import com.tngtech.archunit.core.domain.properties.HasUpperBounds;
 
+import static com.google.common.collect.Iterables.concat;
 import static com.google.common.collect.Iterables.getOnlyElement;
 import static com.tngtech.archunit.PublicAPI.Usage.ACCESS;
 import static com.tngtech.archunit.base.Guava.toGuava;
 import static com.tngtech.archunit.core.domain.properties.HasName.Functions.GET_NAME;
 import static java.util.Collections.emptyList;
+import static java.util.Collections.emptySet;
 
 /**
  * Represents a type variable used by generic types and members.<br>
@@ -49,6 +53,7 @@ public final class JavaTypeVariable<OWNER extends HasDescription> implements Jav
     private final OWNER owner;
     private List<JavaType> upperBounds = emptyList();
     private JavaClass erasure;
+    private Set<Dependency> dependencies = emptySet();
 
     JavaTypeVariable(String name, OWNER owner, JavaClass erasure) {
         this.name = name;
@@ -59,6 +64,42 @@ public final class JavaTypeVariable<OWNER extends HasDescription> implements Jav
     void setUpperBounds(List<JavaType> upperBounds) {
         this.upperBounds = upperBounds;
         erasure = upperBounds.isEmpty() ? erasure : upperBounds.get(0).toErasure();
+        ImmutableSet.Builder<Dependency> dependenciesBuilder = ImmutableSet.builder();
+        for (JavaType bound : getUpperBounds()) {
+            for (JavaClass typeParameterDependency : dependenciesOfType(bound)) {
+                dependenciesBuilder.addAll(Dependency.tryCreateFromTypeParameter(this, typeParameterDependency).asSet());
+            }
+        }
+        dependencies = dependenciesBuilder.build();
+    }
+
+    private Iterable<JavaClass> dependenciesOfType(JavaType javaType) {
+        ImmutableSet.Builder<JavaClass> result = ImmutableSet.builder();
+        if (javaType instanceof JavaClass) {
+            result.add((JavaClass) javaType);
+        } else if (javaType instanceof JavaParameterizedType) {
+            result.addAll(dependenciesOfParameterizedType((JavaParameterizedType) javaType));
+        } else if (javaType instanceof JavaWildcardType) {
+            result.addAll(dependenciesOfWildcardType((JavaWildcardType) javaType));
+        }
+        return result.build();
+    }
+
+    private Set<JavaClass> dependenciesOfParameterizedType(JavaParameterizedType parameterizedType) {
+        ImmutableSet.Builder<JavaClass> result = ImmutableSet.<JavaClass>builder()
+                .add(parameterizedType.toErasure());
+        for (JavaType typeArgument : parameterizedType.getActualTypeArguments()) {
+            result.addAll(dependenciesOfType(typeArgument));
+        }
+        return result.build();
+    }
+
+    private Set<JavaClass> dependenciesOfWildcardType(JavaWildcardType javaType) {
+        ImmutableSet.Builder<JavaClass> result = ImmutableSet.builder();
+        for (JavaType bound : concat(javaType.getUpperBounds(), javaType.getLowerBounds())) {
+            result.addAll(dependenciesOfType(bound));
+        }
+        return result.build();
     }
 
     /**
@@ -116,6 +157,10 @@ public JavaClass toErasure() {
         return erasure;
     }
 
+    Set<Dependency> getDependenciesFromSelf() {
+        return dependencies;
+    }
+
     @Override
     public String toString() {
         String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : "";

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

@@ -173,6 +173,20 @@ public void Dependency_from_member_annotation_member(JavaMember annotatedMember)
                 .contains(annotatedMember.getDescription() + " has annotation member of type <" + memberType.getName() + ">");
     }
 
+    @Test
+    public void Dependency_from_type_parameter() {
+        JavaClass javaClass = importClassesWithContext(ClassWithTypeParameters.class, String.class).get(ClassWithTypeParameters.class);
+        JavaTypeVariable<?> typeParameter = javaClass.getTypeParameters().get(0);
+
+        Dependency dependency = Dependency.tryCreateFromTypeParameter(typeParameter, typeParameter.getUpperBounds().get(0).toErasure()).get();
+
+        assertThatType(dependency.getOriginClass()).matches(ClassWithTypeParameters.class);
+        assertThatType(dependency.getTargetClass()).matches(String.class);
+        assertThat(dependency.getDescription()).as("description").contains(String.format(
+                "Class <%s> has type parameter '%s' depending on <%s> in (%s.java:0)",
+                ClassWithTypeParameters.class.getName(), typeParameter.getName(), String.class.getName(), getClass().getSimpleName()));
+    }
+
     @Test
     public void origin_predicates_match() {
         assertThatDependency(Origin.class, Target.class)
@@ -307,4 +321,8 @@ public ClassWithAnnotatedMembers(Object annotatedField) {
         void annotatedMethod() {
         }
     }
+
+    @SuppressWarnings("unused")
+    private static class ClassWithTypeParameters<T extends String> {
+    }
 }