public enum ToolType {
    CPP_COMPILER("C++ compiler"),
    C_COMPILER("C compiler"),
    OBJECTIVECPP_COMPILER("Objective-C++ compiler"),
    OBJECTIVEC_COMPILER("Objective-C compiler"),
    WINDOW_RESOURCES_COMPILER("Windows resources compiler"),
    ASSEMBLER("Assembler"),
    LINKER("Linker"),
    STATIC_LIB_ARCHIVER("Static library archiver"),
    SWIFT_COMPILER("Swift compiler"),
    SYMBOL_EXTRACTOR("Symbol extractor"),

public typealias KtMetadataCalculator = KaMetadataCalculator

@KaAnalysisNonPublicApi
public interface KaMetadataCalculatorMixIn : KaSessionMixIn {
    /**
     * Calculates metadata that would be generated by the compiler in case this class was compiled to the JVM class file.
     *
     * @param mapping map containing the light elements ([KtLightElement]) for each callable declaration in this class.
     */

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

 */

package org.gradle.api.internal.tasks.compile


import spock.lang.Specification
import spock.lang.Subject

import javax.tools.JavaCompiler

class JdkToolsTest extends Specification {
    @Subject
    JdkTools current = new JdkTools([])

    def "can get java compiler"() {
        def compiler = current.systemJavaCompiler

        expect:
        compiler instanceof JavaCompiler

import org.gradle.api.tasks.WorkResults;
import org.gradle.language.base.internal.compile.Compiler;
import org.gradle.nativeplatform.internal.CompilerOutputFileNamingSchemeFactory;

import java.io.File;

public class OutputCleaningCompiler<T extends NativeCompileSpec> implements Compiler<T> {

    private final Compiler<T> compiler;
    private final String outputFileSuffix;

	newPolicyAccessor func(P) PolicyAccessor,
	newBindingAccessor func(B) BindingAccessor,
	compiler func(P) E,
	paramInformerFactory informers.SharedInformerFactory,
	dynamicClient dynamic.Interface,
	restMapper meta.RESTMapper,
) Source[PolicyHook[P, B, E]] {
	res := &policySource[P, B, E]{
		compiler:             compiler,
		policyInformer:       generic.NewInformer[P](policyInformer),

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

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

// This is the input program for an end-to-end test of the DWARF produced
// by the compiler. It is compiled with various flags, then the resulting
// binary is "debugged" under the control of a harness.  Because the compile+debug
// step is time-consuming, the tests for different bugs are all accumulated here
// so that their cost is only the time to "n" through the additional code.

 * limitations under the License.
 */
package org.gradle.internal.compiler.java;

import com.sun.source.util.JavacTask;
import org.gradle.internal.compiler.java.listeners.classnames.ClassNameCollector;
import org.gradle.internal.compiler.java.listeners.constants.ConstantDependentsConsumer;
import org.gradle.internal.compiler.java.listeners.constants.ConstantsCollector;

import javax.annotation.processing.Processor;

# It's absurd, but builds with -compiler=gccgo used to fail to build module m.
# golang.org/issue/34358

env GO111MODULE=off

[short] skip
[cross] skip # gccgo can't necessarily cross-compile

cd m
go build
exists m$GOEXE
rm m$GOEXE
[exec:gccgo] go build -compiler=gccgo
[exec:gccgo] exists m$GOEXE

-- m/go.mod --
module m
-- m/main.go --
package main