"compile", "org.apache.maven.plugins:maven-compiler-plugin:" + COMPILER_PLUGIN_VERSION + ":compile",
        "process-test-resources",
                "org.apache.maven.plugins:maven-resources-plugin:" + RESOURCES_PLUGIN_VERSION + ":testResources",
        "test-compile", "org.apache.maven.plugins:maven-compiler-plugin:" + COMPILER_PLUGIN_VERSION + ":testCompile",

        return new BindingInitializer<T>(deps) {
            @Override
            public Consumer<T> compile(Function<Key<?>, Supplier<?>> compiler) {
                return instance -> bindingInitializers.stream()
                        .map(bindingInitializer -> bindingInitializer.compile(compiler))
                        .forEach(i -> i.accept(instance));
            }
        };
    }

import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.language.base.internal.compile.CompileSpec;
import org.gradle.language.base.internal.compile.Compiler;

/**
 * Creates Java compilers based on the provided compile options.
 */
@ServiceScope(Scope.Project.class)
public interface JavaCompilerFactory {
    <T extends CompileSpec> Compiler<T> create(Class<T> type);

	tg.run("test", "-c", "-n", "p1")
	tg.grepBothNot(`([\\/]compile|gccgo).* (-p main|-fgo-pkgpath=main).*p1\.go`, "should not have run compile -p main p1.go")
	tg.grepStderr(`([\\/]compile|gccgo).* (-p p1|-fgo-pkgpath=p1).*p1\.go`, "should have run compile -p p1 p1.go")
}

// Issue 4104.
func TestGoTestWithPackageListedMultipleTimes(t *testing.T) {

			}
		}
		strictCost := false
		if utilfeature.DefaultFeatureGate.Enabled(features.StrictCostEnforcementForWebhooks) {
			strictCost = true
		}
		m.compiledMatcher = matchconditions.NewMatcher(compiler.Compile(
			expressions,
			cel.OptionalVariableDeclarations{
				HasParams:     false,
				HasAuthorizer: true,
				StrictCost:    strictCost,
			},
			environment.StoredExpressions,

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'.

 * limitations under the License.
 */

package org.gradle.platform.base.internal.toolchain;

import org.gradle.language.base.internal.compile.CompileSpec;
import org.gradle.language.base.internal.compile.Compiler;

public interface ToolProvider extends ToolSearchResult {
    <T extends CompileSpec> Compiler<T> newCompiler(Class<T> spec);

    <T> T get(Class<T> toolType);

# golang.org/x/text/language@commit should resolve.
# Because of -d, the compiler should not run.
go get -x golang.org/x/text/language@14c0d48
! stderr 'compile|cp|gccgo .*language\.a$'

# go get should skip build with no Go files in root
go get golang.org/x/text@14c0d48

# dropping -d, we should see a build.
[short] skip

env GOCACHE=$WORK/gocache  # Looking for compile commands, so need a clean cache.

#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/tensorflow/analysis/side_effect_analysis.h"
#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_types.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/passes.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/tpu_rewrite_device_util.h"

        boolean isCompile = ideaScopes.contains(GeneratedIdeaScope.COMPILE);

        if (isProvided) {
            ideaScopes.remove(GeneratedIdeaScope.TEST);
        }

        if (isRuntime && isProvided) {
            ideaScopes.add(GeneratedIdeaScope.COMPILE);
            isCompile = true;
        }

        if (isCompile) {
            ideaScopes.remove(GeneratedIdeaScope.TEST);