if (result instanceof InternalIncrementalTaskResult) {
            InternalIncrementalTaskResult taskResult = (InternalIncrementalTaskResult) result;
            return TaskExecutionDetails.of(taskResult.isIncremental(), taskResult.getExecutionReasons());
        }
        return TaskExecutionDetails.unsupported();
    }

    private static @Nullable WorkItemOperationResult toWorkItemResult(InternalOperationResult result) {

        false       | PathSensitivity.NAME_ONLY

        inputChanges = incremental ? "@Inject abstract InputChanges getInputChanges()" : ""
        normalization = (sensitivity?.name()?.toLowerCase()?.replaceAll("_", " ") ?: "no") + " path sensitivity"
        type = (incremental ? "incremental" : "non-incremental")
    }

    def "re-runs incremental transform when input artifact file changes from file to missing"() {

Implies `<<#incremental,@Incremental>>`.

| [[incremental]]`@link:{javadocPath}/org/gradle/work/Incremental.html[Incremental]`
| `Provider<FileSystemLocation>` or `FileCollection`

	// Full determines whether a full push is required or not. If false, an incremental update will be sent.
	// Incremental pushes:
	// * Do not recompute the push context
	// * Do not recompute proxy state (such as ServiceInstances)
	// * Are not reported in standard metrics such as push time
	// As a result, configuration updates should never be incremental. Generally, only EDS will set this, but
	// in the future SDS will as well.

            transformActionClass == "MakeGreen"

            transformerName == "MakeGreen"
            subjectName == "producer.jar (project :included:producer)"
        }
    }

    def "incremental project transform execution can be up-to-date or from build cache"() {
        createDirs("producer", "consumer")
        settingsFile << """
            include 'producer', 'consumer'
        """

Only plugins which use the infrastructure provided by Gradle for performing requests will see their requests verified.
--

[[sec:verification-update]]
=== Using generation for incremental updates

The verification file generated by Gradle has a strict ordering for all its content.
It also uses the information from the existing state to limit changes to the strict minimum.

		re.Op = OpLiteral
		re.Rune = re.Rune[:1]
		re.Flags = p.flags | FoldCase
	} else {
		// Incremental concatenation.
		p.maybeConcat(-1, 0)
	}

	p.stack = append(p.stack, re)
	p.checkLimits(re)
	return re
}

// maybeConcat implements incremental concatenation
// of literal runes into string nodes. The parser calls this
// before each push, so only the top fragment of the stack

====

The above example demonstrates the basic syntax and also highlights two major limitations of using the `copy()` method:

1. The `copy()` method is not <<incremental_build.adoc#incremental_build,incremental>>.
The example's `copyMethod` task will _always_ execute because it has no information about what files make up the task's inputs.
You have to define the task inputs and outputs manually.

You should now use the `InputChanges` type instead.
Please refer to the <<custom_tasks.adoc#sec:implementing_an_incremental_task, userguide section about implementing incremental tasks for more details>>.

=== Potential breaking changes

==== Version catalog only accepts a single TOML import file

Only a single file will be accepted when using a `from` import method.

* Support for several source languages.
* Support for building different variants of the same software, for different architectures, operating systems, or for any purpose.
* Incremental parallel compilation, precompiled headers.
* Dependency management between native software components.
* Unit test execution.
* Generate Visual studio solution and project files.