Address finalize review findings (#249)

- Remove the dead optional `producer` parameter from the KMP/JVM wiring
  helpers and rewrite the stale KDoc that described the obsolete pure-layout
  workaround removed by the @OutputDirectory refactor.
- Narrow the helper parameter from Provider<out Any> to Provider<out Directory>.
- Warn (instead of silently no-op) when an AGP module has no Kotlin `main`
  source set, pointing the developer at the missing Kotlin Android plugin.
- Pass --no-build-cache in the wiring TestKit runs so a cached compile cannot
  mask broken wiring.
- Fix the GeneratedSourceWiringTest KDoc and CLAUDE.md to reflect the dedicated
  generated/featured/registry directory.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: kirich1409

CLAUDE.md

@@ -81,7 +81,7 @@ Two plugins, two roles:
 
 **Enum-flag classpath gotcha.** `featuredAggregation(project(":foo"))` only pulls the manifest variant — not `:foo`'s compile classpath. If `:foo` declares an `enum` flag whose enum type lives in `:foo`, the aggregator module must also declare `implementation(project(":foo"))` so the enum class is visible at compile time. Primitive-only modules need no extra dependency.
 
-**Auto-wiring policy.** Both `generateConfigParam` (from `dev.androidbroadcast.featured`) and `generateFeaturedRegistry` (from the aggregator plugin) auto-wire their generated output directory into the consumer module's compilation — consumers need **zero** manual `srcDir` / `dependsOn`. The plugin detects the applied Kotlin/Android plugin and wires the right source set: KMP `commonMain` and Kotlin/JVM `main` via a `srcDir(Provider)` (Gradle auto-infers the task dependency); plain AGP via `sourceSets["main"].kotlin.directories.add(<resolved path>)` plus an explicit `dependsOn` on every `compile*Kotlin` / `ksp*` task (the AGP source set rejects `Provider`s at configuration time). The three branches are mutually exclusive in AGP 9, so exactly one fires per module.
+**Auto-wiring policy.** Both `generateConfigParam` (from `dev.androidbroadcast.featured`) and `generateFeaturedRegistry` (from the aggregator plugin) auto-wire their generated output directory into the consumer module's compilation — consumers need **zero** manual `srcDir` / `dependsOn`. They write to **distinct** directories so the two outputs never overlap when a module applies both plugins: `generateConfigParam` → `build/generated/featured/commonMain`, `generateFeaturedRegistry` → `build/generated/featured/registry`. The plugin detects the applied Kotlin/Android plugin and wires the right source set: KMP `commonMain` and Kotlin/JVM `main` via a `srcDir(Provider)` (Gradle auto-infers the task dependency); plain AGP via `sourceSets["main"].kotlin.directories.add(<resolved path>)` plus an explicit `dependsOn` on every `compile*Kotlin` / `ksp*` task (the AGP source set rejects `Provider`s at configuration time). The three branches are mutually exclusive in AGP 9, so exactly one fires per module.
 
 ## Multi-Module Pattern (canonical, demonstrated in `:sample`)
 

featured-gradle-plugin/CLAUDE.md

@@ -54,8 +54,11 @@ featured {
 ## Auto-wiring generated sources
 
 `generateConfigParam` (this plugin) and `generateFeaturedRegistry` (the
-`dev.androidbroadcast.featured.application` aggregator) auto-wire their `build/generated/featured/commonMain`
-output into the consumer module's compilation — consumers write **zero** manual `srcDir` / `dependsOn`.
+`dev.androidbroadcast.featured.application` aggregator) auto-wire their generated output into the
+consumer module's compilation — consumers write **zero** manual `srcDir` / `dependsOn`. They write to
+**distinct** directories so the two outputs never overlap when a module applies both plugins:
+`generateConfigParam` → `build/generated/featured/commonMain`, `generateFeaturedRegistry` →
+`build/generated/featured/registry`.
 The plugin reacts to the applied Kotlin/Android plugin and picks the right source set
 (`GeneratedSourceWiring.kt`):
 

featured-gradle-plugin/src/main/kotlin/dev/androidbroadcast/featured/gradle/GeneratedSourceWiring.kt

@@ -3,6 +3,7 @@ package dev.androidbroadcast.featured.gradle
 import com.android.build.api.dsl.CommonExtension
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.file.Directory
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.TaskProvider
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
@@ -16,11 +17,11 @@ import java.io.File
  * `com.android.application` / `com.android.library` + `org.jetbrains.kotlin.multiplatform` a hard
  * error, and Android Kotlin uses `org.jetbrains.kotlin.android`, never `.jvm`).
  *
