IssueTracker

OP and +1's, please take a look at the following proposal and let us know if it would meet your needs.

Proposal:

Instead of exposing source set names, AGP could add APIs to support this specific use case. AGP would handle creating the configurations, etc.

interface AndroidComponentsExtension {

    /**
     * Adds a custom configuration for each source set.
     *
     * The [suffix] parameter determines the naming convention for the generated configurations.
     * For example, if [suffix] is "custom", the generated configurations would be "custom",
     * "debugCustom", "releaseCustom", "testCustom", etc.
     *
     * Under the hood, this API:
     * 1. Creates a configuration for each source set.
     * 2. Creates resolvable configurations for each component.
     * 3. Ensures that each resolvable configuration extends the corresponding source set
     *    configurations.
     *
     * Each component's corresponding resolvable configuration can be accessed via
     * [Component.getResolvableConfiguration].
     *
     * Example usage:
     * ```kotlin
     *  androidComponents {
     *      addSourceSetConfigurations("foo")
     *      onVariants { variant ->
     *          val resolvableConfiguration = variant.getResolvableConfiguration("foo")
     *          variant.nestedComponents.forEach { component ->
     *              val nestedResolvableConfiguration =
     *                  component.getResolvableConfiguration("foo")
     *          }
     *      }
     *  }
     * ```
     *
     * @param suffix the suffix to append to the generated configuration names.
     */
    @Incubating
    fun addSourceSetConfigurations(suffix: String)
}

interface Component {

    /**
     * Access to the component's resolvable configuration corresponding to the source set
     * configurations added via [AndroidComponentsExtension.addSourceSetConfigurations].
     *
     * Example usage:
     * ```kotlin
     *  androidComponents {
     *      addSourceSetConfigurations("foo")
     *      onVariants { variant ->
     *          val resolvableConfiguration = variant.getResolvableConfiguration("foo")
     *          variant.nestedComponents.forEach { component ->
     *              val nestedResolvableConfiguration =
     *                  component.getResolvableConfiguration("foo")
     *          }
     *      }
     *  }
     * ```
     *
     * The returned [Configuration] should not be resolved until execution time.
     */
    @Incubating
    fun getResolvableConfiguration(sourceSetConfigurationsAffix: String): Configuration
}

Under the hood, AGP would (1) create configurations per source set, (2) create a resolvable configuration per component, and (3) make each resolvable configuration extend from the corresponding source set configurations.

Example Usage:

androidComponents {
    addSourceSetConfigurations(suffix = "pluginDeps")
    onVariants { variant ->
        val variantResolvableConfiguration = variant.getResolvableConfiguration("pluginDeps")
        // ...
        variant.nestedComponents.forEach { component ->
            val nestedResolvableConfiguration = component.getResolvableConfiguration("pluginDeps")
            // ...
        }
    }
}

(Edited Jan 8th, 2025 to reflect final APIs)

Please respond soon if the proposal in comment #3 won't work for your use case.

Otherwise, we plan to implement it to unblock https://github.com/google/ksp/issues/2250.