super(delegate.getStartTime(), delegate.getEndTime(), delegate.isUpToDate(), delegate.isFromCache(), delegate.getOutcomeDescription(), delegate.isIncremental(), delegate.getExecutionReasons());
        this.annotationProcessorResults = annotationProcessorResults;
    }

    @Nullable
    @Override

    @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;
    }

        this.changes = changes;
        this.incrementalInputProperties = incrementalInputProperties;
    }

    @Override
    public boolean isIncremental() {
        return true;
    }

    @Override
    public Iterable<FileChange> getFileChanges(FileCollection parameter) {
        return getObjectFileChanges(parameter);
    }

    @Override

 */

package org.gradle.api.internal.tasks.compile.incremental.recomp;

import org.gradle.api.internal.tasks.compile.JavaCompileSpec;
import org.gradle.api.internal.tasks.compile.incremental.transaction.CompileTransaction;
import org.gradle.api.tasks.WorkResult;

/**
 * In a typical incremental recompilation, there're three steps:

            .orElseThrow(() -> new IllegalStateException("Changes are not tracked, unable determine incremental changes."));
        InputChangesInternal inputChanges = changes.createInputChanges();
        if (!inputChanges.isIncremental()) {
            LOGGER.info("The input changes require a full rebuild for incremental {}.", work.getDisplayName());
        }
        return inputChanges;
    }

     *
     * @return {@code true} if this task was executed incrementally
     * @throws UnsupportedMethodException For Gradle versions older than 5.1, where this method is not supported.
     */
    boolean isIncremental();

    /**
     * Returns the reasons why this task was executed.
     *
     * @return the reasons why this task was executed; an empty list indicates the task was up-to-date;

        }
    }

    @Override
    public List<String> getUpToDateMessages() {
        return executionReasons;
    }

    @Override
    public boolean isIncremental() {
        return incremental;
    }

    onlyIf("mySkipTests property is not set") {
        !skipTestsProvider.isPresent()
    }
}
// end::skip-tests-condition[]

// tag::java-compiler-options[]
tasks.compileJava {
    options.isIncremental = true
    options.isFork = true
    options.isFailOnError = false
}
// end::java-compiler-options[]

// tag::java-release-flag[]
tasks.compileJava {
    options.release = 7
}