// license that can be found in the LICENSE file.

// Check the compiler's switch handling that happens
// at typechecking time.
// This must be separate from other checks,
// because errors during typechecking
// prevent other errors from being discovered.

package main

// Verify that type switch statements with impossible cases are detected by the compiler.
func f0(e error) {
	switch e.(type) {

     */
    Task getCompileTask();

    /**
     * Returns the compiler executable that is used to compile this binary.
     *
     * @return The compiler executable or {@code null} if the compiler for this binary is not available.
     */
    @Nullable

Sterling Greene <******@****.***> 1700166003 -0500

        !platformToolChain.available
        getMessage(platformToolChain) == "c compiler not found"
    }

    def "is unavailable when no C++ compiler can be found and building C++"() {
        def compilerMissing = Stub(CommandLineToolSearchResult) {
            isAvailable() >> false
            explain(_) >> { DiagnosticsVisitor visitor -> visitor.node("c++ compiler not found") }
        }

        given:

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

class CLanguageIntegrationTest extends AbstractNativeLanguageIntegrationTest {

    HelloWorldApp helloWorldApp = new CHelloWorldApp()

    @ToBeFixedForConfigurationCache
    def "sources are compiled with C compiler"() {
        def app = new CCompilerDetectingTestApp()

        given:
        app.writeSources(file('src/main'))

        and:
        buildFile << """
            model {

#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"

    </dependency>

    <dependency>
      <groupId>maven-test-compile</groupId>
      <artifactId>scope-runtime</artifactId>
      <version>1.0</version>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>maven-test-compile</groupId>
      <artifactId>scope-compile</artifactId>
      <version>1.0</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>

#include "absl/types/span.h"
#include "tensorflow/compiler/jit/device_compilation_cache.h"
#include "tensorflow/compiler/jit/device_compilation_cluster_signature.h"
#include "tensorflow/compiler/jit/device_compilation_profiler.h"
#include "tensorflow/compiler/jit/device_compiler_client.h"
#include "tensorflow/compiler/jit/device_executable_persistor.h"
#include "tensorflow/compiler/jit/flags.h"

## Level 2: Container diagram

When used for the compilation of scripts of a Gradle build, the Kotlin DSL Provider compiles scripts using an embedded Kotlin compiler.

When used for the compilation of Kotlin source sets, e.g. in `buildSrc`, the `kotlin-dsl` plugin provide Kotlin DSL features to source sets and compiles Kotlin code using the Kotlin Gradle Plugin.