//
//   XLAs `mhlo.transpose` operation requires permutation to be an attribute
//   (compile time value), so it means that if we want to put `tf.Transpose`
//   into a cluster that will be compiled with XLA, the `%perm` operand must
//   be a known compiled time value, e.g. result of a `tf.Const` operation.
//
class ClusteringPolicy {
 public:
  virtual ~ClusteringPolicy() = default;

// compile

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Using a multi-result function as an argument to
// append should compile successfully. Previously there
// was a missing *int -> interface{} conversion that caused
// the compiler to ICE.

package p

func f() ([]interface{}, *int) {
	return nil, nil
}

        def vsDir = tmpDir.createDir("vs")
        def compiler = vsDir.file("cl.exe")

        when:
        List<VisualStudioInstallCandidate> metadata = locator.getVisualStudioInstalls()

        then:
        1 * os.findInPath("cl.exe") >> compiler
        1 * versionDeterminer.getVisualStudioMetadataFromCompiler(compiler) >> vsMetadata(vsDir, "15.0")

        and:
        metadata.size() == 1

cross-compiled programs when a simulator or other execution method is
available.

By default, 'go run' compiles the binary without generating the information
used by debuggers, to reduce build time. To include debugger information in
the binary, use 'go build'.

The exit status of Run is not the exit status of the compiled binary.

For more about build flags, see 'go help build'.

 */

package org.gradle.language.base.compile;

import org.gradle.api.Incubating;
import org.gradle.api.NonNullApi;
import org.gradle.api.tasks.Input;

/**
 * Version of a compiler.
 *
 * @since 4.4
 */
@Incubating
@NonNullApi
public interface CompilerVersion {

    /**
     * Returns the type of the compiler.
     */
    @Input
    String getType();

    /**

env GOCACHE=$WORK/gocache
mkdir $GOCACHE

# Building trivial non-main package should run compiler the first time.
go build -x lib.go
stderr '(compile|gccgo)( |\.exe).*lib\.go'

# ... but not again ...
go build -x lib.go
! stderr '(compile|gccgo)( |\.exe).*lib\.go'

# ... unless we use -a.
go build -a -x lib.go
stderr '(compile|gccgo)( |\.exe)'

-- lib.go --

        scriptCompiles*.displayName == relativePaths(
            "Compile initialization script 'init.gradle' (CLASSPATH)",
            "Compile initialization script 'init.gradle' (BODY)",
            "Compile settings file 'settings.gradle' (CLASSPATH)",
            "Compile settings file 'settings.gradle' (BODY)",
            "Compile build file 'build.gradle' (CLASSPATH)",
            "Compile build file 'build.gradle' (BODY)",

        failure.assertHasCause("Swift compiler version '${toolChain.version}' doesn't support Swift language version '${SwiftVersion.SWIFT3.version}'")
    }

    @RequiresInstalledToolChain(ToolChainRequirement.SWIFTC_3)
    @ToBeFixedForConfigurationCache
    def "can compile Swift 3 component on Swift 3 compiler"() {
        given:
        makeSingleProject()

// compile

// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 2588.  Used to trigger internal compiler error on 8g,
// because the compiler tried to registerize the int64 being
// used as a memory operand of a int64->float64 move.

package p

func f1(a int64) {
	f2(float64(a), float64(a))
}

func f2(a,b float64) {

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_device.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops_a_m.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_types.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/lower_tf.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/attribute_utils.h"