@Override
            public void execute(BufferedWriter bufferedWriter) {
                // Rewrite swiftc generated YAML file with our understanding of the current state of
                // swift sources. This doesn't use Yaml.dump because snakeyaml produces a YAML file
                // that swiftc cannot read.
                PrintWriter pw = new PrintWriter(bufferedWriter);

    //
    // Many of our old tests assume that available tool chains can compile many/most languages, so they do not try to
    // restrict the required set of tool chains.
    //
    // The swiftc tool chain can build _only_ Swift, so tests that expect to use the swiftc tool chain properly annotate
    // their requirements with ToolChainRequirement.SWIFTC (or a version-specific requirement).
    //

    private final CachingCompilerMetaDataProvider<SwiftcMetadata> swiftc;

    public CompilerMetaDataProviderFactory(ExecActionFactory execActionFactory) {
        gcc = new CachingCompilerMetaDataProvider<GccMetadata>(GccMetadataProvider.forGcc(execActionFactory));
        clang = new CachingCompilerMetaDataProvider<GccMetadata>(GccMetadataProvider.forClang(execActionFactory));

        public boolean meets(ToolChainRequirement requirement) {
            switch (requirement) {
                case SWIFTC:
                    return true;
                case SWIFTC_3:
                    return getVersion().getMajor() == 3;
                case SWIFTC_4:
                    return getVersion().getMajor() == 4;
                case SWIFTC_5:
                    return getVersion().getMajor() == 5;

    def "source generation is skipped when swift sources detected with #scriptDsl build scripts"() {
        setup:
        subprojectDir.file("src/main/swift/main.swift") << """
            public func hola() -> String {
                return "Hola, Mundo!"
            }

            print(hola())
        """
        subprojectDir.file("src/test/swift/HolaTests.swift") << """

        def newMetadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        0 * _
        newMetadata.is(metadata)

        where:
        compiler << ['gcc', 'clang', 'swiftc']
    }

    def "different #compiler executables are probed and cached"() {
        def firstBinary = new File("first")
        def secondBinary = new File("second")
        when:

import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SwiftcToolChain extends ExtendableToolChain<SwiftcPlatformToolChain> implements Swiftc {
    public static final String DEFAULT_NAME = "swiftc";

    private final CompilerOutputFileNamingSchemeFactory compilerOutputFileNamingSchemeFactory;
    private final CompilerMetaDataProvider<SwiftcMetadata> compilerMetaDataProvider;

        SwiftLinker swiftLinker = new SwiftLinker(buildOperationExecutor, commandLineTool(ToolType.LINKER, "swiftc"), context(linkerTool), workerLeaseService);
        return new VersionAwareCompiler<LinkerSpec>(swiftLinker, new DefaultCompilerVersion("swiftc", swiftcMetaData.getVendor(), swiftcMetaData.getVersion()));
    }

    protected Compiler<SwiftCompileSpec> createSwiftCompiler() {

    def "creates sample source if no source present with #scriptDsl build scripts"() {
        when:
        run('init', '--type', 'swift-library', '--dsl', scriptDsl.id)

        then:
        subprojectDir.file("src/main/swift").assertHasDescendants(SAMPLE_LIBRARY_CLASS)
        subprojectDir.file("src/test/swift").assertHasDescendants(SAMPLE_LIBRARY_TEST_CLASS, LINUX_MAIN_DOT_SWIFT)

        and:

        when:
        fails "check"
        then:
        failure.assertHasCause("""No tool chain is available to build Swift for host operating system '${osName}' architecture '${archName}':
  - Tool chain 'swiftc' (Swift Compiler):
      - Could not find Swift compiler 'swiftc' in system path.""")
    }