*/
    boolean hasAttribute(Attribute<?> key);

    /**
     * Adds attributes to the precedence order. Attributes listed first have higher precedence.
     * <p>
     * The attributes will be added to any existing precedence order. If an attribute has already been added, adding it again
     * will fail.
     *
     * @param attributes the attributes in order
     *

	if s == "" {
		s = "token(" + strconv.Itoa(int(tok)) + ")"
	}
	return s
}

// A set of constants for precedence-based expression parsing.
// Non-operators have lowest precedence, followed by operators
// starting with precedence 1 up to unary operators. The highest
// precedence serves as "catch-all" precedence for selector,
// indexing, and other operator and delimiter tokens.
const (
	LowestPrec  = 0 // non-operators

            if (!precedence.add(attribute)) {
                throw new IllegalArgumentException(String.format("Attribute '%s' precedence has already been set.", attribute.getName()));
            }
        }
    }

    @Override
    public void setAttributeDisambiguationPrecedence(List<Attribute<?>> attributes) {
        precedence.clear();

     * The actual method instance used is significant.
     * The method instance is for the “nearest” declaration, where classes take precedence over interfaces.
     * Interface precedence is breadth-first, declaration.
     *
     * The order of the methods follows the same precedence.
     * That is, the “nearer” declarations are earlier in the list.
     */
    Collection<Method> getGetters();

    /**

    content: |
      This fix changes the behavior of overlapping wildcard hosts in VirtualService. Previously, the oldest VirtualService would take precedence
      regardless of whether or not it was the most specific host match. Now, the most specific host match will take precedence. To persist the old behavior,

                    configure<my.MySettingsExtension> {
                        action()
                    }
                }
            """
        )

        val result = build("ok")

        // then:
        result.assertOutputContains("It's 42!")
        result.assertOutputContains("Plugin extension takes precedence!")
    }

    @Test

        controller.loadGradlePropertiesFrom(new File('b'), true)

        then:
        thrown(IllegalStateException)
    }

    def "environment variables have precedence over project properties"() {
        given:
        def settingsDir = new File("settingsDir")
        def gradleUserHomePropertiesFile = propertiesFileFromDir(gradleUserHome)

    @Rule SetSystemProperties systemProperties = new SetSystemProperties()

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "build property set on command line takes precedence over properties file"() {
        when:
        file('gradle.properties') << """
org.gradle.configureondemand=true
"""
        buildFile << """
task assertCodEnabled {
    doLast {

        expect:
        EmptySchema.INSTANCE.attributes.empty
        !EmptySchema.INSTANCE.hasAttribute(Attribute.of(String))
    }

    def "has no precedence"() {
        expect:
        EmptySchema.INSTANCE.attributeDisambiguationPrecedence.empty
    }

    def "cannot set precedence"() {
        when:
        EmptySchema.INSTANCE.attributeDisambiguationPrecedence(Attribute.of("attribute", String))
        then:

    File getGlobalSettingsFile();

    /**
     * Sets the global settings file. A non-existent settings file is equivalent to empty settings. If both user
     * settings and global settings are given, the user settings take precedence.
     *
     * @param globalSettingsFile The global settings file, may be {@code null} to disable global settings.
     * @return This request, never {@code null}.
     */