1 files changed, 50 insertions, 76 deletions

diff --git a/java/dagger/internal/codegen/validation/DependencyRequestValidator.java b/java/dagger/internal/codegen/validation/DependencyRequestValidator.java
index f28049753..68c960478 100644
--- a/java/dagger/internal/codegen/validation/DependencyRequestValidator.java
+++ b/java/dagger/internal/codegen/validation/DependencyRequestValidator.java
@@ -77,21 +77,11 @@ final class DependencyRequestValidator {
       // Don't validate assisted parameters. These are not dependency requests.
       return;
     }
-    if (missingQualifierMetadata(requestElement)) {
-      report.addError(
-          "Unable to read annotations on an injected Kotlin property. The Dagger compiler must"
-              + " also be applied to any project containing @Inject properties.",
-          requestElement);
-
-      // Skip any further validation if we don't have valid metadata for a type that needs it.
-      return;
-    }
-
-    new Validator(report, requestElement, requestType).validate();
+    checkQualifiers(report, requestElement);
+    checkType(report, requestElement, requestType);
   }
 
-  /** Returns {@code true} if a kotlin inject field is missing metadata about its qualifiers. */
-  private boolean missingQualifierMetadata(Element requestElement) {
+  private void checkQualifiers(ValidationReport.Builder<?> report, Element requestElement) {
     if (requestElement.getKind() == ElementKind.FIELD
         // static injected fields are not supported, no need to get qualifier from kotlin metadata
         && !requestElement.getModifiers().contains(STATIC)
@@ -101,80 +91,64 @@ final class DependencyRequestValidator {
           Optional.ofNullable(
               elements.getTypeElement(
                   membersInjectorNameForType(asType(requestElement.getEnclosingElement()))));
-      return !membersInjector.isPresent();
-    }
-    return false;
-  }
-
-  private final class Validator {
-    private final ValidationReport.Builder<?> report;
-    private final Element requestElement;
-    private final TypeMirror requestType;
-    private final TypeMirror keyType;
-    private final RequestKind requestKind;
-    private final ImmutableCollection<? extends AnnotationMirror> qualifiers;
-
-
-    Validator(ValidationReport.Builder<?> report, Element requestElement, TypeMirror requestType) {
-      this.report = report;
-      this.requestElement = requestElement;
-      this.requestType = requestType;
-      this.keyType = extractKeyType(requestType);
-      this.requestKind = RequestKinds.getRequestKind(requestType);
-      this.qualifiers = injectionAnnotations.getQualifiers(requestElement);
-    }
-
-    void validate() {
-      checkQualifiers();
-      checkType();
+      if (!membersInjector.isPresent()) {
+        report.addError(
+            "Unable to read annotations on an injected Kotlin property. The Dagger compiler must"
+                + " also be applied to any project containing @Inject properties.",
+            requestElement);
+        return; // finish checking qualifiers since current information is unreliable.
+      }
     }
 
-    private void checkQualifiers() {
-      if (qualifiers.size() > 1) {
-        for (AnnotationMirror qualifier : qualifiers) {
-          report.addError(
-              "A single dependency request may not use more than one @Qualifier",
-              requestElement,
-              qualifier);
-        }
+    ImmutableCollection<? extends AnnotationMirror> qualifiers =
+        injectionAnnotations.getQualifiers(requestElement);
+    if (qualifiers.size() > 1) {
+      for (AnnotationMirror qualifier : qualifiers) {
+        report.addError(
+            "A single dependency request may not use more than one @Qualifier",
+            requestElement,
+            qualifier);
       }
     }
+  }
 
-    private void checkType() {
-      if (qualifiers.isEmpty() && keyType.getKind() == TypeKind.DECLARED) {
-        TypeElement typeElement = asTypeElement(keyType);
-        if (isAssistedInjectionType(typeElement)) {
-          report.addError(
-              "Dagger does not support injecting @AssistedInject type, "
-                  + requestType
-                  + ". Did you mean to inject its assisted factory type instead?",
-              requestElement);
-        }
-        if (requestKind != RequestKind.INSTANCE && isAssistedFactoryType(typeElement)) {
-          report.addError(
-              "Dagger does not support injecting Provider<T>, Lazy<T>, Producer<T>, "
-                  + "or Produced<T> when T is an @AssistedFactory-annotated type such as "
-                  + keyType,
-              requestElement);
-        }
+  private void checkType(
+      ValidationReport.Builder<?> report, Element requestElement, TypeMirror requestType) {
+    TypeMirror keyType = extractKeyType(requestType);
+    RequestKind requestKind = RequestKinds.getRequestKind(requestType);
+    if (keyType.getKind() == TypeKind.DECLARED) {
+      TypeElement typeElement = asTypeElement(keyType);
+      if (isAssistedInjectionType(typeElement)) {
+        report.addError(
+            "Dagger does not support injecting @AssistedInject type, "
+                + requestType
+                + ". Did you mean to inject its assisted factory type instead?",
+            requestElement);
       }
-      if (keyType.getKind().equals(WILDCARD)) {
-        // TODO(ronshapiro): Explore creating this message using RequestKinds.
+      if (requestKind != RequestKind.INSTANCE && isAssistedFactoryType(typeElement)) {
         report.addError(
             "Dagger does not support injecting Provider<T>, Lazy<T>, Producer<T>, "
-                + "or Produced<T> when T is a wildcard type such as "
+                + "or Produced<T> when T is an @AssistedFactory-annotated type such as "
                 + keyType,
             requestElement);
       }
-      if (MoreTypes.isType(keyType) && MoreTypes.isTypeOf(MembersInjector.class, keyType)) {
-        DeclaredType membersInjectorType = MoreTypes.asDeclared(keyType);
-        if (membersInjectorType.getTypeArguments().isEmpty()) {
-          report.addError("Cannot inject a raw MembersInjector", requestElement);
-        } else {
-          report.addSubreport(
-              membersInjectionValidator.validateMembersInjectionRequest(
-                  requestElement, membersInjectorType.getTypeArguments().get(0)));
-        }
+    }
+    if (keyType.getKind().equals(WILDCARD)) {
+      // TODO(ronshapiro): Explore creating this message using RequestKinds.
+      report.addError(
+          "Dagger does not support injecting Provider<T>, Lazy<T>, Producer<T>, "
+              + "or Produced<T> when T is a wildcard type such as "
+              + keyType,
+          requestElement);
+    }
+    if (MoreTypes.isType(keyType) && MoreTypes.isTypeOf(MembersInjector.class, keyType)) {
+      DeclaredType membersInjectorType = MoreTypes.asDeclared(keyType);
+      if (membersInjectorType.getTypeArguments().isEmpty()) {
+        report.addError("Cannot inject a raw MembersInjector", requestElement);
+      } else {
+        report.addSubreport(
+            membersInjectionValidator.validateMembersInjectionRequest(
+                requestElement, membersInjectorType.getTypeArguments().get(0)));
       }
     }
   }