variant.getFiles(), variant.getCapabilities(), variantToDependencies.get(variant.getName()), variant.isExternalVariant()));
        }
        ImmutableList<AbstractRealisedModuleComponentResolveMetadata.ImmutableRealisedVariantImpl> realisedVariants = builder.build();

                variant.getFiles(), variant.getCapabilities(), variantToDependencies.get(variant.getName()), variant.isExternalVariant()));
        }
        ImmutableList<AbstractRealisedModuleComponentResolveMetadata.ImmutableRealisedVariantImpl> realisedVariants = builder.build();
        return new RealisedIvyModuleResolveMetadata(resolveMetadata, realisedVariants, readIvyConfigurations(decoder, resolveMetadata));

            formatter.node("Cannot choose between the available variants of ");
        } else {
            String node = "The consumer was configured to find " + describer.describeAttributeSet(failure.getRequestedAttributes().asMap());
            if (listAvailableVariants) {
                node = node + ". However we cannot choose between the following variants of ";
            } else {

    }

    private static void assertAttributes(GradleModuleMetadata.Variant variant, Map<String, Object> expected) {
        assert variant.attributes.size() == expected.size()
        expected.each { attribute, value ->
            assert variant.attributes.containsKey(attribute)
            assert variant.attributes[attribute] == value
        }
    }

    void assertNoDependencies() {

            .findFirst().orElseThrow(IllegalStateException::new);
    }

    private String suggestDependencyInsight() {
        return "Use the dependencyInsight report with the --all-variants option to view all variants of the ambiguous dependency.  This report is described at " + getDocumentationRegistry().getDocumentationFor("viewing_debugging_dependencies", "sec:identifying_reason_dependency_selection") + ".";
    }

 */

package org.gradle.internal.component.resolution.failure.type;

/**
 * An abstract {@link ResolutionFailure} that represents the situation when a requested variant has attributes
 * that are not compatible with any of the available variants.
 */
public abstract class AbstractVariantSelectionFailure implements ResolutionFailure {
    private final String requestedName;

 * be migrated to {@link ExternalComponentGraphResolveState}</p>
 */
public interface ExternalComponentGraphResolveMetadata extends ComponentGraphResolveMetadata {

    /**
     * Returns the set of variants of this component to use for variant aware resolution of the dependency graph nodes.
     * May be empty, in which case selection falls back to an ecosystem-specific selection strategy.
     */

        resolve.prepare()
    }

    @Override
    boolean isJavaEcosystem() {
        false
    }

    @Issue("https://github.com/gradle/gradle/issues/20145")
    def "component metadata rules can add variants even if no derivation rules are present"() {
        given: "a published module"
        repository {
            group("org") {
                module("a") {
                    version("1") {

import org.gradle.api.internal.attributes.ImmutableAttributes;

/**
 * An abstract {@link ResolutionFailure} that represents the situation when a requested variant has attributes
 * that are not compatible with any of the available variants.
 */
public abstract class AbstractIncompatibleAttributesSelectionFailure extends AbstractVariantSelectionFailure {
    private final ImmutableAttributes requestedAttributes;

        StringBuilder sb = new StringBuilder("Multiple incompatible variants of ")
            .append(failure.getRequestedName())
            .append(" were selected:\n");
        for (AssessedCandidate assessedCandidate : failure.getAssessedCandidates()) {
            sb.append("   - Variant ").append(assessedCandidate.getDisplayName()).append(" has attributes ");