projectVersion = project.version
    projectDirectory = layout.buildDirectory.dir("buildshipProject").get().asFile
}

@DisableCachingByDefault(because = "Not worth caching")
abstract class CreateBuildshipEclipseProjectTask extends DefaultTask {

    @InputFile
    abstract RegularFileProperty getToolingApiShadedJar()

    @Input
    abstract Property<String> getProjectVersion()

Gradle's _incremental build_ feature helps to avoid work that is already done, but once you re-execute a task, any previous results are forgotten.
When you are switching branches back and forth, the local results get rebuilt over and over again, even if you are building something that has already been built before.

  @Override
  public int indexOf(@CheckForNull Object target) {
    int index = delegateCollection().indexOf(target);

    // TODO(kevinb): reconsider if it's really worth making feeble attempts at
    // sanity for inconsistent comparators.

    // The equals() check is needed when the comparator isn't compatible with
    // equals().

        def watchableHierarchies = ["first", "second", "third"].collect { file(it).createDir() }
        def fileInWatchableHierarchies = file("first/inside/root/dir/file.txt")
        def fileOutsideOfWatchableHierarchies = file("forth").file("someFile.txt")

        when:
        registerWatchableHierarchies(watchableHierarchies)
        then:
        0 * _

        when:
        fileInWatchableHierarchies.createFile()

     * [computePackageNamesWithTopLevelCallables] if either returns `null`. It depends on the declaration provider whether it's worth
     * computing separate package sets for classifiers and callables, or just one set containing all package names.
     */
    public open fun computePackageNames(): Set<String>? = null

    /**

Evaluation starts with the rules file closest to the package.  If that file
makes a determination to allow or forbid the import, evaluation is done.  If
the import does not match any rule, the next-closest rules file is consulted,
and so forth.  If the rules files are exhausted and no determination has been
made, the import will be flagged as an error.

### What are rules files?

A rules file is a JSON or YAML document with two top-level keys, both optional:

import org.gradle.kotlin.dsl.internal.sharedruntime.codegen.licenseHeader
import org.gradle.work.DisableCachingByDefault

import java.io.File


@Suppress("unused")
@DisableCachingByDefault(because = "Not worth caching")
abstract class GenerateKotlinDependencyExtensions : CodeGenerationTask() {

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

    @get:Input

 * [class name 1]=[instrumented super type 1],[instrumented super type 2],...<br>
 * [class name 2]=[instrumented super type 1],[instrumented super type 2],...<br>
 * ...
 */
@DisableCachingByDefault(because = "Not worth caching.")
public abstract class MergeInstrumentationAnalysisTransform implements TransformAction<MergeInstrumentationAnalysisTransform.Parameters> {

    public interface Parameters extends TransformParameters {
        @Internal

    if (&block.front() == &block.back()) {
      // The tf_device.launch is empty (except for the return).
      // Remove the whole tf_device.launch, since later passes will make it send
      // the arguments back and forth between the devices.
      Operation* return_op = &block.back();
      assert(llvm::isa<tf_device::ReturnOp>(return_op));
      for (auto [inner, outer] :

import org.gradle.internal.util.PropertiesUtils
import org.gradle.util.internal.VersionNumber
import org.gradle.work.DisableCachingByDefault
import java.util.Properties


@DisableCachingByDefault(because = "Not worth caching")
abstract class UpdateInitPluginTemplateVersionFile : DefaultTask() {

    private
    val devSuffixes = arrayOf(
        "-SNAP\\d+",
        "-SNAPSHOT",
        "-alpha.*\\d+",
        "-beta.*\\d+",