Provide Project Isolation compatible way to add dependencies to a project

[martinbonnin]

Expected Behavior

Make it possible to add a dependency to another project without breaking project isolation.

Maybe in IsolatedProject ?

interface IsolatedProject {
  addDependency(configurationName: String, projectPath: String)
}

Current Behavior (optional)

The 2 use cases I have in mind are kdoc and publishing. In a multi-module project, it's frequent that not all modules require publishing and to have some "aggregating" task in the root project to document/publish the required subprojects.

I currently see 2 solutions.

1. keeping track of the list of projects in the root project

dependencies {
    // List all projects here
    // It feels a bit awkward because I have 2 places to edit when I'm adding a module
    add("aggregatingConfiguration", project(":module1"))
    add("aggregatingConfiguration", project(":module2"))
    // ...
}

2. using a lenient configuration

allprojects.forEach {
  add("aggregatingConfiguration", project(":${it.path}"))
}

Both of these solutions have limitations. 1. requires keeping track of a separate project list which is error prone. 2. might defeat configuration on demand. Also makes it hard to debug issues because some (valid) resolution errors might end up being ignored.
See also this comment that describes the same problem.

Or is there another way?

Context

• Introduce a mechanism to apply shared build logic to all projects in a manner compatible with Isolated Projects #22514 (comment)
• Provide a way for build logic to share data across projects #25179
• More convenient project-isolation compatible support to aggregate artifacts across projects #29403
• Incubating Isolated Projects build-tool-roadmap#43
• apollo-kotlin
• gradle-nexus-publish-plugin
• Slack discussion #1
• Slack discussion #2

[ljacomet]

This issue needs a decision from the team responsible for that area. They have been informed. Response time may vary.

[adam-enko]

This would also be useful for libraries that have define BOMs for library users.

For example: kotlin-wrappers-bom. Currently it has to explicitly list all projects. This is inconvenient and requires care to maintain. It's easy to forget to add a subproject, and there's no reasonable way to verify a project hasn't been missed.

It would be convenient if the BOM subproject could query all other subprojects and select those that have a specific convention plugin applied.

// foo-bom/build.gradle.kts

dependencies {
  constraints {
    projects       // Get the currently experimental typesafe project accessors
      .forEach {    // select subprojects that have a specific plugin
        it.hasPlugin("convention.kotlin-library")
      }
      .forEach { sp: Provider<Project> ->
        api(it)
      }
  }
}

[mlopatkin]

This feature request is in the backlog of the relevant team and is prioritized by them.

---

This seems to be a potential use case for shared data #25179.

[martinbonnin]

I think it's more than just "shared data" though? It's more like "shared data with dependencies", i.e. the evaluation order is important, or if that "shared data" is serialized, it should be serialized per-project or something like this. I have a very superficial understanding of everything that's happening in project isolation but my hunch is there might be more to it?