#if swift(>=5.0)
                print("Compiled using Swift 5.x compiler")
            #elseif swift(>=4.0)
                print("Compiled using Swift 4.x compiler")
            #elseif swift(>=3.0)
                print("Compiled using Swift 3.x compiler")
            #else
                print("Compiled using unknown compiler")
            #endif
        """)
    }

    @Override

public interface KaCompiledFile {
    /**
     * Path of the compiled file relative to the root of the output directory.
     */
    public val path: String

    /**
     * Source files that were compiled to produce this file.
     */
    public val sourceFiles: List<File>

    /**
     * Content of the compiled file.
     */
    public val content: ByteArray
}

        file("src/main/groovy/compile/test/Person.groovy") << """
            package parameters.test
            class Person {
                void setFullName(String fullName) {
                    // no-op
                }
            }
        """.stripIndent()

        expect:
        succeeds 'compileGroovy'
        def compiled = groovyClassFile("parameters/test/Person.class")

env GO111MODULE=on

[short] skip
[!cgo] skip

# Regression test for golang.org/issue/29667:
# spurious 'failed to cache compiled Go files' errors.

env GOCACHE=$WORK/gocache
mkdir $GOCACHE

go list -json -compiled -test=false -export=false -deps=true -- . &
go list -json -compiled -test=false -export=false -deps=true -- . &
wait

-- go.mod --
module sandbox/bar
-- bar.go --
package bar

# dependencies are, so it's can't construct the same action IDs.
[short] skip
go list -find -compiled net
go list -find -compiled -x net
! stderr 'cgo'

-- x/y/z/z.go --
package z

namespace tensorflow {

// Name of attribute used to tag operators for compilation with XLA

// Implies must-compile semantics: either it will be compiled
// with XLA, or an error will be thrown.
extern const char* const kXlaMustCompileAttr;  // "_XlaMustCompile"

// Implies auto-clustering: tagged nodes will be clustered and compiled with XLA
// on a best-effort basis.
extern const char* const kXlaCompileAttr;  // "_XlaCompile"

/**
 * Tests that task classes compiled against earlier versions of Gradle using the static Groovy compiler are still compatible.
 *
 * <p>Note: Groovy introduced static compilation ({@link groovy.transform.CompileStatic}) in Groovy 2.0.0.
 * We switched to using Groovy 2.3.3 from 1.8.6 in Gradle 2.0. However, Groovy 2.3.3 shipped with Gradle 2.0 had a bug that prevents the test to be compiled.

#include <cstdint>
#include <string>

#include "tensorflow/compiler/jit/xla_compile_util.h"
#include "tensorflow/core/framework/attr_value.pb.h"

namespace tensorflow {

// Tracks statistics for device compilation and uses these to determine whether
// the given cluster should be compiled or not.
class DeviceCompilationProfiler : public ResourceBase {
 public:

#include "mlir/Pass/PassRegistry.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_device.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/passes.h"

namespace mlir {
namespace TFTPU {

namespace {

cd x
go list -f '{{.Imports}}'
! stdout runtime/cgo
! stdout unsafe
! stdout syscall
stdout C
stdout unicode
stdout unicode/utf16

# go list -compiled should report imports in compiled files as well,
# adding "runtime/cgo", "unsafe", and "syscall" but not dropping "C".
go list -compiled -f '{{.Imports}}'
stdout runtime/cgo
stdout unsafe
stdout syscall
stdout C
stdout unicode
stdout unicode/utf16

-- x/x.go --
package x