* queried. The file tree is also live, so that it scans for files each time the contents of the file tree are
     * queried.
     *
     * You can combine this method with the [copy] method to unzip a ZIP file.
     *
     * @param zipPath The ZIP file. Evaluated as per [file].
     * @return The file tree.
     */
    fun zipTree(zipPath: Any): FileTree

    /**

     * queried. The file tree is also live, so that it scans for files each time the contents of the file tree are
     * queried.
     *
     * You can combine this method with the [copy] method to unzip a ZIP file.
     *
     * @param zipPath The ZIP file. Evaluated as per [file].
     * @return The file tree.
     */
    @Suppress("unused")

     * queried. The file tree is also live, so that it scans for files each time the contents of the file tree are
     * queried.
     *
     * You can combine this method with the [KotlinInitScript.copy] method to unzip a ZIP file.
     *
     * @param zipPath The ZIP file. Evaluated as per [KotlinInitScript.file].
     * @return The file tree.
     */
    @Suppress("unused")

         */
        KILL_ALL_GRADLE_PROCESSES
    }

    private static final Pattern UNIX_PID_PATTERN = Pattern.compile("([0-9]+)");
    private static final Pattern WINDOWS_PID_PATTERN = Pattern.compile("([0-9]+)\\s*$");
    private static final String MY_PID = String.valueOf(ProcessHandle.current().pid());
    private static final String JAVA_EXECUTABLE_PATTERN_STR = "java(?:\\.exe)?";

object DocumentOverlay {
    /**
     * Produces a new document by merging the sources, namely [underlay] and [overlay], in a way that:
     * * configuring elements are combined, as if the block content of [underlay] goes before the block content of [overlay]
     * * elements that create a new object are merged together; the elements from [underlay] will appear first;

     */
    ExecutionTimeValue<? extends T> calculateExecutionTimeValue();

    @Override
    default <U, R> Provider<R> zip(Provider<U> right, BiFunction<? super T, ? super U, ? extends R> combiner) {
        return new BiProvider<>(null, this, right, combiner);
    }

    /**
     * Returns a provider that attaches the side effect to the values it produces.
     * <p>

            onDependencyFailure = FailureAction.FAIL_TO_START
            onDependencyCancel = FailureAction.FAIL_TO_START
        }
    }
}

fun Dependencies.compileAllDependency(compileAllId: String) {
    // Compile All has to succeed before anything else is started
    dependsOn(RelativeId(compileAllId))
    // Get the build receipt from sanity check to reuse the timestamp
    artifacts(RelativeId(compileAllId)) {

 * either implement the [java.io.Externalizable] interface, or implement the [java.io.Serializable] interface and define one of the following combination of methods:
 * - a `writeObject` method combined with a `readObject` method to control exactly which information to store;
 * - a `writeObject` method with no corresponding `readObject`; `writeObject` must eventually call [ObjectOutputStream.defaultWriteObject];

  "durations" : [ {
    "testProject" : "mediumNativeMonolithic",
    "linux" : 359
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.nativeplatform.SwiftBuildPerformanceTest.incremental compile",
  "durations" : [ {
    "testProject" : "bigSwiftApp",
    "linux" : 285
  }, {
    "testProject" : "mediumSwiftMulti",
    "linux" : 1140
  } ]
}, {

    private
    val ref: Parser<T> = { parser() }
}


/**
 * Returns a shell parser, holding a mutable reference to another parser.
 * Can be combined with other parsers in the usual way and its delegate can be set at a later moment in time.
 *
 * It can also be used to create recursive parsers.