import org.gradle.internal.operations.logging.BuildOperationLogger;
import org.gradle.internal.operations.logging.BuildOperationLoggerFactory;
import org.gradle.language.base.compile.CompilerVersion;
import org.gradle.language.base.internal.compile.Compiler;
import org.gradle.language.base.internal.compile.VersionAwareCompiler;
import org.gradle.language.swift.SwiftVersion;
import org.gradle.language.swift.tasks.internal.DefaultSwiftCompileSpec;

#ifndef TENSORFLOW_COMPILER_JIT_PJRT_COMPILE_UTIL_H_
#define TENSORFLOW_COMPILER_JIT_PJRT_COMPILE_UTIL_H_

#include "tensorflow/compiler/jit/xla_compile_util.h"
#include "tensorflow/compiler/jit/xla_platform_info.h"
#include "tensorflow/compiler/tf2xla/xla_compiler.h"
#include "xla/pjrt/pjrt_client.h"
#include "tensorflow/core/framework/device_base.h"
#include "tensorflow/core/framework/op_kernel.h"

|===

[[sec:scala_compiler_plugins]]
== Adding plugins to the Scala compiler

The Scala plugin adds a configuration named `scalaCompilerPlugins` which is used to declare and resolve optional compiler plugins.

.Adding a dependency on a Scala compiler plugin
====

    }

    protected Compiler<?> createCCompiler() {
        throw unavailableTool("C compiler is not available");
    }

    protected Compiler<?> createCPCHCompiler() {
        throw unavailableTool("C pre-compiled header compiler is not available");
    }

    protected Compiler<?> createObjectiveCppCompiler() {

  );

  let assemblyFormat = "attr-dict";
}

def CompileAndExecuteOp : TensorflowMlrtTpu_Op<"compile_and_execute"> {
  let summary = "tpu compile and execute operation";
  let description = [{
    tf_mlrt_tpu.compile_and_execute compiles a mlir tpu program and executes the compiled tpu program.

    $mlir_module is a serialized MLIR module with a `main` function that contains target computation.

     * <p>
     * The source path indicates the location of source files that <i>may</i> be compiled if necessary.
     * It is effectively a complement to the class path, where the classes to be compiled against are in source form.
     * It does <b>not</b> indicate the actual primary source being compiled.
     * <p>
     * The source path feature of the Java compiler is rarely needed for modern builds that use dependency management.
     * <p>

tasks.withType<JavaCompile>().configureEach {
    // Generated classes may not adhere to the strict no-warning policy that we apply to handwritten code
    // For example, external JMH plugin generates code that produces compiler warnings
    if (!name.contains("CompileGeneratedClasses")) {
        options.compilerArgs.addAll(strictCompilerArgs)
    }

        setDidWork(doCompile(spec, platformToolProvider).getDidWork());
    }

    protected void configureSpec(NativeCompileSpec spec) {
    }

    private <T extends NativeCompileSpec> WorkResult doCompile(T spec, PlatformToolProvider platformToolProvider) {
        Class<T> specType = Cast.uncheckedCast(spec.getClass());
        Compiler<T> baseCompiler = platformToolProvider.newCompiler(specType);

Apache Maven Built-By: BEBE Build-Jdk: 1.6.0_07 META-INF/maven/plugin.xml A test plugin to assist testing of Maven core. org.apache.maven.plugins maven-compiler-plugin 0.1 compiler false true testCompile Does nothing. test false true false false false true org.apache.maven.plugin.coreit.TestMojo java per-lookup once-per-session compile Does nothing. compile false true false false false true org.apache.maven.plugin.coreit.ItMojo java per-lookup once-per-session org.apache.maven maven-plugin-api jar 2.0...

import org.gradle.language.base.internal.compile.Compiler;
import org.gradle.util.internal.CollectionUtils;

import java.io.File;
import java.util.List;

/**
 * A Scala {@link Compiler} which does some normalization of the compile configuration and behaviour before delegating to some other compiler.
 */
public class NormalizingScalaCompiler implements Compiler<ScalaJavaJointCompileSpec> {