[XPoet Migration]: Replace TypeName usages in AutoValue with Equivalence.Wrapper<XType>.

As part of the XPoet migration, I've been replacing `TypeName` with `XTypeName`. However, that doesn't apply to cases where we currently rely on the equals/hashcode of `TypeName`, e.g. AutoValue classes. In these cases, I'm replacing `TypeName` with an `Equivalence.Wrapper<XType>` that has the same equals/hashcode as `TypeName`. This change should be a noop.

RELNOTES=N/A
PiperOrigin-RevId: 750346029

Author: bcorso

dagger-compiler/main/java/dagger/internal/codegen/binding/AssistedInjectionAnnotations.java

@@ -36,10 +36,10 @@
 import androidx.room.compiler.processing.XVariableElement;
 import com.google.auto.value.AutoValue;
 import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.base.Equivalence;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.TypeName;
 import dagger.assisted.Assisted;
 import dagger.assisted.AssistedFactory;
 import dagger.internal.codegen.model.BindingKind;
@@ -222,24 +222,22 @@ public static AssistedParameter create(
               Optional.ofNullable(parameter.getAnnotation(XTypeNames.ASSISTED))
                   .map(assisted -> assisted.getAsString("value"))
                   .orElse(""),
-              parameterType.getTypeName());
+              XTypes.equivalence().wrap(parameterType));
       assistedParameter.parameterElement = parameter;
-      assistedParameter.parameterType = parameterType;
       return assistedParameter;
     }
 
     private XExecutableParameterElement parameterElement;
-    private XType parameterType;
 
     /** Returns the string qualifier from the {@link Assisted#value()}. */
     public abstract String qualifier();
 
-    /** Returns the type annotated with {@link Assisted}. */
-    abstract TypeName typeName();
+    /** Returns the equivalence wrapper for the type annotated with {@link Assisted}. */
+    abstract Equivalence.Wrapper<XType> wrappedType();
 
     /** Returns the type annotated with {@link Assisted}. */
     public final XType type() {
-      return parameterType;
+      return wrappedType().get();
     }
 
     public final XExecutableParameterElement element() {

dagger-compiler/main/java/dagger/internal/codegen/binding/ComponentRequirement.java

@@ -30,13 +30,14 @@
 import androidx.room.compiler.processing.XType;
 import androidx.room.compiler.processing.XTypeElement;
 import com.google.auto.value.AutoValue;
-import com.squareup.javapoet.TypeName;
+import com.google.common.base.Equivalence;
 import dagger.internal.codegen.model.BindingKind;
 import dagger.internal.codegen.model.Key;
 import dagger.internal.codegen.xprocessing.Nullability;
 import dagger.internal.codegen.xprocessing.XParameterSpecs;
 import dagger.internal.codegen.xprocessing.XTypeElements;
 import dagger.internal.codegen.xprocessing.XTypeNames;
+import dagger.internal.codegen.xprocessing.XTypes;
 import java.util.Optional;
 
 /** A type that a component needs an instance of. */
@@ -65,8 +66,6 @@ public boolean isModule() {
     }
   }
 
-  private XType type;
-
   /** The kind of requirement. */
   public abstract Kind kind();
 
@@ -76,17 +75,17 @@ final boolean isBoundInstance() {
     return kind().isBoundInstance();
   }
 
-  /** The type of the instance the component must have. */
-  abstract TypeName typeName();
+  /** Returns the equivalence wrapper for the component requirement type. */
+  abstract Equivalence.Wrapper<XType> wrappedType();
 
   /** The type of the instance the component must have. */
   public XType type() {
-    return type;
+    return wrappedType().get();
   }
 
   /** The element associated with the type of this requirement. */
   public XTypeElement typeElement() {
-    return type.getTypeElement();
+    return type().getTypeElement();
   }
 
   /** The action a component builder should take if it {@code null} is passed. */
@@ -241,9 +240,8 @@ private static ComponentRequirement create(
       String variableName) {
     ComponentRequirement requirement =
         new AutoValue_ComponentRequirement(
-            kind, type.getTypeName(), overrideNullPolicy, key, variableName);
+            kind, XTypes.equivalence().wrap(type), overrideNullPolicy, key, variableName);
     requirement.nullability = nullability;
