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)
    }

#define TENSORFLOW_COMPILER_JIT_TF_GRAPH_TO_HLO_COMPILER_H_

#include <memory>
#include <vector>

#include "tensorflow/compiler/jit/tf_to_hlo_compiler.h"
#include "tensorflow/compiler/tf2xla/xla_compiler.h"
#include "tensorflow/compiler/tf2xla/xla_helpers.h"

namespace tensorflow {

class TfGraphToHloCompiler : public TfToHloCompiler {
 public:
  TfGraphToHloCompiler() = delete;

package org.gradle.groovy.scripts;

/**
 * A factory for script compilers.
 */
public interface ScriptCompilerFactory {
    /**
     * Creates a compiler for the given source. The returned compiler can be used to compile the script into various
     * different forms.
     *
     * @param source The script source.
     * @return a compiler which can be used to compiler the script.
     */

Class <org.gradle.language.base.internal.compile.CompileSpec> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (CompileSpec.java:0)
Class <org.gradle.language.base.internal.compile.Compiler> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (Compiler.java:0)

#ifdef MLRT_TF_OPS
#else
#define MLRT_TF_OPS

include "tensorflow/compiler/mlir/tfrt/ir/mlrt/tf_mlrt_dialect.td"
include "tensorflow/compiler/mlir/tfrt/ir/mlrt/mlrt_dialect.td"
include "tensorflow/compiler/mlir/tensorflow/ir/tf_op_base.td"
include "tfrt/compiler/opdefs/tfrt_op_interfaces.td"  // from @tf_runtime
include "tfrt/compiler/opdefs/tfrt_traits.td"  // from @tf_runtime

    /**
     * Returns the name of the compile only configuration for this source set.
     *
     * @return The compile only configuration name
     *
     * @since 2.12
     */
    String getCompileOnlyConfigurationName();

    /**
     * Returns the name of the 'compile only api' configuration for this source set.
     *
     * @return The 'compile only api' configuration name
     *
     * @since 6.7

#include "tensorflow/compiler/jit/variable_info.h"
#include "tensorflow/compiler/jit/variable_info_util.h"
#include "tensorflow/compiler/jit/xla_compile_util.h"
#include "tensorflow/compiler/jit/xla_compiler_options_util.h"
#include "tensorflow/compiler/jit/xla_launch_util.h"
#include "tensorflow/compiler/jit/xla_platform_info.h"
#include "tensorflow/compiler/tf2xla/const_analysis.h"
#include "tensorflow/compiler/tf2xla/tf2xla_util.h"

        return compileOptions;
    }

    abstract protected Compiler<ScalaJavaJointCompileSpec> getCompiler(ScalaJavaJointCompileSpec spec);

    @TaskAction
    public void compile() {
        ScalaJavaJointCompileSpec spec = createSpec();
        configureIncrementalCompilation(spec);
        Compiler<ScalaJavaJointCompileSpec> compiler = getCompiler(spec);
        if (isNonIncrementalCompilation()) {

//
//     int foo;
//     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
//                                      // not a compile-time constant.
//
// - By using the type CompileAssert<(bool(expr))>, we ensures that
//   expr is a compile-time constant.  (Template arguments must be
//   determined at compile-time.)
//
// - The outer parentheses in CompileAssert<(bool(expr))> are necessary

    def "compiles script into class and wraps instance in script runner"() {
        given:
        def target = new Object()

        when:
        def compiler = factory.createCompiler(source)
        def result = compiler.compile(Script, target, targetScope, operation, verifier)

        then:
        result == runner