}

    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> {

                    return toolProvider;
                }
                ToolSearchResult compiler = toolProvider.locateTool(ToolType.CPP_COMPILER);
                if (compiler.isAvailable()) {
                    return toolProvider;
                }
                compiler = toolProvider.locateTool(ToolType.OBJECTIVEC_COMPILER);
                if (compiler.isAvailable()) {

import org.gradle.api.internal.tasks.compile.incremental.recomp.PreviousCompilationAccess;
import org.gradle.api.internal.tasks.compile.incremental.recomp.PreviousCompilationData;
import org.gradle.api.internal.tasks.compile.incremental.recomp.RecompilationSpec;
import org.gradle.api.internal.tasks.compile.incremental.recomp.RecompilationSpecProvider;

     * <p>
     * When this option is set to {@code false} (the default), Groovy code will not be subject to annotation processing, but any joint compiled Java code will be.
     * If the compiler argument {@code "-proc:none"} was specified as part of the Java compile options, the value of this flag will be ignored.
     * No annotation processing will be performed regardless, on Java or Groovy source.
     */
    @Input