[Refactor]: Move ProvisionMethods#create()/InjectionSiteMethods#create() into the generator that uses it.

Note: this CL shouldn't cause any changes to the generated code.

`FactoryGenerator` is the only class that uses `ProvisionMethods#create()`, and `MembersInjectorGenerator` is the only class that uses `InjectionSiteMethods#create()`. Thus, I'm moving these methods into these classes for better encapsulation. This will also make the XPoet migration easier since I plan to migrate `FactoryGenerator` and `MembersInjectorGenerator` separately.

Note that these methods were sharing some logic that now needs to be duplicated, but IMO this creates more readable code since we're no longer entangling the two use cases. For example, now that `ProvisionMethods` and `InjectionSiteMethods` define their own versions of `methodProxy()` method, we no longer need the multiple enums (i.e. `InstanceCastPolicy` and `CheckNotNullPolicy`) as input to these methods.

RELNOTES=N/A
PiperOrigin-RevId: 700035303

Author: bcorso

java/dagger/internal/codegen/binding/SourceFiles.java

@@ -36,13 +36,15 @@
 import static dagger.internal.codegen.model.BindingKind.ASSISTED_INJECTION;
 import static dagger.internal.codegen.model.BindingKind.INJECTION;
 import static dagger.internal.codegen.xprocessing.XElements.asExecutable;
+import static dagger.internal.codegen.xprocessing.XElements.asMethod;
 import static dagger.internal.codegen.xprocessing.XElements.asTypeElement;
 import static dagger.internal.codegen.xprocessing.XElements.getSimpleName;
 import static dagger.internal.codegen.xprocessing.XTypeElements.typeVariableNames;
 import static javax.lang.model.SourceVersion.isName;
 
 import androidx.room.compiler.processing.XExecutableElement;
 import androidx.room.compiler.processing.XFieldElement;
+import androidx.room.compiler.processing.XMethodElement;
 import androidx.room.compiler.processing.XTypeElement;
 import com.google.common.base.Joiner;
 import com.google.common.collect.ImmutableList;
@@ -58,6 +60,7 @@
 import com.squareup.javapoet.TypeVariableName;
 import dagger.internal.codegen.base.MapType;
 import dagger.internal.codegen.base.SetType;
+import dagger.internal.codegen.binding.MembersInjectionBinding.InjectionSite;
 import dagger.internal.codegen.javapoet.TypeNames;
 import dagger.internal.codegen.model.DependencyRequest;
 import dagger.internal.codegen.model.RequestKind;
@@ -144,6 +147,23 @@ public ImmutableMap<DependencyRequest, CodeBlock> frameworkFieldUsages(
         dep -> frameworkTypeUsageStatement(CodeBlock.of("$N", fields.get(dep)), dep.kind()));
   }
 
