}

            ComponentSelector requested = dependencyEdge.getRequested();

            if(!isExpectedComponentSelector(requested)) {
                throw new IllegalArgumentException("Unexpected component selector type for dependency edge: " + requested.getClass());
            }
        }

        private boolean isExpectedComponentSelector(ComponentSelector componentSelector) {

                    mutable.attribute(desugared, value.toString());
                }
            }
            return mutable.asImmutable();
        });
    }

    public ComponentSelector desugarSelector(ComponentSelector selector) {
        if (selector instanceof ModuleComponentSelector) {
            ModuleComponentSelector module = (ModuleComponentSelector) selector;

import org.gradle.api.artifacts.component.ComponentSelector;
import org.gradle.api.artifacts.result.ComponentSelectionReason;
import org.gradle.api.artifacts.result.ResolvedVariantResult;

import java.util.List;
import java.util.Set;

public interface DependencyEdge {
    boolean isResolvable();

    ComponentSelector getRequested();

    ComponentIdentifier getActual();

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.vcs.internal;

import org.gradle.api.artifacts.component.ComponentSelector;
import org.gradle.api.model.ObjectFactory;

public class DefaultVcsMappingFactory implements VcsMappingFactory {
    private final ObjectFactory objectFactory;
    private final VersionControlSpecFactory specFactory;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.tooling.internal.consumer.converters;

import org.gradle.tooling.model.ComponentSelector;
import org.gradle.tooling.model.eclipse.EclipseExternalDependency;

/**
 * This is used for compatibility with clients <6.7
 */
public class EclipseExternalDependencyUnresolvedMixin {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.artifacts.result;

import org.gradle.api.artifacts.component.ComponentSelector;
import org.gradle.internal.scan.UsedByScanPlugin;

/**
 * An edge in the dependency graph. Provides information about the origin of the dependency and the requested component.
 *
 * @see ResolutionResult
 */

        ComponentSelector selector = createSelector(dependencyConstraint);
        return new LocalComponentDependencyMetadata(selector, null,
            Collections.emptyList(), Collections.emptyList(), ((DependencyConstraintInternal) dependencyConstraint).isForce(), false, false, true, false, dependencyConstraint.getReason());
    }

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph;

import org.gradle.api.artifacts.component.ComponentSelector;

/**
 * A dependency selector in the dependency graph
 */
public interface DependencyGraphSelector {
    /**
     * Returns a simple id for this selector, unique across selectors in the same graph.

    }

    private AbstractRenderableDependencyResult dep(ComponentSelector requested, ComponentIdentifier selected) {
        return new AbstractRenderableDependencyResult() {
            ComponentSelector getRequested() {
                return requested
            }

            ComponentIdentifier getActual() {
                return selected

    }

    @Override
    public DependencyMetadata withTarget(ComponentSelector target) {
        if (target.equals(selector)) {
            return this;
        }
        return delegate.withTarget(target);
    }

    @Override
    public DependencyMetadata withTargetAndArtifacts(ComponentSelector target, List<IvyArtifactName> artifacts) {