# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.

# This script collects a CPU profile of the compiler
# for building all targets in std and cmd, and puts
# the profile at cmd/compile/default.pgo.

dir=$(mktemp -d)
cd $dir
seed=$(date)

for p in $(go list std cmd); do
	h=$(echo $seed $p | md5sum | cut -d ' ' -f 1)
	echo $p $h

    }

    def "new generated classes are removed on the compile failure and incremental compilation works after a failure"() {
        def b = source("package b; class B {}")
        source("class Unrelated {}")
        outputs.snapshot { run language.compileTaskName }

        when:
        // Compile more classes, so there is possibility some is generated before a compile failure.

`swiftCompileTest__Variant__` (e.g. `swiftCompileTest`) extends `test__Variant__ExecutableImplementation`::
Used for compiling the test component.
This configuration contains the compile module of the test component and is therefore used when invoking the Swift compiler to compile it.

`nativeLinkTest__Variant__` (e.g. `nativeLinkTest`) extends `test__Variant__ExecutableImplementation`::
Used for linking the test component.

import sbt.internal.inc.ZincUtil;
import sbt.internal.inc.classpath.ClassLoaderCache;
import scala.Option;
import scala.collection.JavaConverters;
import xsbti.ArtifactInfo;
import xsbti.compile.ClasspathOptionsUtil;
import xsbti.compile.ScalaCompiler;
import xsbti.compile.ZincCompilerUtil;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.net.MalformedURLException;
import java.net.URL;

org.gradle.listener.ListenerBroadcast
org.gradle.listener.ListenerManager
org.gradle.platform.base.internal.toolchain.ToolResolver
org.gradle.runtime.jvm.toolchain.JavaToolChain
org.gradle.api.internal.tasks.compile.Compiler
org.gradle.api.internal.tasks.compile.GroovyJavaJointCompiler
org.gradle.api.internal.tasks.scala.ScalaJavaJointCompiler
org.gradle.api.internal.xml.XmlTransformer
org.gradle.api.internal.XmlTransformer

			continue
		}

		for GOARCH := range allGOARCH {
			context := build.Context{
				GOOS:      "linux", // darwin has custom assembly
				GOARCH:    GOARCH,
				GOROOT:    testenv.GOROOT(t),
				Compiler:  build.Default.Compiler,
				BuildTags: []string{"purego", "math_big_pure_go"},
			}

			pkg, err := context.Import(pkgName, "", 0)
			if err != nil {
				t.Fatal(err)
			}
			if len(pkg.SFiles) == 0 {
				continue

==============================================================================*/
#include "tensorflow/compiler/mlir/quantization/tensorflow/passes/remove_identity_op_pattern.h"

#include "mlir/IR/PatternMatch.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

namespace mlir {
namespace quant {

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <executions>
          <execution>
            <id>normal</id>

            <goals>
              <goal>compile</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Verify that erroneous initialization expressions are caught by the compiler
// Does not compile.

package main

type S struct {
	A, B, C, X, Y, Z int
}

type T struct {
	S
}

var x = 1
var a1 = S{0, X: 1}                             // ERROR "mixture|undefined" "too few values"

    def platform = Mock(NativePlatformInternal)
    def platformToolChain = Mock(PlatformToolProvider)
    Compiler<ObjectiveCppPCHCompileSpec> objCppPCHCompiler = Mock(Compiler)

    def setup() {
        objCppPCHCompile = TestUtil.createTask(ObjectiveCppPreCompiledHeaderCompile, project)
    }

    def "executes using the Cpp PCH Compiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)