push sheeet

pkgs/development/compilers/swift/swiftpm/cmake-glue.nix

@@ -0,0 +1,92 @@
+# SwiftPM dependencies are normally not installed using CMake, and only provide
+# CMake modules to link them together in a build tree. We have separate
+# derivations, so need a real install step. Here we provide our own minimal
+# CMake modules to install along with the build products.
+{
+  lib,
+  stdenv,
+  swift,
+}:
+let
+
+  inherit (stdenv.hostPlatform) extensions;
+
+  # This file exports shell snippets for use in postInstall.
+  mkInstallScript = module: template: ''
+    mkdir -p $out/lib/cmake/${module}
+    (
+      export staticLibExt="${extensions.staticLibrary}"
+      export sharedLibExt="${extensions.sharedLibrary}"
+      export swiftOs="${swift.swiftOs}"
+      substituteAll \
+        ${builtins.toFile "${module}Config.cmake" template} \
+        $out/lib/cmake/${module}/${module}Config.cmake
+    )
+  '';
+
+in
+lib.mapAttrs mkInstallScript {
+  SwiftSystem = ''
+    add_library(SwiftSystem::SystemPackage STATIC IMPORTED)
+    set_property(TARGET SwiftSystem::SystemPackage PROPERTY IMPORTED_LOCATION "@out@/lib/swift_static/@swiftOs@/libSystemPackage@staticLibExt@")
+  '';
+
+  SwiftCollections = ''
+    add_library(SwiftCollections::Collections STATIC IMPORTED)
+    set_property(TARGET SwiftCollections::Collections PROPERTY IMPORTED_LOCATION "@out@/lib/swift_static/@swiftOs@/libCollections@staticLibExt@")
+
+    add_library(SwiftCollections::DequeModule STATIC IMPORTED)
+    set_property(TARGET SwiftCollections::DequeModule PROPERTY IMPORTED_LOCATION "@out@/lib/swift_static/@swiftOs@/libDequeModule@staticLibExt@")
+
+    add_library(SwiftCollections::OrderedCollections STATIC IMPORTED)
+    set_property(TARGET SwiftCollections::OrderedCollections PROPERTY IMPORTED_LOCATION "@out@/lib/swift_static/@swiftOs@/libOrderedCollections@staticLibExt@")
+  '';
+
+  TSC = ''
+    add_library(TSCLibc SHARED IMPORTED)
+    set_property(TARGET TSCLibc PROPERTY IMPORTED_LOCATION "@out@/lib/libTSCLibc@sharedLibExt@")
+
+    add_library(TSCBasic SHARED IMPORTED)
+    set_property(TARGET TSCBasic PROPERTY IMPORTED_LOCATION "@out@/lib/libTSCBasic@sharedLibExt@")
+
+    add_library(TSCUtility SHARED IMPORTED)
+    set_property(TARGET TSCUtility PROPERTY IMPORTED_LOCATION "@out@/lib/libTSCUtility@sharedLibExt@")
+  '';
+
+  ArgumentParser = ''
+    add_library(ArgumentParser SHARED IMPORTED)
+    set_property(TARGET ArgumentParser PROPERTY IMPORTED_LOCATION "@out@/lib/swift/@swiftOs@/libArgumentParser@sharedLibExt@")
+
+    add_library(ArgumentParserToolInfo SHARED IMPORTED)
+    set_property(TARGET ArgumentParserToolInfo PROPERTY IMPORTED_LOCATION "@out@/lib/swift/@swiftOs@/libArgumentParserToolInfo@sharedLibExt@")
+  '';
+
+  Yams = ''
+    add_library(Yams SHARED IMPORTED)
+    set_property(TARGET Yams PROPERTY IMPORTED_LOCATION "@out@/lib/swift/@swiftOs@/libYams@sharedLibExt@")
+  '';
+
+  LLBuild = ''
+    add_library(libllbuild SHARED IMPORTED)
+    set_property(TARGET libllbuild PROPERTY IMPORTED_LOCATION "@out@/lib/libllbuild@sharedLibExt@")
+
+    add_library(llbuildSwift SHARED IMPORTED)
+    set_property(TARGET llbuildSwift PROPERTY IMPORTED_LOCATION "@out@/lib/swift/pm/llbuild/libllbuildSwift@sharedLibExt@")
+  '';
+
+  SwiftDriver = ''
+    add_library(SwiftDriver SHARED IMPORTED)
+    set_property(TARGET SwiftDriver PROPERTY IMPORTED_LOCATION "@out@/lib/libSwiftDriver@sharedLibExt@")
+
+    add_library(SwiftDriverExecution SHARED IMPORTED)
+    set_property(TARGET SwiftDriverExecution PROPERTY IMPORTED_LOCATION "@out@/lib/libSwiftDriverExecution@sharedLibExt@")
+
+    add_library(SwiftOptions SHARED IMPORTED)
+    set_property(TARGET SwiftOptions PROPERTY IMPORTED_LOCATION "@out@/lib/libSwiftOptions@sharedLibExt@")
+  '';
+
+  SwiftCrypto = ''
+    add_library(Crypto SHARED IMPORTED)
+    set_property(TARGET Crypto PROPERTY IMPORTED_LOCATION "@out@/lib/swift/@swiftOs@/libCrypto@sharedLibExt@")
+  '';
+}

pkgs/development/compilers/swift/swiftpm/default.nix

