* it is superseded by {@link org.gradle.api.artifacts.component.ModuleComponentSelector}, so check this first, and only
 * add methods here if it's for bridging.
 */
public interface ModuleVersionSelector {

    /**
     * The group of the module.
     *
     * @return module group
     */
    String getGroup();

    /**
     * The name of the module.
     *
     * @return module name

import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.artifacts.ModuleVersionIdentifier;
import org.gradle.api.artifacts.ModuleVersionSelector;
import org.gradle.api.artifacts.component.ModuleComponentSelector;

public class DefaultModuleVersionSelector implements ModuleVersionSelector {

    private final ModuleIdentifier module;
    private final String version;

import org.gradle.api.artifacts.ModuleVersionIdentifier;
import org.gradle.api.artifacts.ModuleVersionSelector;
import org.gradle.api.specs.Spec;

public class ModuleVersionSelectorStrictSpec implements Spec<ModuleVersionIdentifier> {

    private final ModuleVersionSelector selector;

    public ModuleVersionSelectorStrictSpec(ModuleVersionSelector selector) {
        assert selector != null;
        this.selector = selector;
    }

public class DefaultDependencyResolveDetails implements DependencyResolveDetails {

    private static final NotationParser<Object, ModuleVersionSelector> USE_TARGET_NOTATION_PARSER = ModuleVersionSelectorParsers.parser("useTarget()");

    private final DependencySubstitutionInternal delegate;
    private final ModuleVersionSelector requested;

    private String customDescription;
    private VersionConstraint useVersion;

    public static NotationParser<Object, Set<ModuleVersionSelector>> multiParser(String dslContext) {
        return builder(dslContext).toFlatteningComposite();
    }

    public static NotationParser<Object, ModuleVersionSelector> parser(String dslContext) {
        return builder(dslContext).toComposite();
    }

    private static NotationParserBuilder<Object, ModuleVersionSelector> builder(String dslContext) {

        def differentFrom = factory.createUnresolvedDependency(selector('requested'), newModule('xxx'), false, selectedModule, new ModuleVersionResolveException(moduleVersionSelector('requested'), broken))
        def differentConstraint = factory.createUnresolvedDependency(selector('requested'), fromModule, true, selectedModule, new ModuleVersionResolveException(moduleVersionSelector('requested'), broken))

    private final Map<ModuleIdentifier, String> forcedModules;

    public ModuleForcingResolveRule(Collection<? extends ModuleVersionSelector> forcedModules) {
        if (!forcedModules.isEmpty()) {
            this.forcedModules = new HashMap<>();
            for (ModuleVersionSelector module : forcedModules) {
                this.forcedModules.put(module.getModule(), module.getVersion());
            }
        } else {

import org.gradle.api.artifacts.ModuleVersionSelector;
import org.gradle.api.artifacts.UnresolvedDependency;

public class DefaultUnresolvedDependency implements UnresolvedDependency {
    private final Throwable problem;
    private final ModuleVersionSelector selector;

    public DefaultUnresolvedDependency(ModuleVersionSelector selector, Throwable problem) {
        this.selector = selector;

 */

package org.gradle.internal.enterprise.impl;

import org.gradle.StartParameter;
import org.gradle.api.Project;
import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.artifacts.ModuleVersionSelector;
import org.gradle.api.initialization.Settings;
import org.gradle.api.internal.StartParameterInternal;
import org.gradle.api.internal.artifacts.DefaultModuleIdentifier;

import org.gradle.api.NonNullApi;
import org.gradle.api.artifacts.ModuleVersionSelector;
import org.gradle.plugin.management.PluginRequest;
import org.gradle.plugin.use.PluginId;

import javax.annotation.Nullable;

@NonNullApi
public final class PluginCoordinates {

    private final PluginId id;
    private final ModuleVersionSelector module;