Update to dagger 2.50

compiler-utils/dependencies/runtimeClasspath.txt

@@ -1,4 +1,4 @@
-com.google.dagger:dagger:2.46.1
+com.google.dagger:dagger:2.50
 com.squareup:kotlinpoet-jvm:1.16.0
 com.squareup:kotlinpoet:1.16.0
 javax.inject:javax.inject:1

compiler-utils/src/testFixtures/java/com/squareup/anvil/compiler/internal/testing/AnvilCompilation.kt

@@ -16,6 +16,7 @@ import com.tschuchort.compiletesting.kspArgs
 import com.tschuchort.compiletesting.kspWithCompilation
 import com.tschuchort.compiletesting.symbolProcessorProviders
 import dagger.internal.codegen.ComponentProcessor
+import dagger.internal.codegen.KspComponentProcessor
 import org.intellij.lang.annotations.Language
 import org.jetbrains.kotlin.config.JvmTarget
 import java.io.File
@@ -107,7 +108,11 @@ public class AnvilCompilation internal constructor(
               ServiceLoader.load(
                 SymbolProcessorProvider::class.java,
                 SymbolProcessorProvider::class.java.classLoader,
-              ),
+              )
+                // TODO for now, we don't want to run the dagger KSP processor while we're testing
+                //  KSP. This will change when we start supporting dagger-KSP, at which point we can
+                //  change this filter to be based on https://github.com/square/anvil/pull/713
+                .filterNot { it is KspComponentProcessor.Provider },
             )
             addAll(mode.symbolProcessorProviders)
           }

compiler/build.gradle.kts

@@ -53,6 +53,8 @@ dependencies {
 
   testImplementation(testFixtures(project(":compiler-utils")))
   testImplementation(libs.dagger2.compiler)
+  // Force later guava version for Dagger's needs
+  testImplementation(libs.guava)
   testImplementation(libs.kotlin.annotationProcessingEmbeddable)
   testImplementation(libs.kotlin.compileTesting)
   testImplementation(libs.kotlin.compileTesting.ksp)

compiler/dependencies/runtimeClasspath.txt

@@ -1,4 +1,4 @@
-com.google.dagger:dagger:2.46.1
+com.google.dagger:dagger:2.50
 com.squareup:kotlinpoet-jvm:1.16.0
 com.squareup:kotlinpoet-ksp:1.16.0
 com.squareup:kotlinpoet:1.16.0

compiler/src/main/java/com/squareup/anvil/compiler/codegen/dagger/AssistedFactoryCodeGen.kt

@@ -558,19 +558,24 @@ internal object AssistedFactoryCodeGen : AnvilApplicabilityChecker {
             .build(),
         )
         .apply {
+          fun createFactory(name: String, providerTypeName: ClassName): FunSpec {
+            return FunSpec.builder(name)
+              .jvmStatic()
+              .addTypeVariables(typeParameters)
+              .addParameter(DELEGATE_FACTORY_NAME, generatedFactoryTypeName)
+              .returns(providerTypeName.parameterizedBy(baseFactoryTypeName))
+              .addStatement(
+                "return %T.create(%T($DELEGATE_FACTORY_NAME))",
+                InstanceFactory::class,
+                implParameterizedTypeName,
+              )
+              .build()
+          }
           TypeSpec.companionObjectBuilder()
+            .addFunction(createFactory("create", Provider::class.asClassName()))
+            // New in Dagger 2.50: factories for dagger.internal.Provider
             .addFunction(
-              FunSpec.builder("create")
-                .jvmStatic()
-                .addTypeVariables(typeParameters)
-                .addParameter(DELEGATE_FACTORY_NAME, generatedFactoryTypeName)
-                .returns(Provider::class.asClassName().parameterizedBy(baseFactoryTypeName))
-                .addStatement(
-                  "return %T.create(%T($DELEGATE_FACTORY_NAME))",
-                  InstanceFactory::class,
-                  implParameterizedTypeName,
-                )
-                .build(),
+              createFactory("createFactoryProvider", dagger.internal.Provider::class.asClassName()),
             )
             .build()
             .let {

compiler/src/main/java/com/squareup/anvil/compiler/codegen/dagger/BindsMethodValidator.kt

@@ -59,9 +59,15 @@ internal class BindsMethodValidator : PrivateCodeGenerator() {
       )
     }
 
+    if (function.function.isExtensionDeclaration()) {
+      throw AnvilCompilationExceptionFunctionReference(
+        message = "@Binds methods can not be an extension function",
+        functionReference = function,
+      )
+    }
+
     val hasSingleBindingParameter =
-      (function.parameters.size == 1 && !function.function.isExtensionDeclaration()) ||
-        (function.parameters.isEmpty() && function.function.isExtensionDeclaration())
+      function.parameters.size == 1 && !function.function.isExtensionDeclaration()
     if (!hasSingleBindingParameter) {
       throw AnvilCompilationExceptionFunctionReference(
         message = "@Binds methods must have exactly one parameter, " +

compiler/src/main/java/com/squareup/anvil/compiler/codegen/dagger/ProvidesMethodFactoryCodeGen.kt

@@ -65,6 +65,7 @@ import dagger.internal.Factory
 import dagger.internal.Preconditions
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.psiUtil.isExtensionDeclaration
 import java.io.File
 
 internal object ProvidesMethodFactoryCodeGen : AnvilApplicabilityChecker {
@@ -151,6 +152,12 @@ internal object ProvidesMethodFactoryCodeGen : AnvilApplicabilityChecker {
     }
 
     private fun CallableReference.Companion.from(function: KSFunctionDeclaration): CallableReference {
+      if (function.extensionReceiver != null) {
+        throw KspAnvilException(
+          message = "@Provides methods cannot be extension functions",
+          node = function,
+        )
+      }
       val type = function.returnType?.resolve() ?: throw KspAnvilException(
         message = "Error occurred in type resolution and could not resolve return type.",
         node = function,
@@ -281,6 +288,12 @@ internal object ProvidesMethodFactoryCodeGen : AnvilApplicabilityChecker {
     }
 
     private fun CallableReference.Companion.from(function: MemberFunctionReference.Psi): CallableReference {
+      if (function.function.isExtensionDeclaration()) {
+        throw AnvilCompilationExceptionFunctionReference(
+          message = "@Provides methods can not be an extension function",
+          functionReference = function,
+        )
+      }
       val type = function.returnTypeOrNull() ?: throw AnvilCompilationExceptionFunctionReference(
         message = "Dagger provider methods must specify the return type explicitly when using " +
           "Anvil. The return type cannot be inferred implicitly.",