for i, n := range as2init.Lhs {
				if n == name && !canRepeat(as2init.Rhs[i]) {
					return false
				}
			}
		}
	}

	// Possible static init.
	// Build tree with args substituted for params and try it.
	args := make(map[*ir.Name]ir.Node)
	for i, v := range as2init.Lhs {
		if ir.IsBlank(v) {
			continue
		}
		args[v.(*ir.Name)] = as2init.Rhs[i]
	}

    }

    @Issue("https://github.com/gradle/gradle/issues/14529")
    def "transform of project artifact can consume transform of external artifact whose upstream dependency has been substituted with local project"() {
        given:
        def m1 = mavenRepo.module("test", "lib", "1.2").publish()
        mavenRepo.module("test", "lib2", "1.2").dependsOn(m1).publish()

A project name with kebab case (`some-lib`) or snake case (`some_lib`) will be converted to camel case in accessors: `projects.someLib`.

=== Local forks of module dependencies

A module dependency can be substituted by a dependency to a local fork of the sources of that module, if the module itself is built with Gradle.
This can be done by utilising <<composite_builds.adoc#defining_composite_builds,composite builds>>.

// Normally it is empty, meaning run the binaries directly.
// If cross-compiling and running on a remote system or
// simulator, it is typically go_GOOS_GOARCH_exec, with
// the target GOOS and GOARCH substituted.
// The -exec flag overrides these defaults.
var ExecCmd []string

// FindExecCmd derives the value of ExecCmd to use.
// It returns that value and leaves ExecCmd set for direct use.
func FindExecCmd() []string {

    }

    @Issue("gradle/gradle#8944")
    def 'verify that cleaning up constraints no longer causes a ConcurrentModificationException'() {
        given:
        // Direct dependency with transitive to be substituted by project
        def project = mavenRepo.module('org', 'project', '1.0')
        mavenRepo.module('org', 'direct', '1.0').dependsOn(project).publish()

        // Updated version no longer depends on project

				template = rt
			} else {
				st.failEarlier("substituted template parameter not in scope of template", st.off-off)
			}
			if template == nil {
				// This template parameter is within
				// the scope of a cast operator.
				return &TemplateParam{Index: index, Template: nil}
			}

			if index >= len(template.Args) {

			// If we do change to support that, this test should
			// catch failures to filter out special tag names which
			// would violate the structure preservation property --
			// if any special tag name could be substituted, then
			// the content could be raw text/RCDATA for some inputs
			// and regular HTML content for others.
			`<{{"script"}}>{{"doEvil()"}}</{{"script"}}>`,
			`&lt;script>doEvil()&lt;/script>`,
		},
		{

    override fun substitute(substitutor: KaSubstitutor): KaFunctionLikeSignature<S> = withValidityAssertion {
        KaFe10FunctionLikeSignature(
            symbol,
            substitutor.substitute(returnType),
            receiverType?.let { substitutor.substitute(it) },
            valueParameters.map { valueParameter ->

    override fun <S : KaFunctionLikeSymbol> substitute(symbol: S, substitutor: KaSubstitutor): KaFunctionLikeSignature<S> {
        if (substitutor is KaSubstitutor.Empty) return asSignature(symbol)
        return asSignature(symbol).substitute(substitutor)
    }

    override fun <S : KaVariableLikeSymbol> substitute(symbol: S, substitutor: KaSubstitutor): KaVariableLikeSignature<S> {
        if (substitutor is KaSubstitutor.Empty) return asSignature(symbol)

If you have a Maven dependency pointing to an Ivy dependency where the `default` configuration dependencies do not match the `compile` + `runtime` + `master` ones
_and_ that Ivy dependency was substituted (using a `resolutionStrategy.force`, `resolutionStrategy.eachDependency` or `resolutionStrategy.dependencySubstitution`)
then this fix will impact you.