}

    def swiftdocFileFor(File sourceFile, String intermediateFilesDir = "build/obj/main/debug") {
        return intermediateFileFor(sourceFile, intermediateFilesDir, "~partial.swiftdoc")
    }

    def swiftDepsFileFor(File sourceFile, String intermediateFilesDir = "build/obj/main/debug") {
        return intermediateFileFor(sourceFile, intermediateFilesDir, ".swiftdeps")
    }

        hackBuildPhase.setShellScript("# Script to generate specific Swift files Xcode expects when running tests.\n"
            + "set -eu\n"
            + "ARCH_ARRAY=($ARCHS)\n"
            + "SUFFIXES=(swiftdoc swiftmodule h)\n"
            + "for ARCH in \"${ARCH_ARRAY[@]}\"\n"
            + "do\n"
            + "  for SUFFIX in \"${SUFFIXES[@]}\"\n"
            + "  do\n"

import org.gradle.api.Incubating;

import java.io.File;
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.
     */

        when:
        result.explain(visitor)

        then:
        visitor.toString() == "Could not determine SwiftC metadata: swiftc produced unexpected output."

        where:
        out << ["not sure about this", ""]
    }

    def "handles failure to execute swiftc"() {
        given:
        def visitor = new TreeFormatter()
        def action = Mock(ExecAction)

class SwiftPmRunner {
    private final AvailableToolChains.InstalledSwiftc swiftc
    private File projectDir
    private List<String> args = []

    static SwiftPmRunner create(AvailableToolChains.InstalledSwiftc swiftc) {
        return new SwiftPmRunner(swiftc)
    }

    private SwiftPmRunner(AvailableToolChains.InstalledSwiftc swiftc) {
        this.swiftc = swiftc
    }

    SwiftPmRunner withProjectDir(File projectDir) {

            toolChainRegistry.registerFactory(Swiftc.class, new NamedDomainObjectFactory<Swiftc>() {
                @Override
                public Swiftc create(String name) {
                    return instantiator.newInstance(SwiftcToolChain.class, name, buildOperationExecutor, OperatingSystem.current(), fileResolver, execActionFactory, compilerOutputFileNamingSchemeFactory, metaDataProviderFactory.swiftc(), instantiator, workerLeaseService);
                }

        failure.assertHasCause("""No tool chain is available to build Swift for host operating system '${osName}' architecture '${archName}':
  - Tool chain '${toolChain.id}' (Swift Compiler):
      - Could not determine SwiftC metadata: swiftc produced unexpected output.""")
    }

    //
    // 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 static final CompilerType SWIFTC_COMPILER_TYPE = new CompilerType() {
        @Override
        public String getIdentifier() {
            return "swiftc";
        }

        @Override
        public String getDescription() {
            return "SwiftC";
        }
    };

    public SwiftcMetadataProvider(ExecActionFactory execActionFactory) {
        super(execActionFactory);
    }

    @Override

abstract class AbstractSwiftPackageManagerExportIntegrationTest extends AbstractIntegrationSpec {
    def swiftc = AvailableToolChains.getToolChain(ToolChainRequirement.SWIFTC_4)

    def setup() {
        settingsFile << """rootProject.name = 'test'
"""
    }

    ExecOutput swiftPmBuildSucceeds() {
        return SwiftPmRunner.create(swiftc)
            .withProjectDir(testDirectory)
            .withArguments("build")
            .build()