+  public static String generatedProxyMethodName(ContributionBinding binding) {
+    switch (binding.kind()) {
+      case INJECTION:
+      case ASSISTED_INJECTION:
+        return "newInstance";
+      case PROVISION:
+        XMethodElement method = asMethod(binding.bindingElement().get());
+        String simpleName = getSimpleName(method);
+        // If the simple name is already defined in the factory, prepend "proxy" to the name.
+        return simpleName.contentEquals("get") || simpleName.contentEquals("create")
+            ? "proxy" + LOWER_CAMEL.to(UPPER_CAMEL, simpleName)
+            : simpleName;
+      default:
+        throw new AssertionError("Unexpected binding kind: " + binding);
+    }
+  }
+
   /** Returns the generated factory or members injector name for a binding. */
   public static ClassName generatedClassNameForBinding(Binding binding) {
     switch (binding.kind()) {
@@ -206,6 +226,29 @@ public static String memberInjectedFieldSignatureForVariable(XFieldElement field
     return field.getEnclosingElement().getClassName().canonicalName() + "." + getSimpleName(field);
   }
 
+  /*
+   * TODO(ronshapiro): this isn't perfect, as collisions could still exist. Some examples:
+   *
+   *  - @Inject void members() {} will generate a method that conflicts with the instance
+   *    method `injectMembers(T)`
+   *  - Adding the index could conflict with another member:
+   *      @Inject void a(Object o) {}
+   *      @Inject void a(String s) {}
+   *      @Inject void a1(String s) {}
+   *
+   *    Here, Method a(String) will add the suffix "1", which will conflict with the method
+   *    generated for a1(String)
+   *  - Members named "members" or "methods" could also conflict with the {@code static} injection
+   *    method.
+   */
+  public static String membersInjectorMethodName(InjectionSite injectionSite) {
+    int index = injectionSite.indexAmongAtInjectMembersWithSameSimpleName();
+    String indexString = index == 0 ? "" : String.valueOf(index + 1);
+    return "inject"
+        + LOWER_CAMEL.to(UPPER_CAMEL, getSimpleName(injectionSite.element()))
+        + indexString;
+  }
+
   public static String classFileName(ClassName className) {
     return CLASS_FILE_NAME_JOINER.join(className.simpleNames());
   }

java/dagger/internal/codegen/writing/FactoryGenerator.java

@@ -24,6 +24,7 @@
 import static dagger.internal.codegen.binding.SourceFiles.bindingTypeElementTypeVariableNames;
 import static dagger.internal.codegen.binding.SourceFiles.generateBindingFieldsForDependencies;
 import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+import static dagger.internal.codegen.binding.SourceFiles.generatedProxyMethodName;
 import static dagger.internal.codegen.binding.SourceFiles.parameterizedGeneratedTypeNameForBinding;
 import static dagger.internal.codegen.extension.DaggerStreams.presentValues;
 import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
@@ -36,15 +37,26 @@
 import static dagger.internal.codegen.model.BindingKind.INJECTION;
 import static dagger.internal.codegen.model.BindingKind.PROVISION;
 import static dagger.internal.codegen.writing.GwtCompatibility.gwtIncompatibleAnnotation;
+import static dagger.internal.codegen.writing.InjectionMethods.copyParameter;
+import static dagger.internal.codegen.writing.InjectionMethods.copyParameters;
+import static dagger.internal.codegen.xprocessing.XElements.asConstructor;
+import static dagger.internal.codegen.xprocessing.XElements.asMethod;
+import static dagger.internal.codegen.xprocessing.XElements.asTypeElement;
+import static dagger.internal.codegen.xprocessing.XTypeElements.typeVariableNames;
 import static javax.lang.model.element.Modifier.FINAL;
 import static javax.lang.model.element.Modifier.PRIVATE;
 import static javax.lang.model.element.Modifier.PUBLIC;
 import static javax.lang.model.element.Modifier.STATIC;
 
+import androidx.room.compiler.processing.XConstructorElement;
 import androidx.room.compiler.processing.XElement;
+import androidx.room.compiler.processing.XExecutableElement;
 import androidx.room.compiler.processing.XExecutableParameterElement;
 import androidx.room.compiler.processing.XFiler;
+import androidx.room.compiler.processing.XMethodElement;
 import androidx.room.compiler.processing.XProcessingEnv;
+import androidx.room.compiler.processing.XType;
+import androidx.room.compiler.processing.XTypeElement;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
@@ -56,6 +68,7 @@
 import com.squareup.javapoet.ParameterSpec;
 import com.squareup.javapoet.TypeName;
 import com.squareup.javapoet.TypeSpec;
+import dagger.internal.Preconditions;
 import dagger.internal.codegen.base.SourceFileGenerator;
 import dagger.internal.codegen.base.UniqueNameSet;
 import dagger.internal.codegen.binding.AssistedInjectionBinding;
@@ -73,6 +86,7 @@
 import dagger.internal.codegen.model.Scope;
 import dagger.internal.codegen.writing.InjectionMethods.InjectionSiteMethod;
 import dagger.internal.codegen.writing.InjectionMethods.ProvisionMethod;
+import dagger.internal.codegen.xprocessing.Nullability;
 import java.util.Optional;
 import java.util.stream.Stream;
 import javax.inject.Inject;
@@ -136,7 +150,7 @@ private TypeSpec.Builder factoryBuilder(ContributionBinding binding) {
     return factoryBuilder
         .addMethod(getMethod(binding, factoryFields))
         .addMethod(staticCreateMethod(binding, factoryFields))
-        .addMethod(staticProvisionMethod(binding));
+        .addMethod(staticProxyMethod(binding));
   }
 
   // private static final class InstanceHolder {
@@ -298,17 +312,101 @@ private MethodSpec getMethod(ContributionBinding binding, FactoryFields factoryF
     return getMethod.build();
   }
 
-  // Example 1: Provision binding
-  // public static Foo provideFoo(FooModule module, Bar bar, Baz baz) {
-  //   return Preconditions.checkNotNullFromProvides(module.provideFoo(bar, baz));
-  // }
+  private MethodSpec staticProxyMethod(ContributionBinding binding) {
+    switch (binding.kind()) {
+      case INJECTION:
+      case ASSISTED_INJECTION:
+        return staticProxyMethodForInjection(binding);
+      case PROVISION:
+        return staticProxyMethodForProvision((ProvisionBinding) binding);
+      default:
+        throw new AssertionError("Unexpected binding kind: " + binding);
+    }
+  }
+
+  // Example:
   //
-  // Example 2: Injection binding
   // public static Foo newInstance(Bar bar, Baz baz) {
   //   return new Foo(bar, baz);
   // }
-  private MethodSpec staticProvisionMethod(ContributionBinding binding) {
-    return ProvisionMethod.create(binding, compilerOptions);
+  private static MethodSpec staticProxyMethodForInjection(ContributionBinding binding) {
+    XConstructorElement constructor = asConstructor(binding.bindingElement().get());
+    XTypeElement enclosingType = constructor.getEnclosingElement();
+    MethodSpec.Builder builder =
+        methodBuilder(generatedProxyMethodName(binding))
+            .addModifiers(PUBLIC, STATIC)
+            .varargs(constructor.isVarArgs())
+            .returns(enclosingType.getType().getTypeName())
+            .addTypeVariables(typeVariableNames(enclosingType))
+            .addExceptions(getThrownTypes(constructor));
+    CodeBlock arguments = copyParameters(builder, new UniqueNameSet(), constructor.getParameters());
+    return builder
+        .addStatement("return new $T($L)", enclosingType.getType().getTypeName(), arguments)
+        .build();
+  }
+
+  // Example:
+  //
+  // public static Foo provideFoo(FooModule module, Bar bar, Baz baz) {
+  //   return Preconditions.checkNotNullFromProvides(module.provideFoo(bar, baz));
+  // }
+  private MethodSpec staticProxyMethodForProvision(ProvisionBinding binding) {
+    XMethodElement method = asMethod(binding.bindingElement().get());
+    MethodSpec.Builder builder =
+        methodBuilder(generatedProxyMethodName(binding))
+            .addModifiers(PUBLIC, STATIC)
+            .varargs(method.isVarArgs())
+            .addExceptions(getThrownTypes(method));
+
+    XTypeElement enclosingType = asTypeElement(method.getEnclosingElement());
+    UniqueNameSet parameterNameSet = new UniqueNameSet();
+    CodeBlock module;
+    if (method.isStatic() || enclosingType.isCompanionObject()) {
+      module = CodeBlock.of("$T", enclosingType.getClassName());
+    } else if (enclosingType.isKotlinObject()) {
+      // Call through the singleton instance.
+      // See: https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#static-methods
+      module = CodeBlock.of("$T.INSTANCE", enclosingType.getClassName());
+    } else {
+      builder.addTypeVariables(typeVariableNames(enclosingType));
+      module = copyInstance(builder, parameterNameSet, enclosingType.getType());
+    }
+    CodeBlock arguments = copyParameters(builder, parameterNameSet, method.getParameters());
+    CodeBlock invocation = CodeBlock.of("$L.$L($L)", module, method.getJvmName(), arguments);
+
+    Nullability nullability = Nullability.of(method);
+    nullability
+        .nonTypeUseNullableAnnotations()
+        .forEach(builder::addAnnotation);
+    return builder
+        .returns(
+            method.getReturnType().getTypeName()
+                .annotated(
+                    nullability.typeUseNullableAnnotations().stream()
+                        .map(annotation -> AnnotationSpec.builder(annotation).build())
+                        .collect(toImmutableList())))
+        .addStatement("return $L", maybeWrapInCheckForNull(binding, invocation))
+        .build();
+  }
+
+  private CodeBlock maybeWrapInCheckForNull(ProvisionBinding binding, CodeBlock codeBlock) {
+    return binding.shouldCheckForNull(compilerOptions)
+        ? CodeBlock.of("$T.checkNotNullFromProvides($L)", Preconditions.class, codeBlock)
+        : codeBlock;
+  }
+
+  private static CodeBlock copyInstance(
+      MethodSpec.Builder methodBuilder, UniqueNameSet parameterNameSet, XType type) {
+    return copyParameter(
+        methodBuilder,
+        type,
+        parameterNameSet.getUniqueName("instance"),
+        /* useObject= */ false,
+        Nullability.NOT_NULLABLE);
+  }
+
+  private static ImmutableList<TypeName> getThrownTypes(XExecutableElement executable) {
+    return executable.getThrownTypes().stream().map(XType::getTypeName).collect(toImmutableList());
   }
 
   private AnnotationSpec scopeMetadataAnnotation(ContributionBinding binding) {