declaredReplacements 'a->b'
        buildFile << """
            configurations.all { resolutionStrategy.eachDependency { dep ->
                if (dep.requested.name == 'c') { dep.useTarget 'org:a:1' }
                if (dep.requested.name == 'd') { dep.useTarget 'org:b:1' }
            }}
        """
        expect:
        resolvedModules 'b'
    }

            def targetProject = findProject(":${dependency.requested.module}")
            if (targetProject != null) {
                dependency.useTarget targetProject
            }
        }
    }
}
// end::project_substitution[]

dependencies {
    implementation "org.example:project1:1.0"
}

tasks.register('showJarFiles') {

            if (it is ModuleComponentSelector && it.group == "org.example") {
                val targetProject = findProject(":${it.module}")
                if (targetProject != null) {
                    useTarget(targetProject)
                }
            }
        }
    }
}
// end::project_substitution[]

dependencies {
    implementation("org.example:project1:1.0")
}

tasks.register("showJarFiles") {

                        it.useTarget group: it.requested.group, name: it.requested.module, version: '1.4'
                    }
                    all {
                        assert it.target.version == '1.4'
                        assert it.target.module == it.requested.module
                        assert it.target.group == it.requested.group

     * </ul>
     *
     * @param notation the notation that gets parsed into an instance of {@link ComponentSelector}.
     */
    void useTarget(Object notation);

    /**
     * This method can be used to replace a dependency before it is resolved,
     * e.g. change group, name or version (or all three of them), or replace it

     *   all { DependencySubstitution dependency ->
     *     if (dependency.requested instanceof ModuleComponentSelector && dependency.requested.module == 'groovy-all') {
     *       dependency.useTarget dependency.requested.group + ':groovy:' + dependency.requested.version
     *     }
     *   }
     *   // Use a rule to replace all missing projects with module dependencies

        @Override
        public ComponentSelector getRequested() {
            return selector;
        }

        @Override
        public void useTarget(Object notation) {
            didSubstitute = true;
        }

        @Override
        public void useTarget(Object notation, String reason) {
            didSubstitute = true;
        }

        @Override

            if (forcedModules.containsKey(key)) {
                DefaultImmutableVersionConstraint versionConstraint = new DefaultImmutableVersionConstraint(forcedModules.get(key));
                details.useTarget(newSelector(key, versionConstraint, selector.getAttributes(), selector.getRequestedCapabilities()), ComponentSelectionReasons.FORCED);

            }
        }
    }

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionDescriptorInternal;

import java.util.List;

public interface DependencySubstitutionInternal extends DependencySubstitution {
    void useTarget(Object notation, ComponentSelectionDescriptor ruleDescriptor);

    ComponentSelector getTarget();

    List<ComponentSelectionDescriptorInternal> getRuleDescriptors();

    boolean isUpdated();

                conf 'org.utils:a:1.2', 'org.utils:b:2.0'
            }

            configurations.conf.resolutionStrategy.eachDependency {
                if (it.requested.name == 'a') {
                    it.useTarget(it.requested.group + ':b:2.1')
                }
            }
"""
        resolve.prepare("conf")

        expect:
        succeeds("checkDeps")
        resolve.expectGraph {