}
    };

    abstract boolean isIncremental();

    @Nullable
    abstract List<String> getExecutionReasons();

    public static TaskExecutionDetails of(final boolean incremental, final List<String> executionReasons) {
        return new TaskExecutionDetails() {
            @Override
            public boolean isIncremental() {
                return incremental;
            }

            @Override

plugins {
    id("groovy")
}

dependencies {
    implementation(localGroovy())
}

// tag::enable-groovy-incremental[]
tasks.withType<GroovyCompile>().configureEach {
    options.isIncremental = true
    options.incrementalAfterFailure = true
}

        return this.upToDate;
    }

    @Override
    public boolean isFromCache() {
        return fromCache;
    }

    @Override
    public boolean isIncremental() {
        return taskExecutionDetails.isIncremental();
    }

    @Override
    @Nullable
    public List<String> getExecutionReasons() {
        return taskExecutionDetails.getExecutionReasons();
    }

        super(startTime, endTime, failures);
        this.taskExecutionDetails = taskExecutionDetails;
    }

    @Override
    public boolean isIncremental() {
        return taskExecutionDetails.isIncremental();
    }

    @Override
    @Nullable
    public List<String> getExecutionReasons() {
        return taskExecutionDetails.getExecutionReasons();
    }

        tasks.withType<JavaCompile> {
            options.isFork = true
            options.isIncremental = true
            options.forkOptions.memoryInitialSize = compilerMemory
            options.forkOptions.memoryMaximumSize = compilerMemory
        }
        tasks.withType<GroovyCompile> {
            options.isFork = true
            options.isIncremental = true
            options.forkOptions.memoryInitialSize = compilerMemory

        /**
         * Returns if this task was executed incrementally.
         *
         * See {@code org.gradle.work.InputChanges#isIncremental()}.
         */
        @NotUsedByScanPlugin("used to report incrementality to TAPI progress listeners")
        boolean isIncremental();

    }

    private ExecuteTaskBuildOperationType() {

    }

    override
    fun transform(outputs: TransformOutputs) {
        val outputDir = outputs.dir("${input.get().asFile.name}.loc")
        println("Running transform on ${input.get().asFile.name}, incremental: ${inputChanges.isIncremental}")
        inputChanges.getFileChanges(input).forEach { change ->          // <2>
            val changedFile = change.file
            if (change.fileType != FileType.FILE) {
                return@forEach

    @get:Input
    abstract val inputProperty: Property<String>

    @TaskAction
    fun execute(inputChanges: InputChanges) {
        println(
            if (inputChanges.isIncremental) "Executing incrementally"
            else "Executing non-incrementally"
        )

        // tag::process-changed-inputs[]
        inputChanges.getFileChanges(inputDir).forEach { change ->

 *
 * @since 5.1
 */
public interface InternalIncrementalTaskResult extends InternalTaskResult {

    /**
     * Returns whether this task is incremental.
     */
    boolean isIncremental();

    /**
     * Returns the reasons for executing this task.
     *
     * @return the list of reasons; {@code null} if undetermined (e.g. if the task was skipped).
     */

    public Optional<InputChangesInternal> getInputChanges() {
        return Optional.ofNullable(inputChanges);
    }

    public boolean isIncrementalExecution() {
        return inputChanges != null && inputChanges.isIncremental();
    }

    @Override
    public CachingState getCachingState() {
        return cachingState;
    }