create(name, registeredDefaults.get(name));
        }
    }

    @Override
    public NativeToolChain getForPlatform(NativePlatform targetPlatform) {
        return getForPlatform(NativeLanguage.ANY, (NativePlatformInternal) targetPlatform);
    }

    @Override
    public NativeToolChainInternal getForPlatform(NativeLanguage sourceLanguage, NativePlatformInternal targetMachine) {

        registry.registerDefaultToolChain("test3", TestNativeToolChain)
        registry.addDefaultToolChains()

        and:
        def tc = registry.getForPlatform(platform)
        def result = tc.select(platform)

        when:
        result.newCompiler(CCompileSpec.class)

        then:
        GradleException e = thrown()

 */
@Incubating
public interface ToolChainRegistry<P extends Platform, T extends ToolChain> {
    /**
     * Returns the best tool chain to build for the target platform.
     */
    T getForPlatform(P targetPlatform);

     */
    void addDefaultToolChains();

    /**
     * Selects the tool chain that can build binaries from the given source language that can run on the target machine.
     */
    NativeToolChainInternal getForPlatform(NativeLanguage sourceLanguage, NativePlatformInternal targetMachine);

    def project = Mock(Project)

    def toolProvider = Mock(PlatformToolProvider)
    def platform = Mock(NativePlatformInternal)
    def toolChains = Mock(NativeToolChainRegistryInternal) {
        getForPlatform(platform) >> Mock(NativeToolChainInternal) {
            select(platform) >> toolProvider
        }
    }

    def setup() {
        project.buildDir >> tmpDir.testDirectory
    }

        result.targetPlatform.targetMachine.architecture == machineArchitecture
        result.platformToolProvider == toolProvider

        and:
        registry.getForPlatform(NativeLanguage.CPP, _) >> { args ->
            assert args[1].architecture == Architectures.forInput(architecture)
            return toolChain
        }
        toolChain.select(NativeLanguage.CPP, _) >> { args ->

    }

    private static NativeToolChainInternal toolChainFor(NativeBinarySpec nativeBinary, NativeToolChainRegistryInternal toolChains) {
        return (NativeToolChainInternal) toolChains.getForPlatform(nativeBinary.getTargetPlatform());
    }

        NativeToolChainRegistryInternal registry = modelRegistry.realize("toolChains", NativeToolChainRegistryInternal.class);
        NativeToolChainInternal toolChain = registry.getForPlatform(sourceLanguage, targetNativePlatform);
        toolChain.assertSupported();

        return toolChain;
    }

    static SwiftVersion toSwiftVersion(VersionNumber swiftCompilerVersion) {

      se::PlatformManager::PlatformWithId(platform_info.platform_id());
  if (!platform.ok()) {
    return platform.status();
  }

  absl::StatusOr<xla::Compiler*> compiler_for_platform =
      xla::Compiler::GetForPlatform(platform.value());
  if (!compiler_for_platform.ok()) {
    // In some rare cases (usually in unit tests with very small clusters) we
    // may end up transforming an XLA cluster with at least one GPU operation

            final ModelRegistry modelRegistry = ((ProjectInternal) project).getModelRegistry();
            final NativeToolChain toolChain = modelRegistry.realize("toolChains", NativeToolChainRegistryInternal.class).getForPlatform(currentPlatform);

            // Platform specific arguments
            // TODO: Need to lazily configure compile task