"cmd/go/internal/par"
)

// Tool returns the path to the named tool (for example, "vet").
// If the tool cannot be found, Tool exits the process.
func Tool(toolName string) string {
	toolPath, err := ToolPath(toolName)
	if err != nil && len(cfg.BuildToolexec) == 0 {
		// Give a nice message if there is no tool with that name.
		fmt.Fprintf(os.Stderr, "go: no such tool %q\n", toolName)
		SetExitStatus(2)
		Exit()
	}

import java.util.List;

/**
 * Configuration of the arguments of a ToolChain executable.
 */
@Incubating
public interface Tool {
    /**
     * The arguments passed when executing this tool.
     */
    List<String> getArgs();

    /**
     * Adds a number of arguments to be passed to the tool.
     */
    void args(String... args);

Guillaume Nodet <******@****.***> 1686839096 +0200

)

func main() {
	tool, args := os.Args[1], os.Args[2:]
	toolName := filepath.Base(tool)
	if len(args) > 0 && args[0] == "-V=full" {
		// We can't alter the version output.
	} else {
		// Print which tool we're running, and on what package.
		fmt.Fprintf(os.Stdout, "%s TOOLEXEC_IMPORTPATH=%q\n", toolName, os.Getenv("TOOLEXEC_IMPORTPATH"))
	}

	// Simply run the tool.
	cmd := exec.Command(tool, args...)

    }

    def "transform can receive a file collection containing substituted external dependencies as parameter"() {
        createDirs("tools", "tools/tool-a", "tools/tool-b")
        file("tools/settings.gradle") << """
            include 'tool-a', 'tool-b'
        """
        file("tools/build.gradle") << """
            allprojects {
                group = 'test'
                configurations.create("default")

go 1.15

replace (
	example.net/tools v0.1.0 => ./tools
	example.net/cmd v0.1.0 => ./cmd
	example.net/testonly v0.1.0 => ./testonly
	example.net/missing v0.1.0 => ./missing
)

-- tools/go.mod --
module example.net/tools

go 1.15

// Requirements intentionally omitted.

-- tools/tools.go --
// +build tools

package tools

import (
	_ "example.net/cmd/tool"
	_ "example.net/missing"
)

    private final Map<ToolType, CommandLineToolConfigurationInternal> tools = new HashMap<ToolType, CommandLineToolConfigurationInternal>();

    public DefaultSwiftcPlatformToolChain(NativePlatform platform) {
        this.platform = platform;
    }

    public void add(DefaultCommandLineToolConfiguration tool) {
        tools.put(tool.getToolType(), tool);
    }

    @Override

        return tools.get(toolType);
    }

    public Collection<GccCommandLineToolConfigurationInternal> getTools() {
        return tools.values();
    }

    public Collection<GccCommandLineToolConfigurationInternal> getCompilers() {
        return Arrays.asList(tools.get(ToolType.C_COMPILER), tools.get(ToolType.CPP_COMPILER), tools.get(ToolType.OBJECTIVEC_COMPILER), tools.get(ToolType.OBJECTIVECPP_COMPILER));
    }

        get() = analysisSession.token

    override fun getResolveExtensionScopeWithTopLevelDeclarations(): KaScope {
        val tools = analysisSession.extensionTools
        if (tools.isEmpty()) return KaEmptyScope(token)
        return KaFirResolveExtensionScope(analysisSession, tools)
    }

    @OptIn(KtModuleStructureInternals::class)
    override fun isResolveExtensionFile(file: VirtualFile): Boolean =

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.api;

import javax.tools.DocumentationTool;
import javax.tools.JavaFileManager;
import javax.tools.StandardLocation;

import java.io.File;
import java.nio.file.Path;
import java.util.Objects;
import java.util.Optional;
import java.util.StringJoiner;