val parameterObject: TransformParameters? = read()?.uncheckedCast()
        val implementationClass = readClass()
        val cacheable = readBoolean()

        return DefaultTransform.IsolateTransformParameters(
            parameterObject,
            implementationClass,
            cacheable,
            RootScriptDomainObjectContext.INSTANCE,
            parameterScheme.inspectionScheme.propertyWalker,

    @Override
    public InternalProblems getProblemsService() {
        return ProblemsProgressEventEmitterHolder.get();
    }

    @Override
    public TypeValidationContext forType(Class<?> type, boolean cacheable) {
        types.add(type);
        Supplier<Optional<PluginId>> pluginId = () -> typeOriginInspector.findPluginDefining(type);
        return new ProblemRecordingTypeValidationContext(type, pluginId) {
            @Override

rootProject.name = "cacheable-bundle-task"...

<component name="ProjectDictionaryState">
  <dictionary name="4u7">
    <words>
      <w>aarch</w>
      <w>bintray</w>
      <w>cacheability</w>
      <w>cacheable</w>
      <w>cidr</w>
      <w>fastutil</w>
      <w>foldable</w>
      <w>instrumentator</w>
      <w>jdks</w>
      <w>jsshell</w>
      <w>proguarded</w>
      <w>protobuf</w>
      <w>redirector</w>
      <w>remapper</w>
      <w>sonatype</w>

import org.gradle.work.DisableCachingByDefault;

/**
 * Compiles C++ header source files into object files.
 */
@DisableCachingByDefault(because = "Not made cacheable, yet")
public abstract class CppPreCompiledHeaderCompile extends AbstractNativePCHCompileTask {
    @Override
    protected NativeCompileSpec createCompileSpec() {
        return new DefaultCppPCHCompileSpec();
    }

import org.gradle.work.DisableCachingByDefault;

/**
 * Compiles Objective C++ header source files into object files.
 */
@DisableCachingByDefault(because = "Not made cacheable, yet")
public abstract class ObjectiveCppPreCompiledHeaderCompile extends AbstractNativePCHCompileTask {
    @Override
    protected NativeCompileSpec createCompileSpec() {
        return new DefaultObjectiveCppPCHCompileSpec();

import org.gradle.plugin.use.PluginId;

import java.util.List;
import java.util.Optional;

public interface WorkValidationContext {
    TypeValidationContext forType(Class<?> type, boolean cacheable);

    InternalProblems getProblemsService();

    List<Problem> getProblems();

    ImmutableSet<Class<?>> getValidatedTypes();

    interface TypeOriginInspector {

[short] skip  # sleeps to make mtime cacheable

go mod init example

cd subdir
go mod init example/subdir
sleep 2s  # allow go.mod mtime to be cached

go list -f '{{.Dir}}: {{.ImportPath}}' ./pkg
stdout $PWD${/}pkg': example/subdir/pkg$'

rm go.mod  # expose ../go.mod

go list -f '{{.Dir}}: {{.ImportPath}}' ./pkg
stdout $PWD${/}pkg': example/subdir/pkg$'

-- subdir/pkg/pkg.go --

 * limitations under the License.
 */
package gradlebuild.performance.generator.tasks

import org.gradle.work.DisableCachingByDefault

@DisableCachingByDefault(because = "Not made cacheable, yet")
class KtsProjectGeneratorTask extends JvmProjectGeneratorTask {

    KtsProjectGeneratorTask() {
        this.rootProjectTemplates = ['kts-settings', 'kts-empty', 'gradle-properties']

        return classInfos.get(type, aClass -> createTaskClassInfo(aClass.asSubclass(Task.class)));
    }

    private static TaskClassInfo createTaskClassInfo(Class<? extends Task> type) {
        boolean cacheable = type.isAnnotationPresent(CacheableTask.class);
        Optional<String> reasonNotToTrackState = Optional.ofNullable(type.getAnnotation(UntrackedTask.class))
            .map(UntrackedTask::because);