uboot: (firmwareOdroidC2/C4) don't invoke patch tool, use patches = [] instead

https://github.com/NixOS/nixpkgs/blob/master/pkgs/stdenv/generic/setup.sh#L948
this can do it nicely.

Signed-off-by: Anton Arapov <anton@deadbeef.mx>

pkgs/development/compilers/rust/1_61.nix

@@ -0,0 +1,64 @@
+# New rust versions should first go to staging.
+# Things to check after updating:
+# 1. Rustc should produce rust binaries on x86_64-linux, aarch64-linux and x86_64-darwin:
+#    i.e. nix-shell -p fd or @GrahamcOfBorg build fd on github
+#    This testing can be also done by other volunteers as part of the pull
+#    request review, in case platforms cannot be covered.
+# 2. The LLVM version used for building should match with rust upstream.
+#    Check the version number in the src/llvm-project git submodule in:
+#    https://github.com/rust-lang/rust/blob/<version-tag>/.gitmodules
+# 3. Firefox and Thunderbird should still build on x86_64-linux.
+
+{ stdenv, lib
+, buildPackages
+, newScope, callPackage
+, CoreFoundation, Security, SystemConfiguration
+, pkgsBuildTarget, pkgsBuildBuild, pkgsBuildHost
+, makeRustPlatform
+, llvmPackages_11
+, llvmPackages_14, llvm_14
+} @ args:
+
+import ./default.nix {
+  rustcVersion = "1.61.0";
+  rustcSha256 = "1vfs05hkf9ilk19b2vahqn8l6k17pl9nc1ky9kgspaascx8l62xd";
+
+  llvmSharedForBuild = pkgsBuildBuild.llvmPackages_14.libllvm.override { enableSharedLibraries = true; };
+  llvmSharedForHost = pkgsBuildHost.llvmPackages_14.libllvm.override { enableSharedLibraries = true; };
+  llvmSharedForTarget = pkgsBuildTarget.llvmPackages_14.libllvm.override { enableSharedLibraries = true; };
+
+  llvmBootstrapForDarwin = llvmPackages_11;
+
+  # For use at runtime
+  llvmShared = llvm_14.override { enableSharedLibraries = true; };
+
+  # Expose llvmPackages used for rustc from rustc via passthru for LTO in Firefox
+  llvmPackages = llvmPackages_14;
+
+  # Note: the version MUST be one version prior to the version we're
+  # building
+  bootstrapVersion = "1.60.0";
+
+  # fetch hashes by running `print-hashes.sh ${bootstrapVersion}`
+  bootstrapHashes = {
+    i686-unknown-linux-gnu = "2a635269dc9ad8f7bbdf168cdf120e1ec803d36adc832c0804f38e0acc3e2357";
+    x86_64-unknown-linux-gnu = "b8a4c3959367d053825e31f90a5eb86418eb0d80cacda52bfa80b078e18150d5";
+    x86_64-unknown-linux-musl = "f0feefcb1985c5c894ad9b0f44e6f09900b31c0eb5f49827da9f37d332a63894";
+    arm-unknown-linux-gnueabihf = "161b2b97d4512080350cc6656b0765ebae870335e86c2896bed08b32c66fbdf4";
+    armv7-unknown-linux-gnueabihf = "f2d76e9458949675bab8fcae44f600d30d91f62bf93c127b6b1fe3130e67d5d9";
+    aarch64-unknown-linux-gnu = "99c419c2f35d4324446481c39402c7baecd7a8baed7edca9f8d6bbd33c05550c";
+    aarch64-unknown-linux-musl = "fe7e9bad8beea84973f7ffa39879929de4ac8afad872650fb0af6b068f05faa6";
+    x86_64-apple-darwin = "0b10dc45cddc4d2355e38cac86d71a504327cb41d41d702d4050b9847ad4258c";
+    aarch64-apple-darwin = "b532672c278c25683ca63d78e82bae829eea1a32308e844954fb66cfe34ad222";
+    powerpc64le-unknown-linux-gnu = "80125e90285b214c2b1f56ab86a09c8509aa17aec9d7127960a86a7008e8f7de";
+    riscv64gc-unknown-linux-gnu = "9cc7c6804bcbbecb9c35232035fc488dbcc8487606cc6be3da553cc446bf0fcd";
+    mips64el-unknown-linux-gnuabi64 = "d413681c22511259f7cd15414a00050cf151d46ac0f9282e765faeb86688deac";
+  };
+
+  selectRustPackage = pkgs: pkgs.rust_1_61;
+
+  rustcPatches = [
+  ];
+}
+
+(builtins.removeAttrs args [ "fetchpatch" "pkgsBuildHost" "llvmPackages_11" "llvmPackages_14" "llvm_14"])

