":api"          | ":impl"
    }

    def "provides dependency substitution rule that orderly aggregates user specified rules"() {
        given:
        substitutions.all({ it.useTarget("1.0") } as Action)
        substitutions.all({ it.useTarget("2.0") } as Action)
        substitutions.all({ it.useTarget("3.0") } as Action)
        def details = Mock(DependencySubstitutionInternal)

    /**
     * Adds a new substitutions to the substitutor which is being built.
     * If there already was a substitution with a [KaTypeParameterSymbol] which is present in a [substitutions],
     * replaces corresponding substitution with a new one.
     */
    public fun substitutions(substitutions: Map<KaTypeParameterSymbol, KaType>): Unit = withValidityAssertion {
        backingMapping += substitutions
    }
}

        }
        substitutions.incrementAndGet()
        threadLocalDecorators.set(substitution)
    }

    void cancelSubstitutionForCurrentThread() {
        if (threadLocalDecorators.get() == original) {
            throw new IllegalStateException("there was no substitution for the current thread")
        }
        substitutions.decrementAndGet()
        threadLocalDecorators.remove()
    }

In `dependencySubstitution` terms, the default substitutions are:
```
dependencySubstitution {
    ... for each project in included build ...
    substitute module("${project.group}:${project.name}") using project(":${project.name}")
}
```

== Declaring substitutions for included build

[[included_build_substitution_requirements]]
=== Cases where included build substitutions must be declared

Many builds will function automatically as an included build, without declared substitutions.
Here are some common cases where declared substitutions are required:

* When the `archivesBaseName` property is used to set the name of the published artifact.

        }

        val substitutions = LinkedHashMap<TypeConstructor, TypeProjection>(parameters.size)
        for (index in parameters.indices) {
            val parameterTypeConstructor = parameters[index].typeConstructor
            substitutions[parameterTypeConstructor] = TypeProjectionImpl(arguments[index] as KotlinType)
        }

        then:
        result == "result"
    }

    @Issue("https://github.com/gradle/gradle/issues/5167")
    @TargetGradleVersion('>6.6')
    def "Can run no-op build action against root of composite build with substitutions after Gradle 6.6"() {
        given:
        singleProjectBuildInRootFolder("root") {
            settingsFile << """
                includeBuild('includedBuild') {
                    dependencySubstitution {

      ToolSubst('not.exe', unresolved='fatal')
  ]

  llvm_config.config.substitutions.append(
      ('%python', '"%s"' % (sys.executable)))

  llvm_config.add_tool_substitutions(tool_patterns,
                                     [llvm_config.config.llvm_tools_dir])
else:
  llvm_config.use_default_substitutions()

llvm_config.config.substitutions.append(
    ('%tfrt_bindir', 'tensorflow/compiler/aot'))

    void addAvailableModules(Set<Pair<ModuleVersionIdentifier, ProjectComponentIdentifier>> availableModules);
    void registerSubstitution(Action<DependencySubstitution> substitutions);

            group = 'g'
            dependencies {
                implementation 'g:sub-a'
            }
        """
    }

    def "Eclipse model respects composite build substitutions in root build"() {
        given:
        compositeIncludedRoot()

        when:
        def model = withConnection {
            getModel(HierarchicalEclipseProject)
        }

        then: