[XPoet Migration]: Migrate more CodeBlock usages to XCodeBlock

This CL migrates the remaining classes in `dagger/internal/codegen/binding/*` to XPoet and the associated classes.

RELNOTES=N/A
PiperOrigin-RevId: 740034904

Author: bcorso

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

@@ -16,23 +16,22 @@
 
 package dagger.internal.codegen.binding;
 
-import static androidx.room.compiler.codegen.XTypeNameKt.toJavaPoet;
 import static androidx.room.compiler.processing.XTypeKt.isArray;
 import static dagger.internal.codegen.binding.SourceFiles.classFileName;
 import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
-import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
 import static dagger.internal.codegen.xprocessing.XAnnotationValues.characterLiteralWithSingleQuotes;
+import static dagger.internal.codegen.xprocessing.XCodeBlocks.makeParametersCodeBlock;
+import static dagger.internal.codegen.xprocessing.XCodeBlocks.toParametersCodeBlock;
 import static dagger.internal.codegen.xprocessing.XElements.getSimpleName;
 import static dagger.internal.codegen.xprocessing.XTypes.asArray;
 import static dagger.internal.codegen.xprocessing.XTypes.isTypeOf;
 
 import androidx.room.compiler.codegen.XClassName;
+import androidx.room.compiler.codegen.XCodeBlock;
 import androidx.room.compiler.processing.XAnnotation;
 import androidx.room.compiler.processing.XAnnotationValue;
 import androidx.room.compiler.processing.XType;
 import androidx.room.compiler.processing.XTypeElement;
-import com.squareup.javapoet.CodeBlock;
 import dagger.internal.codegen.xprocessing.XTypeNames;
 
 /**
@@ -59,14 +58,14 @@ public final class AnnotationExpression {
    * Returns an expression that calls static methods on the annotation's creator class to create an
    * annotation instance equivalent the annotation passed to the constructor.
    */