pkgs/development/compilers/rust/binary.nix

@@ -0,0 +1,108 @@
+{ lib, stdenv, makeWrapper, bash, curl, darwin, zlib
+, version
+, src
+, platform
+, versionType
+}:
+
+let
+  inherit (lib) optionalString;
+  inherit (darwin.apple_sdk.frameworks) Security;
+
+  bootstrapping = versionType == "bootstrap";
+
+  installComponents
+    = "rustc,rust-std-${platform}"
+    + (optionalString bootstrapping ",cargo")
+    ;
+in
+
+rec {
+  rustc = stdenv.mkDerivation {
+    pname = "rustc-${versionType}";
+
+    inherit version;
+    inherit src;
+
+    meta = with lib; {
+      homepage = "http://www.rust-lang.org/";
+      description = "A safe, concurrent, practical language";
+      maintainers = with maintainers; [ qknight ];
+      license = [ licenses.mit licenses.asl20 ];
+    };
+
+    buildInputs = [ bash ]
+      ++ lib.optional stdenv.isDarwin Security;
+
+    postPatch = ''
+      patchShebangs .
+    '';
+
+    installPhase = ''
+      ./install.sh --prefix=$out \
+        --components=${installComponents}
+
+      ${optionalString (stdenv.isLinux && bootstrapping) (''
+        patchelf \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
+          "$out/bin/rustc"
+        '' + optionalString (lib.versionAtLeast version "1.46")
+        # rustc bootstrap needs libz starting from 1.46
+        ''
+          ln -s ${zlib}/lib/libz.so.1 $out/lib/libz.so.1
+          ln -s ${zlib}/lib/libz.so $out/lib/libz.so
+        '' + ''
+        patchelf \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
+          "$out/bin/rustdoc"
+        patchelf \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
+          "$out/bin/cargo"
+      '')}
+
+      # Do NOT, I repeat, DO NOT use `wrapProgram` on $out/bin/rustc
+      # (or similar) here. It causes strange effects where rustc loads
+      # the wrong libraries in a bootstrap-build causing failures that
+      # are very hard to track down. For details, see
+      # https://github.com/rust-lang/rust/issues/34722#issuecomment-232164943
+    '';
+
+    setupHooks = ./setup-hook.sh;
+  };
+
+  cargo = stdenv.mkDerivation {
+    pname = "cargo-${versionType}";
+
+    inherit version;
+    inherit src;
+
+    meta = with lib; {
+      homepage = "http://www.rust-lang.org/";
+      description = "A safe, concurrent, practical language";
+      maintainers = with maintainers; [ qknight ];
+      license = [ licenses.mit licenses.asl20 ];
+    };
+
+    nativeBuildInputs = [ makeWrapper ];
+    buildInputs = [ bash ] ++ lib.optional stdenv.isDarwin Security;
+
+    postPatch = ''
+      patchShebangs .
+    '';
+
+    installPhase = ''
+      patchShebangs ./install.sh
+      ./install.sh --prefix=$out \
+        --components=cargo
+
+      ${optionalString (stdenv.isLinux && bootstrapping) ''
+        patchelf \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
+          "$out/bin/cargo"
+      ''}
+
+      wrapProgram "$out/bin/cargo" \
+        --suffix PATH : "${rustc}/bin"
+    '';
+  };
+}

pkgs/development/compilers/rust/bootstrap.nix

@@ -0,0 +1,14 @@
+{ stdenv, fetchurl, rust, callPackage, version, hashes }:
+
+let
+  platform = rust.toRustTarget stdenv.hostPlatform;
+
+  src = fetchurl {
+     url = "https://static.rust-lang.org/dist/rust-${version}-${platform}.tar.gz";
+     sha256 = hashes.${platform} or (throw "missing bootstrap url for platform ${platform}");
+  };
+
+in callPackage ./binary.nix
+  { inherit version src platform;
+    versionType = "bootstrap";
+  }

pkgs/development/compilers/rust/cargo.nix

