Fix issue with DaggerSuperficialValidation#validateTypeHierarchyOf().

This CL fixes an issue with `DaggerSuperficialValidation#validateTypeHierarchyOf()` that can affect `@Binds` method validation. In particular, the issue is that we don't recursively validate the type hierarchy for the type arguments. For example, if `class Foo extends Bar<Baz>` and `Baz` extends an invalid type (e.g. `class Baz extends MissingType`) then we previously didn't catch this case and we assumed the type was valid. This causes issues with `@Binds` validation because if there's an invalid type in the hierarchy the `KSType#isAssignableFrom(KSType)` check will be incorrect.

RELNOTES=Fix issue with DaggerSuperficialValidation#validateTypeHierarchyOf().
PiperOrigin-RevId: 808650035

Author: bcorso

dagger-compiler/main/java/dagger/internal/codegen/base/DaggerSuperficialValidation.java

@@ -39,12 +39,15 @@
 import static dagger.internal.codegen.xprocessing.XExecutableTypes.getKindName;
 import static dagger.internal.codegen.xprocessing.XExecutableTypes.isMethodType;
 import static dagger.internal.codegen.xprocessing.XTypes.asArray;
+import static dagger.internal.codegen.xprocessing.XTypes.asTypeVariable;
 import static dagger.internal.codegen.xprocessing.XTypes.getKindName;
 import static dagger.internal.codegen.xprocessing.XTypes.isDeclared;
 import static dagger.internal.codegen.xprocessing.XTypes.isTypeOf;
+import static dagger.internal.codegen.xprocessing.XTypes.isTypeVariable;
 import static dagger.internal.codegen.xprocessing.XTypes.isWildcard;
 
 import androidx.room.compiler.codegen.XClassName;
+import androidx.room.compiler.codegen.XTypeName;
 import androidx.room.compiler.processing.XAnnotation;
 import androidx.room.compiler.processing.XAnnotationValue;
 import androidx.room.compiler.processing.XElement;
@@ -68,8 +71,10 @@
 import dagger.internal.codegen.xprocessing.XTypes;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 import javax.inject.Inject;
 
 /**
@@ -230,16 +235,32 @@ public void validateAnnotationOf(XElement element, XAnnotation annotation) {
    */
   public void validateTypeHierarchyOf(String typeDescription, XElement element, XType type) {
     try {
-      validateTypeHierarchy(typeDescription, type);
+      validateTypeHierarchy(typeDescription, type, new HashSet<>());
     } catch (RuntimeException exception) {
       throw ValidationException.from(exception).append(element);
     }
   }
 
-  private void validateTypeHierarchy(String desc, XType type) {
+  private void validateTypeHierarchy(String desc, XType type, Set<XTypeName> visited) {
+    if (!visited.add(type.asTypeName())) {
+      return;
+    }
     validateType(desc, type);
     try {
-      type.getSuperTypes().forEach(supertype -> validateTypeHierarchy("supertype", supertype));
+      if (isArray(type)) {
+        validateTypeHierarchy("array component type", asArray(type).getComponentType(), visited);
+      } else if (isDeclared(type)) {
+        type.getTypeArguments()
+            .forEach(typeArg -> validateTypeHierarchy("type argument", typeArg, visited));
+        type.getSuperTypes()
+            .forEach(supertype -> validateTypeHierarchy("supertype", supertype, visited));
+      } else if (isWildcard(type) && type.extendsBound() != null) {
+        validateTypeHierarchy("extends bound type", type.extendsBound(), visited);
+      } else if (isTypeVariable(type)) {
+        asTypeVariable(type)
+            .getUpperBounds()
+            .forEach(bound -> validateTypeHierarchy("type variable bound type", bound, visited));
+      }
     } catch (RuntimeException exception) {
       throw ValidationException.from(exception).append(desc, type);
     }

javatests/dagger/internal/codegen/DaggerSuperficialValidationTest.java

@@ -707,6 +707,99 @@ public void invalidSupertypeInInterface() {
         });
   }
 
