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

                return "java-compilation-error";
            case WARNING:
            case MANDATORY_WARNING:
                return "java-compilation-warning";
            case NOTE:
                return "java-compilation-note";
            case OTHER:
                return "java-compilation-problem";
            default:
                return "unknown-java-compilation-problem";
        }
    }

        // Case 1a: outside compilation to outside compilation control edge.
        edges_to_remove.push_back(e);

        TF_RETURN_IF_ERROR(AppendToListAttr<string>(
            e->dst(), kXlaControlDependenciesWithinXlaClusterAttrName,
            e->src()->name()));
      }
    } else if (src_outside_compilation && !dst_outside_compilation) {
      // Case 1b: outside compilation to its XLA computation control edge.

}

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,

    std::vector<tensorflow::Flag>* flag_list);

// Disables XLA compilation, forces it to return an error message instead. Can
// be used by a server to ensure that JIT compilation is opt-in.
void DisableXlaCompilation();

// Enables XLA compilation. Can be used with `DisableXlaCompilation` to
// enable/disable JIT compilation at different stages.
void EnableXlaCompilation();

  // 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,

                result.assertNotOutput("Stored cache entry for Kotlin DSL script compilation")
                result.assertOutputContains("Caching of Kotlin script compilation disabled by property")
            } else {
                result.assertOutputContains("Stored cache entry for Kotlin DSL script compilation")
                result.assertNotOutput("Caching of Kotlin script compilation disabled by property")
            }