-  CodeBlock getAnnotationInstanceExpression() {
+  XCodeBlock getAnnotationInstanceExpression() {
     return getAnnotationInstanceExpression(annotation);
   }
 
-  private CodeBlock getAnnotationInstanceExpression(XAnnotation annotation) {
-    return CodeBlock.of(
-        "$T.$L($L)",
-        toJavaPoet(creatorClass),
+  private XCodeBlock getAnnotationInstanceExpression(XAnnotation annotation) {
+    return XCodeBlock.of(
+        "%T.%L(%L)",
+        creatorClass,
         createMethodName(annotation.getType().getTypeElement()),
         makeParametersCodeBlock(
             annotation.getAnnotationValues().stream()
@@ -93,45 +92,43 @@ public static String createMethodName(XTypeElement annotationType) {
    * Returns an expression that evaluates to a {@code value} of a given type on an {@code
    * annotation}.
    */
-  CodeBlock getValueExpression(XAnnotationValue value) {
+  XCodeBlock getValueExpression(XAnnotationValue value) {
     if (isArray(value.getValueType())) {
       XType componentType = asArray(value.getValueType()).getComponentType();
-      return CodeBlock.of(
-          "new $T[] {$L}",
+      return XCodeBlock.of(
+          "new %T[] {%L}",
           // TODO(b/264464791): The KClass -> Class swap can be removed once this bug is fixed.
-          toJavaPoet(
-              isTypeOf(componentType, XTypeNames.KCLASS)
-                  ? XTypeNames.CLASS
-                  : componentType.getRawType().asTypeName()),
+          isTypeOf(componentType, XTypeNames.KCLASS)
+              ? XTypeNames.CLASS
+              : componentType.getRawType().asTypeName(),
           value.asAnnotationValueList().stream()
               .map(this::getValueExpression)
               .collect(toParametersCodeBlock()));
     } else if (value.hasEnumValue()) {
-      return CodeBlock.of(
-          "$T.$L",
-          value.asEnum().getEnclosingElement().getClassName(),
-          getSimpleName(value.asEnum()));
+      return XCodeBlock.of(
+          "%T.%L",
+          value.asEnum().getEnclosingElement().asClassName(), getSimpleName(value.asEnum()));
     } else if (value.hasAnnotationValue()) {
       return getAnnotationInstanceExpression(value.asAnnotation());
     } else if (value.hasTypeValue()) {
-      return CodeBlock.of("$T.class", value.asType().getTypeElement().getClassName());
+      return XCodeBlock.of("%T.class", value.asType().getTypeElement().asClassName());
     } else if (value.hasStringValue()) {
-      return CodeBlock.of("$S", value.asString());
+      return XCodeBlock.of("%S", value.asString());
     } else if (value.hasByteValue()) {
-      return CodeBlock.of("(byte) $L", value.asByte());
+      return XCodeBlock.of("(byte) %L", value.asByte());
     } else if (value.hasCharValue()) {
       // TODO(bcorso): Replace when https://github.com/square/javapoet/issues/698 is fixed.
-      return CodeBlock.of("$L", characterLiteralWithSingleQuotes(value.asChar()));
+      return XCodeBlock.of("%L", characterLiteralWithSingleQuotes(value.asChar()));
     } else if (value.hasDoubleValue()) {
-      return CodeBlock.of("$LD", value.asDouble());
+      return XCodeBlock.of("%LD", value.asDouble());
     } else if (value.hasFloatValue()) {
-      return CodeBlock.of("$LF", value.asFloat());
+      return XCodeBlock.of("%LF", value.asFloat());
     } else if (value.hasLongValue()) {
-      return CodeBlock.of("$LL", value.asLong());
+      return XCodeBlock.of("%LL", value.asLong());
     } else if (value.hasShortValue()) {
-      return CodeBlock.of("(short) $L", value.asShort());
+      return XCodeBlock.of("(short) %L", value.asShort());
     } else {
-      return CodeBlock.of("$L", value.getValue());
+      return XCodeBlock.of("%L", value.getValue());
     }
   }
 }

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

@@ -16,7 +16,7 @@
 
 package dagger.internal.codegen.binding;
 
-import static androidx.room.compiler.codegen.XTypeNameKt.toJavaPoet;
+import static androidx.room.compiler.codegen.compat.XConverters.toJavaPoet;
 import static androidx.room.compiler.processing.XTypeKt.isArray;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.collect.Iterables.getOnlyElement;
@@ -25,6 +25,7 @@
 import static dagger.internal.codegen.binding.SourceFiles.elementBasedClassName;
 import static dagger.internal.codegen.extension.DaggerCollectors.toOptional;
 import static dagger.internal.codegen.xprocessing.XElements.asExecutable;
+import static dagger.internal.codegen.xprocessing.XElements.asMethod;
 import static dagger.internal.codegen.xprocessing.XElements.getSimpleName;
 import static dagger.internal.codegen.xprocessing.XTypes.isDeclared;
 import static dagger.internal.codegen.xprocessing.XTypes.isTypeOf;
@@ -33,6 +34,7 @@
 import static javax.lang.model.element.Modifier.STATIC;
 
 import androidx.room.compiler.codegen.XClassName;
+import androidx.room.compiler.codegen.XCodeBlock;
 import androidx.room.compiler.processing.XAnnotation;
 import androidx.room.compiler.processing.XAnnotationValue;
 import androidx.room.compiler.processing.XElement;
@@ -41,7 +43,6 @@
 import androidx.room.compiler.processing.XType;
 import androidx.room.compiler.processing.XTypeElement;
 import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.CodeBlock;
 import com.squareup.javapoet.MethodSpec;
 import dagger.MapKey;
 import dagger.internal.codegen.base.DaggerSuperficialValidation;
@@ -134,38 +135,38 @@ public static XType getUnwrappedMapKeyType(XType mapKeyAnnotationType) {
    * @throws IllegalStateException if {@code binding} is not a {@link dagger.multibindings.IntoMap
    *     map} contribution.
    */
-  public static CodeBlock getMapKeyExpression(
+  public static XCodeBlock getMapKeyExpression(
       ContributionBinding binding, XClassName requestingClass, XProcessingEnv processingEnv) {
     XAnnotation mapKeyAnnotation = binding.mapKey().get();
     return MapKeyAccessibility.isMapKeyAccessibleFrom(
             mapKeyAnnotation, requestingClass.getPackageName())
         ? directMapKeyExpression(mapKeyAnnotation, processingEnv)
-        : CodeBlock.of("$T.create()", toJavaPoet(mapKeyProxyClassName(binding)));
+        : XCodeBlock.of("%T.create()", mapKeyProxyClassName(binding));
   }
 
   /**
    * Returns a code block for the map key annotation {@code mapKey}.
    *
    * <p>This method assumes the map key will be accessible in the context that the returned {@link
-   * CodeBlock} is used. Use {@link #getMapKeyExpression(ContributionBinding, XClassName,
+   * XCodeBlock} is used. Use {@link #getMapKeyExpression(ContributionBinding, XClassName,
    * XProcessingEnv)} when that assumption is not guaranteed.
    *
    * @throws IllegalArgumentException if the element is annotated with more than one {@code MapKey}
    *     annotation
    * @throws IllegalStateException if {@code bindingElement} is not annotated with a {@code MapKey}
    *     annotation
    */
-  private static CodeBlock directMapKeyExpression(
+  private static XCodeBlock directMapKeyExpression(
       XAnnotation mapKey, XProcessingEnv processingEnv) {
     Optional<XAnnotationValue> unwrappedValue = unwrapValue(mapKey);
     if (mapKey.getQualifiedName().contentEquals("dagger.android.AndroidInjectionKey")) {
       XTypeElement unwrappedType =
           DaggerSuperficialValidation.requireTypeElement(
               processingEnv, unwrappedValue.get().asString());
-      return CodeBlock.of(
-          "$T.of($S)",
-          toJavaPoet(XClassName.get("dagger.android.internal", "AndroidInjectionKeys")),
-          unwrappedType.getClassName().reflectionName());
+      return XCodeBlock.of(
+          "%T.of(%S)",
+          XClassName.get("dagger.android.internal", "AndroidInjectionKeys"),
+          unwrappedType.asClassName().getReflectionName());
     }
     AnnotationExpression annotationExpression = new AnnotationExpression(mapKey);
     return unwrappedValue.isPresent()
@@ -196,7 +197,8 @@ public static Optional<MethodSpec> mapKeyFactoryMethod(
                 methodBuilder("create")
                     .addModifiers(PUBLIC, STATIC)
                     .returns(mapKeyType(mapKey).getTypeName())
-                    .addStatement("return $L", directMapKeyExpression(mapKey, processingEnv))
+                    .addStatement(
+                        "return $L", toJavaPoet(directMapKeyExpression(mapKey, processingEnv)))
                     .build());
   }
 
@@ -221,12 +223,10 @@ public static boolean useLazyClassKey(Binding binding, BindingGraph graph) {
     return false;
   }
 
-  public static CodeBlock getLazyClassMapKeyExpression(ContributionBinding contributionBinding) {
-    XClassName proxyClassName =
-        lazyClassKeyProxyClassName(XElements.asMethod(contributionBinding.bindingElement().get()));
-    return CodeBlock.of(
-        "$T.$N",
-        toJavaPoet(proxyClassName),
+  public static XCodeBlock getLazyClassMapKeyExpression(ContributionBinding contributionBinding) {
+    return XCodeBlock.of(
+        "%T.%N",
+        lazyClassKeyProxyClassName(asMethod(contributionBinding.bindingElement().get())),
         LAZY_CLASS_KEY_NAME_FIELD);
   }
 

dagger-compiler/main/java/dagger/internal/codegen/javapoet/Expression.java

@@ -16,8 +16,10 @@
 
 package dagger.internal.codegen.javapoet;
 
+import static androidx.room.compiler.codegen.compat.XConverters.toJavaPoet;
 import static dagger.internal.codegen.xprocessing.XTypes.isPrimitive;
 
+import androidx.room.compiler.codegen.XCodeBlock;
 import androidx.room.compiler.processing.XRawType;
 import androidx.room.compiler.processing.XType;
 import com.squareup.javapoet.CodeBlock;
@@ -45,11 +47,21 @@ private Expression(ExpressionType type, CodeBlock codeBlock) {
     this.codeBlock = codeBlock;
   }
 
+  /** Creates a new {@link Expression} with a {@link XType} and {@link CodeBlock}. */
+  public static Expression create(XType type, XCodeBlock expression) {
+    return create(type, toJavaPoet(expression));
+  }
+
   /** Creates a new {@link Expression} with a {@link XType} and {@link CodeBlock}. */
   public static Expression create(XType type, CodeBlock expression) {
     return new Expression(ExpressionType.create(type), expression);
   }
 
+  /** Creates a new {@link Expression} with a {@link ExpressionType} and {@link CodeBlock}. */
+  public static Expression create(ExpressionType type, XCodeBlock expression) {
+    return create(type, toJavaPoet(expression));
+  }
+
   /** Creates a new {@link Expression} with a {@link ExpressionType} and {@link CodeBlock}. */
   public static Expression create(ExpressionType type, CodeBlock expression) {
     return new Expression(type, expression);

dagger-compiler/main/java/dagger/internal/codegen/writing/MapFactoryCreationExpression.java

@@ -16,13 +16,14 @@
 
 package dagger.internal.codegen.writing;
 
-import static androidx.room.compiler.codegen.XTypeNameKt.toJavaPoet;
+import static androidx.room.compiler.codegen.compat.XConverters.toJavaPoet;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static dagger.internal.codegen.binding.MapKeys.getLazyClassMapKeyExpression;
 import static dagger.internal.codegen.binding.MapKeys.getMapKeyExpression;
 import static dagger.internal.codegen.binding.SourceFiles.mapFactoryClassName;
 
 import androidx.room.compiler.codegen.XClassName;
+import androidx.room.compiler.codegen.XCodeBlock;
 import androidx.room.compiler.codegen.XTypeName;
 import androidx.room.compiler.processing.XProcessingEnv;
 import com.squareup.javapoet.CodeBlock;
@@ -64,37 +65,36 @@ final class MapFactoryCreationExpression extends MultibindingFactoryCreationExpr
   @Override
   public CodeBlock creationExpression() {
     XClassName mapFactoryClassName = mapFactoryClassName(binding);
-    CodeBlock.Builder builder = CodeBlock.builder().add("$T.", toJavaPoet(mapFactoryClassName));
+    XCodeBlock.Builder builder = XCodeBlock.builder().add("%T.", mapFactoryClassName);
     XTypeName valueTypeName = XTypeName.ANY_OBJECT;
     if (!useRawType()) {
       MapType mapType = MapType.from(binding.key());
       valueTypeName = mapType.unwrappedFrameworkValueType().asTypeName();
       builder.add(
-          "<$T, $T>",
-          toJavaPoet(useLazyClassKey ? XTypeName.STRING : mapType.keyType().asTypeName()),
-          toJavaPoet(valueTypeName));
+          "<%T, %T>",
+          useLazyClassKey ? XTypeName.STRING : mapType.keyType().asTypeName(), valueTypeName);
     }
 
-    builder.add("builder($L)", binding.dependencies().size());
+    builder.add("builder(%L)", binding.dependencies().size());
 
     for (DependencyRequest dependency : binding.dependencies()) {
       ContributionBinding contributionBinding = graph.contributionBinding(dependency.key());
       builder.add(
-          ".put($L, $L)",
+          ".put(%L, %L)",
           useLazyClassKey
               ? getLazyClassMapKeyExpression(graph.contributionBinding(dependency.key()))
               : getMapKeyExpression(
                   contributionBinding, componentImplementation.name(), processingEnv),
           multibindingDependencyExpression(dependency));
     }
 
-    return useLazyClassKey
-        ? CodeBlock.of(
-            "$T.<$T>of($L)",
-            toJavaPoet(lazyMapFactoryClassName(binding)),
-            toJavaPoet(valueTypeName),
-            builder.add(".build()").build())
-        : builder.add(".build()").build();
+    XCodeBlock creationExpression = builder.add(".build()").build();
+    return toJavaPoet(
+        useLazyClassKey
+            ? XCodeBlock.of(
+                "%T.<%T>of(%L)",
+                lazyMapFactoryClassName(binding), valueTypeName, creationExpression)
+            : creationExpression);
   }
 
   private static XClassName lazyMapFactoryClassName(MultiboundMapBinding binding) {