task.setGroup("documentation");
            task.setDescription("Generates DSL reference HTML documentation.");
            task.onlyIf(t -> !extension.getQuickFeedback().get());

            task.source(dslStandaloneDocbook);
            task.getStylesheetDirectory().convention(dslReference.getStylesheetDirectory());

 *
 * <p>You can use {@link CacheBuilder#withInitializer(java.util.function.Consumer)} to provide an action to initialize the contents
 * of the cache, for building a read-only cache. An exclusive lock is held by this process while the initializer is running.</p>
 *
 * <p>You can also use {@link #useCache(java.util.function.Supplier)} to perform some action on the cache while holding an exclusive

            return new GroovyRuntimeException(String.format(
                    "Cannot get the value of write-only property '%s' for %s of type %s.", name, getDisplayName(), publicType.getName()));
        } else if (publicType != null) {
            return new GroovyRuntimeException(String.format(
                    "Cannot get the value of write-only property '%s' for object of type %s.", name, publicType.getName()));
        } else {

 */
public interface ExclusiveCacheAccessCoordinator {
    /**
     * Performs some work against the cache. Acquires exclusive locks on the appropriate resources, so that the given action is the only action to execute across all processes (including this one). Releases the locks and all resources at the end of the action.
     *
     * <p>This method is re-entrant, so that an action can call back into this method.</p>
     *

package org.gradle.test;

/**
 * This is a java class.
 */
public class JavaClass extends A implements CombinedInterface, JavaInterface {
    /**
     * A read-only property.
     */
    public String getReadOnly() {
        return "value";
    }

    /**
     * An ignored field.
     */
    String ignoreMe1;

    /**
     * Another ignored field.
     */
    final long ignoreMe2 = 9;

    /**

            if (!cacheFile.isFile()) {
                cacheFile.createNewFile();
            }
            chmod.chmod(cacheFile.getParentFile(), 0700); // read-write-execute for user only
            chmod.chmod(cacheFile, 0600); // read-write for user only
            OutputStreamBackedEncoder encoder = new OutputStreamBackedEncoder(new BufferedOutputStream(new FileOutputStream(cacheFile)));
            try {

 *
 * <p>The managed property represents a property that is able to serve all its declaring view methods. For example, if the view
 * types declaring the struct only specify the property via a getter, then the managed property will be read-only. However, if
 * even one of the view types declare a setter for the property, it will be a read-write property. </p>
 *

 */
public interface ExecutionInputState {
    /**
     * The main implementation snapshots.
     */
    ImplementationSnapshot getImplementation();

    /**
     * Used only for tasks to return all the task actions.
     */
    ImmutableList<ImplementationSnapshot> getAdditionalImplementations();

    /**
     * The non-file inputs.
     */

import javax.annotation.concurrent.ThreadSafe;
import org.codehaus.groovy.ast.ClassHelper;
import org.codehaus.groovy.ast.ClassNode;
import org.gradle.api.Action;

/**
 * The verifier is the only thing in the Groovy compiler chain that gets to visit the classes generated from closure expressions. If we want to transform these classes, we have to do it with this
 * *hack*.
 */
@ThreadSafe

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

/**
 * Identifies if a path is underneath one of Gradle's global caches.
 *
 * We expect only Gradle itself to change things in the global caches directories.
 *
 * The quasi-immutability of global caches allows for some optimizations by retaining file system state in-memory.
 */
@ServiceScope(Scope.UserHome.class)