private final JavaTool toolName;

    private final JvmInstallationMetadata toolchainMetadata;

    public DefaultJavaToolchainUsageProgressDetails(JavaTool toolName, JvmInstallationMetadata toolchainMetadata) {
        this.toolName = toolName;
        this.toolchainMetadata = toolchainMetadata;
    }

    @Override
    public String getToolName() {
        return toolName.getToolName();
    }

    @Override

// 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()
	}
	return toolPath
}

    SWIFT_COMPILER("Swift compiler"),
    SYMBOL_EXTRACTOR("Symbol extractor"),
    STRIPPER("Stripper");

    private final String toolName;

    ToolType(String toolName) {
        this.toolName = toolName;
    }

    public String getToolName() {
        return toolName;
    }

    @Override
    public String toString() {
        return GUtil.toLowerCamelCase(name());
    }

		listTools()
		return
	}
	toolName := args[0]
	// The tool name must be lower-case letters, numbers or underscores.
	for _, c := range toolName {
		switch {
		case 'a' <= c && c <= 'z', '0' <= c && c <= '9', c == '_':
		default:
			fmt.Fprintf(os.Stderr, "go: bad tool name %q\n", toolName)
			base.SetExitStatus(2)
			return
		}
	}

	toolPath, err := base.ToolPath(toolName)
	if err != nil {

        return "JDK[" + getJavaHome() + "]";
    }

    public String findTool(String toolName) {
        Path toRet = findTool(toolName, Paths.get(getJavaHome()).normalize());
        if (toRet != null) {
            return toRet.toAbsolutePath().toString();
        }
        return null;
    }

    private static Path findTool(String toolName, Path installDir) {
        Path bin = installDir.resolve("bin"); // NOI18N

                architecture: jdkMetadata.architecture,
            ]
        }
    }

    static void assertToolchainUsage(String toolName, JvmInstallationMetadata jdkMetadata, BuildOperationRecord.Progress usageEvent) {
        assert usageEvent.details.toolName == toolName
        def usedToolchain = usageEvent.details.toolchain
        assert usedToolchain == [
            javaVersion: jdkMetadata.javaVersion,

     */
    String getType();

    /**
     * Gets the platform tool executable.
     *
     * @param toolName the tool platform independent tool name.
     * @return file representing the tool executable, or null if the tool can not be found
     */
    String findTool(String toolName);

     */
    String getType();

    /**
     * Gets the platform tool executable.
     *
     * @param toolName the tool platform independent tool name
     * @return file representing the tool executable, or null if the tool cannot be found
     */
    String findTool(String toolName);

    /**
     * Let the toolchain decide if it matches requirements defined
     * in the toolchain plugin configuration.
     *

    }

    @Internal
    public boolean isFallbackToolchain() {
        return isFallbackToolchain;
    }

    public RegularFile findExecutable(String toolName) {
        return getInstallationPath().file(getBinaryPath(toolName));
    }

    @Override
    public String toString() {
        return "JavaToolchain(javaHome=" + getDisplayName() + ")";
    }

        config.execute(toolchainSpec);
        return toolchainSpec;
    }

    private void emitEvent(JavaToolchain toolchain, JavaTool toolName) {
        eventEmitter.emitNowForCurrent(new DefaultJavaToolchainUsageProgressDetails(toolName, toolchain.getMetadata()));
    }