private ImmutableAttributesFactory attributesFactory = AttributeTestUtil.attributesFactory()
    private List<ImmutableAttributes> candidates = []
    private AttributeContainerInternal requested = attributesFactory.mutable()

    private List<Attribute<?>> extraAttributes

    def "collects extra attributes, single candidate"() {
        def attr1 = Attribute.of("foo", String)
        def attr2 = Attribute.of("bar", String)

 * limitations under the License.
 */

package org.gradle.api.internal.project;

/**
 * A service can implement this interface to indicate that it holds mutable project scoped state that should be discarded when
 * projects are discarded.
 */
public interface HoldsProjectState {
    /**
     * Discards any project state.
     */
    void discardAll();

    a `tf_saved_model.exported_names` attribute.

    The `value` attribute contains the tensor's value (or initial value, in the
    case it is mutable).

    The `type` attribute contains the tensor's type, which for the case of
    mutable tensors might be more general than just the fixed static shape of
    the `value` attribute. For example, a global tensor might be unranked such

     * </pre>
     *
     * This is useful to reuse task classes from a plugin or to apply it to some other target than the current script.
     *
     * @param id the id of the plugin to depend on
     * @return a mutable plugin dependency specification that can be used to further refine the dependency
     */
    PluginDependencySpec id(String id);

    /**
     * Adds a plugin dependency using a notation coming from a version catalog.

    public void preventFromFurtherMutation() {
        this.mutable = false;
        NamedDomainObjectList<ArtifactRepository> repositoryHandler = getRepositories();
        repositoryHandler.whenObjectAdded(this::mutationDisallowed);
        repositoryHandler.whenObjectRemoved(this::mutationDisallowed);
    }

    private void assertMutable() {
        if (!mutable) {

import org.gradle.tooling.provider.model.internal.ToolingModelScope;

/**
 * Coordinates the building of tooling models.
 */
public interface BuildToolingModelController {
    /**
     * Returns the mutable model, configuring if necessary.
     */
    GradleInternal getConfiguredModel();

    ToolingModelScope locateBuilderForTarget(String modelName, boolean param);

                    String variantName = StringUtils.uncapitalize(String.join("", variantNameToken));

                    AttributeContainer runtimeAttributes = attributesFactory.mutable();
                    runtimeAttributes.attribute(Usage.USAGE_ATTRIBUTE, runtimeUsage);
                    addCommonAttributes(buildType, targetMachine, runtimeAttributes);

import org.gradle.internal.service.scopes.Scope


@EventScope(Scope.Build::class)
interface CoupledProjectsListener {
    /**
     * Notified when the build logic for a [referrer] project accesses the mutable state of some other [target] project.
     *
     * The [referrer] and [target] might represent the same project, and the listener implementation

            .mutate {
            it.path "values" node {
                it.addLinkInstance("values.mutable", new MutableValue())
            }
        }

        when:
        registry.get("values")

        then:
        registry.get("values.mutable", MutableValue).value == "foo"
    }

    static class ByTypeBindingSubjectRule extends RuleSource {
        @Mutate

            }

            class TestAttributes {
                // shared mutable state for tests, don't do this at home!
                static AttributeContainer INSTANCE
            }
            TestAttributes.INSTANCE = project.services.get(org.gradle.api.internal.attributes.ImmutableAttributesFactory)
               .mutable()
               .attribute(Attribute.of("test.attribute", String), "value")