/**
     * 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

            // the ones for which we need to register substitutions early so that they are available
            // during plugin application from plugin builds.
            // See: DefaultIncludedBuildRegistry.ensureConfigured()
            return;
        }
        processed.add(build);
        DependencySubstitutionsInternal substitutions = resolveDependencySubstitutions(build);
        if (!substitutions.rulesMayAddProjectDependency()) {

        buildC = singleProjectBuild("buildC") {
            buildFile << """
                apply plugin: 'java-library'
"""
        }
    }

    def "does not configure build with declared substitutions that is not required for dependency substitution"() {
        given:
        dependency "org.test:buildB:1.0"

        includeBuild buildB
        includeBuild buildC, """

        this.availableModules.addAll(availableModules);
    }

    @Override
    public void registerSubstitution(Action<DependencySubstitution> substitutions) {
        substitutionRules.add(substitutions);
    }

    @Override
    public Action<DependencySubstitution> getRuleAction() {
        List<Action<DependencySubstitution>> allActions = new ArrayList<>();

        }

        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'))

package filepath

import (
	"os"
	"strings"
	"syscall"
)

func evalSymlinks(path string) (string, error) {
	// Plan 9 doesn't have symbolic links, so no need for substitutions.
	if len(path) > 0 {
		// Check validity of path
		_, err := os.Lstat(path)
		if err != nil {
			// Return the same error value as on other operating systems
			if strings.HasSuffix(err.Error(), "not a directory") {