@@ -0,0 +1,76 @@
+{ lib, stdenv, pkgsHostHost
+, file, curl, pkg-config, python3, openssl, cmake, zlib
+, installShellFiles, makeWrapper, cacert, rustPlatform, rustc
+, CoreFoundation, Security
+}:
+
+rustPlatform.buildRustPackage {
+  pname = "cargo";
+  inherit (rustc) version src;
+
+  # the rust source tarball already has all the dependencies vendored, no need to fetch them again
+  cargoVendorDir = "vendor";
+  buildAndTestSubdir = "src/tools/cargo";
+
+  passthru.rustc = rustc;
+
+  # changes hash of vendor directory otherwise
+  dontUpdateAutotoolsGnuConfigScripts = true;
+
+  nativeBuildInputs = [
+    pkg-config cmake installShellFiles makeWrapper
+    (lib.getDev pkgsHostHost.curl)
+  ];
+  buildInputs = [ cacert file curl python3 openssl zlib ]
+    ++ lib.optionals stdenv.isDarwin [ CoreFoundation Security ];
+
+  # cargo uses git-rs which is made for a version of libgit2 from recent master that
+  # is not compatible with the current version in nixpkgs.
+  #LIBGIT2_SYS_USE_PKG_CONFIG = 1;
+
+  # fixes: the cargo feature `edition` requires a nightly version of Cargo, but this is the `stable` channel
+  RUSTC_BOOTSTRAP = 1;
+
+  postInstall = ''
+    # NOTE: We override the `http.cainfo` option usually specified in
+    # `.cargo/config`. This is an issue when users want to specify
+    # their own certificate chain as environment variables take
+    # precedence
+    wrapProgram "$out/bin/cargo" \
+      --suffix PATH : "${rustc}/bin" \
+      --set CARGO_HTTP_CAINFO "${cacert}/etc/ssl/certs/ca-bundle.crt" \
+      --set SSL_CERT_FILE "${cacert}/etc/ssl/certs/ca-bundle.crt"
+
+    installManPage src/tools/cargo/src/etc/man/*
+
+    installShellCompletion --bash --name cargo \
+      src/tools/cargo/src/etc/cargo.bashcomp.sh
+
+    installShellCompletion --zsh src/tools/cargo/src/etc/_cargo
+  '';
+
+  checkPhase = ''
+    # Disable cross compilation tests
+    export CFG_DISABLE_CROSS_TESTS=1
+    cargo test
+  '';
+
+  # Disable check phase as there are failures (4 tests fail)
+  doCheck = false;
+
+  doInstallCheck = !stdenv.hostPlatform.isStatic &&
+    stdenv.hostPlatform.parsed.kernel.execFormat == lib.systems.parse.execFormats.elf;
+  installCheckPhase = ''
+    runHook preInstallCheck
+    readelf -a $out/bin/.cargo-wrapped | grep -F 'Shared library: [libcurl.so'
+    runHook postInstallCheck
+  '';
+
+  meta = with lib; {
+    homepage = "https://crates.io";
+    description = "Downloads your Rust project's dependencies and builds your project";
+    maintainers = with maintainers; [ retrry ];
+    license = [ licenses.mit licenses.asl20 ];
+    platforms = platforms.unix;
+  };
+}

pkgs/development/compilers/rust/clippy.nix

@@ -0,0 +1,34 @@
+{ stdenv, lib, rustPlatform, rustc, Security, patchelf }:
+rustPlatform.buildRustPackage {
+  pname = "clippy";
+  inherit (rustc) version src;
+
+  # the rust source tarball already has all the dependencies vendored, no need to fetch them again
+  cargoVendorDir = "vendor";
+  buildAndTestSubdir = "src/tools/clippy";
+
+  # changes hash of vendor directory otherwise
+  dontUpdateAutotoolsGnuConfigScripts = true;
+
+  buildInputs = [ rustc rustc.llvm ] ++ lib.optionals stdenv.isDarwin [ Security ];
+
+  # fixes: error: the option `Z` is only accepted on the nightly compiler
+  RUSTC_BOOTSTRAP = 1;
+
+  # Without disabling the test the build fails with:
+  # error: failed to run custom build command for `rustc_llvm v0.0.0
+  #   (/private/tmp/nix-build-clippy-1.36.0.drv-0/rustc-1.36.0-src/src/librustc_llvm)
+  doCheck = false;
+
+  preFixup = lib.optionalString stdenv.isDarwin ''
+    install_name_tool -add_rpath "${rustc}/lib" $out/bin/clippy-driver
+  '';
+
+  meta = with lib; {
+    homepage = "https://rust-lang.github.io/rust-clippy/";
+    description = "A bunch of lints to catch common mistakes and improve your Rust code";
+    maintainers = with maintainers; [ basvandijk ];
+    license = with licenses; [ mit asl20 ];
+    platforms = platforms.unix;
+  };
+}

pkgs/development/compilers/rust/default.nix

@@ -0,0 +1,89 @@
+{ rustcVersion
+, rustcSha256
+, enableRustcDev ? true
+, bootstrapVersion
+, bootstrapHashes
+, selectRustPackage
+, rustcPatches ? []
+, llvmBootstrapForDarwin
+, llvmShared
+, llvmSharedForBuild
+, llvmSharedForHost
+, llvmSharedForTarget
+, llvmPackages # Exposed through rustc for LTO in Firefox
+}:
+{ stdenv, lib
+, buildPackages
+, newScope, callPackage
+, CoreFoundation, Security, SystemConfiguration
+, pkgsBuildTarget, pkgsBuildBuild
+, makeRustPlatform
+}:
+
+let
+  # Use `import` to make sure no packages sneak in here.
+  lib' = import ../../../build-support/rust/lib { inherit lib; };
+in
+{
+  lib = lib';
+
+  # Backwards compat before `lib` was factored out.
+  inherit (lib') toTargetArch toTargetOs toRustTarget toRustTargetSpec;
+
+  # This just contains tools for now. But it would conceivably contain
+  # libraries too, say if we picked some default/recommended versions from
+  # `cratesIO` to build by Hydra and/or try to prefer/bias in Cargo.lock for
+  # all vendored Carnix-generated nix.
+  #
+  # In the end game, rustc, the rust standard library (`core`, `std`, etc.),
+  # and cargo would themselves be built with `buildRustCreate` like
+  # everything else. Tools and `build.rs` and procedural macro dependencies
+  # would be taken from `buildRustPackages` (and `bootstrapRustPackages` for
+  # anything provided prebuilt or their build-time dependencies to break
+  # cycles / purify builds). In this way, nixpkgs would be in control of all
+  # bootstrapping.
+  packages = {
+    prebuilt = callPackage ./bootstrap.nix {
+      version = bootstrapVersion;
+      hashes = bootstrapHashes;
+    };
+    stable = lib.makeScope newScope (self: let
+      # Like `buildRustPackages`, but may also contain prebuilt binaries to
+      # break cycle. Just like `bootstrapTools` for nixpkgs as a whole,
+      # nothing in the final package set should refer to this.
+      bootstrapRustPackages = self.buildRustPackages.overrideScope' (_: _:
+        lib.optionalAttrs (stdenv.buildPlatform == stdenv.hostPlatform)
+          (selectRustPackage buildPackages).packages.prebuilt);
+      bootRustPlatform = makeRustPlatform bootstrapRustPackages;
+    in {
+      # Packages suitable for build-time, e.g. `build.rs`-type stuff.
+      buildRustPackages = (selectRustPackage buildPackages).packages.stable;
+      # Analogous to stdenv
+      rustPlatform = makeRustPlatform self.buildRustPackages;
+      rustc = self.callPackage ./rustc.nix ({
+        version = rustcVersion;
+        sha256 = rustcSha256;
+        inherit enableRustcDev;
+        inherit llvmShared llvmSharedForBuild llvmSharedForHost llvmSharedForTarget llvmPackages;
+
+        patches = rustcPatches;
+
+        # Use boot package set to break cycle
+        rustPlatform = bootRustPlatform;
+      } // lib.optionalAttrs (stdenv.cc.isClang && stdenv.hostPlatform == stdenv.buildPlatform) {
+        stdenv = llvmBootstrapForDarwin.stdenv;
+        pkgsBuildBuild = pkgsBuildBuild // { targetPackages.stdenv = llvmBootstrapForDarwin.stdenv; };
+        pkgsBuildHost = pkgsBuildBuild // { targetPackages.stdenv = llvmBootstrapForDarwin.stdenv; };
+        pkgsBuildTarget = pkgsBuildTarget // { targetPackages.stdenv = llvmBootstrapForDarwin.stdenv; };
+      });
+      rustfmt = self.callPackage ./rustfmt.nix { inherit Security; };
+      cargo = self.callPackage ./cargo.nix {
+        # Use boot package set to break cycle
+        rustPlatform = bootRustPlatform;
+        inherit CoreFoundation Security;
+      };
+      clippy = self.callPackage ./clippy.nix { inherit Security; };
+      rls = self.callPackage ./rls { inherit CoreFoundation Security SystemConfiguration; };
+    });
+  };
+}

pkgs/development/compilers/rust/make-rust-platform.nix

@@ -0,0 +1,35 @@
+{ buildPackages, callPackage, stdenv, runCommand }@prev:
+
+{ rustc, cargo, stdenv ? prev.stdenv, ... }:
+
+rec {
+  rust = {
+    inherit rustc cargo;
+  };
+
+  fetchCargoTarball = buildPackages.callPackage ../../../build-support/rust/fetch-cargo-tarball {
+    git = buildPackages.gitMinimal;
+    inherit cargo;
+  };
+
+  buildRustPackage = callPackage ../../../build-support/rust/build-rust-package {
+    git = buildPackages.gitMinimal;
+    inherit stdenv cargoBuildHook cargoCheckHook cargoInstallHook cargoSetupHook
+      fetchCargoTarball importCargoLock rustc;
+  };
+
+  importCargoLock = buildPackages.callPackage ../../../build-support/rust/import-cargo-lock.nix {};
+
+  rustcSrc = callPackage ./rust-src.nix {
+    inherit runCommand rustc;
+  };
+
+  rustLibSrc = callPackage ./rust-lib-src.nix {
+    inherit runCommand rustc;
+  };
+
+  # Hooks
+  inherit (callPackage ../../../build-support/rust/hooks {
+    inherit stdenv cargo rustc;
+  }) cargoBuildHook cargoCheckHook cargoInstallHook cargoSetupHook maturinBuildHook bindgenHook;
+}

pkgs/development/compilers/rust/print-hashes.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# All rust-related downloads can be found at
+# https://static.rust-lang.org/dist/index.html.  To find the date on
+# which a particular thing was last updated, look for the *-date.txt
+# file, e.g.
+# https://static.rust-lang.org/dist/channel-rust-beta-date.txt
+
+PLATFORMS=(
+  i686-unknown-linux-gnu
+  x86_64-unknown-linux-gnu
+  x86_64-unknown-linux-musl
+  arm-unknown-linux-gnueabihf
+  armv7-unknown-linux-gnueabihf
+  aarch64-unknown-linux-gnu
+  aarch64-unknown-linux-musl
+  x86_64-apple-darwin
+  aarch64-apple-darwin
+  powerpc64le-unknown-linux-gnu
+  riscv64gc-unknown-linux-gnu
+  mips64el-unknown-linux-gnuabi64
+)
+BASEURL=https://static.rust-lang.org/dist
+VERSION=${1:-}
+DATE=${2:-}
+
+if [[ -z $VERSION ]]
+then
+    echo "No version supplied"
+    exit -1
+fi
+
+if [[ -n $DATE ]]
+then
+    BASEURL=$BASEURL/$DATE
+fi
+
+for PLATFORM in "${PLATFORMS[@]}"
+do
+    URL="$BASEURL/rust-$VERSION-$PLATFORM.tar.gz.sha256"
+    SHA256=$(curl -sSfL $URL | cut -d ' ' -f 1)
+    echo "$PLATFORM = \"$SHA256\";"
+done

pkgs/development/compilers/rust/rls/default.nix

@@ -0,0 +1,53 @@
+{ lib, stdenv, makeWrapper, fetchFromGitHub, rustPlatform
+, openssh, openssl, pkg-config, cmake, zlib, curl, libiconv
+, CoreFoundation, Security, SystemConfiguration }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "rls";
+  inherit (rustPlatform.rust.rustc) src version;
+
+  # changes hash of vendor directory otherwise
+  dontUpdateAutotoolsGnuConfigScripts = true;
+
+  cargoVendorDir = "vendor";
+  buildAndTestSubdir = "src/tools/rls";
+
+  preBuild = ''
+    # client tests are flaky
+    rm ${buildAndTestSubdir}/tests/client.rs
+  '';
+
+  # a nightly compiler is required unless we use this cheat code.
+  RUSTC_BOOTSTRAP=1;
+
+  # As of rustc 1.45.0, these env vars are required to build rls
+  # (due to https://github.com/rust-lang/rust/pull/72001)
+  CFG_RELEASE = "${rustPlatform.rust.rustc.version}-nightly";
+  CFG_RELEASE_CHANNEL = "nightly";
+
+  # rls-rustc links to rustc_private crates
+  CARGO_BUILD_RUSTFLAGS = if stdenv.isDarwin then "-C rpath" else null;
+
+  nativeBuildInputs = [ pkg-config cmake makeWrapper ];
+  buildInputs = [ openssh openssl curl zlib libiconv rustPlatform.rust.rustc.llvm ]
+    ++ lib.optionals stdenv.isDarwin [ CoreFoundation Security SystemConfiguration ];
+
+  doCheck = true;
+
+  doInstallCheck = true;
+  installCheckPhase = ''
+    $out/bin/rls --version
+  '';
+
+  RUST_SRC_PATH = rustPlatform.rustLibSrc;
+  postInstall = ''
+    wrapProgram $out/bin/rls --set-default RUST_SRC_PATH ${rustPlatform.rustLibSrc}
+  '';
+
+  meta = with lib; {
+    description = "Rust Language Server - provides information about Rust programs to IDEs and other tools";
+    homepage = "https://github.com/rust-lang/rls/";
+    license = with licenses; [ asl20 /* or */ mit ];
+    maintainers = with maintainers; [ symphorien ];
+  };
+}

