KRPC-238: Address review feedback — KMP DSL extensions, Android flavor codegen tests

Author: Mr3zee

gradle-plugin/api/gradle-plugin.api

@@ -194,7 +194,9 @@ public final class kotlinx/rpc/protoc/ProtoSourceSetKt {
 	public static final fun getProto (Lorg/jetbrains/kotlin/gradle/plugin/KotlinSourceSet;)Lkotlinx/rpc/protoc/ProtoSourceSet;
 	public static final fun proto (Lorg/gradle/api/NamedDomainObjectProvider;Lorg/gradle/api/Action;)V
 	public static final fun proto (Lorg/gradle/api/tasks/SourceSet;Lorg/gradle/api/Action;)V
+	public static final fun proto (Lorg/jetbrains/kotlin/gradle/plugin/KotlinDependencyHandler;Ljava/lang/Object;)Lorg/gradle/api/artifacts/Dependency;
 	public static final fun proto (Lorg/jetbrains/kotlin/gradle/plugin/KotlinSourceSet;Lorg/gradle/api/Action;)V
+	public static final fun protoImport (Lorg/jetbrains/kotlin/gradle/plugin/KotlinDependencyHandler;Ljava/lang/Object;)Lorg/gradle/api/artifacts/Dependency;
 	public static final fun proto_kotlin (Lorg/gradle/api/NamedDomainObjectProvider;)Lorg/gradle/api/provider/Provider;
 	public static final fun proto_kotlin (Lorg/gradle/api/NamedDomainObjectProvider;Lorg/gradle/api/Action;)V
 }

gradle-plugin/src/main/kotlin/kotlinx/rpc/protoc/ProtoSourceSet.kt

@@ -5,14 +5,18 @@
 package kotlinx.rpc.protoc
 
 import org.gradle.api.Action
+import org.gradle.api.Named
 import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.NamedDomainObjectProvider
+import org.gradle.api.artifacts.Dependency
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.provider.SetProperty
 import org.gradle.api.tasks.SourceSet
+import org.jetbrains.kotlin.gradle.plugin.HasProject
+import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 
 public typealias ProtoSourceSets = NamedDomainObjectContainer<ProtoSourceSet>
@@ -344,3 +348,65 @@ public fun NamedDomainObjectProvider<SourceSet>.proto(action: Action<ProtoSource
         proto(action)
     }
 }
+
+/**
+ * Adds a proto dependency for code generation from within [KotlinSourceSet.dependencies].
+ *
+ * Proto files (`.proto`) from the resolved archives will be included in code generation.
+ *
+ * Example:
+ * ```kotlin
+ * kotlin.sourceSets {
+ *     commonMain {
+ *         dependencies {
+ *             proto("com.example:shared-protos:1.0")
+ *         }
+ *     }
+ * }
+ * ```
+ */
+public fun KotlinDependencyHandler.proto(dependencyNotation: Any): Dependency? {
+    val configName = resolveProtoConfigurationName(this, "Proto")
+    return project.dependencies.add(configName, dependencyNotation)
+}
+
+/**
+ * Adds a proto import dependency from within [KotlinSourceSet.dependencies].
+ *
+ * Proto files (`.proto`) from the resolved archives will be available as imports only,
+ * but will not be used for code generation.
+ *
+ * Example:
+ * ```kotlin
+ * kotlin.sourceSets {
+ *     commonMain {
+ *         dependencies {
+ *             protoImport("com.example:common-protos:1.0")
+ *         }
+ *     }
+ * }
+ * ```
+ */
+public fun KotlinDependencyHandler.protoImport(dependencyNotation: Any): Dependency? {
+    val configName = resolveProtoConfigurationName(this, "ProtoImport")
+    return project.dependencies.add(configName, dependencyNotation)
+}
+
+private fun resolveProtoConfigurationName(handler: KotlinDependencyHandler, suffix: String): String {
+    val sourceSetName = try {
+        val getParent = handler::class.java.getMethod("getParent")
+        val parent = getParent.invoke(handler)
+        (parent as? Named)?.name
+    } catch (_: Exception) {
+        null
+    } ?: error(
+        "Cannot determine source set name for proto dependency. " +
+                "Use top-level dependencies { <sourceSetName>${suffix}(\"...\") } syntax instead."
+    )
+
+    return if (sourceSetName == "main") {
+        suffix.replaceFirstChar { it.lowercase() }
+    } else {
+        "$sourceSetName$suffix"
+    }
+}

gradle-plugin/src/test/kotlin/kotlinx/rpc/GrpcAndroidProjectTest.kt

@@ -262,6 +262,40 @@ class GrpcAndroidProjectTest : GrpcBaseTest() {
         runGradle("test_tasks", "--no-configuration-cache")
     }
 
