// thread safety analysis. Instead we use a boolean flag and release the lock
  // in the VariableInfo destructor.
  bool lock_held_ = false;
  bool shared_lock_held_ = false;

  // Whether this variable is going to be mutated. Left false if the caller
  // doesn't provide this information.
  bool read_only_ = false;
};

}  // namespace tensorflow

        writer.println(" is invalid due to incompatible types.");
        writer.print("This element was created by ");
        writer.print(creator);
        writer.print(" and can be ");
        writer.print(writable ? "mutated" : "read");
        writer.println(" as the following types:");
        boolean first = true;
        for (String candidateType : candidateTypes) {
            if (!first) {
                writer.println();
            }

  // Prints MLIR after specified passes. Supports regular expressions for
  // matching against the names of the desired passes. Currently only prints
  // after a pass if the MLIR is mutated.
  optional string print_ir_after = 6 [default = ""];

  // If true, always print the top-level operation when printing IR for
  // print_ir_[before|after].
  optional bool print_ir_module_scope = 7 [default = true];

// Check verifies that no objects in the cacheMutationCheck have been mutated.
func (cmc *cacheMutationCheck) Check(t *testing.T) {
	for _, o := range cmc.objects {
		if !reflect.DeepEqual(o.original, o.deepCopy) {
			// Cached objects can't be safely mutated and instead should be deep
			// copied before changed in any way.
			t.Errorf("Cached object was unexpectedly mutated. Original: %+v, Mutated: %+v", o.deepCopy, o.original)
		}
	}

        and:
        file("build", "libs", "sign-1.0.jar.asc").text
        file("build", "publications", "mavenJava", "pom-default.xml.asc").text
    }

    def "component can still be mutated after signing is configured for a Maven publication"() {
        given:
        buildFile << """
            apply plugin: 'maven-publish'
            ${keyInfo.addAsPropertiesScript()}

            publishing {

)

// PopulateRefs recursively replaces Refs in the schema with the referred one.
// schemaOf is the callback to find the corresponding schema by the ref.
// This function will not mutate the original schema. If the schema needs to be
// mutated, a copy will be returned, otherwise it returns the original schema.
func PopulateRefs(schemaOf func(ref string) (*spec.Schema, bool), rootRef string) (*spec.Schema, error) {

	// the type includes "kind", "apiVersion" field
	// the "metadata" field requires "name" and "generateName" to be set
	// The original schema must not be mutated. Make a copy if necessary.
	WithTypeAndObjectMeta() Schema
}

// Validations contains OpenAPI validation that the CEL library uses.
type Validations interface {
	Pattern() string
	Minimum() *float64

import org.gradle.api.Task;

import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;

/**
 * An execution plan that has been finalized and can no longer be mutated.
 *
 * <p>Implementations may or may not be thread-safe.</p>
 */
public interface QueryableExecutionPlan {
    QueryableExecutionPlan EMPTY = new QueryableExecutionPlan() {
        @Override

     * <p>Creates a read-only {@link FileCollection} containing the given files, as defined by {@link Project#files(Object...)}.
     *
     * <p>This method can also be used to create an empty collection, but the collection may not be mutated later.</p>
     *
     * @param paths The paths to the files. May be empty.
     * @return The file collection. Never returns null.
     * @since 4.8
     */
    FileCollection files(Object... paths);

        super(type, new IterationOrderRetainingSetElementSource<T>(), decorator);
    }

    /**
     * Adds an action which is executed before this collection is mutated with the addition or removal of elements.
     * Any exception thrown by the action will veto the mutation.
     *