pkgs/development/compilers/rust/rust-lib-src.nix

@@ -0,0 +1,6 @@
+{ runCommand, rustc }:
+
+runCommand "rust-lib-src" { } ''
+  tar --strip-components=1 -xzf ${rustc.src}
+  mv library $out
+''

pkgs/development/compilers/rust/rust-src.nix

@@ -0,0 +1,21 @@
+{ lib, runCommand, rustc, minimalContent ? true }:
+
+runCommand "rust-src" { } ''
+  tar -xzf ${rustc.src}
+  mv rustc-${rustc.version}-src $out
+  rm -rf $out/{${lib.concatStringsSep "," ([
+    "ci"
+    "doc"
+    "etc"
+    "grammar"
+    "llvm-project"
+    "llvm-emscripten"
+    "rtstartup"
+    "rustllvm"
+    "test"
+    "vendor"
+  ] ++ lib.optionals minimalContent [
+    "tools"
+    "stdarch"
+  ])}}
+''

pkgs/development/compilers/rust/rustc.nix

@@ -0,0 +1,192 @@
+{ lib, stdenv, removeReferencesTo, pkgsBuildBuild, pkgsBuildHost, pkgsBuildTarget
+, llvmShared, llvmSharedForBuild, llvmSharedForHost, llvmSharedForTarget, llvmPackages
+, fetchurl, file, python3
+, darwin, cmake, rust, rustPlatform
+, pkg-config, openssl
+, libiconv
+, which, libffi
+, withBundledLLVM ? false
+, enableRustcDev ? true
+, version
+, sha256
+, patches ? []
+}:
+
+let
+  inherit (lib) optionals optional optionalString concatStringsSep;
+  inherit (darwin.apple_sdk.frameworks) Security;
+in stdenv.mkDerivation rec {
+  pname = "rustc";
+  inherit version;
+
+  src = fetchurl {
+    url = "https://static.rust-lang.org/dist/rustc-${version}-src.tar.gz";
+    inherit sha256;
+  };
+
+  __darwinAllowLocalNetworking = true;
+
+  # rustc complains about modified source files otherwise
+  dontUpdateAutotoolsGnuConfigScripts = true;
+
+  # Running the default `strip -S` command on Darwin corrupts the
+  # .rlib files in "lib/".
+  #
+  # See https://github.com/NixOS/nixpkgs/pull/34227
+  #
+  # Running `strip -S` when cross compiling can harm the cross rlibs.
+  # See: https://github.com/NixOS/nixpkgs/pull/56540#issuecomment-471624656
+  stripDebugList = [ "bin" ];
+
+  NIX_LDFLAGS = toString (
+       # when linking stage1 libstd: cc: undefined reference to `__cxa_begin_catch'
+       optional (stdenv.isLinux && !withBundledLLVM) "--push-state --as-needed -lstdc++ --pop-state"
+    ++ optional (stdenv.isDarwin && !withBundledLLVM) "-lc++"
+    ++ optional stdenv.isDarwin "-rpath ${llvmSharedForHost}/lib");
+
+  # Increase codegen units to introduce parallelism within the compiler.
+  RUSTFLAGS = "-Ccodegen-units=10";
+
+  # We need rust to build rust. If we don't provide it, configure will try to download it.
+  # Reference: https://github.com/rust-lang/rust/blob/master/src/bootstrap/configure.py
+  configureFlags = let
+    setBuild  = "--set=target.${rust.toRustTarget stdenv.buildPlatform}";
+    setHost   = "--set=target.${rust.toRustTarget stdenv.hostPlatform}";
+    setTarget = "--set=target.${rust.toRustTarget stdenv.targetPlatform}";
+    ccForBuild  = "${pkgsBuildBuild.targetPackages.stdenv.cc}/bin/${pkgsBuildBuild.targetPackages.stdenv.cc.targetPrefix}cc";
+    cxxForBuild = "${pkgsBuildBuild.targetPackages.stdenv.cc}/bin/${pkgsBuildBuild.targetPackages.stdenv.cc.targetPrefix}c++";
+    ccForHost  = "${pkgsBuildHost.targetPackages.stdenv.cc}/bin/${pkgsBuildHost.targetPackages.stdenv.cc.targetPrefix}cc";
+    cxxForHost = "${pkgsBuildHost.targetPackages.stdenv.cc}/bin/${pkgsBuildHost.targetPackages.stdenv.cc.targetPrefix}c++";
+    ccForTarget  = "${pkgsBuildTarget.targetPackages.stdenv.cc}/bin/${pkgsBuildTarget.targetPackages.stdenv.cc.targetPrefix}cc";
+    cxxForTarget = "${pkgsBuildTarget.targetPackages.stdenv.cc}/bin/${pkgsBuildTarget.targetPackages.stdenv.cc.targetPrefix}c++";
+  in [
+    "--release-channel=stable"
+    "--set=build.rustc=${rustPlatform.rust.rustc}/bin/rustc"
+    "--set=build.cargo=${rustPlatform.rust.cargo}/bin/cargo"
+    "--enable-rpath"
+    "--enable-vendor"
+    "--build=${rust.toRustTargetSpec stdenv.buildPlatform}"
+    "--host=${rust.toRustTargetSpec stdenv.hostPlatform}"
+    # std is built for all platforms in --target. When building a cross-compiler
+    # we need to add the host platform as well so rustc can compile build.rs
+    # scripts.
+    "--target=${concatStringsSep "," ([
+      (rust.toRustTargetSpec stdenv.targetPlatform)
+    ] ++ optionals (stdenv.hostPlatform != stdenv.targetPlatform) [
+      (rust.toRustTargetSpec stdenv.hostPlatform)
+    ])}"
+
+    "${setBuild}.cc=${ccForBuild}"
+    "${setHost}.cc=${ccForHost}"
+    "${setTarget}.cc=${ccForTarget}"
+
+    "${setBuild}.linker=${ccForBuild}"
+    "${setHost}.linker=${ccForHost}"
+    "${setTarget}.linker=${ccForTarget}"
+
+    "${setBuild}.cxx=${cxxForBuild}"
+    "${setHost}.cxx=${cxxForHost}"
+    "${setTarget}.cxx=${cxxForTarget}"
+  ] ++ optionals (!withBundledLLVM) [
+    "--enable-llvm-link-shared"
+    "${setBuild}.llvm-config=${llvmSharedForBuild.dev}/bin/llvm-config"
+    "${setHost}.llvm-config=${llvmSharedForHost.dev}/bin/llvm-config"
+    "${setTarget}.llvm-config=${llvmSharedForTarget.dev}/bin/llvm-config"
+  ] ++ optionals (stdenv.isLinux && !stdenv.targetPlatform.isRedox) [
+    "--enable-profiler" # build libprofiler_builtins
+  ] ++ optionals stdenv.buildPlatform.isMusl [
+    "${setBuild}.musl-root=${pkgsBuildBuild.targetPackages.stdenv.cc.libc}"
+  ] ++ optionals stdenv.hostPlatform.isMusl [
+    "${setHost}.musl-root=${pkgsBuildHost.targetPackages.stdenv.cc.libc}"
+  ] ++ optionals stdenv.targetPlatform.isMusl [
+    "${setTarget}.musl-root=${pkgsBuildTarget.targetPackages.stdenv.cc.libc}"
+  ] ++ optionals (stdenv.isDarwin && stdenv.isx86_64) [
+    # https://github.com/rust-lang/rust/issues/92173
+    "--set rust.jemalloc"
+  ];
+
+  # The bootstrap.py will generated a Makefile that then executes the build.
+  # The BOOTSTRAP_ARGS used by this Makefile must include all flags to pass
+  # to the bootstrap builder.
+  postConfigure = ''
+    substituteInPlace Makefile \
+      --replace 'BOOTSTRAP_ARGS :=' 'BOOTSTRAP_ARGS := --jobs $(NIX_BUILD_CORES)'
+  '';
+
+  # the rust build system complains that nix alters the checksums
+  dontFixLibtool = true;
+
+  inherit patches;
+
+  postPatch = ''
+    patchShebangs src/etc
+
+    ${optionalString (!withBundledLLVM) "rm -rf src/llvm"}
+
+    # Fix the configure script to not require curl as we won't use it
+    sed -i configure \
+      -e '/probe_need CFG_CURL curl/d'
+
+    # Useful debugging parameter
+    # export VERBOSE=1
+  '';
+
+  # rustc unfortunately needs cmake to compile llvm-rt but doesn't
+  # use it for the normal build. This disables cmake in Nix.
+  dontUseCmakeConfigure = true;
+
+  nativeBuildInputs = [
+    file python3 rustPlatform.rust.rustc cmake
+    which libffi removeReferencesTo pkg-config
+  ];
+
+  buildInputs = [ openssl ]
+    ++ optionals stdenv.isDarwin [ libiconv Security ]
+    ++ optional (!withBundledLLVM) llvmShared;
+
+  outputs = [ "out" "man" "doc" ];
+  setOutputFlags = false;
+
+  postInstall = lib.optionalString enableRustcDev ''
+    # install rustc-dev components. Necessary to build rls, clippy...
+    python x.py dist rustc-dev
+    tar xf build/dist/rustc-dev*tar.gz
+    cp -r rustc-dev*/rustc-dev*/lib/* $out/lib/
+    rm $out/lib/rustlib/install.log
+    for m in $out/lib/rustlib/manifest-rust*
+    do
+      sort --output=$m < $m
+    done
+
+  '' + ''
+    # remove references to llvm-config in lib/rustlib/x86_64-unknown-linux-gnu/codegen-backends/librustc_codegen_llvm-llvm.so
+    # and thus a transitive dependency on ncurses
+    find $out/lib -name "*.so" -type f -exec remove-references-to -t ${llvmShared} '{}' '+'
+
+    # remove uninstall script that doesn't really make sense for Nix.
+    rm $out/lib/rustlib/uninstall.sh
+  '';
+
+  configurePlatforms = [];
+
+  # https://github.com/NixOS/nixpkgs/pull/21742#issuecomment-272305764
+  # https://github.com/rust-lang/rust/issues/30181
+  # enableParallelBuilding = false;
+
+  setupHooks = ./setup-hook.sh;
+
+  requiredSystemFeatures = [ "big-parallel" ];
+
+  passthru = {
+    llvm = llvmShared;
+    inherit llvmPackages;
+  };
+
+  meta = with lib; {
+    homepage = "https://www.rust-lang.org/";
+    description = "A safe, concurrent, practical language";
+    maintainers = with maintainers; [ madjar cstrahan globin havvy ];
+    license = [ licenses.mit licenses.asl20 ];
+    platforms = platforms.linux ++ platforms.darwin;
+  };
+}

pkgs/development/compilers/rust/rustfmt.nix

@@ -0,0 +1,30 @@
+{ lib, stdenv, rustPlatform, Security, asNightly ? false }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "rustfmt" + lib.optionalString asNightly "-nightly";
+  inherit (rustPlatform.rust.rustc) version src;
+
+  # the rust source tarball already has all the dependencies vendored, no need to fetch them again
+  cargoVendorDir = "vendor";
+  buildAndTestSubdir = "src/tools/rustfmt";
+
+  # changes hash of vendor directory otherwise
+  dontUpdateAutotoolsGnuConfigScripts = true;
+
+  buildInputs = lib.optional stdenv.isDarwin Security;
+
+  # As of 1.0.0 and rustc 1.30 rustfmt requires a nightly compiler
+  RUSTC_BOOTSTRAP = 1;
+
+  # As of rustc 1.45.0, these env vars are required to build rustfmt (due to
+  # https://github.com/rust-lang/rust/pull/72001)
+  CFG_RELEASE = rustPlatform.rust.rustc.version;
+  CFG_RELEASE_CHANNEL = if asNightly then "nightly" else "stable";
+
+  meta = with lib; {
+    description = "A tool for formatting Rust code according to style guidelines";
+    homepage = "https://github.com/rust-lang-nursery/rustfmt";
+    license = with licenses; [ mit asl20 ];
+    maintainers = with maintainers; [ globin basvandijk ];
+  };
+}

pkgs/development/compilers/rust/setup-hook.sh

@@ -0,0 +1,4 @@
+# Fix 'failed to open: /homeless-shelter/.cargo/.package-cache' in rust 1.36.
+if [[ -z ${IN_NIX_SHELL-} && -z ${CARGO_HOME-} ]]; then
+    export CARGO_HOME=$TMPDIR
+fi