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;

import org.gradle.nativeplatform.toolchain.internal.metadata.CompilerMetaDataProvider
import org.gradle.nativeplatform.toolchain.internal.tools.CommandLineToolSearchResult
import org.gradle.nativeplatform.toolchain.internal.tools.GccCommandLineToolConfigurationInternal
import org.gradle.nativeplatform.toolchain.internal.tools.ToolSearchPath
import org.gradle.platform.base.internal.toolchain.ComponentFound

import java.util.List;

/**
 * The <a href="https://swift.org/">Swift Compiler</a> tool chain.
 *
 * @since 4.1
 */
@Incubating
public interface Swiftc extends NativeToolChain {
    /**
     * The paths setting required for executing the tool chain.
     * These are used to locate tools for this tool chain, and are prepended to the system PATH when executing these tools.
     */
    List<File> getPath();

    /**

                linker.executable = 'does-not-exist'
            }
        }
    }
}
"""

        then:
        succeeds "help"
    }

    @ToBeFixedForConfigurationCache
    def "tool chain is not available when no tools are available"() {
        when:
        buildFile << """
model {
    toolChains {
        ${toolChain.id} {
            eachPlatform {
                assembler.executable = 'does-not-exist'

1. Run the tool with:

```
go run docs/auditlog/auditlog-echo.go
```

The listen port has a default value (8080), but can be set with the `-port` flag.

2. Configure audit logging in MinIO with for example:

```
mc admin config set myminio audit_webhook enable=on endpoint=http://localhost:8080
```

    /**
     * The paths setting required for executing the tool chain.
     * These are used to locate tools for this tool chain, and are prepended to the system PATH when executing these tools.
     */
    List<File> getPath();

    /**
     * Append an entry or entries to the tool chain path.
     *

func FileVersion(info *types.Info, file *ast.File) string {
	// In x/tools built with Go <= 1.21, we do not have Info.FileVersions
	// available. We use a go version derived from the toolchain used to
	// compile the tool by default.
	// This will be <= go1.21. We take this as the maximum version that
	// this tool can support.
	//
	// There are no features currently in x/tools that need to tell fine grained
	// differences for versions <1.22.

Wenn Sie sich die Benchmarks ansehen, werden häufig mehrere Tools mit unterschiedlichen Eigenschaften als gleichwertig verglichen.

Konkret geht es darum, Uvicorn, Starlette und FastAPI miteinander zu vergleichen (neben vielen anderen Tools).

Je einfacher das Problem, welches durch das Tool gelöst wird, desto besser ist die Performanz. Und die meisten Benchmarks testen nicht die zusätzlichen Funktionen, welche das Tool bietet.

Die Hierarchie ist wie folgt: