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 {

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.

        includeBuild buildB2, """
            substitute module("org.gradle:buildX") using project(":")
"""

        then:
        resolvedGraph {
            edge("org.gradle:buildX:1.0", ":buildB", "org.test:buildB2:1.0") {
                configuration = "runtimeElements"
                compositeSubstitute()
            }
        }
    }

        }

        fun buildSubstitutor(substitutor: ConeSubstitutor): KaSubstitutor {
            if (substitutor == ConeSubstitutor.Empty) return KaSubstitutor.Empty(token)
            return when (substitutor) {
                is ConeSubstitutorByMap -> KaFirMapBackedSubstitutor(substitutor, this@KaSymbolByFirBuilder)
                is ChainedSubstitutor -> KaFirChainedSubstitutor(substitutor, this@KaSymbolByFirBuilder)

    }

    @Issue("https://github.com/gradle/gradle/issues/13204")
    def "can substitute a normal dependency with a platform dependency"() {

        buildFile << """

            configurations {
                conf {
                    resolutionStrategy.dependencySubstitution {
                        substitute module('org:lib') using $notation
                    }
                }
            }

    }

    def "cannot substitute with unversioned module selector"() {
        when:
        substitutions.with {
            substitute project("foo") using module('group:name')
        }

        then:
        def t = thrown(InvalidUserDataException)
        t.message == "Must specify version for target of dependency substitution"
    }

#include <utility>
#include <vector>

#include "absl/container/flat_hash_map.h"
#include "absl/log/log.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"
#include "absl/strings/substitute.h"
#include "tensorflow/cc/framework/cc_op_gen_util.h"
#include "tensorflow/core/framework/api_def.pb.h"
#include "tensorflow/core/framework/op_def.pb.h"
#include "tensorflow/core/framework/op_def_util.h"

     *   resolutionStrategy.dependencySubstitution {
     *     // Substitute project and module dependencies
     *     substitute module('org.gradle:api') using project(':api')
     *     substitute project(':util') using module('org.gradle:util:3.0')
     *
     *     // Substitute one module dependency for another
     *     substitute module('org.gradle:api:2.0') using module('org.gradle:api:2.1')
     *   }
     * }

                   resolutionStrategy {
                       dependencySubstitution {
                           if ($fixConflict) {
                              substitute module('org.apache:groovy') using module('org.apache:groovy-all:1.0')
                              substitute module('org.apache:groovy-json') using module('org.apache:groovy-all:1.0')
                           }
                       }
                   }