@@ -0,0 +1,477 @@
+{
+  lib,
+  stdenv,
+  callPackage,
+  fetchpatch,
+  cmake,
+  ninja,
+  git,
+  swift,
+  swiftpm2nix,
+  Foundation,
+  XCTest,
+  pkg-config,
+  sqlite,
+  ncurses,
+  replaceVars,
+  runCommandLocal,
+  makeWrapper,
+  DarwinTools, # sw_vers
+  cctools, # vtool
+  xcbuild,
+}:
+
+let
+
+  inherit (swift) swiftOs swiftModuleSubdir swiftStaticModuleSubdir;
+  sharedLibraryExt = stdenv.hostPlatform.extensions.sharedLibrary;
+
+  sources = callPackage ../sources.nix { };
+  generated = swiftpm2nix.helpers ./generated;
+  cmakeGlue = callPackage ./cmake-glue.nix { };
+
+  # Common attributes for the bootstrap swiftpm and the final swiftpm.
+  commonAttrs = {
+    inherit (sources) version;
+    src = sources.swift-package-manager;
+    nativeBuildInputs = [ makeWrapper ];
+    # Required at run-time for the host platform to build package manifests.
+    propagatedBuildInputs = [ Foundation ];
+    patches = [
+      ./patches/cmake-disable-rpath.patch
+      ./patches/cmake-fix-quoting.patch
+      ./patches/disable-index-store.patch
+      ./patches/disable-sandbox.patch
+      ./patches/disable-xctest.patch
+      ./patches/fix-clang-cxx.patch
+      ./patches/nix-pkgconfig-vars.patch
+      (replaceVars ./patches/fix-stdlib-path.patch {
+        inherit (builtins) storeDir;
+        swiftLib = swift.swift.lib;
+      })
+    ];
+    postPatch = ''
+      # The location of xcrun is hardcoded. We need PATH lookup instead.
+      find Sources -name '*.swift' | xargs sed -i -e 's|/usr/bin/xcrun|xcrun|g'
+
+      # Patch the location where swiftpm looks for its API modules.
+      substituteInPlace Sources/PackageModel/UserToolchain.swift \
+        --replace \
+          'librariesPath = applicationPath.parentDirectory' \
+          "librariesPath = AbsolutePath(\"$out\")"
+
+      # Fix case-sensitivity issues.
+      # Upstream PR: https://github.com/apple/swift-package-manager/pull/6500
+      substituteInPlace Sources/CMakeLists.txt \
+        --replace \
+          'packageCollectionsSigning' \
+          'PackageCollectionsSigning'
+      substituteInPlace Sources/PackageCollectionsSigning/CMakeLists.txt \
+        --replace \
+          'SubjectPublickeyInfo' \
+          'SubjectPublicKeyInfo'
+      substituteInPlace Sources/PackageCollections/CMakeLists.txt \
+        --replace \
+          'FilepackageCollectionsSourcesStorage' \
+          'FilePackageCollectionsSourcesStorage'
+    '';
+  };
+
+  # Tools invoked by swiftpm at run-time.
+  runtimeDeps = [
+    git
+  ]
+  ++ lib.optionals stdenv.hostPlatform.isDarwin [
+    xcbuild.xcrun
+    # These tools are part of cctools, but adding that as a build input puts
+    # an unwrapped linker in PATH, and breaks builds. This small derivation
+    # exposes just the tools we need:
+    # - vtool is used to determine a minimum deployment target.
+    # - libtool is used to build static libraries.
+    (runCommandLocal "swiftpm-cctools" { } ''
+      mkdir -p $out/bin
+      ln -s ${cctools}/bin/vtool $out/bin/vtool
+      ln -s ${cctools}/bin/libtool $out/bin/libtool
+    '')
+  ];
+
+  # Common attributes for the bootstrap derivations.
+  mkBootstrapDerivation =
+    attrs:
+    stdenv.mkDerivation (
+      attrs
+      // {
+        nativeBuildInputs =
+          (attrs.nativeBuildInputs or [ ])
+          ++ [
+            cmake
+            ninja
+            swift
+          ]
+          ++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
+
+        buildInputs = (attrs.buildInputs or [ ]) ++ [ Foundation ];
+
+        postPatch =
+          (attrs.postPatch or "")
+          + lib.optionalString stdenv.hostPlatform.isDarwin ''
+            # On Darwin only, Swift uses arm64 as cpu arch.
+            if [ -e cmake/modules/SwiftSupport.cmake ]; then
+              substituteInPlace cmake/modules/SwiftSupport.cmake \
+                --replace '"aarch64" PARENT_SCOPE' '"arm64" PARENT_SCOPE'
+            fi
+          '';
+
+        postInstall =
+          (attrs.postInstall or "")
+          + lib.optionalString stdenv.hostPlatform.isDarwin ''
+            # The install name of libraries is incorrectly set to lib/ (via our
+            # CMake setup hook) instead of lib/swift/. This'd be easily fixed by
+            # fixDarwinDylibNames, but some builds create libraries that reference
+            # eachother, and we also have to fix those references.
+            dylibs="$(find $out/lib/swift* -name '*.dylib')"
+            changes=""
+            for dylib in $dylibs; do
+              changes+=" -change $(otool -D $dylib | tail -n 1) $dylib"
+            done
+            for dylib in $dylibs; do
+              install_name_tool -id $dylib $changes $dylib
+            done
+          '';
+
+        cmakeFlags = (attrs.cmakeFlags or [ ]) ++ [
+          # Some builds link to libraries within the same build. Make sure these
+          # create references to $out. None of our builds run their own products,
+          # so we don't have to account for that scenario.
+          "-DCMAKE_BUILD_WITH_INSTALL_NAME_DIR=ON"
+        ];
+      }
+    );
+
+  # On Darwin, we only want ncurses in the linker search path, because headers
+  # are part of libsystem. Adding its headers to the search path causes strange
+  # mixing and errors.
+  # TODO: Find a better way to prevent this conflict.
+  ncursesInput = if stdenv.hostPlatform.isDarwin then ncurses.out else ncurses;
+
+  # Derivations for bootstrapping dependencies using CMake.
+  # This is based on the `swiftpm/Utilities/bootstrap` script.
+  #
+  # Some of the installation steps here are a bit hacky, because it seems like
+  # these packages were not really meant to be installed using CMake. The
+  # regular swiftpm bootstrap simply refers to the source and build
+  # directories. The advantage of separate builds is that we can more easily
+  # link libs together using existing Nixpkgs infra.
+  #
+  # In the end, we don't expose these derivations, and they only exist during
+  # the bootstrap phase. The final swiftpm derivation does not depend on them.
+
+  swift-system = mkBootstrapDerivation {
+    name = "swift-system";
+    src = generated.sources.swift-system;
+
+    postInstall =
+      cmakeGlue.SwiftSystem
+      + lib.optionalString (!stdenv.hostPlatform.isDarwin) ''
+        # The cmake rules apparently only use the Darwin install convention.
+        # Fix up the installation so the module can be found on non-Darwin.
+        mkdir -p $out/${swiftStaticModuleSubdir}
+        mv $out/lib/swift_static/${swiftOs}/*.swiftmodule $out/${swiftStaticModuleSubdir}/
+      '';
+  };
+
+  swift-collections = mkBootstrapDerivation {
+    name = "swift-collections";
+    src = generated.sources.swift-collections;
+
+    postPatch = ''
+      # Only builds static libs on Linux, but this installation difference is a
+      # hassle. Because this installation is temporary for the bootstrap, may
+      # as well build static libs everywhere.
+      sed -i -e '/BUILD_SHARED_LIBS/d' CMakeLists.txt
+    '';
+
+    postInstall =
+      cmakeGlue.SwiftCollections
+      + lib.optionalString (!stdenv.hostPlatform.isDarwin) ''
+        # The cmake rules apparently only use the Darwin install convention.
+        # Fix up the installation so the module can be found on non-Darwin.
+        mkdir -p $out/${swiftStaticModuleSubdir}
+        mv $out/lib/swift_static/${swiftOs}/*.swiftmodule $out/${swiftStaticModuleSubdir}/
+      '';
+  };
+
+  # Part of this patch fixes for glibc 2.39: glibc patch 64b1a44183a3094672ed304532bedb9acc707554
+  # marks the `FILE*` argument to a few functions including `ferror` & `fread` as non-null. However
+  # the code passes an `Optional<T>` to these functions.
+  # This patch uses a `guard` which effectively unwraps the type (or throws an exception).
+  swift-tools-support-core-glibc-fix = fetchpatch {
+    url = "https://github.com/apple/swift-tools-support-core/commit/990afca47e75cce136d2f59e464577e68a164035.patch";
+    hash = "sha256-PLzWsp+syiUBHhEFS8+WyUcSae5p0Lhk7SSRdNvfouE=";
+    includes = [ "Sources/TSCBasic/FileSystem.swift" ];
+  };
+
+  swift-tools-support-core = mkBootstrapDerivation {
+    name = "swift-tools-support-core";
+    src = generated.sources.swift-tools-support-core;
+
+    patches = [
+      swift-tools-support-core-glibc-fix
+    ];
+
+    buildInputs = [
+      swift-system
+      sqlite
+    ];
+
+    postInstall = cmakeGlue.TSC + ''
+      # Swift modules are not installed.
+      mkdir -p $out/${swiftModuleSubdir}
+      cp swift/*.swift{module,doc} $out/${swiftModuleSubdir}/
+
+      # Static libs are not installed.
+      cp lib/*.a $out/lib/
+
+      # Headers are not installed.
+      mkdir -p $out/include
+      cp -r ../Sources/TSCclibc/include $out/include/TSC
+    '';
+  };
+
+  swift-argument-parser = mkBootstrapDerivation {
+    name = "swift-argument-parser";
+    src = generated.sources.swift-argument-parser;
+
+    buildInputs = [
+      ncursesInput
+      sqlite
+    ];
+
+    cmakeFlags = [
+      "-DBUILD_TESTING=NO"
+      "-DBUILD_EXAMPLES=NO"
+    ];
+
+    postInstall =
+      cmakeGlue.ArgumentParser
+      + lib.optionalString stdenv.hostPlatform.isLinux ''
+        # Fix rpath so ArgumentParserToolInfo can be found.
+        patchelf --add-rpath "$out/lib/swift/${swiftOs}" \
+          $out/lib/swift/${swiftOs}/libArgumentParser.so
+      '';
+  };
+
+  Yams = mkBootstrapDerivation {
+    name = "Yams";
+    src = generated.sources.Yams;
+
+    # Conflicts with BUILD file on case-insensitive filesystems.
+    cmakeBuildDir = "_build";
+
+    postInstall = cmakeGlue.Yams;
+  };
+
+  llbuild = mkBootstrapDerivation {
+    name = "llbuild";
+    src = generated.sources.swift-llbuild;
+
+    nativeBuildInputs = lib.optional stdenv.hostPlatform.isDarwin xcbuild;
+    buildInputs = [
+      ncursesInput
+      sqlite
+    ];
+
+    patches = [
+      ./patches/llbuild-cmake-disable-rpath.patch
+    ];
+
+    postPatch = ''
+      # Substitute ncurses for curses.
+      find . -name CMakeLists.txt | xargs sed -i -e 's/curses/ncurses/'
+
+      # Use absolute install names instead of rpath.
+      substituteInPlace \
+        products/libllbuild/CMakeLists.txt \
+        products/llbuildSwift/CMakeLists.txt \
+        --replace '@rpath' "$out/lib"
+
+      # This subdirectory is enabled for Darwin only, but requires ObjC XCTest
+      # (and only Swift XCTest is open source).
+      substituteInPlace perftests/CMakeLists.txt \
+        --replace 'add_subdirectory(Xcode/' '#add_subdirectory(Xcode/'
+    '';
+
+    cmakeFlags = [
+      "-DLLBUILD_SUPPORT_BINDINGS=Swift"
+    ];
+
+    postInstall = cmakeGlue.LLBuild + ''
+      # Install module map.
+      cp ../products/libllbuild/include/module.modulemap $out/include
+
+      # Swift modules are not installed.
+      mkdir -p $out/${swiftModuleSubdir}
+      cp products/llbuildSwift/*.swift{module,doc} $out/${swiftModuleSubdir}/
+    '';
+  };
+
+  swift-driver = mkBootstrapDerivation {
+    name = "swift-driver";
+    src = generated.sources.swift-driver;
+
+    buildInputs = [
+      Yams
+      llbuild
+      swift-system
+      swift-argument-parser
+      swift-tools-support-core
+    ];
+
+    postPatch = ''
+      # Tries to link against CYaml, but that's private.
+      substituteInPlace Sources/SwiftDriver/CMakeLists.txt \
+        --replace CYaml ""
+    '';
+
+    postInstall = cmakeGlue.SwiftDriver + ''
+      # Swift modules are not installed.
+      mkdir -p $out/${swiftModuleSubdir}
+      cp swift/*.swift{module,doc} $out/${swiftModuleSubdir}/
+    '';
+  };
+
+  swift-crypto = mkBootstrapDerivation {
+    name = "swift-crypto";
+    src = generated.sources.swift-crypto;
+
+    postPatch = ''
+      # Fix use of hardcoded tool paths on Darwin.
+      substituteInPlace CMakeLists.txt \
+        --replace /usr/bin/ar $NIX_CC/bin/ar
+      substituteInPlace CMakeLists.txt \
+        --replace /usr/bin/ranlib $NIX_CC/bin/ranlib
+    '';
+
+    postInstall = cmakeGlue.SwiftCrypto + ''
+      # Static libs are not installed.
+      cp lib/*.a $out/lib/
+
+      # Headers are not installed.
+      cp -r ../Sources/CCryptoBoringSSL/include $out/include
+    '';
+  };
+
+  # Build a bootrapping swiftpm using CMake.
+  swiftpm-bootstrap = mkBootstrapDerivation (
+    commonAttrs
+    // {
+      pname = "swiftpm-bootstrap";
+
+      buildInputs = [
+        llbuild
+        sqlite
+        swift-argument-parser
+        swift-collections
+        swift-crypto
+        swift-driver
+        swift-system
+        swift-tools-support-core
+      ];
+
+      cmakeFlags = [
+        "-DUSE_CMAKE_INSTALL=ON"
+      ];
+
+      postInstall = ''
+        for program in $out/bin/swift-*; do
+          wrapProgram $program --prefix PATH : ${lib.makeBinPath runtimeDeps}
+        done
+      '';
+    }
+  );
+
+in
+# Build the final swiftpm with the bootstrapping swiftpm.
+stdenv.mkDerivation (
+  commonAttrs
+  // {
+    pname = "swiftpm";
+
+    nativeBuildInputs = commonAttrs.nativeBuildInputs ++ [
+      pkg-config
+      swift
+      swiftpm-bootstrap
+    ];
+    buildInputs = [
+      ncursesInput
+      sqlite
+      XCTest
+    ];
+
+    configurePhase = generated.configure + ''
+      # Functionality provided by Xcode XCTest, but not available in
+      # swift-corelibs-xctest.
+      swiftpmMakeMutable swift-tools-support-core
+      substituteInPlace .build/checkouts/swift-tools-support-core/Sources/TSCTestSupport/XCTestCasePerf.swift \
+        --replace 'canImport(Darwin)' 'false'
+      patch -p1 -d .build/checkouts/swift-tools-support-core -i ${swift-tools-support-core-glibc-fix}
+
+      # Prevent a warning about SDK directories we don't have.
+      swiftpmMakeMutable swift-driver
+      patch -p1 -d .build/checkouts/swift-driver -i ${
+        replaceVars ../swift-driver/patches/prevent-sdk-dirs-warnings.patch {
+          inherit (builtins) storeDir;
+        }
+      }
+    '';
+
+    buildPhase = ''
+      TERM=dumb swift-build -c release
+    '';
+
+    # TODO: Tests depend on indexstore-db being provided by an existing Swift
+    # toolchain. (ie. looks for `../lib/libIndexStore.so` relative to swiftc.
+    #doCheck = true;
+    #checkPhase = ''
+    #  TERM=dumb swift-test -c release
+    #'';
+
+    # The following is derived from Utilities/bootstrap, see install_swiftpm.
+    installPhase = ''
+      binPath="$(swift-build --show-bin-path -c release)"
+
+      mkdir -p $out/bin $out/lib/swift
+
+      cp $binPath/swift-package-manager $out/bin/swift-package
+      wrapProgram $out/bin/swift-package \
+        --prefix PATH : ${lib.makeBinPath runtimeDeps}
+      for tool in swift-build swift-test swift-run swift-package-collection swift-experimental-destination; do
+        ln -s $out/bin/swift-package $out/bin/$tool
+      done
+
+      installSwiftpmModule() {
+        mkdir -p $out/lib/swift/pm/$2
+        cp $binPath/lib$1${sharedLibraryExt} $out/lib/swift/pm/$2/
+
+        if [[ -f $binPath/$1.swiftinterface ]]; then
+          cp $binPath/$1.swiftinterface $out/lib/swift/pm/$2/
+        else
+          cp -r $binPath/$1.swiftmodule $out/lib/swift/pm/$2/
+        fi
+        cp $binPath/$1.swiftdoc $out/lib/swift/pm/$2/
+      }
+      installSwiftpmModule PackageDescription ManifestAPI
+      installSwiftpmModule PackagePlugin PluginAPI
+    '';
+
+    setupHook = ./setup-hook.sh;
+
+    meta = {
+      description = "Package Manager for the Swift Programming Language";
+      homepage = "https://github.com/apple/swift-package-manager";
+      platforms = with lib.platforms; linux ++ darwin;
+      license = lib.licenses.asl20;
+      teams = [ lib.teams.swift ];
+    };
+  }
+)

pkgs/development/compilers/swift/swiftpm/generated/default.nix

@@ -0,0 +1,14 @@
+# This file was generated by swiftpm2nix.
+{
+  workspaceStateFile = ./workspace-state.json;
+  hashes = {
+    "swift-argument-parser" = "1jph9w7lk9nr20fsv2c8p4hisx3dda817fh7pybd0r0j1jwa9nmw";
+    "swift-collections" = "1k6sjx5rqmp3gklny77b480hyzy6gkhpi23r0s8ljfbrcwawgnan";
+    "swift-crypto" = "0kllp7j0hd8k67l9b9zr2c3ddc5bvshldchzivhcz3q31qvq9ag8";
+    "swift-driver" = "0cbvddj54k3sbw0vzlmzhccs7h43hi5kq6i3n2i0mysz3bf0c6zg";
+    "swift-llbuild" = "106vnssh6pgy5s9dnq1hi1c9v2wkfydqgncg5dy7c9n23iisjy3s";
+    "swift-system" = "0402hkx2q2dv27gccnn8ma79ngvwiwzkhcv4zlcdldmy6cgi0px7";
+    "swift-tools-support-core" = "1qvblyiazv58qwyxgyk2dh5ymbab3y70vm2q81qs6rmv43hs8ciz";
+    "Yams" = "0b4lprxl4f6yqq0djnp394mxgmsxm2pljr7fh4f6ihdhnpwfsfvl";
+  };
+}

pkgs/development/compilers/swift/swiftpm/generated/workspace-state.json

@@ -0,0 +1,144 @@
+{
+  "object": {
+    "artifacts": [],
+    "dependencies": [
+      {
+        "basedOn": null,
+        "packageRef": {
+          "identity": "swift-argument-parser",
+          "kind": "remoteSourceControl",
+          "location": "https://github.com/apple/swift-argument-parser.git",
+          "name": "swift-argument-parser"
+        },
+        "state": {
+          "checkoutState": {
+            "revision": "e394bf350e38cb100b6bc4172834770ede1b7232",
+            "version": "1.0.3"
+          },
+          "name": "sourceControlCheckout"
+        },
+        "subpath": "swift-argument-parser"
+      },
+      {
+        "basedOn": null,
+        "packageRef": {
+          "identity": "swift-collections",
+          "kind": "remoteSourceControl",
+          "location": "https://github.com/apple/swift-collections.git",
+          "name": "swift-collections"
+        },
+        "state": {
+          "checkoutState": {
+            "revision": "937e904258d22af6e447a0b72c0bc67583ef64a2",
+            "version": "1.0.4"
+          },
+          "name": "sourceControlCheckout"
+        },
+        "subpath": "swift-collections"
+      },
+      {
+        "basedOn": null,
+        "packageRef": {
+          "identity": "swift-crypto",
+          "kind": "remoteSourceControl",
+          "location": "https://github.com/apple/swift-crypto.git",
+          "name": "swift-crypto"
+        },
+        "state": {
+          "checkoutState": {
+            "revision": "75ec60b8b4cc0f085c3ac414f3dca5625fa3588e",
+            "version": "2.2.4"
+          },
+          "name": "sourceControlCheckout"
+        },
+        "subpath": "swift-crypto"
+      },
+      {
+        "basedOn": null,
+        "packageRef": {
+          "identity": "swift-driver",
+          "kind": "remoteSourceControl",
+          "location": "https://github.com/apple/swift-driver.git",
+          "name": "swift-driver"
+        },
+        "state": {
+          "checkoutState": {
+            "branch": "release/5.8",
+            "revision": "7cfe0c0b6e6297efe88a3ce34e6138ee7eda969e"
+          },
+          "name": "sourceControlCheckout"
+        },
+        "subpath": "swift-driver"
+      },
+      {
+        "basedOn": null,
+        "packageRef": {
+          "identity": "swift-llbuild",
+          "kind": "remoteSourceControl",
+          "location": "https://github.com/apple/swift-llbuild.git",
+          "name": "llbuild"
+        },
+        "state": {
+          "checkoutState": {
+            "branch": "release/5.8",
+            "revision": "dccfc2e127a34b89a849407594cf2d604b598ba9"
+          },
+          "name": "sourceControlCheckout"
+        },
+        "subpath": "swift-llbuild"
+      },
+      {
+        "basedOn": null,
+        "packageRef": {
+          "identity": "swift-system",
+          "kind": "remoteSourceControl",
+          "location": "https://github.com/apple/swift-system.git",
+          "name": "swift-system"
+        },
+        "state": {
+          "checkoutState": {
+            "revision": "836bc4557b74fe6d2660218d56e3ce96aff76574",
+            "version": "1.1.1"
+          },
+          "name": "sourceControlCheckout"
+        },
+        "subpath": "swift-system"
+      },
+      {
+        "basedOn": null,
+        "packageRef": {
+          "identity": "swift-tools-support-core",
+          "kind": "remoteSourceControl",
+          "location": "https://github.com/apple/swift-tools-support-core.git",
+          "name": "swift-tools-support-core"
+        },
+        "state": {
+          "checkoutState": {
+            "branch": "release/5.8",
+            "revision": "ac4871e01ef338cb95b5d28328cab0ec1dfae935"
+          },
+          "name": "sourceControlCheckout"
+        },
+        "subpath": "swift-tools-support-core"
+      },
+      {
+        "basedOn": null,
+        "packageRef": {
+          "identity": "yams",
+          "kind": "remoteSourceControl",
+          "location": "https://github.com/jpsim/Yams.git",
+          "name": "Yams"
+        },
+        "state": {
+          "checkoutState": {
+            "revision": "f47ba4838c30dbd59998a4e4c87ab620ff959e8a",
+            "version": "5.0.5"
+          },
+          "name": "sourceControlCheckout"
+        },
+        "subpath": "Yams"
+      }
+    ]
+  },
+  "version": 6
+}

pkgs/development/compilers/swift/swiftpm/patches/cmake-disable-rpath.patch

@@ -0,0 +1,36 @@
+Disable rpath for the bootstrap build with CMake.
+
+--- a/Sources/PackageDescription/CMakeLists.txt
++++ b/Sources/PackageDescription/CMakeLists.txt
+@@ -31,14 +31,11 @@ if(CMAKE_HOST_SYSTEM_NAME STREQUAL Darwin)
+   set(SWIFT_INTERFACE_PATH ${CMAKE_BINARY_DIR}/pm/ManifestAPI/PackageDescription.swiftinterface)
+   target_compile_options(PackageDescription PUBLIC
+     $<$<COMPILE_LANGUAGE:Swift>:-emit-module-interface-path$<SEMICOLON>${SWIFT_INTERFACE_PATH}>)
+-  target_link_options(PackageDescription PRIVATE
+-    "SHELL:-Xlinker -install_name -Xlinker @rpath/libPackageDescription.dylib")
+ endif()
+ 
+ set_target_properties(PackageDescription PROPERTIES
+     Swift_MODULE_NAME PackageDescription
+     Swift_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/pm/ManifestAPI
+-    INSTALL_NAME_DIR \\@rpath
+     OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/pm/ManifestAPI
+     OUTPUT_NAME PackageDescription
+     ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/pm/ManifestAPI
+--- a/Sources/PackagePlugin/CMakeLists.txt
++++ b/Sources/PackagePlugin/CMakeLists.txt
+@@ -29,14 +29,11 @@ if(CMAKE_HOST_SYSTEM_NAME STREQUAL Darwin)
+   set(SWIFT_INTERFACE_PATH ${CMAKE_BINARY_DIR}/pm/PluginAPI/PackagePlugin.swiftinterface)
+   target_compile_options(PackagePlugin PUBLIC
+     $<$<COMPILE_LANGUAGE:Swift>:-emit-module-interface-path$<SEMICOLON>${SWIFT_INTERFACE_PATH}>)
+-  target_link_options(PackagePlugin PRIVATE
+-    "SHELL:-Xlinker -install_name -Xlinker @rpath/libPackagePlugin.dylib")
+ endif()
+ 
+ set_target_properties(PackagePlugin PROPERTIES
+   Swift_MODULE_NAME PackagePlugin
+   Swift_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/pm/PluginAPI
+-  INSTALL_NAME_DIR \\@rpath
+   OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/pm/PluginAPI
+   OUTPUT_NAME PackagePlugin
+   ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/pm/PluginAPI

pkgs/development/compilers/swift/swiftpm/patches/cmake-fix-quoting.patch

@@ -0,0 +1,12 @@
+--- a/Sources/PackageCollectionsSigning/CMakeLists.txt
++++ b/Sources/PackageCollectionsSigning/CMakeLists.txt
+@@ -43,6 +43,7 @@ target_link_libraries(PackageCollectionsSigning PUBLIC
+   PackageCollectionsModel
+   TSCBasic)
+ target_link_libraries(PackageCollectionsSigning PRIVATE
+-  PackageCollectionsSigningLibc
+-  $<$<PLATFORM_ID:Darwin>:SHELL:-Xlinker -framework -Xlinker Security>)
++  PackageCollectionsSigningLibc)
++target_link_options(PackageCollectionsSigning PRIVATE
++  "$<$<PLATFORM_ID:Darwin>:SHELL:-Xlinker -framework -Xlinker Security>")
+ 

pkgs/development/compilers/swift/swiftpm/patches/disable-index-store.patch

@@ -0,0 +1,23 @@
+The `-index-store-path` option is an Apple extension not available in our
+Clang. Make it opt-in by default.
+
+(It is assumed the `target.type == test` check is for Xcode support, because
+there is no evidence of it in swift-corelibs-xctest.)
+
+--- a/Sources/Build/BuildPlan.swift
++++ b/Sources/Build/BuildPlan.swift
+@@ -103,14 +103,7 @@ extension BuildParameters {
+         case .off:
+             addIndexStoreArguments = false
+         case .auto:
+-            if configuration == .debug {
+-                addIndexStoreArguments = true
+-            } else if target.type == .test {
+-                // Test discovery requires an index store for the test target to discover the tests
+-                addIndexStoreArguments = true
+-            } else {
+                 addIndexStoreArguments = false
+-            }
+         }
+ 
+         if addIndexStoreArguments {

pkgs/development/compilers/swift/swiftpm/patches/disable-sandbox.patch

@@ -0,0 +1,21 @@
+Nix may already sandbox the build, in which case sandbox_apply will fail.
+
+--- a/Sources/Basics/Sandbox.swift
++++ b/Sources/Basics/Sandbox.swift
+@@ -33,12 +33,14 @@ public enum Sandbox {
+         readOnlyDirectories: [AbsolutePath] = []
+     ) throws -> [String] {
+         #if os(macOS)
++        let env = ProcessInfo.processInfo.environment
++        if env["NIX_BUILD_TOP"] == nil || env["IN_NIX_SHELL"] != nil {
+         let profile = try macOSSandboxProfile(strictness: strictness, writableDirectories: writableDirectories, readOnlyDirectories: readOnlyDirectories)
+         return ["/usr/bin/sandbox-exec", "-p", profile] + command
+-        #else
++        }
++        #endif
+         // rdar://40235432, rdar://75636874 tracks implementing sandboxes for other platforms.
+         return command
+-        #endif
+     }
+ 
+     /// Basic strictness level of a sandbox applied to a command line.

pkgs/development/compilers/swift/swiftpm/patches/disable-xctest.patch

@@ -0,0 +1,37 @@
+XCTest is not fully open-source, only the Swift library parts. We don't have a
+command-line runner available, so disable support.
+
+--- a/Sources/Commands/Utilities/TestingSupport.swift
++++ b/Sources/Commands/Utilities/TestingSupport.swift
+@@ -72,7 +72,7 @@ enum TestingSupport {
+     /// - Returns: Array of TestSuite
+     static func getTestSuites(fromTestAt path: AbsolutePath, swiftTool: SwiftTool, enableCodeCoverage: Bool, sanitizers: [Sanitizer]) throws -> [TestSuite] {
+         // Run the correct tool.
+-        #if os(macOS)
++        #if false
+         let data: String = try withTemporaryFile { tempFile in
+             let args = [try Self.xctestHelperPath(swiftTool: swiftTool).pathString, path.pathString, tempFile.path.pathString]
+             var env = try Self.constructTestEnvironment(
+--- a/Sources/swiftpm-xctest-helper/main.swift
++++ b/Sources/swiftpm-xctest-helper/main.swift
+@@ -11,8 +11,11 @@
+ //===----------------------------------------------------------------------===//
+ 
+ #if os(macOS)
+-import XCTest
+ import func Darwin.C.exit
++print("Not supported in Nix.")
++exit(1)
++#if false
++import XCTest
+ 
+ /// A helper tool to get list of tests from a XCTest Bundle on macOS.
+ ///
+@@ -134,6 +137,7 @@ do {
+     exit(1)
+ }
+ 
++#endif // nix
+ #else
+ 
+ #if os(Windows)

pkgs/development/compilers/swift/swiftpm/patches/fix-clang-cxx.patch

@@ -0,0 +1,121 @@
+Swiftpm may invoke clang, not clang++, to compile C++. Our cc-wrapper also
+doesn't pick up the arguments that enable C++ compilation in this case. Patch
+swiftpm to properly invoke clang++.
+
+--- a/Sources/Build/BuildPlan.swift
++++ b/Sources/Build/BuildPlan.swift
+@@ -2089,7 +2089,7 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
+         for target in dependencies.staticTargets {
+             if case let target as ClangTarget = target.underlyingTarget, target.isCXX {
+                 if buildParameters.hostTriple.isDarwin() {
+-                    buildProduct.additionalFlags += ["-lc++"]
++                    buildProduct.additionalFlags += ["-lc++", "-lc++abi"]
+                 } else if buildParameters.hostTriple.isWindows() {
+                     // Don't link any C++ library.
+                 } else {
+--- a/Sources/Build/LLBuildManifestBuilder.swift
++++ b/Sources/Build/LLBuildManifestBuilder.swift
+@@ -786,7 +786,7 @@ extension LLBuildManifestBuilder {
+ 
+             args += ["-c", path.source.pathString, "-o", path.object.pathString]
+ 
+-            let clangCompiler = try buildParameters.toolchain.getClangCompiler().pathString
++            let clangCompiler = try buildParameters.toolchain.getClangCompiler(isCXX: isCXX).pathString
+             args.insert(clangCompiler, at: 0)
+ 
+             let objectFileNode: Node = .file(path.object)
+--- a/Sources/PackageModel/Toolchain.swift
++++ b/Sources/PackageModel/Toolchain.swift
+@@ -23,7 +23,7 @@ public protocol Toolchain {
+     var macosSwiftStdlib: AbsolutePath { get throws }
+ 
+     /// Path of the `clang` compiler.
+-    func getClangCompiler() throws -> AbsolutePath
++    func getClangCompiler(isCXX: Bool) throws -> AbsolutePath
+ 
+     // FIXME: This is a temporary API until index store is widely available in
+     // the OSS clang compiler. This API should not used for any other purpose.
+--- a/Sources/PackageModel/UserToolchain.swift
++++ b/Sources/PackageModel/UserToolchain.swift
+@@ -57,7 +57,7 @@ public final class UserToolchain: Toolchain {
+     /// Only use search paths, do not fall back to `xcrun`.
+     let useXcrun: Bool
+ 
+-    private var _clangCompiler: AbsolutePath?
++    private var _clangCompiler: [Bool: AbsolutePath] = [:]
+ 
+     private let environment: EnvironmentVariables
+ 
+@@ -196,29 +196,31 @@ public final class UserToolchain: Toolchain {
+     }
+ 
+     /// Returns the path to clang compiler tool.
+-    public func getClangCompiler() throws -> AbsolutePath {
++    public func getClangCompiler(isCXX: Bool) throws -> AbsolutePath {
+         // Check if we already computed.
+-        if let clang = self._clangCompiler {
++        if let clang = self._clangCompiler[isCXX] {
+             return clang
+         }
+ 
+         // Check in the environment variable first.
+-        if let toolPath = UserToolchain.lookup(variable: "CC", searchPaths: self.envSearchPaths, environment: environment) {
+-            self._clangCompiler = toolPath
++        let envVar = isCXX ? "CXX" : "CC";
++        if let toolPath = UserToolchain.lookup(variable: envVar, searchPaths: self.envSearchPaths, environment: environment) {
++            self._clangCompiler[isCXX] = toolPath
+             return toolPath
+         }
+ 
+         // Then, check the toolchain.
++        let tool = isCXX ? "clang++" : "clang";
+         do {
+-            if let toolPath = try? UserToolchain.getTool("clang", binDir: self.destination.toolchainBinDir) {
+-                self._clangCompiler = toolPath
++            if let toolPath = try? UserToolchain.getTool(tool, binDir: self.destination.binDir) {
++                self._clangCompiler[isCXX] = toolPath
+                 return toolPath
+             }
+         }
+ 
+         // Otherwise, lookup it up on the system.
+-        let toolPath = try UserToolchain.findTool("clang", envSearchPaths: self.envSearchPaths, useXcrun: useXcrun)
+-        self._clangCompiler = toolPath
++        let toolPath = try UserToolchain.findTool(tool, envSearchPaths: self.envSearchPaths, useXcrun: useXcrun)
++        self._clangCompiler[isCXX] = toolPath
+         return toolPath
+     }
+ 
+--- a/Sources/SPMBuildCore/BuildParameters.swift
++++ b/Sources/SPMBuildCore/BuildParameters.swift
+@@ -394,7 +394,7 @@ private struct _Toolchain: Encodable {
+     public func encode(to encoder: Encoder) throws {
+         var container = encoder.container(keyedBy: CodingKeys.self)
+         try container.encode(toolchain.swiftCompilerPath, forKey: .swiftCompiler)
+-        try container.encode(toolchain.getClangCompiler(), forKey: .clangCompiler)
++        try container.encode(toolchain.getClangCompiler(isCXX: false), forKey: .clangCompiler)
+ 
+         try container.encode(toolchain.extraFlags.cCompilerFlags, forKey: .extraCCFlags)
+         // Maintaining `extraCPPFlags` key for compatibility with older encoding.
+--- a/Sources/XCBuildSupport/XcodeBuildSystem.swift
++++ b/Sources/XCBuildSupport/XcodeBuildSystem.swift
+@@ -182,7 +182,7 @@ public final class XcodeBuildSystem: SPMBuildCore.BuildSystem {
+         // Generate a table of any overriding build settings.
+         var settings: [String: String] = [:]
+         // An error with determining the override should not be fatal here.
+-        settings["CC"] = try? buildParameters.toolchain.getClangCompiler().pathString
++        settings["CC"] = try? buildParameters.toolchain.getClangCompiler(isCXX: false).pathString
+         // Always specify the path of the effective Swift compiler, which was determined in the same way as for the native build system.
+         settings["SWIFT_EXEC"] = buildParameters.toolchain.swiftCompilerPath.pathString
+         settings["LIBRARY_SEARCH_PATHS"] = "$(inherited) \(try buildParameters.toolchain.toolchainLibDir.pathString)"
+--- a/Tests/BuildTests/MockBuildTestHelper.swift
++++ b/Tests/BuildTests/MockBuildTestHelper.swift
+@@ -23,7 +23,7 @@ struct MockToolchain: PackageModel.Toolchain {
+     #else
+     let extraFlags = BuildFlags(cxxCompilerFlags: ["-lstdc++"])
+     #endif
+-    func getClangCompiler() throws -> AbsolutePath {
++    func getClangCompiler(isCXX: Bool) throws -> AbsolutePath {
+         return AbsolutePath(path: "/fake/path/to/clang")
+     }
+ 

pkgs/development/compilers/swift/swiftpm/patches/fix-stdlib-path.patch

@@ -0,0 +1,25 @@
+Swiftpm looks for the Swift stdlib relative to the swift compiler, but that's a
+wrapper in our case. It wants to add the stdlib to the rpath, which is
+necessary for back-deployment of some features.
+
+--- a/Sources/PackageModel/Toolchain.swift
++++ b/Sources/PackageModel/Toolchain.swift
+@@ -53,12 +53,18 @@ extension Toolchain {
+ 
+     public var macosSwiftStdlib: AbsolutePath {
+         get throws {
++            if swiftCompilerPath.pathString.starts(with: "@storeDir@") {
++                return AbsolutePath("@swiftLib@/lib/swift/macosx")
++            }
+             return try AbsolutePath(validating: "../../lib/swift/macosx", relativeTo: resolveSymlinks(swiftCompilerPath))
+         }
+     }
+ 
+     public var toolchainLibDir: AbsolutePath {
+         get throws {
++            if swiftCompilerPath.pathString.starts(with: "@storeDir@") {
++                return AbsolutePath("@swiftLib@/lib")
++            }
+             // FIXME: Not sure if it's better to base this off of Swift compiler or our own binary.
+             return try AbsolutePath(validating: "../../lib", relativeTo: resolveSymlinks(swiftCompilerPath))
+         }

pkgs/development/compilers/swift/swiftpm/patches/llbuild-cmake-disable-rpath.patch

@@ -0,0 +1,14 @@
+Specifying `-platform_version` targeting macos before 10.15 causes cctools ld
+to link with `@rpath`. This may have something to do with Swift ABI stability.
+
+--- a/products/llbuildSwift/CMakeLists.txt
++++ b/products/llbuildSwift/CMakeLists.txt
+@@ -22,7 +17,7 @@ endif()
+
+ # TODO(compnerd) move both of these outside of the CMake into the invocation
+ if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
+-  add_compile_options(-target ${CMAKE_OSX_ARCHITECTURES}-apple-macosx10.10)
++  add_compile_options(-target ${CMAKE_OSX_ARCHITECTURES}-apple-macosx10.15)
+   if(NOT CMAKE_OSX_SYSROOT STREQUAL "")
+     add_compile_options(-sdk ${CMAKE_OSX_SYSROOT})
+   endif()

pkgs/development/compilers/swift/swiftpm/patches/nix-pkgconfig-vars.patch

@@ -0,0 +1,28 @@
+Swift parses .pc files manually, but this means it bypasses our pkg-config
+wrapper. That wrapper normally takes care of introducing the correct
+PKG_CONFIG_PATH for cross compiling.
+
+--- a/Sources/PackageLoading/PkgConfig.swift
++++ b/Sources/PackageLoading/PkgConfig.swift
+@@ -123,14 +123,17 @@ public struct PkgConfig {
+ 
+     private static var envSearchPaths: [AbsolutePath] {
+         get throws {
+-            if let configPath = ProcessEnv.vars["PKG_CONFIG_PATH"] {
++            var result: [AbsolutePath] = []
++            for envVar in ["PKG_CONFIG_PATH", "PKG_CONFIG_PATH_FOR_TARGET"] {
++            if let configPath = ProcessEnv.vars[envVar] {
+                 #if os(Windows)
+-                return try configPath.split(separator: ";").map({ try AbsolutePath(validating: String($0)) })
++                result += try configPath.split(separator: ";").map({ try AbsolutePath(validating: String($0)) })
+                 #else
+-                return try configPath.split(separator: ":").map({ try AbsolutePath(validating: String($0)) })
++                result += try configPath.split(separator: ":").map({ try AbsolutePath(validating: String($0)) })
+                 #endif
+             }
+-            return []
++            }
++            return result
+         }
+     }
+ }

pkgs/development/compilers/swift/swiftpm/setup-hook.sh

@@ -0,0 +1,62 @@
+# shellcheck shell=bash
+
+# Build using 'swift-build'.
+swiftpmBuildPhase() {
+    runHook preBuild
+
+    local buildCores=1
+    if [ "${enableParallelBuilding-1}" ]; then
+        buildCores="$NIX_BUILD_CORES"
+    fi
+
+    local flagsArray=(
+        -j "$buildCores"
+        -c "${swiftpmBuildConfig-release}"
+    )
+    concatTo flagsArray swiftpmFlags swiftpmFlagsArray
+
+    echoCmd 'build flags' "${flagsArray[@]}"
+    TERM=dumb swift-build "${flagsArray[@]}"
+
+    runHook postBuild
+}
+
+if [ -z "${dontUseSwiftpmBuild-}" ] && [ -z "${buildPhase-}" ]; then
+    buildPhase=swiftpmBuildPhase
+fi
+
+# Check using 'swift-test'.
+swiftpmCheckPhase() {
+    runHook preCheck
+
+    local buildCores=1
+    if [ "${enableParallelBuilding-1}" ]; then
+        buildCores="$NIX_BUILD_CORES"
+    fi
+
+    local flagsArray=(
+        -j "$buildCores"
+        -c "${swiftpmBuildConfig-release}"
+    )
+    concatTo flagsArray swiftpmFlags swiftpmFlagsArray
+
+    echoCmd 'check flags' "${flagsArray[@]}"
+    TERM=dumb swift-test "${flagsArray[@]}"
+
+    runHook postCheck
+}
+
+if [ -z "${dontUseSwiftpmCheck-}" ] && [ -z "${checkPhase-}" ]; then
+    checkPhase=swiftpmCheckPhase
+fi
+
+# Helper used to find the binary output path.
+# Useful for performing the installPhase of swiftpm packages.
+swiftpmBinPath() {
+    local flagsArray=(
+        -c "${swiftpmBuildConfig-release}"
+    )
+    concatTo flagsArray swiftpmFlags swiftpmFlagsArray
+
+    swift-build --show-bin-path "${flagsArray[@]}"
+}