cacheable = computeCacheable();
    }

    private boolean computeCacheable() {
        boolean isCacheable = false;
        for (ConfigurableRule<DETAILS> configurableRule : configurableRules) {
            if (configurableRule.isCacheable()) {
                isCacheable = true;
            }
        }
        return isCacheable;
    }

    @Override
    public List<ConfigurableRule<DETAILS>> getConfigurableRules() {

        dirty.put(block.getPos(), block);
    }

    private <T extends BlockPayload> void maybeCache(T block) {
        if (isCacheable(block)) {
            indexBlockCache.put(block.getPos(), block);
        }
    }

    private <T extends BlockPayload> boolean isCacheable(T block) {
        return cacheableBlockTypes.contains(block.getClass());
    }

            write(value.toAttributes)
            writeEnum(value.inputArtifactNormalizer as InputNormalizer)
            writeEnum(value.inputArtifactDependenciesNormalizer as InputNormalizer)
            writeBoolean(value.isCacheable)
            writeEnum(value.inputArtifactDirectorySensitivity)
            writeEnum(value.inputArtifactDependenciesDirectorySensitivity)
            writeEnum(value.inputArtifactLineEndingNormalization)

        this.cachedSchemes = cachedSchemes;
        this.resolver = resolver;
    }

    @Override
    public TextResource loadUri(String description, URI source) {
        if (isCacheable(source)) {
            LocallyAvailableExternalResource resource = externalResourceAccessor.resolveUri(source);
            if (resource == null) {
                throw ResourceExceptions.getMissing(source);
            }

        this.reasonNotToTrackState = reasonNotToTrackState;
    }

    public ImmutableList<TaskActionFactory> getTaskActionFactories() {
        return taskActionFactories;
    }

    public boolean isCacheable() {
        return cacheable;
    }

    public Optional<String> getReasonNotToTrackState() {
        return reasonNotToTrackState;
    }

 */
package org.gradle.internal.action;

import java.util.List;

public interface ConfigurableRules<DETAILS> {
    List<ConfigurableRule<DETAILS>> getConfigurableRules();
    boolean isCacheable();

import org.gradle.internal.isolation.Isolatable;

public interface ConfigurableRule<DETAILS> {
    Class<? extends Action<DETAILS>> getRuleClass();
    Isolatable<Object[]> getRuleParams();
    boolean isCacheable();

            ((TaskInternal) task).prependParallelSafeAction(actionFactory.create(instantiator));
        }

        // Enabled caching if task type is annotated with @CacheableTask
        if (taskClassInfo.isCacheable()) {
            task.getOutputs().cacheIf("Annotated with @CacheableTask", Specs.SATISFIES_ALL);
        }
        taskClassInfo.getReasonNotToTrackState()
            .ifPresent(task::doNotTrackState);

    override suspend fun WriteContext.encode(value: DefaultTransform.IsolateTransformParameters) {
        write(value.parameterObject)
        writeClass(value.implementationClass)
        writeBoolean(value.isCacheable)
    }

    override suspend fun ReadContext.decode(): DefaultTransform.IsolateTransformParameters? {
        val parameterObject: TransformParameters? = read()?.uncheckedCast()
        val implementationClass = readClass()

    /**
     * Whether the transformer requires {@link InputChanges} to be injected.
     */
    boolean requiresInputChanges();

    /**
     * Whether the transformer is cacheable.
     */
    boolean isCacheable();

    TransformExecutionResult transform(Provider<FileSystemLocation> inputArtifactProvider, File outputDir, TransformDependencies dependencies, @Nullable InputChanges inputChanges);

    /**