+    @TestFactory
+    fun `Dependency Proto Import Flavors Codegen`() = runGrpcTest(versionsPredicate = { !isAgp9 }) {
+        // Verify proto imports work across all flavor variants
+        // protoImport declared on main → inherited by all variants
+
+        fun runForVariant(sourceSet: SSets, vararg extraTasks: SSets) {
+            val result = runForSet(sourceSet)
+
+            result.assertTaskExecuted(
+                sourceSet = sourceSet,
+                protoFiles = listOf(
+                    Path("some.proto"),
+                ),
+                importProtoFiles = listOf(
+                    Path("dependency.proto"),
+                ),
+                generatedFiles = listOf(
+                    Path("Some.kt"),
+                    Path("Some.ext.kt"),
+                    Path(RPC_INTERNAL, "Some.kt"),
+                ),
+                notExecuted = emptyList(),
+            )
+        }
+
+        // arm variants
+        runForVariant(SSetsAndroid.Flavors.armDebug)
+        runForVariant(SSetsAndroid.Flavors.armRelease)
+
+        // x86 variants
+        runForVariant(SSetsAndroid.Flavors.x86Debug)
+        runForVariant(SSetsAndroid.Flavors.x86Release)
+    }
+
     @TestFactory
     fun `No gRPC`() = runGrpcTest(versionsPredicate = { !isAgp9 }) {
         SSetsAndroid.Default.entries.forEach {

gradle-plugin/src/test/kotlin/kotlinx/rpc/GrpcKmpProjectTest.kt

@@ -32,6 +32,25 @@ class GrpcKmpProjectTest : GrpcBaseTest() {
         )
     }
 
+    @TestFactory
+    fun `Dependency Proto Import KMP DSL`() = runGrpcTest {
+        val result = runGradle(bufGenerateCommonMain)
+
+        result.assertOutcome(TaskOutcome.SUCCESS, bufGenerateCommonMain)
+        result.assertOutcome(TaskOutcome.SUCCESS, processCommonMainProtoFiles)
+
+        assertWorkspaceProtoFilesCopied(mainSourceSet, Path("some.proto"))
+        assertWorkspaceImportProtoFilesCopied(mainSourceSet, Path("dependency.proto"))
+
+        assertSourceCodeGenerated(
+            mainSourceSet,
+            Path("Some.kt"),
+            Path(RPC_INTERNAL, "Some.kt"),
+        )
+
+        dryRunCompilation(SSetsKmp.Default.jvmMain)
+    }
+
     @TestFactory
     fun `Dependency Proto Import`() = runGrpcTest {
         val result = runGradle(bufGenerateCommonMain)

gradle-plugin/src/test/kotlin/kotlinx/rpc/base/GrpcBaseTest.kt

@@ -639,6 +639,37 @@ inputs:
                 return entries
             }
         }
+
+        enum class Flavors(
+            override val mode: PluginMode? = null,
+            override val minKotlin: KotlinVersion = KtVersion.v2_0_0,
+        ) : SSetsAndroid {
+            // non-executable root source sets
+            main, test, androidTest,
+
+            // per-flavor non-executable
+            arm, x86,
+
+            // build-type non-executable
+            debug, release,
+
+            // executable leaf variants
+            armDebug(plm.a), armRelease(plm.a),
+            x86Debug(plm.a), x86Release(plm.a),
+
+            // test variants
+            testArmDebug(plm.a), testArmRelease(plm.a),
+            testX86Debug(plm.a), testX86Release(plm.a),
+
+            // androidTest variants
+            androidTestArmDebug(plm.a),
+            androidTestX86Debug(plm.a),
+            ;
+
+            override fun all(): List<SSets> {
+                return entries
+            }
+        }
     }
 
     enum class PluginMode {

gradle-plugin/src/test/resources/projects/GrpcAndroidProjectTest/dependency_proto_import_flavors_codegen/build.gradle.kts

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+import org.gradle.kotlin.dsl.version
+
+plugins {
+    id("com.android.application") version "<android-version>"
+    kotlin("android") version "<kotlin-version>"
+    id("org.jetbrains.kotlinx.rpc.plugin") version "<rpc-version>"
+}
+
+rpc {
+    protoc()
+}
+
+android {
+    namespace = "com.example.myapp"
+    compileSdk = 34
+
+    flavorDimensions("abi")
+
+    productFlavors {
+        create("arm") {
+            dimension = "abi"
+        }
+        create("x86") {
+            dimension = "abi"
+        }
+    }
+}
+
+dependencies {
+    // protoImport on main — inherited by all variants (debug, release, arm*, x86*)
+    protoImport(files("dependency-protos.zip"))
+}

gradle-plugin/src/test/resources/projects/GrpcAndroidProjectTest/dependency_proto_import_flavors_codegen/dependency-protos.zip

@@ -0,0 +1,8 @@
+syntax = "proto3";
+
+import "dependency.proto";
+
+message Some {
+  string content = 1;
+  dependency.DependencyMessage dep = 2;
+}

gradle-plugin/src/test/resources/projects/GrpcAndroidProjectTest/dependency_proto_import_flavors_codegen/src/main/proto/some.proto

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+import org.gradle.kotlin.dsl.version
+import kotlinx.rpc.protoc.*
+
+plugins {
+    kotlin("multiplatform") version "<kotlin-version>"
+    id("org.jetbrains.kotlinx.rpc.plugin") version "<rpc-version>"
+}
+
+kotlin {
+    jvm()
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                protoImport(files("dependency-protos.zip"))
+            }
+        }
+    }
+}
+
+rpc {
+    protoc()
+}