- * KMP / Kotlin-JVM receive the producer task's native @OutputDirectory provider
- * (`generateConfigParam.outputDir`, a `Provider<Directory>` obtained via `flatMap`). Passing it to
- * `SourceDirectorySet.srcDir(Provider)` records the producer as the directory's builder, so Gradle
- * auto-infers the task dependency for EVERY consumer (compile*, sourcesJar, metadata, lint, …) with
- * no name-matched `dependsOn`. AGP cannot take a provider (its source set rejects one at
+ * KMP / Kotlin-JVM receive the producer task's native @OutputDirectory provider — a
+ * `Provider<Directory>` obtained via `task.flatMap { it.outputDir }`. Passing it to
+ * `SourceDirectorySet.srcDir(Provider)` records the producer task as the directory's builder, so
+ * Gradle auto-infers the task dependency for EVERY consumer (compile*, sourcesJar, metadata, lint, …)
+ * with no name-matched `dependsOn`. AGP cannot take a provider (its source set rejects one at
  * configuration time), so it gets a resolved [File] plus the explicit [dependOnProducer] ordering.
  */
 
@@ -32,57 +33,45 @@ import java.io.File
  * co-requires `org.jetbrains.kotlin.multiplatform` (`commonMain` exists), so this branch covers it
  * too.
  *
- * Two wiring shapes share this helper:
- * - **Task-carrying provider (per-module `FeaturedPlugin`, [producer] omitted).** [generatedDir] is
- *   the producer task's @OutputDirectory provider (`generateConfigParam.outputDir`, obtained via
- *   `flatMap`). `srcDir(Provider)` records the producer as the directory's builder, so Gradle
- *   auto-infers the task dependency for every consumer — no explicit `dependsOn` needed.
- * - **Pure layout provider (aggregator, [producer] passed).** The registry task is @OutputFile-based;
- *   a derived `.map { it.parentFile }` provider eager-errors inside
- *   `com.android.kotlin.multiplatform.library`. The aggregator therefore passes a plain layout
- *   provider (no task attached) for [generatedDir] and supplies [producer] so ordering is carried by
- *   an explicit `dependsOn` via [dependOnProducer].
+ * [generatedDir] is the producer task's @OutputDirectory provider (`task.flatMap { it.outputDir }`).
+ * `srcDir(Provider)` records the producer task as the directory's builder, so Gradle auto-infers the
+ * task dependency for every consumer — no explicit `dependsOn` needed.
  */
 internal fun wireGeneratedSourcesToKmp(
     project: Project,
-    generatedDir: Provider<out Any>,
-    producer: TaskProvider<*>? = null,
+    generatedDir: Provider<out Directory>,
 ) {
     val kotlin = project.extensions.getByType(KotlinMultiplatformExtension::class.java)
     kotlin.sourceSets
         .getByName("commonMain")
         .kotlin
         .srcDir(generatedDir)
-    if (producer != null) dependOnProducer(project, producer)
 }
 
 /**
  * Wires [generatedDir] into the Kotlin/JVM `main` source set.
  *
  * As with [wireGeneratedSourcesToKmp], `KotlinSourceSet.kotlin` is Gradle's
- * [org.gradle.api.file.SourceDirectorySet]. When [generatedDir] is the producer task's
- * @OutputDirectory provider (per-module `FeaturedPlugin`, [producer] omitted) the task dependency is
- * auto-inferred for every consumer. When [generatedDir] is a pure layout provider (aggregator,
- * because the registry task is @OutputFile-based and a derived provider eager-errors), [producer] is
- * passed so ordering is carried by an explicit `dependsOn` via [dependOnProducer].
+ * [org.gradle.api.file.SourceDirectorySet]. [generatedDir] is the producer task's @OutputDirectory
+ * provider (`task.flatMap { it.outputDir }`); `srcDir(Provider)` records the producer task as the
+ * directory's builder, so Gradle auto-infers the task dependency for every consumer — no explicit
+ * `dependsOn` needed.
  */
 internal fun wireGeneratedSourcesToKotlinJvm(
     project: Project,
-    generatedDir: Provider<out Any>,
-    producer: TaskProvider<*>? = null,
+    generatedDir: Provider<out Directory>,
 ) {
     val kotlin = project.extensions.getByType(KotlinJvmProjectExtension::class.java)
     kotlin.sourceSets
         .getByName("main")
         .kotlin
         .srcDir(generatedDir)
-    if (producer != null) dependOnProducer(project, producer)
 }
 
 /**
  * Adds an explicit `dependsOn([producer])` to every Kotlin-compile, `ksp*`, and AGP
  * annotation-extraction (`extract*Annotations`) task so the generated sources are produced before
- * any task that consumes the generated source dir. Used by the AGP branch only — its
+ * any task that consumes the generated source dir. This is AGP-only — its
  * `AndroidSourceDirectorySet` takes a resolved [File] that carries no task dependency. The KMP and
  * Kotlin/JVM branches do not call this: their `srcDir(Provider)` auto-infers the dependency.
  * AGP's `extractDebugAnnotations` / `extractReleaseAnnotations` read the generated source directory
@@ -123,16 +112,25 @@ private fun dependOnProducer(
  * reusing one global [producer] task across `debug` + `release` would share a single dir and bypass
  * AGP path generation.
  *
- * No-ops on an Android module with no Kotlin source set (a pure-Java AGP module never references the
- * generated objects).
+ * Warns and no-ops on an Android module with no Kotlin `main` source set — typically
+ * `com.android.library` applied without `org.jetbrains.kotlin.android`, so the generated objects
+ * would never compile anyway.
  */
 internal fun wireGeneratedSourcesToAndroid(
     project: Project,
     generatedDirFile: File,
     producer: TaskProvider<*>,
 ) {
     val android = project.extensions.getByType(CommonExtension::class.java)
-    val mainSourceSet = android.sourceSets.findByName("main") ?: return
+    val mainSourceSet =
+        android.sourceSets.findByName("main") ?: run {
+            project.logger.warn(
+                "Featured: ${project.path} has no Android 'main' Kotlin source set — generated " +
+                    "sources will NOT be wired into compilation. Apply the Kotlin Android plugin " +
+                    "(org.jetbrains.kotlin.android) to this module.",
+            )
+            return
+        }
     // Resolved absolute path, not a Provider — the Android source set rejects providers at
     // configuration time. directories is a MutableSet<String> (srcDir(Any) is @Deprecated).
     mainSourceSet.kotlin.directories.add(generatedDirFile.absolutePath)

featured-gradle-plugin/src/test/kotlin/dev/androidbroadcast/featured/gradle/GeneratedSourceWiringTest.kt

@@ -28,8 +28,11 @@ import kotlin.test.assertTrue
  * strictly stronger than reading a source-set directory list, which could list a directory that is
  * never actually compiled.
  *
- * The generated directory is `build/generated/featured/commonMain` for every plugin shape
- * (see [GenerateConfigParamTask] / GenerateFeaturedRegistryTask output convention).
+ * The generated directory depends on the plugin: `build/generated/featured/commonMain` for
+ * `generateConfigParam` (per-module, see [GenerateConfigParamTask]) and
+ * `build/generated/featured/registry` for `generateFeaturedRegistry` (the aggregator, see
+ * GenerateFeaturedRegistryTask) — distinct directories so the two outputs never overlap when a
+ * module applies both plugins.
  *
  * AGP-based cases skip when `ANDROID_HOME` / `ANDROID_SDK_ROOT` is unset, matching the rest of the
  * integration suite.
@@ -46,7 +49,7 @@ class GeneratedSourceWiringTest {
 
         val result =
             gradleRunner(projectDir)
-                .withArguments("compileKotlin", "--stacktrace")
+                .withArguments("compileKotlin", "--stacktrace", "--no-build-cache")
                 .build()
 
         assertGeneratedSourceTaskRan(result, ":$GENERATE_CONFIG_PARAM_TASK_NAME")
@@ -61,7 +64,7 @@ class GeneratedSourceWiringTest {
 
         val result =
             gradleRunner(projectDir)
-                .withArguments("compileKotlinJvm", "--stacktrace")
+                .withArguments("compileKotlinJvm", "--stacktrace", "--no-build-cache")
                 .build()
 
         assertGeneratedSourceTaskRan(result, ":$GENERATE_CONFIG_PARAM_TASK_NAME")
@@ -77,7 +80,7 @@ class GeneratedSourceWiringTest {
 
         val result =
             gradleRunner(projectDir)
-                .withArguments("compileDebugKotlin", "--stacktrace")
+                .withArguments("compileDebugKotlin", "--stacktrace", "--no-build-cache")
                 .build()
 
         assertGeneratedSourceTaskRan(result, ":$GENERATE_CONFIG_PARAM_TASK_NAME")
@@ -93,7 +96,7 @@ class GeneratedSourceWiringTest {
 
         val result =
             gradleRunner(projectDir)
-                .withArguments("compileDebugKotlin", "--stacktrace")
+                .withArguments("compileDebugKotlin", "--stacktrace", "--no-build-cache")
                 .build()
 
         assertGeneratedSourceTaskRan(result, ":$GENERATE_CONFIG_PARAM_TASK_NAME")
@@ -109,7 +112,7 @@ class GeneratedSourceWiringTest {
 
         val result =
             gradleRunner(projectDir)
-                .withArguments(":app:compileDebugKotlin", "--stacktrace")
+                .withArguments(":app:compileDebugKotlin", "--stacktrace", "--no-build-cache")
                 .build()
 
         // The aggregator plugin must auto-wire generateFeaturedRegistry; compiling the app must