Add new diagnostic for providing intrinsic wrapped types (#2190)

Author: ZacSweers

CHANGELOG.md

@@ -7,6 +7,7 @@ Changelog
 ### New
 
 - Add a new `desugaredProviderSeverity` option (default: `WARN`) that reports a diagnostic when `Provider<T>` is used instead of the preferred `() -> T` form. Set this to `NONE` to disable the warning during migration, or `ERROR` to enforce the new style. Automatically treated as `NONE` when `enableFunctionProviders` is disabled.
+- **[FIR]** Add diagnostic checks against providing intrinsic types (`Provider`, `Lazy`, etc.) from `@Provides` declarations.
 - **[Gradle]** Introduce a new `compilerOptions {}` DSL for free Metro compiler options and flags.
 - **[Gradle]** Add `IDE_WARN` and `IDE_ERROR` members to `DiagnosticSeverity` to allow configuring some diagnostics to _only_ run in IDE sessions. Useful for diagnostics you only want to surface to readers in the IDE without emitting compiler warnings in real (CLI) compilations.
 

compiler-tests/src/test/data/diagnostic/dependencygraph/DependencyGraphFactory_ProvidesParamCannotBeIntrinsic.fir.diag.txt

@@ -0,0 +1,7 @@
+/DependencyGraphFactory_ProvidesParamCannotBeIntrinsic.kt:(579,595): error: `@Provides` graph factory parameters may not be intrinsic types, but `string` is `Provider<Double>`. Remove the wrapper and let Metro handle the underlying type directly.
+
+/DependencyGraphFactory_ProvidesParamCannotBeIntrinsic.kt:(625,634): error: `@Provides` graph factory parameters may not be intrinsic types, but `lazyTarget` is `Lazy<Int>`. Remove the wrapper and let Metro handle the underlying type directly.
+
+/DependencyGraphFactory_ProvidesParamCannotBeIntrinsic.kt:(661,673): error: `@Provides` graph factory parameters may not be intrinsic types, but `factory` is `() -> String`. Remove the wrapper and let Metro handle the underlying type directly. Note: `enableFunctionProviders` is enabled, so parameter-less Kotlin function literal types are treated as provider types by Metro and cannot be unique bindings on the graph.
+
+/DependencyGraphFactory_ProvidesParamCannotBeIntrinsic.kt:(725,735): error: `@BindsInstance` graph factory parameters may not be intrinsic types, but `bindsInstanceFactory` is `() -> Long`. Remove the wrapper and let Metro handle the underlying type directly. Note: `enableFunctionProviders` is enabled, so parameter-less Kotlin function literal types are treated as provider types by Metro and cannot be unique bindings on the graph.

compiler-tests/src/test/data/diagnostic/dependencygraph/DependencyGraphFactory_ProvidesParamCannotBeIntrinsic.kt

@@ -0,0 +1,25 @@
+// RENDER_DIAGNOSTICS_FULL_TEXT
+// ENABLE_DAGGER_INTEROP
+
+// `@Provides` on a @DependencyGraph.Factory parameter is Metro's analog to Dagger's
+// `@BindsInstance`. Passing a pre-wrapped intrinsic type silently double-wraps the binding,
+// so intrinsic parameter types are rejected the same way as intrinsic return types on
+// `@Provides`/`@Binds` declarations.
+
+class Target
+
+@DependencyGraph
+interface ExampleGraph {
+  val string: String
+  val target: Target
+
+  @DependencyGraph.Factory
+  interface Factory {
+    fun create(
+      @Provides string: <!INTRINSIC_BINDING_ERROR!>Provider<Double><!>,
+      @Provides lazyTarget: <!INTRINSIC_BINDING_ERROR!>Lazy<Int><!>,
+      @Provides factory: <!INTRINSIC_BINDING_ERROR!>() -> String<!>,
+      @dagger.BindsInstance bindsInstanceFactory: <!INTRINSIC_BINDING_ERROR!>() -> Long<!>,
+    ): ExampleGraph
+  }
+}

compiler-tests/src/test/data/diagnostic/dependencygraph/extensions/GraphExtensionFactory_ProvidesParamCannotBeIntrinsic.fir.diag.txt

@@ -0,0 +1,7 @@
+/GraphExtensionFactory_ProvidesParamCannotBeIntrinsic.kt:(519,535): error: `@Provides` graph factory parameters may not be intrinsic types, but `string` is `Provider<Double>`. Remove the wrapper and let Metro handle the underlying type directly.
+
+/GraphExtensionFactory_ProvidesParamCannotBeIntrinsic.kt:(565,574): error: `@Provides` graph factory parameters may not be intrinsic types, but `lazyTarget` is `Lazy<Int>`. Remove the wrapper and let Metro handle the underlying type directly.
+
+/GraphExtensionFactory_ProvidesParamCannotBeIntrinsic.kt:(601,613): error: `@Provides` graph factory parameters may not be intrinsic types, but `factory` is `() -> String`. Remove the wrapper and let Metro handle the underlying type directly. Note: `enableFunctionProviders` is enabled, so parameter-less Kotlin function literal types are treated as provider types by Metro and cannot be unique bindings on the graph.
+
+/GraphExtensionFactory_ProvidesParamCannotBeIntrinsic.kt:(665,675): error: `@BindsInstance` graph factory parameters may not be intrinsic types, but `bindsInstanceFactory` is `() -> Long`. Remove the wrapper and let Metro handle the underlying type directly. Note: `enableFunctionProviders` is enabled, so parameter-less Kotlin function literal types are treated as provider types by Metro and cannot be unique bindings on the graph.

compiler-tests/src/test/data/diagnostic/dependencygraph/extensions/GraphExtensionFactory_ProvidesParamCannotBeIntrinsic.kt

@@ -0,0 +1,27 @@
+// RENDER_DIAGNOSTICS_FULL_TEXT
+// ENABLE_DAGGER_INTEROP
+
+// Same rule applies to @GraphExtension.Factory `@Provides` parameters as to
+// @DependencyGraph.Factory parameters — intrinsic parameter types silently double-wrap
+// and are rejected.
+
+class Target
+
+@DependencyGraph
+interface ParentGraph : ChildGraph.Factory
+
+@GraphExtension
+interface ChildGraph {
+  val string: String
+  val target: Target
+
+  @GraphExtension.Factory
+  interface Factory {
+    fun create(
+      @Provides string: <!INTRINSIC_BINDING_ERROR!>Provider<Double><!>,
+      @Provides lazyTarget: <!INTRINSIC_BINDING_ERROR!>Lazy<Int><!>,
+      @Provides factory: <!INTRINSIC_BINDING_ERROR!>() -> String<!>,
+      @dagger.BindsInstance bindsInstanceFactory: <!INTRINSIC_BINDING_ERROR!>() -> Long<!>,
+    ): ChildGraph
+  }
+}

compiler-tests/src/test/data/diagnostic/provides/Provides_ElementsIntoSet_AllowsIntrinsicElementType.kt

@@ -0,0 +1,19 @@
+// RENDER_DIAGNOSTICS_FULL_TEXT
+
+// @ElementsIntoSet declarations may return Set<Provider<T>> — the return type itself is
+// Set<...>, not an intrinsic, so the check naturally passes. Also negative coverage for
+// user-defined subtypes of Provider, which should not be caught by the identity-based check.
+
+class MyProvider : Provider<String> { override fun invoke(): String = "" }
+
+@DependencyGraph
+interface ExampleGraph {
+  val strings: Set<Provider<String>>
+  val myProvider: MyProvider
+
+  @Provides @ElementsIntoSet fun provideStrings(): Set<Provider<String>> =
+    setOf(provider { "a" }, provider { "b" })
+
+  // User-defined subclass of Provider is allowed (identity check, no supertype walk).
+  @Provides fun provideMyProvider(): MyProvider = MyProvider()
+}

compiler-tests/src/test/data/diagnostic/provides/Provides_ReturnTypeCannotBeIntrinsic.fir.diag.txt

@@ -0,0 +1,17 @@
+/Provides_ReturnTypeCannotBeIntrinsic.kt:(391,407): error: `@Provides` declarations may not return intrinsic types, but `provideProvider` returns `Provider<String>`. Remove the wrapper and let Metro provide the underlying type directly.
+
+/Provides_ReturnTypeCannotBeIntrinsic.kt:(515,536): error: `@Provides` declarations may not return intrinsic types, but `provideJavaxProvider` returns `Provider<String>`. Remove the wrapper and let Metro provide the underlying type directly.
+
+/Provides_ReturnTypeCannotBeIntrinsic.kt:(653,676): error: `@Provides` declarations may not return intrinsic types, but `provideJakartaProvider` returns `Provider<String>`. Remove the wrapper and let Metro provide the underlying type directly.
+
+/Provides_ReturnTypeCannotBeIntrinsic.kt:(772,784): error: `@Provides` declarations may not return intrinsic types, but `provideLazy` returns `Lazy<String>`. Remove the wrapper and let Metro provide the underlying type directly.
+
+/Provides_ReturnTypeCannotBeIntrinsic.kt:(876,893): error: `@Provides` declarations may not return intrinsic types, but `provideNullable` returns `Provider<String>?`. Remove the wrapper and let Metro provide the underlying type directly.
+
+/Provides_ReturnTypeCannotBeIntrinsic.kt:(996,1011): error: `@Provides` declarations may not return intrinsic types, but `provideAliased` returns `Provider<String>`. Remove the wrapper and let Metro provide the underlying type directly.
+
+/Provides_ReturnTypeCannotBeIntrinsic.kt:(1156,1168): error: `@Provides` declarations may not return intrinsic types, but `provideFunction` returns `() -> String`. Remove the wrapper and let Metro provide the underlying type directly. Note: `enableFunctionProviders` is enabled, so parameter-less Kotlin function types are treated as provider types by Metro and cannot be unique bindings on the graph.
+
+/Provides_ReturnTypeCannotBeIntrinsic.kt:(1353,1369): error: `@Provides` declarations may not return intrinsic types, but `provideString` returns `Provider<String>`. Remove the wrapper and let Metro provide the underlying type directly.
+
+/Provides_ReturnTypeCannotBeIntrinsic.kt:(1580,1596): error: `@Provides` declarations may not return intrinsic types, but `provideString` returns `Provider<String>`. Remove the wrapper and let Metro provide the underlying type directly.

compiler-tests/src/test/data/diagnostic/provides/Provides_ReturnTypeCannotBeIntrinsic.kt

@@ -0,0 +1,51 @@
+// RENDER_DIAGNOSTICS_FULL_TEXT
+// ENABLE_DAGGER_INTEROP
+
+import javax.inject.Provider as JavaxProvider
+import jakarta.inject.Provider as JakartaProvider
+
+typealias AliasedProvider = Provider<String>
+
+class MyClass
+
+interface ExampleGraph {
+  val string: String
+  val myClass: MyClass
+
+  // Metro Provider is an intrinsic type
+  @Provides fun provideProvider(): <!INTRINSIC_BINDING_ERROR!>Provider<String><!> = provider { "" }
+
+  // javax.inject.Provider is an intrinsic type
+  @Provides fun provideJavaxProvider(): <!INTRINSIC_BINDING_ERROR!>JavaxProvider<String><!> = JavaxProvider { "" }
+
+  // jakarta.inject.Provider is an intrinsic type
+  @Provides fun provideJakartaProvider(): <!INTRINSIC_BINDING_ERROR!>JakartaProvider<String><!> = JakartaProvider { "" }
+
+  // kotlin.Lazy is an intrinsic type
+  @Provides fun provideLazy(): <!INTRINSIC_BINDING_ERROR!>Lazy<String><!> = lazy { "" }
+
+  // Nullable wrappers are also rejected
+  @Provides fun provideNullable(): <!INTRINSIC_BINDING_ERROR!>Provider<String>?<!> = null
+
+  // Type aliases that resolve to an intrinsic are rejected
+  @Provides fun provideAliased(): <!INTRINSIC_BINDING_ERROR!>AliasedProvider<!> = provider { "" }
+
+  // With `enableFunctionProviders` enabled (the default), Function0 is an intrinsic type
+  @Provides fun provideFunction(): <!INTRINSIC_BINDING_ERROR!>() -> String<!> = { "" }
+}
+
+// Companion object @Provides is also checked
+@DependencyGraph
+interface GraphWithCompanion {
+  val string: String
+
+  companion object {
+    @Provides fun provideString(): <!INTRINSIC_BINDING_ERROR!>Provider<String><!> = provider { "" }
+  }
+}
+
+// @IntoSet / @IntoMap contributions returning an intrinsic are rejected — there's no
+// multibinding carve-out.
+interface MultibindingGraph {
+  @Provides @IntoSet fun provideString(): <!INTRINSIC_BINDING_ERROR!>Provider<String><!> = provider { "" }
+}

compiler-tests/src/test/data/diagnostic/provides/Provides_ReturnTypeCannotBeIntrinsic_DaggerInterop.fir.diag.txt

@@ -0,0 +1 @@
+/Provides_ReturnTypeCannotBeIntrinsic_DaggerInterop.kt:(296,314): error: `@Provides` declarations may not return intrinsic types, but `provideLazy` returns `Lazy<String>`. Remove the wrapper and let Metro provide the underlying type directly.

compiler-tests/src/test/data/diagnostic/provides/Provides_ReturnTypeCannotBeIntrinsic_DaggerInterop.kt

@@ -0,0 +1,11 @@
+// RENDER_DIAGNOSTICS_FULL_TEXT
+// ENABLE_DAGGER_INTEROP
+
+import dagger.Lazy as DaggerLazy
+
+interface ExampleGraph {
+  val string: String
+
+  // dagger.Lazy is an intrinsic type (under Dagger runtime interop it's treated as kotlin.Lazy)
+  @Provides fun provideLazy(): <!INTRINSIC_BINDING_ERROR!>DaggerLazy<String><!> = DaggerLazy { "" }
+}