* </li>
 * <li>
 * Otherwise continue with disambiguation. Disambiguation iterates through the attributes and presents the different values to the {@link AttributeSelectionSchema}.
 * The schema can declare a subset of these values as preferred. Candidates whose value is not in that subset are rejected. If a single candidate remains after

Disambiguation Rules
--------------------------------------------------
The following Attributes have disambiguation rules defined.

    - flavor""")

        and:
        doesNotHaveLegacyLegend()
    }

    def "disambiguation rules are printed if added to attributes"() {

[[sec:abm_disambiguation_rules]]
=== Attribute disambiguation rules

Since multiple values for an attribute can be _compatible_, Gradle needs to choose the "best" candidate between all compatible candidates. This is called "disambiguation".

This is done by implementing an link:{javadocPath}/org/gradle/api/attributes/AttributeDisambiguationRule.html[attribute disambiguation rule].

        failure.assertHasCause("Unexpected type for attribute 'flavor' provided. Expected a value of type Flavor but found a value of type java.lang.Integer.")
    }

    def "selects best compatible match using consumers disambiguation rules when multiple are compatible"() {
        given:
        createDirs("a", "b")
        file('settings.gradle') << "include 'a', 'b'"
        buildFile << """
            $typeDefs

        Usage.JAVA_RUNTIME           | JavaEcosystemSupport.DEPRECATED_JAVA_RUNTIME_JARS      | true
    }

    @Issue("gradle/gradle#8700")
    def "check usage disambiguation rules (consumer=#consumer, candidates=#candidates, selected=#preferred)"() {
        given:
        JavaEcosystemSupport.UsageDisambiguationRules rules = new JavaEcosystemSupport.UsageDisambiguationRules(

// The Go 1.18 frontend failed to disambiguate instantiations of
// different, locally defined generic types with the same name.
//
// The unified frontend also exposed the scope-disambiguation mangling
// to end users in reflect data.

package main

import (
	"reflect"
)

func one() any { type T[_ any] int; return T[int](0) }
func two() any { type T[_ any] int; return T[int](0) }

}

type NegMult struct{}

func (NegMult) Multiply(a, b int) int {
	for i := 0; i < 1000; i++ {
		sink++
	}
	return -1 * a * b
}

// N.B. Different types than AddFunc to test intra-line disambiguation.
type MultFunc func(int64, int64) int64

func MultFn(a, b int64) int64 {
	for i := 0; i < 1000; i++ {
		sink++
	}
	return a * b
}

func NegMultFn(a, b int64) int64 {
	for i := 0; i < 1000; i++ {

        2 * attributeMatcher.matches(_, _, _) >> [variant, otherVariant]
        2 * attributeMatcher.isMatching(_, _, _) >> true
        0 * consumerProvidedVariantFinder._
    }

    def 'does not perform schema disambiguation against a single transform result'() {
        given:
        def transformed = Mock(ResolvedArtifactSet)
        def variants = [variant]
        def transformedVariants = transformedVariants(variants)

            // artifact repository. We always check whether the schema has a more strongly typed
            // version of an attribute and use that one instead to apply its disambiguation rules.
            Attribute<?> schemaAttribute = schema.getAttribute(extraAttribute.getName());
            if (schemaAttribute != null) {
                extraAttributesArray[i] = schemaAttribute;
            }

        // Often times, collections of candidates will themselves differ even though their attributes are the same.
        // Disambiguating two different candidate lists which map to the same attribute lists in reality performs
        // the same work, so instead we cache disambiguation results based on the attributes being disambiguated.
        // The result of this is a list of indices into the original candidate list from which the