+  @Test
+  public void invalidSuperInterfaceInTypeHierarchy() {
+    runTest(
+        CompilerTests.javaSource(
+            "test.Foo",
+            "package test;",
+            "class Foo extends Bar<Baz> {}",
+            "class Bar<T> {}",
+            "class Baz extends MissingType {}"),
+        CompilerTests.kotlinSource(
+            "test.Foo.kt",
+            "package test;",
+            "class Foo : Bar<Baz> {}",
+            "open class Bar<T> {}",
+            "class Baz : MissingType {}"),
+        (processingEnv, superficialValidation) -> {
+          XTypeElement foo = processingEnv.findTypeElement("test.Foo");
+          if (isKAPT(processingEnv)) {
+            // https://youtrack.jetbrains.com/issue/KT-34193/Kapt-CorrectErrorTypes-doesnt-work-for-generics
+            // There's no way to work around this bug in KAPT so validation doesn't catch this case.
+            superficialValidation.validateTypeHierarchyOf("type", foo, foo.getType());
+            return;
+          }
+          ValidationException exception =
+              assertThrows(
+                  ValidationException.KnownErrorType.class,
+                  () -> superficialValidation.validateTypeHierarchyOf("type", foo, foo.getType()));
+          assertThat(exception)
+              .hasMessageThat()
+              .contains(
+                  NEW_LINES.join(
+                      "Validation trace:",
+                      "  => element (CLASS): test.Foo",
+                      "  => type (DECLARED type): test.Foo",
+                      "  => type (DECLARED supertype): test.Bar<test.Baz>",
+                      "  => type (DECLARED type argument): test.Baz",
+                      "  => type (ERROR supertype): MissingType"));
+        });
+  }
+
+  @Test
+  public void invalidSuperInterfaceInArrayTypeHierarchy() {
+    runTest(
+        CompilerTests.javaSource(
+            "test.Outer",
+            "package test;",
+            "",
+            "final class Outer {",
+            "  static class Foo extends Bar<Baz[]> {}",
+            "  static class Bar<T> {}",
+            "  static class Baz extends MissingType {}",
+            "  Foo getFoo() { return null; }",
+            "}"),
+        CompilerTests.kotlinSource(
+            "test.Outer.kt",
+            "package test;",
+            "",
+            "class Outer {",
+            "  class Foo : Bar<Array<Baz>> {}",
+            "  open class Bar<T> {}",
+            "  class Baz : MissingType {}",
+            "  fun getFoo(): Foo = TODO()",
+            "}"),
+        (processingEnv, superficialValidation) -> {
+          XTypeElement outerElement = processingEnv.findTypeElement("test.Outer");
+          XMethodElement getFooMethod = outerElement.getDeclaredMethods().get(0);
+          if (isKAPT(processingEnv)) {
+            // https://youtrack.jetbrains.com/issue/KT-34193/Kapt-CorrectErrorTypes-doesnt-work-for-generics
+            // There's no way to work around this bug in KAPT so validation doesn't catch this case.
+            superficialValidation.validateTypeHierarchyOf(
+                "return type", getFooMethod, getFooMethod.getReturnType());
+            return;
+          }
+          ValidationException exception =
+              assertThrows(
+                  ValidationException.KnownErrorType.class,
+                  () ->
+                      superficialValidation.validateTypeHierarchyOf(
+                          "return type", getFooMethod, getFooMethod.getReturnType()));
+          final String expectedTrace =
+              NEW_LINES.join(
+                  "Validation trace:",
+                  "  => element (CLASS): test.Outer",
+                  "  => element (METHOD): getFoo()",
+                  "  => type (DECLARED return type): test.Outer.Foo",
+                  "  => type (DECLARED supertype): test.Outer.Bar<test.Outer.Baz[]>",
+                  "  => type (ARRAY type argument): test.Outer.Baz[]",
+                  "  => type (DECLARED array component type): test.Outer.Baz",
+                  "  => type (ERROR supertype): MissingType");
+          assertThat(exception).hasMessageThat().contains(expectedTrace);
+        });
+  }
+
   private void runTest(
       Source.JavaSource javaSource,
       Source.KotlinSource kotlinSource,