// sort (lib/Transforms/TopologicalSort.cpp) but also takes a priority
// function to determine the next op to emit in the case of ambiguity. This
// makes it possible to group operations by certain attributes. For example,
// the order_by_dialect pass uses this function to group by dialect.
// Only the operations nested directly under the block will be reordered.
// Nested blocks will be left alone.

import java.io.PrintStream;

/**
 * An entry point is the point at which execution will never return from.
 * <p>
 * Its purpose is to consistently apply our completion logic of forcing the JVM
 * to exit at a certain point instead of waiting for all threads to die, and to provide
 * some consistent unhandled exception catching.
 * <p>
 * Entry points may be nested, as is the case when a foreground daemon is started.
 * <p>

	return checks
}

// addSwapCheck adds a swap check
func addSwapCheck(checks []Checker) []Checker {
	checks = append(checks, SwapCheck{})
	return checks
}

// addExecChecks adds checks that verify if certain binaries are in PATH
func addExecChecks(checks []Checker, execer utilsexec.Interface) []Checker {
	checks = append(checks,
		InPathCheck{executable: "crictl", mandatory: false, exec: execer},

   * situations for compatibility.
   *
   * @since 17.0
   */
  public static final MediaType WOFF = createConstant(APPLICATION_TYPE, "font-woff");

  /**
   * <a href="https://tools.ietf.org/html/rfc8081">RFC 8081</a> declares {@link #FONT_WOFF2
   * font/woff2} to be the correct media type for WOFF2, but this may be necessary in certain
   * situations for compatibility.
   *

     * explicitly. In most cases, explicit type error handling should be preferred.
     *
     * As a motivating example, consider that we want to find all functions which can be called with an argument of a certain type and show
     * them to a user. The user has provided a type `List<>` with an unspecified type argument, which translates to `List<ERROR>`. We still

 * <p>
 * Even though specification properties can be configured independently,
 * the configuration must follow certain rules in order to form a  specification.
 * <p>
 * A {@code JavaToolchainSpec} is considered valid in two cases:
 * <ul>
 * <li> when no properties have been set, i.e. the specification is empty;

 *
 * <p>This class maintains a set of instants reached by the test. An instant records the point in time that a test thread reached a certain point of its execution.
 * Once the test threads have completed, you can make assertions about the ordering of the various instants relative to each other. You can also block until a given
 * instant has been reached.
 *

This guide is about Gradle’s build cache, but you may have also heard about the https://developer.android.com/studio/build/build-cache[Android build cache].
These are different things.
The Android cache is internal to certain tasks in the Android plugin, and will eventually be removed in favor of native Gradle support.

== Why use the build cache?

  Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License.  This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License.  We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.

  When a program is linked with a library, whether statically or using

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.execution


/**
 * The result of partially evaluating a Kotlin DSL [program][Program] of a certain [kind][ProgramKind]
 * against a given [target][ProgramTarget].
 *
 * @see PartialEvaluator.reduce
 */
internal
sealed class ResidualProgram {

    /**
     * A static residue, can be compiled ahead of time.