import org.gradle.groovy.scripts.Transformer;
import org.gradle.internal.serialize.Serializer;

/**
 * A stateful “backing” for a compilation operation.
 * <p>
 * The compilation may extract data from the source under compilation, made available after compilation by {@link #getExtractedData()}.
 * The exposed transformer typically gathers the data while transforming.
 * <p>

            return delegate.execute(spec);
        } catch (RuntimeException e) {
            // in-process Groovy compilation throws a CompilationFailedException from another classloader, hence testing class name equality
            // TODO:pm Prefer class over class name for equality check once using WorkerExecutor for in-process groovy compilation
            if ((spec.getCompileOptions().isFailOnError() && spec.getGroovyCompileOptions().isFailOnError())

gFunctionalSpec/test/oww7k/settings.gradle into local compilation cache > Compiling settings file '/Users/daniel/gradle/gradle/build/tmp/teŝt files/BasicGroupedTaskLoggingFunctionalSpec/test/oww7k/settings.gradle' to cross build script cache\u001B[m\u001B[335D\u001B[1B\u001B[1A\u001B[1m> settings > Compiling /Users/daniel/gradle/gradle/build/tmp/teŝt files/BasicGroupedTaskLoggingFunctionalSpec/test/oww7k/settings.gradle into local compilation cache\u001B[m\u001B[0K\u001B[165D\u001B[1B\u001B[1A\u001B[1m>...

// Whether soft placement is allowed. If true, the marked node is eligible for
// outside compilation.
inline constexpr llvm::StringRef kAllowSoftPlacementAttr =
    "allow_soft_placement";

// Marks a node for XLA compilation. The attribute value indicates the
// compilation device type.
inline constexpr llvm::StringRef kCompileDeviceTypeAttr =
    "_xla_compile_device_type";

those provided by package "net/rpc".

The implementation compiles a custom codec for each data type in the stream
and is most efficient when a single Encoder is used to transmit a stream of
values, amortizing the cost of compilation.
-- text --

* The class analysis is also an output stored in the build cache, which means that if a compilation output is fetched from the build cache, then the incremental compilation analysis will be too and the next compilation will be incremental.

[[sec:incremental_compilation_known_issues]]
=== Known issues

}

dependencies {
    implementation localGroovy()
}

// tag::groovy-compilation-avoidance[]
configurations { astTransformation }
dependencies {
    astTransformation(project(":ast-transformation"))
}
tasks.withType(GroovyCompile).configureEach {
    astTransformationClasspath.from(configurations.astTransformation)
}

  bool cpu_global_jit_enabled = 2;

  XlaAutoClusteringSummary summary = 3;
}

// Listeners listening for JIT compilation events get messages of this type.
// Each instance of XlaJitCompilationActivity corresponds to a single
// compilation of a single XLA cluster.  E.g. if a graph has two clusters, A and
// B, and A is compiled 5 times and B is compiled 2 times then we will generate

import org.gradle.api.tasks.scala.ScalaForkOptions;

import javax.annotation.Nullable;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;

/**
 * Options for Scala platform compilation.
 */
public abstract class BaseScalaCompileOptions extends AbstractOptions {

    private static final long serialVersionUID = 0;

    private boolean failOnError = true;

    private boolean deprecation = true;

            Rel(providerExecution, providerClasspath, "Uses", "for compilation")
            Rel_Neighbor(providerClasspath, providerAccessors, "Uses", "for compilation")
            Rel(providerExecution, gradleKotlinDslApi, "Uses", "for compilation")
            Rel(providerExecution, providerImports, "Queries", "for compilation")
        }