/**
 * A service that backups a class just before new version of a class is generated.
 * This is used for restoring compiler outputs on compilation failure.
 *
 * Service only backups classes that:
 * - exists before compilation
 * - were not deleted before compilation
 * - javac tries to overwrite during compilation.
 *
 * This service is called by compiler through Compiler API.
 *

	c := &Controller{}
	if filter != nil {
		compilation := cel.Compiler.CompileCELExpression(filter.Selector, environment.StoredExpressions)
		if compilation.Error != nil {
			// Shouldn't happen because of validation.
			return nil, fmt.Errorf("compile class filter CEL expression: %w", compilation.Error)
		}
		c.filter = &compilation
	}
	for _, request := range requests {

                ) {
                }
            }
        """

        when:
        Compilation compilation = compile(givenSource)

        then:
        assertThat(compilation).succeededWithoutWarnings()
        assertThat(compilation)
            .generatedFile(CLASS_OUTPUT, "META-INF/services/org.gradle.internal.classpath.intercept.FilterableCallInterceptor")

import org.gradle.api.model.ObjectFactory;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.LocalState;

import javax.inject.Inject;

/**
 * Options for incremental compilation of Scala code. Only used for compilation with Zinc.
 *
 * This is not sent to the compiler daemon as options.
 */
public abstract class IncrementalCompileOptions {
    private final RegularFileProperty analysisFile;

/**
 * Indicates a fatal error during compilation. Gradle will not try to recover output files from a previous compilation.
 */
public class CompilationFatalException extends RuntimeException implements CompilationFailedIndicator {

    public CompilationFatalException(Throwable cause) {
        super("Unrecoverable compilation error: " + cause.getMessage(), cause);
    }

            << " because it is megamorphic.";
    return false;
  }

  // TODO(b/255826209): Figure out if Lazy compilation is still needed given
  // that we always compile a cluster the first time it is executed (explained
  // below) regardless of compilation mode. If it is not, clean up the related
  // logic.
  // We always compile a cluster the very first time it is executed.  This is an

}

dependencies {
    implementation(localGroovy())
}

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

}

dependencies {
    implementation 'org.codehaus.groovy:groovy-all:2.4.15'
    testImplementation 'junit:junit:4.13'
}

// tag::groovy-cross-compilation[]
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(7)
    }
}

#include <memory>
#include <string>

#include "tensorflow/compiler/tf2xla/xla_argument.h"
#include "tensorflow/core/graph/graph.h"

namespace tensorflow {
// The number of compiler threads to use for asynchronous device compilation.
inline constexpr int64_t kNumAsyncDeviceCompilerThreads = 10;

enum class DeviceCompileMode {
  kLazy,
  kStrict,
  kAsync,
};

enum class DeviceCompileState {
  kUncompiled,
  kCompiling,

  // cluster and also determines whether the cluster has gone megamorphic (and
  // sets the megamorphic bit accordingly).
  void RegisterExecution(const NameAttrList& function);

  // Registers a cluster compilation. Increments the compilation count and
  // accumulates the compile time for the given cluster. Also broadcasts an
  // XlaJitCompilationActivity.
  virtual Status RegisterCompilation(const NameAttrList& function,