-    requirement.type = type;
     return requirement;
   }
 

dagger-compiler/main/java/dagger/internal/codegen/binding/MethodSignature.java

@@ -23,19 +23,20 @@
 import androidx.room.compiler.processing.XProcessingEnv;
 import androidx.room.compiler.processing.XType;
 import com.google.auto.value.AutoValue;
+import com.google.common.base.Equivalence;
 import com.google.common.collect.ImmutableList;
-import com.squareup.javapoet.TypeName;
 import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.xprocessing.XTypes;
 
 /** A class that defines proper {@code equals} and {@code hashcode} for a method signature. */
 @AutoValue
 public abstract class MethodSignature {
 
   abstract String name();
 
-  abstract ImmutableList<TypeName> parameterTypes();
+  abstract ImmutableList<Equivalence.Wrapper<XType>> parameterTypes();
 
-  abstract ImmutableList<TypeName> thrownTypes();
+  abstract ImmutableList<Equivalence.Wrapper<XType>> thrownTypes();
 
   public static MethodSignature forComponentMethod(
       ComponentMethodDescriptor componentMethod,
@@ -44,12 +45,14 @@ public static MethodSignature forComponentMethod(
     XMethodType methodType = componentMethod.methodElement().asMemberOf(componentType);
     return new AutoValue_MethodSignature(
         getSimpleName(componentMethod.methodElement()),
-        methodType.getParameterTypes().stream().map(XType::getTypeName).collect(toImmutableList()),
+        methodType.getParameterTypes().stream()
+            .map(XTypes.equivalence()::wrap)
+            .collect(toImmutableList()),
         // Using the thrown types of the method element, which should be the same as the method type
         // since thrown types can't use type variables.
         // TODO(bcorso): Support getting thrown types from XExecutableType in XProcessing.
         componentMethod.methodElement().getThrownTypes().stream()
-            .map(XType::getTypeName)
+            .map(XTypes.equivalence()::wrap)
             .collect(toImmutableList()));
   }
 }

dagger-compiler/main/java/dagger/internal/codegen/validation/ComponentDescriptorValidator.java

@@ -46,11 +46,11 @@
 import androidx.room.compiler.processing.XMethodType;
 import androidx.room.compiler.processing.XType;
 import androidx.room.compiler.processing.XTypeElement;
+import com.google.common.base.Equivalence;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSetMultimap;
 import com.google.common.collect.Multimaps;
 import com.google.common.collect.Sets;
-import com.squareup.javapoet.TypeName;
 import dagger.internal.codegen.base.DaggerSuperficialValidation;
 import dagger.internal.codegen.binding.ComponentCreatorDescriptor;
 import dagger.internal.codegen.binding.ComponentDescriptor;
@@ -338,19 +338,19 @@ private void validateCreators(ComponentDescriptor component) {
       }
 
       // Validate that declared creator requirements (modules, dependencies) have unique types.
-      ImmutableSetMultimap<TypeName, XElement> declaredRequirementsByType =
+      ImmutableSetMultimap<Equivalence.Wrapper<XType>, XElement> declaredRequirementsByType =
           Multimaps.filterKeys(
                   creator.unvalidatedRequirementElements(),
                   creatorModuleAndDependencyRequirements::contains)
               .entries()
               .stream()
               .collect(
                   toImmutableSetMultimap(
-                      entry -> entry.getKey().type().getTypeName(), Entry::getValue));
+                      entry -> XTypes.equivalence().wrap(entry.getKey().type()), Entry::getValue));
       declaredRequirementsByType
           .asMap()
           .forEach(
-              (type, elementsForType) -> {
+              (wrappedType, elementsForType) -> {
                 if (elementsForType.size() > 1) {
                   // TODO(cgdecker): Attach this error message to the factory method rather than
                   // the component type if the elements are factory method parameters AND the
@@ -359,7 +359,7 @@ private void validateCreators(ComponentDescriptor component) {
                       .addError(
                           String.format(
                               messages.multipleSettersForModuleOrDependencyType(),
-                              type,
+                              XTypes.toStableString(wrappedType.get()),
                               transform(
                                   elementsForType, element -> formatElement(element, container))),
                           creator.typeElement());