Fix handling of Kotlin object Producer modules so that @JvmStatic isn't required

RELNOTES=n/a
PiperOrigin-RevId: 644066003

Author: Chang-Eric

java/dagger/internal/codegen/writing/ProducerFactoryGenerator.java

@@ -314,25 +314,34 @@ private MethodSpec callProducesMethod(ProductionBinding binding, FactoryFields f
       methodBuilder.addAnnotation(AnnotationSpecs.suppressWarnings(UNCHECKED));
     }
 
-    CodeBlock moduleCodeBlock =
+    CodeBlock moduleCodeBlock;
+    if (factoryFields.moduleField.isPresent()) {
+      moduleCodeBlock = CodeBlock.of(factoryFields.moduleField.get().name);
+    } else if (binding.contributingModule().isPresent()
+        && binding.contributingModule().get().isKotlinObject()) {
+      moduleCodeBlock = CodeBlock.of(
+          "$T.INSTANCE", binding.bindingTypeElement().get().getClassName());
+    } else {
+      moduleCodeBlock = CodeBlock.of("$T", binding.bindingTypeElement().get().getClassName());
+    }
+
+    CodeBlock factoryMethodCall =
         CodeBlock.of(
             "$L.$L($L)",
-            factoryFields.moduleField.isPresent()
-                ? factoryFields.moduleField.get().name
-                : CodeBlock.of("$T", binding.bindingTypeElement().get().getClassName()),
+            moduleCodeBlock,
             getSimpleName(binding.bindingElement().get()),
             makeParametersCodeBlock(parameterCodeBlocks.build()));
 
     switch (binding.productionKind().get()) {
       case IMMEDIATE:
         methodBuilder.addStatement(
-            "return $T.<$T>immediateFuture($L)", FUTURES, contributedTypeName, moduleCodeBlock);
+            "return $T.<$T>immediateFuture($L)", FUTURES, contributedTypeName, factoryMethodCall);
         break;
       case FUTURE:
-        methodBuilder.addStatement("return $L", moduleCodeBlock);
+        methodBuilder.addStatement("return $L", factoryMethodCall);
         break;
       case SET_OF_FUTURE:
-        methodBuilder.addStatement("return $T.allAsSet($L)", PRODUCERS, moduleCodeBlock);
+        methodBuilder.addStatement("return $T.allAsSet($L)", PRODUCERS, factoryMethodCall);
         break;
     }
     return methodBuilder.build();

javatests/dagger/functional/producers/kotlin/BUILD

@@ -0,0 +1,47 @@
+# Copyright (C) 2024 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+#   Producers test code with Kotlin language features
+
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+load("//:test_defs.bzl", "GenJavaTests")
+
+package(default_visibility = ["//:src"])
+
+GenJavaTests(
+    name = "ObjectModuleTest",
+    srcs = ["ObjectModuleTest.java"],
+    functional = True,
+    test_only_deps = [
+        "//third_party/java/guava/util/concurrent",
+        "//third_party/java/junit",
+        "//third_party/java/truth",
+    ],
+    deps = [
+        ":ObjectModuleClasses",
+    ],
+)
+
+kt_jvm_library(
+    name = "ObjectModuleClasses",
+    srcs = [
+        "ObjectModuleClasses.kt",
+    ],
+    deps = [
+        "//:dagger_with_compiler",
+        "//:producers_with_compiler",
+        "//third_party/java/guava/util/concurrent",
+    ],
+)

javatests/dagger/functional/producers/kotlin/ObjectModuleClasses.kt

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2024 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.producers.kotlin
+
+import com.google.common.util.concurrent.ListenableFuture
+import com.google.common.util.concurrent.MoreExecutors
+import dagger.Module
+import dagger.Provides
+import dagger.producers.ProducerModule
+import dagger.producers.Produces
+import dagger.producers.Production
+import dagger.producers.ProductionComponent
+import dagger.multibindings.IntoSet
+import java.util.concurrent.Executor
+import javax.inject.Named
+
+@ProductionComponent(
+  modules = [
+    ExecutorModule::class,
+    TestKotlinObjectModule::class,
+    TestModuleForNesting.TestNestedKotlinObjectModule::class
+  ]
+)
+interface TestKotlinComponentWithObjectModule {
+  fun getDataA(): ListenableFuture<TestDataA>
+  @Named("nested-data-a")
+  fun getDataAFromNestedModule(): ListenableFuture<TestDataA>
+  fun getDataB(): ListenableFuture<TestDataB>
+  fun getSetOfDataA(): ListenableFuture<Set<TestDataA>>
+}
+
+@ProducerModule
+object TestKotlinObjectModule {
+  @Produces
+  fun provideDataA() = TestDataA("test")
+
+  @Produces
+  @JvmStatic
+  fun provideDataB() = TestDataB("static-test")
+
+  @Produces
+  @IntoSet
+  fun provideIntoMapDataA() = TestDataA("set-test")
+}
+
+class TestModuleForNesting {
+  @ProducerModule
+  object TestNestedKotlinObjectModule {
+    @Produces
+    @Named("nested-data-a")
+    fun provideDataA() = TestDataA("nested-test")
+  }
+}
+
+data class TestDataA(val data: String)
+data class TestDataB(val data: String)
+
+@Module
+object ExecutorModule {
+  @Provides
+  @Production
+  fun executor(): Executor = MoreExecutors.directExecutor()
+}

javatests/dagger/functional/producers/kotlin/ObjectModuleTest.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2024 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.producers.kotlin;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ObjectModuleTest {
+
+  @Test
+  public void verifyObjectModule() throws Exception {
+    TestKotlinComponentWithObjectModule component =
+        DaggerTestKotlinComponentWithObjectModule.create();
+    assertThat(component.getDataA().get().getData()).isEqualTo("test");
+    assertThat(component.getDataAFromNestedModule().get().getData()).isEqualTo("nested-test");
+    assertThat(component.getDataB().get().getData()).isEqualTo("static-test");
+    ListenableFuture<Set<TestDataA>> setFuture = component.getSetOfDataA();
+    assertThat(setFuture).isNotNull();
+    assertThat(setFuture.get()).hasSize(1);
+    assertThat(setFuture.get().iterator().next().getData()).isEqualTo("set-test");
+  }
+}