rust: 1.77.0 -> 1.80.1

pkgs/by-name/ru/rust/1_77.nix

@@ -1,60 +0,0 @@
-# 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
-, newScope, callPackage
-, CoreFoundation, Security, SystemConfiguration
-, pkgsBuildTarget, pkgsBuildBuild, pkgsBuildHost, pkgsTargetTarget
-, makeRustPlatform
-, wrapRustcWith
-, llvmPackages_17, llvm_17
-, path
-} @ args:
-
-import ./default.nix {
-  rustcVersion = "1.77.1";
-  rustcSha256 = "7hBuTFafUtujtbKCsQWCD4a9j2s9CcBrjc6C+xuzpKE=";
-
-  llvmSharedForBuild = pkgsBuildBuild.llvmPackages_17.libllvm.override { enableSharedLibraries = true; };
-  llvmSharedForHost = pkgsBuildHost.llvmPackages_17.libllvm.override { enableSharedLibraries = true; };
-  llvmSharedForTarget = pkgsBuildTarget.llvmPackages_17.libllvm.override { enableSharedLibraries = true; };
-
-  # For use at runtime
-  llvmShared = llvm_17.override { enableSharedLibraries = true; };
-
-  # Expose llvmPackages used for rustc from rustc via passthru for LTO in Firefox
-  llvmPackages = llvmPackages_17;
-
-  # Note: the version MUST be one version prior to the version we're
-  # building
-  bootstrapVersion = "1.76.0";
-
-  # fetch hashes by running `print-hashes.sh ${bootstrapVersion}`
-  bootstrapHashes = {
-    i686-unknown-linux-gnu = "4c3eefc9341b8809235e6c4fbcbc19ab52a5cbe771292c400df068c12984fa3e";
-    x86_64-unknown-linux-gnu = "9d589d2036b503cc45ecc94992d616fb3deec074deb36cacc2f5c212408f7399";
-    x86_64-unknown-linux-musl = "aa8568f4d262468aaf4f622bd421c5435b24454d8fbcdae48da1162962205384";
-    arm-unknown-linux-gnueabihf = "7d1da067362fc64bcad198d90a61e024d5712aed76e17b28e1cd7e8ba263cc6f";
-    armv7-unknown-linux-gnueabihf = "c03346d56d4a860cd3a8d2d2a7ea75c510b68204e3ad97b3770076595261c913";
-    aarch64-unknown-linux-gnu = "2e8313421e8fb673efdf356cdfdd4bc16516f2610d4f6faa01327983104c05a0";
-    aarch64-unknown-linux-musl = "a1d1c8ccb8ea00cfa2b79d80411b8eb22b2bef5214f86536825361e98d7c617a";
-    x86_64-apple-darwin = "7bdbe085695df8e46389115e99eda7beed37a9494f6b961b45554c658e53b8e7";
-    aarch64-apple-darwin = "17496f15c3cb6ff73d5c36f5b54cc110f1ac31fa09521a7991c0d7ddd890dceb";
-    powerpc64le-unknown-linux-gnu = "44b3494675284d26b04747a824dc974e32fd8fd46fc0aa06a7c8ebe851332d2c";
-    riscv64gc-unknown-linux-gnu = "4a9db321874fc441235b71eb8aa295fc50251305e461540b25b4eef89fb56255";
-  };
-
-  selectRustPackage = pkgs: pkgs.rust_1_77;
-
-  rustcPatches = [ ];
-}
-
-(builtins.removeAttrs args [ "llvmPackages_17" "llvm_17"])

pkgs/by-name/ru/rust/1_80.nix

@@ -0,0 +1,138 @@
+# 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,
+  newScope,
+  callPackage,
+  CoreFoundation,
+  Security,
+  SystemConfiguration,
+  pkgsBuildTarget,
+  pkgsBuildBuild,
+  pkgsBuildHost,
+  pkgsTargetTarget,
+  makeRustPlatform,
+  wrapRustcWith,
+  llvmPackages_18,
+  llvm_18,
+  wrapCCWith,
+  overrideCC,
+  path,
+}@args:
+let
+  llvmSharedFor =
+    pkgSet:
+    pkgSet.llvmPackages_18.libllvm.override (
+      {
+        enableSharedLibraries = true;
+      }
+      // lib.optionalAttrs (stdenv.targetPlatform.useLLVM or false) {
+        # Force LLVM to compile using clang + LLVM libs when targeting pkgsLLVM
+        stdenv = pkgSet.stdenv.override {
+          allowedRequisites = null;
+          cc = pkgSet.llvmPackages_18.clangUseLLVM;
+        };
+      }
+    );
+in
+import ./default.nix
+  {
+    rustcVersion = "1.80.1";
+    rustcSha256 = "sha256-LAuPZDlC3LgQy8xQ8pJWSxtuRNtdX0UJEVOZbfldLcQ=";
+
+    llvmSharedForBuild = llvmSharedFor pkgsBuildBuild;
+    llvmSharedForHost = llvmSharedFor pkgsBuildHost;
+    llvmSharedForTarget = llvmSharedFor pkgsBuildTarget;
+
+    # For use at runtime
+    llvmShared = llvmSharedFor { inherit llvmPackages_18 stdenv; };
+
+    # Expose llvmPackages used for rustc from rustc via passthru for LTO in Firefox
+    llvmPackages =
+      if (stdenv.targetPlatform.useLLVM or false) then
+        callPackage (
+          {
+            pkgs,
+            bootBintoolsNoLibc ? if stdenv.targetPlatform.linker == "lld" then null else pkgs.bintoolsNoLibc,
+            bootBintools ? if stdenv.targetPlatform.linker == "lld" then null else pkgs.bintools,
+          }:
+          let
+            llvmPackages = llvmPackages_18;
+
+            setStdenv =
+              pkg:
+              pkg.override {
+                stdenv = stdenv.override {
+                  allowedRequisites = null;
+                  cc = llvmPackages.clangUseLLVM;
+                };
+              };
+          in
+          rec {
+            inherit (llvmPackages) bintools;
+
+            libunwind = setStdenv llvmPackages.libunwind;
+            llvm = setStdenv llvmPackages.llvm;
+
+            libcxx = llvmPackages.libcxx.override {
+              stdenv = stdenv.override {
+                allowedRequisites = null;
+                cc = llvmPackages.clangNoLibcxx;
+                hostPlatform = stdenv.hostPlatform // {
+                  useLLVM = !stdenv.isDarwin;
+                };
+              };
+              inherit libunwind;
+            };
+
+            clangUseLLVM = llvmPackages.clangUseLLVM.override { inherit libcxx; };
+
+            stdenv = overrideCC args.stdenv clangUseLLVM;
+          }
+        ) { }
+      else
+        llvmPackages_18;
+
+    # Note: the version MUST be one version prior to the version we're
+    # building
+    bootstrapVersion = "1.79.0";
+
+    # fetch hashes by running `print-hashes.sh ${bootstrapVersion}`
+    bootstrapHashes = {
+      i686-unknown-linux-gnu = "0a1e371809446cd77dba7abce2afb4efac8d8b2e63483cfe19f1c98bf9ab7855";
+      x86_64-unknown-linux-gnu = "628efa8ef0658a7c4199883ee132281f19931448d3cfee4ecfd768898fe74c18";
+      x86_64-unknown-linux-musl = "2e4b0e40d027e2b31a40163986b4c04dfd0bce41c706a99f2e82ba473a4383de";
+      arm-unknown-linux-gnueabihf = "ce8d8d296277a06e0d2f63a21a0586717e09be3df28c0d1a04bc2c6f85eecc15";
+      armv7-unknown-linux-gnueabihf = "31968f88b22058e384dfb3cdf3efe7f60c03481d790300fcffc420d5ba3851f2";
+      aarch64-unknown-linux-gnu = "f7d3b31581331b54af97cf3162e65b8c26c8aa14d42f71c1ce9adc1078ef54e5";
+      aarch64-unknown-linux-musl = "f8100c806754cd21600ded26546467a1a242db9b9ab8a6a666656e3cc4edfa52";
+      x86_64-apple-darwin = "62f018aad30bafa0ef8bff0ed60d5d45e6cadc799769aad9d945509203e9f921";
+      aarch64-apple-darwin = "e70a9362975b94df7dbc6e2ed5ceab4254dd32f72ba497ff4a70440ace3f729f";
+      powerpc64le-unknown-linux-gnu = "9865eeebb5bb20006367d3148d9116576499ec958d847e22b645f008a1bc4170";
+      riscv64gc-unknown-linux-gnu = "c8d38e600ef4dea8b375df2d08153393816ffd3dcab18e4d081ddc19e28b5a40";
+      x86_64-unknown-freebsd = "3c8005f488b8dda0fc6d47928868200852106cac2b568934ae9a2e5c89d3a50d";
+    };
+
+    selectRustPackage = pkgs: pkgs.rust_1_80;
+
+    rustcPatches = [ ];
+  }
+
+  (
+    builtins.removeAttrs args [
+      "llvmPackages_18"
+      "llvm_18"
+      "wrapCCWith"
+      "overrideCC"
+    ]
+  )

pkgs/by-name/ru/rust/binary.nix

@@ -1,23 +1,26 @@
-{ lib, stdenv, makeWrapper, wrapRustc, bash, curl, darwin, zlib
+{
-, autoPatchelfHook, gcc
+  lib,
-, version
+  stdenv,
-, src
+  makeWrapper,
-, platform
+  wrapRustc,
-, versionType
+  bash,
+  darwin,
+  zlib,
+  autoPatchelfHook,
+  gcc,
+  version,
+  src,
+  platform,
+  versionType,
 }:
-
 let
   inherit (lib) optionalString;
   inherit (darwin.apple_sdk.frameworks) Security;
 
   bootstrapping = versionType == "bootstrap";
 
-  installComponents
+  installComponents = "rustc,rust-std-${platform}" + (optionalString bootstrapping ",cargo");
-    = "rustc,rust-std-${platform}"
-    + (optionalString bootstrapping ",cargo")
-    ;
 in
-
 rec {
   rustc-unwrapped = stdenv.mkDerivation {
     pname = "rustc-${versionType}";
@@ -25,17 +28,22 @@ rec {
     inherit version;
     inherit src;
 
-    meta = with lib; {
+    meta = {
       homepage = "https://www.rust-lang.org/";
-      sourceProvenance = with sourceTypes; [ binaryNativeCode ];
+      sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
-      description = "A safe, concurrent, practical language";
+      description = "Safe, concurrent, practical language";
-      maintainers = with maintainers; [ qknight ];
+      maintainers = [ ];
-      license = [ licenses.mit licenses.asl20 ];
+      license = [
+        lib.licenses.mit
+        lib.licenses.asl20
+      ];
     };
 
     nativeBuildInputs = lib.optional (!stdenv.isDarwin) autoPatchelfHook;
-    buildInputs = [ bash ]
+    buildInputs =
-      ++ lib.optionals (!stdenv.isDarwin) [ gcc.cc.lib zlib ]
+      [ bash ]
+      ++ lib.optional (!stdenv.isDarwin && !stdenv.isFreeBSD) gcc.cc.lib
+      ++ lib.optional (!stdenv.isDarwin) zlib
       ++ lib.optional stdenv.isDarwin Security;
 
     postPatch = ''
@@ -73,15 +81,18 @@ rec {
     meta = with lib; {
       homepage = "https://doc.rust-lang.org/cargo/";
       sourceProvenance = with sourceTypes; [ binaryNativeCode ];
-      description = "The Rust package manager";
+      description = "Rust package manager";
       maintainers = with maintainers; [ qknight ];
-      license = [ licenses.mit licenses.asl20 ];
+      license = [
+        licenses.mit
+        licenses.asl20
+      ];
     };
 
-    nativeBuildInputs = [ makeWrapper ]
+    nativeBuildInputs = [ makeWrapper ] ++ lib.optional (!stdenv.isDarwin) autoPatchelfHook;
-      ++ lib.optional (!stdenv.isDarwin) autoPatchelfHook;
+    buildInputs =
-    buildInputs = [ bash ]
+      [ bash ]
-      ++ lib.optional (!stdenv.isDarwin) gcc.cc.lib
+      ++ lib.optional (!stdenv.isDarwin && !stdenv.isFreeBSD) gcc.cc.lib
       ++ lib.optional stdenv.isDarwin Security;
 
     postPatch = ''

pkgs/by-name/ru/rust/cargo-auditable.nix

@@ -1,5 +1,12 @@
-{ lib, buildPackages, fetchFromGitHub, fetchpatch, makeRustPlatform, installShellFiles, stdenv }:
+{
-
+  lib,
+  buildPackages,
+  fetchFromGitHub,
+  fetchpatch,
+  makeRustPlatform,
+  installShellFiles,
+  stdenv,
+}:
 let
   args = rec {
     pname = "cargo-auditable";
@@ -22,44 +29,39 @@ let
 
     cargoHash = "sha256-4o3ctun/8VcBRuj+j0Yaawdkyn6Z6LPp+FTyhPxQWU8=";
 
-    # Cargo.lock is outdated
+    meta = {
-    preConfigure = ''
+      description = "Tool to make production Rust binaries auditable";
-      cargo update --offline
-    '';
-
-    meta = with lib; {
-      description = "A tool to make production Rust binaries auditable";
       mainProgram = "cargo-auditable";
       homepage = "https://github.com/rust-secure-code/cargo-auditable";
       changelog = "https://github.com/rust-secure-code/cargo-auditable/blob/v${version}/cargo-auditable/CHANGELOG.md";
-      license = with licenses; [ mit /* or */ asl20 ];
+      license = with lib.licenses; [
-      maintainers = with maintainers; [ figsoda ];
+        mit # or
+        asl20
+      ];
+      maintainers = with lib.maintainers; [ figsoda ];
       broken = stdenv.hostPlatform != stdenv.buildPlatform;
     };
   };
 
   rustPlatform = makeRustPlatform {
     inherit (buildPackages) rustc;
-    cargo = buildPackages.cargo.override {
+    cargo = buildPackages.cargo.override { auditable = false; };
-      auditable = false;
-    };
   };
 
-  bootstrap = rustPlatform.buildRustPackage (args // {
+  bootstrap = rustPlatform.buildRustPackage (args // { auditable = false; });
-    auditable = false;
-  });
 in
 
-rustPlatform.buildRustPackage.override { cargo-auditable = bootstrap; } (args // {
+rustPlatform.buildRustPackage.override { cargo-auditable = bootstrap; } (
-  nativeBuildInputs = [
+  args
-    installShellFiles
+  // {
-  ];
+    nativeBuildInputs = [ installShellFiles ];
 
-  postInstall = ''
+    postInstall = ''
-    installManPage cargo-auditable/cargo-auditable.1
+      installManPage cargo-auditable/cargo-auditable.1
-  '';
+    '';
 
-  passthru = {
+    passthru = {
-    inherit bootstrap;
+      inherit bootstrap;
-  };
+    };
-})
+  }
+)

pkgs/by-name/ru/rust/cargo.nix

@@ -1,85 +1,114 @@
-{ lib, stdenv, pkgsBuildHost, pkgsHostHost
+{
-, file, curl, pkg-config, python3, openssl, cmake, zlib
+  lib,
-, installShellFiles, makeWrapper, rustPlatform, rustc
+  stdenv,
-, CoreFoundation, Security
+  pkgsHostHost,
-, auditable ? !cargo-auditable.meta.broken
+  file,
-, cargo-auditable
+  curl,
-, pkgsBuildBuild
+  pkg-config,
+  python3,
+  openssl,
+  cmake,
+  zlib,
+  installShellFiles,
+  makeWrapper,
+  rustPlatform,
+  rustc,
+  CoreFoundation,
+  Security,
+  auditable ? !cargo-auditable.meta.broken,
+  cargo-auditable,
+  pkgsBuildBuild,
 }:
 
-rustPlatform.buildRustPackage.override {
+rustPlatform.buildRustPackage.override { cargo-auditable = cargo-auditable.bootstrap; } (
-  cargo-auditable = cargo-auditable.bootstrap;
+  {
-} ({
+    pname = "cargo";
-  pname = "cargo";
+    inherit (rustc.unwrapped) version src;
-  inherit (rustc.unwrapped) version src;
 
-  # the rust source tarball already has all the dependencies vendored, no need to fetch them again
+    # the rust source tarball already has all the dependencies vendored, no need to fetch them again
-  cargoVendorDir = "vendor";
+    cargoVendorDir = "vendor";
-  buildAndTestSubdir = "src/tools/cargo";
+    buildAndTestSubdir = "src/tools/cargo";
 
-  inherit auditable;
+    inherit auditable;
 
-  passthru = {
+    passthru = {
-    rustc = rustc;
+      rustc = rustc;
-    inherit (rustc.unwrapped) tests;
+      inherit (rustc.unwrapped) tests;
-  };
+    };
 
-  # changes hash of vendor directory otherwise
+    # changes hash of vendor directory otherwise
-  dontUpdateAutotoolsGnuConfigScripts = true;
+    dontUpdateAutotoolsGnuConfigScripts = true;
 
-  nativeBuildInputs = [
+    nativeBuildInputs = [
-    pkg-config cmake installShellFiles makeWrapper
+      pkg-config
-    (lib.getDev pkgsHostHost.curl)
+      cmake
-    zlib
+      installShellFiles
-  ];
+      makeWrapper
-  buildInputs = [ file curl python3 openssl zlib ]
+      (lib.getDev pkgsHostHost.curl)
-    ++ lib.optionals stdenv.isDarwin [ CoreFoundation Security ];
+      zlib
+    ];
+    buildInputs =
+      [
+        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
+    # 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.
+    # is not compatible with the current version in nixpkgs.
-  #LIBGIT2_SYS_USE_PKG_CONFIG = 1;
+    #LIBGIT2_SYS_USE_PKG_CONFIG = 1;
 
-  # fixes: the cargo feature `edition` requires a nightly version of Cargo, but this is the `stable` channel
+    # fixes: the cargo feature `edition` requires a nightly version of Cargo, but this is the `stable` channel
-  RUSTC_BOOTSTRAP = 1;
+    RUSTC_BOOTSTRAP = 1;
 
-  postInstall = ''
+    postInstall = ''
-    wrapProgram "$out/bin/cargo" --suffix PATH : "${rustc}/bin"
+      wrapProgram "$out/bin/cargo" --suffix PATH : "${rustc}/bin"
 
-    installManPage src/tools/cargo/src/etc/man/*
+      installManPage src/tools/cargo/src/etc/man/*
 
-    installShellCompletion --bash --name cargo \
+      installShellCompletion --bash --name cargo \
-      src/tools/cargo/src/etc/cargo.bashcomp.sh
+        src/tools/cargo/src/etc/cargo.bashcomp.sh
 
-    installShellCompletion --zsh src/tools/cargo/src/etc/_cargo
+      installShellCompletion --zsh src/tools/cargo/src/etc/_cargo
-  '';
+    '';
 
-  checkPhase = ''
+    checkPhase = ''
-    # Disable cross compilation tests
+      # Disable cross compilation tests
-    export CFG_DISABLE_CROSS_TESTS=1
+      export CFG_DISABLE_CROSS_TESTS=1
-    cargo test
+      cargo test
-  '';
+    '';
 
-  # Disable check phase as there are failures (4 tests fail)
+    # Disable check phase as there are failures (4 tests fail)
-  doCheck = false;
+    doCheck = false;
 
-  doInstallCheck = !stdenv.hostPlatform.isStatic && stdenv.hostPlatform.isElf;
+    doInstallCheck = !stdenv.hostPlatform.isStatic && stdenv.hostPlatform.isElf;
-  installCheckPhase = ''
+    installCheckPhase = ''
-    runHook preInstallCheck
+      runHook preInstallCheck
-    readelf -a $out/bin/.cargo-wrapped | grep -F 'Shared library: [libcurl.so'
+      readelf -a $out/bin/.cargo-wrapped | grep -F 'Shared library: [libcurl.so'
-    runHook postInstallCheck
+      runHook postInstallCheck
-  '';
+    '';
 
-  meta = with lib; {
+    meta = {
-    homepage = "https://crates.io";
+      homepage = "https://crates.io";
-    description = "Downloads your Rust project's dependencies and builds your project";
+      description = "Downloads your Rust project's dependencies and builds your project";
-    mainProgram = "cargo";
+      mainProgram = "cargo";
-    maintainers = teams.rust.members;
+      maintainers = [ ];
-    license = [ licenses.mit licenses.asl20 ];
+      license = [
-    platforms = platforms.unix;
+        lib.licenses.mit
-    # https://github.com/alexcrichton/nghttp2-rs/issues/2
+        lib.licenses.asl20
-    broken = stdenv.hostPlatform.isx86 && stdenv.buildPlatform != stdenv.hostPlatform;
+      ];
-  };
+      platforms = lib.platforms.unix;
-}
+      # https://github.com/alexcrichton/nghttp2-rs/issues/2
-// lib.optionalAttrs (stdenv.buildPlatform.rust.rustcTarget != stdenv.hostPlatform.rust.rustcTarget) {
+      broken = stdenv.hostPlatform.isx86 && stdenv.buildPlatform != stdenv.hostPlatform;
-  HOST_PKG_CONFIG_PATH="${pkgsBuildBuild.pkg-config}/bin/pkg-config";
+    };
-})
+  }
+  // lib.optionalAttrs (
+    stdenv.buildPlatform.rust.rustcTarget != stdenv.hostPlatform.rust.rustcTarget
+  ) { HOST_PKG_CONFIG_PATH = "${pkgsBuildBuild.pkg-config}/bin/pkg-config"; }
+)

pkgs/by-name/ru/rust/clippy.nix

@@ -1,5 +1,10 @@
-{ stdenv, lib, rustPlatform, rustc, Security, patchelf }:
+{
-
+  stdenv,
+  lib,
+  rustPlatform,
+  rustc,
+  Security,
+}:
 rustPlatform.buildRustPackage {
   pname = "clippy";
   inherit (rustc) version src;
@@ -13,8 +18,7 @@ rustPlatform.buildRustPackage {
   # changes hash of vendor directory otherwise
   dontUpdateAutotoolsGnuConfigScripts = true;
 
-  buildInputs = [ rustc.llvm ]
+  buildInputs = [ rustc.llvm ] ++ lib.optionals stdenv.isDarwin [ Security ];
-    ++ lib.optionals stdenv.isDarwin [ Security ];
 
   # fixes: error: the option `Z` is only accepted on the nightly compiler
   RUSTC_BOOTSTRAP = 1;
@@ -35,12 +39,15 @@ rustPlatform.buildRustPackage {
     install_name_tool -add_rpath "${rustc.unwrapped}/lib" "$out/bin/cargo-clippy"
   '';
 
-  meta = with lib; {
+  meta = {
     homepage = "https://rust-lang.github.io/rust-clippy/";
-    description = "A bunch of lints to catch common mistakes and improve your Rust code";
+    description = "Bunch of lints to catch common mistakes and improve your Rust code";
     mainProgram = "cargo-clippy";
-    maintainers = with maintainers; [ basvandijk ] ++ teams.rust.members;
+    maintainers = with lib.maintainers; [ basvandijk ] ++ teams.rust.members;
-    license = with licenses; [ mit asl20 ];
+    license = with lib.licenses; [
-    platforms = platforms.unix;
+      mit
+      asl20
+    ];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/by-name/ru/rust/default.nix

@@ -1,41 +1,61 @@
-{ rustcVersion
+{
-, rustcSha256
+  rustcVersion,
-, enableRustcDev ? true
+  rustcSha256,
-, bootstrapVersion
+  enableRustcDev ? true,
-, bootstrapHashes
+  bootstrapVersion,
-, selectRustPackage
+  bootstrapHashes,
-, rustcPatches ? []
+  selectRustPackage,
-, llvmShared
+  rustcPatches ? [ ],
-, llvmSharedForBuild
+  llvmShared,
-, llvmSharedForHost
+  llvmSharedForBuild,
-, llvmSharedForTarget
+  llvmSharedForHost,
-, llvmPackages # Exposed through rustc for LTO in Firefox
+  llvmSharedForTarget,
+  llvmPackages, # Exposed through rustc for LTO in Firefox
 }:
-{ stdenv, lib
+{
-, newScope, callPackage
+  stdenv,
-, CoreFoundation, Security, SystemConfiguration
+  lib,
-, pkgsBuildBuild
+  newScope,
-, pkgsBuildHost
+  callPackage,
-, pkgsBuildTarget
+  CoreFoundation,
-, pkgsTargetTarget
+  Security,
-, makeRustPlatform
+  SystemConfiguration,
-, wrapRustcWith
+  pkgsBuildBuild,
-, path
+  pkgsBuildHost,
+  pkgsBuildTarget,
+  pkgsTargetTarget,
+  makeRustPlatform,
+  wrapRustcWith,
+  path,
 }:
-
 let
   # Use `import` to make sure no packages sneak in here.
   lib' = import (path + /pkgs/build-support/rust/lib) {
-    inherit lib stdenv pkgsBuildHost pkgsBuildTarget pkgsTargetTarget;
+    inherit
+      lib
+      stdenv
+      pkgsBuildHost
+      pkgsBuildTarget
+      pkgsTargetTarget
+      ;
   };
   # Allow faster cross compiler generation by reusing Build artifacts
-  fastCross = (stdenv.buildPlatform == stdenv.hostPlatform) && (stdenv.hostPlatform != stdenv.targetPlatform);
+  fastCross =
+    (stdenv.buildPlatform == stdenv.hostPlatform) && (stdenv.hostPlatform != stdenv.targetPlatform);
 in
 {
   lib = lib';
 
   # Backwards compat before `lib` was factored out.
-  inherit (lib') toTargetArch toTargetOs toRustTarget toRustTargetSpec IsNoStdTarget toRustTargetForUseInEnvVars envVars;
+  inherit (lib')
+    toTargetArch
+    toTargetOs
+    toRustTarget
+    toRustTargetSpec
+    IsNoStdTarget
+    toRustTargetForUseInEnvVars
+    envVars
+    ;
 
   # This just contains tools for now. But it would conceivably contain
   # libraries too, say if we picked some default/recommended versions to build
@@ -53,55 +73,78 @@ in
       version = bootstrapVersion;
       hashes = bootstrapHashes;
     };
-    stable = lib.makeScope newScope (self: let
+    stable = lib.makeScope newScope (
-      # Like `buildRustPackages`, but may also contain prebuilt binaries to
+      self:
-      # break cycle. Just like `bootstrapTools` for nixpkgs as a whole,
+      let
-      # nothing in the final package set should refer to this.
+        # Like `buildRustPackages`, but may also contain prebuilt binaries to
-      bootstrapRustPackages = if fastCross
+        # break cycle. Just like `bootstrapTools` for nixpkgs as a whole,
-      then pkgsBuildBuild.rustPackages
+        # nothing in the final package set should refer to this.
-      else
+        bootstrapRustPackages =
-        self.buildRustPackages.overrideScope (_: _:
+          if fastCross then
-        lib.optionalAttrs (stdenv.buildPlatform == stdenv.hostPlatform)
+            pkgsBuildBuild.rustPackages
-          (selectRustPackage pkgsBuildHost).packages.prebuilt);
+          else
-      bootRustPlatform = makeRustPlatform bootstrapRustPackages;
+            self.buildRustPackages.overrideScope (
-    in {
+              _: _:
-      # Packages suitable for build-time, e.g. `build.rs`-type stuff.
+              lib.optionalAttrs (stdenv.buildPlatform == stdenv.hostPlatform)
-      buildRustPackages = (selectRustPackage pkgsBuildHost).packages.stable // { __attrsFailEvaluation = true; };
+                (selectRustPackage pkgsBuildHost).packages.prebuilt
-      # Analogous to stdenv
+            );
-      rustPlatform = makeRustPlatform self.buildRustPackages;
+        bootRustPlatform = makeRustPlatform bootstrapRustPackages;
-      rustc-unwrapped = self.callPackage ./rustc.nix ({
+      in
-        version = rustcVersion;
+      {
-        sha256 = rustcSha256;
+        # Packages suitable for build-time, e.g. `build.rs`-type stuff.
-        inherit enableRustcDev;
+        buildRustPackages = (selectRustPackage pkgsBuildHost).packages.stable // {
-        inherit llvmShared llvmSharedForBuild llvmSharedForHost llvmSharedForTarget llvmPackages fastCross;
+          # Prevent `pkgs/top-level/release-attrpaths-superset.nix` from recursing more than one level here.
+          buildRustPackages = self.buildRustPackages // {
+            __attrsFailEvaluation = true;
+          };
+        };
+        # Analogous to stdenv
+        rustPlatform = makeRustPlatform self.buildRustPackages;
+        rustc-unwrapped = self.callPackage ./rustc.nix {
+          version = rustcVersion;
+          sha256 = rustcSha256;
+          inherit enableRustcDev;
+          inherit
+            llvmShared
+            llvmSharedForBuild
+            llvmSharedForHost
+            llvmSharedForTarget
+            llvmPackages
+            fastCross
+            ;
 
-        patches = rustcPatches;
+          patches = rustcPatches;
 
-        # Use boot package set to break cycle
+          # Use boot package set to break cycle
-        inherit (bootstrapRustPackages) cargo rustc rustfmt;
+          inherit (bootstrapRustPackages) cargo rustc rustfmt;
-      });
+        };
-      rustc = wrapRustcWith {
+        rustc = wrapRustcWith {
-        inherit (self) rustc-unwrapped;
+          inherit (self) rustc-unwrapped;
-        sysroot = if fastCross then self.rustc-unwrapped else null;
+          sysroot = if fastCross then self.rustc-unwrapped else null;
-      };
+        };
-      rustfmt = self.callPackage ./rustfmt.nix {
+        rustfmt = self.callPackage ./rustfmt.nix {
-        inherit Security;
+          inherit Security;
-        inherit (self.buildRustPackages) rustc;
+          inherit (self.buildRustPackages) rustc;
-      };
+        };
-      cargo = if (!fastCross) then self.callPackage ./cargo.nix {
+        cargo =
-        # Use boot package set to break cycle
+          if (!fastCross) then
-        rustPlatform = bootRustPlatform;
+            self.callPackage ./cargo.nix {
-        inherit CoreFoundation Security;
+              # Use boot package set to break cycle
-      } else self.callPackage ./cargo_cross.nix {};
+              rustPlatform = bootRustPlatform;
-      cargo-auditable = self.callPackage ./cargo-auditable.nix { };
+              inherit CoreFoundation Security;
-      cargo-auditable-cargo-wrapper = self.callPackage ./cargo-auditable-cargo-wrapper.nix { };
+            }
-      clippy = self.callPackage ./clippy.nix {
+          else
-        # We want to use self, not buildRustPackages, so that
+            self.callPackage ./cargo_cross.nix { };
-        # buildPackages.clippy uses the cross compiler and supports
+        cargo-auditable = self.callPackage ./cargo-auditable.nix { };
-        # linting for the target platform.
+        cargo-auditable-cargo-wrapper = self.callPackage ./cargo-auditable-cargo-wrapper.nix { };
-        rustPlatform = makeRustPlatform self;
+        clippy = self.callPackage ./clippy.nix {
-        inherit Security;
+          # We want to use self, not buildRustPackages, so that
-      };
+          # buildPackages.clippy uses the cross compiler and supports
-    });
+          # linting for the target platform.
+          rustPlatform = makeRustPlatform self;
+          inherit Security;
+        };
+      }
+    );
   };
 }

pkgs/by-name/ru/rust/make-rust-platform.nix

@@ -1,10 +1,19 @@
-{ lib, buildPackages, callPackage, callPackages, cargo-auditable, stdenv, runCommand, path }@prev:
+{
-
+  lib,
-{ rustc
+  buildPackages,
-, cargo
+  callPackage,
-, cargo-auditable ? prev.cargo-auditable
+  callPackages,
-, stdenv ? prev.stdenv
+  cargo-auditable,
-, ...
+  stdenv,
+  runCommand,
+  path,
+}@prev:
+{
+  rustc,
+  cargo,
+  cargo-auditable ? prev.cargo-auditable,
+  stdenv ? prev.stdenv,
+  ...
 }:
 
 rec {
@@ -13,28 +22,45 @@ rec {
     cargo = lib.warn "rustPlatform.rust.cargo is deprecated. Use cargo instead." cargo;
   };
 
-  fetchCargoTarball = buildPackages.callPackage (path + "/pkgs/build-support/rust/fetch-cargo-tarball") {
+  fetchCargoTarball =
-    git = buildPackages.gitMinimal;
+    buildPackages.callPackage (path + "/pkgs/build-support/rust/fetch-cargo-tarball")
-    inherit cargo;
+      {
-  };
+        git = buildPackages.gitMinimal;
+        inherit cargo;
+      };
 
   buildRustPackage = callPackage (path + "/pkgs/build-support/rust/build-rust-package") {
-    inherit stdenv cargoBuildHook cargoCheckHook cargoInstallHook cargoNextestHook cargoSetupHook
+    inherit
-      fetchCargoTarball importCargoLock rustc cargo cargo-auditable;
+      stdenv
+      cargoBuildHook
+      cargoCheckHook
+      cargoInstallHook
+      cargoNextestHook
+      cargoSetupHook
+      fetchCargoTarball
+      importCargoLock
+      rustc
+      cargo
+      cargo-auditable
+      ;
   };
 
-  importCargoLock = buildPackages.callPackage (path + "/pkgs/build-support/rust/import-cargo-lock.nix") { inherit cargo; };
+  importCargoLock = buildPackages.callPackage (
+    path + "/pkgs/build-support/rust/import-cargo-lock.nix"
+  ) { inherit cargo; };
 
-  rustcSrc = callPackage ./rust-src.nix {
+  rustcSrc = callPackage ./rust-src.nix { inherit runCommand rustc; };
-    inherit runCommand rustc;
-  };
 
-  rustLibSrc = callPackage ./rust-lib-src.nix {
+  rustLibSrc = callPackage ./rust-lib-src.nix { inherit runCommand rustc; };
-    inherit runCommand rustc;
-  };
 
   # Hooks
-  inherit (callPackages (path + "/pkgs/build-support/rust/hooks") {
+  inherit (callPackages (path + "/pkgs/build-support/rust/hooks") { inherit stdenv cargo rustc; })
-    inherit stdenv cargo rustc;
+    cargoBuildHook
-  }) cargoBuildHook cargoCheckHook cargoInstallHook cargoNextestHook cargoSetupHook maturinBuildHook bindgenHook;
+    cargoCheckHook
+    cargoInstallHook
+    cargoNextestHook
+    cargoSetupHook
+    maturinBuildHook
+    bindgenHook
+    ;
 }

pkgs/by-name/ru/rust/packages.nix

@@ -1,18 +1,24 @@
 { ... }:
 res: pkgs: super:
 
-with pkgs;
+with pkgs; {
-{
+  rust_1_80 = callPackage ./1_80.nix {
-  rust_1_77 = callPackage ./1_77.nix {
     inherit (darwin.apple_sdk.frameworks) CoreFoundation Security SystemConfiguration;
-    llvm_17 = llvmPackages_17.libllvm;
+    llvm_18 = llvmPackages_18.libllvm;
   };
-  rust = rust_1_77;
+  rust = rust_1_80;
 
-  rustPackages_1_77 = rust_1_77.packages.stable;
+  rustPackages_1_80 = rust_1_80.packages.stable;
-  rustPackages = rustPackages_1_77;
+  rustPackages = rustPackages_1_80;
 
-  inherit (rustPackages) cargo cargo-auditable cargo-auditable-cargo-wrapper clippy rustc rustPlatform;
+  inherit (rustPackages)
+    cargo
+    cargo-auditable
+    cargo-auditable-cargo-wrapper
+    clippy
+    rustc
+    rustPlatform
+    ;
 
   makeRustPlatform = callPackage ./make-rust-platform.nix { };
 }

pkgs/by-name/ru/rust/rustc.nix

@@ -1,30 +1,53 @@
-{ lib, stdenv, removeReferencesTo, pkgsBuildBuild, pkgsBuildHost, pkgsBuildTarget, targetPackages
+{
-, llvmShared, llvmSharedForBuild, llvmSharedForHost, llvmSharedForTarget, llvmPackages
+  lib,
-, fetchurl, file, python3
+  stdenv,
-, darwin, cargo, cmake, rustc, rustfmt
+  removeReferencesTo,
-, pkg-config, openssl, xz
+  pkgsBuildBuild,
-, libiconv
+  pkgsBuildHost,
-, which, libffi
+  pkgsBuildTarget,
-, withBundledLLVM ? false
+  targetPackages,
-, enableRustcDev ? true
+  llvmShared,
-, version
+  llvmSharedForBuild,
-, sha256
+  llvmSharedForHost,
-, patches ? []
+  llvmSharedForTarget,
-# , fd
+  llvmPackages,
-# , ripgrep
+  runCommandLocal,
-# , wezterm
+  fetchurl,
-# , firefox
+  file,
-# , thunderbird
+  python3,
-# This only builds std for target and reuses the rustc from build.
+  darwin,
-, fastCross
+  cargo,
-, lndir
+  cmake,
-, makeWrapper
+  rustc,
+  rustfmt,
+  pkg-config,
+  openssl,
+  xz,
+  zlib,
+  libiconv,
+  which,
+  libffi,
+  withBundledLLVM ? false,
+  enableRustcDev ? true,
+  version,
+  sha256,
+  patches ? [ ],
+  # This only builds std for target and reuses the rustc from build.
+  fastCross,
+  lndir,
+  makeWrapper,
 }:
-
 let
-  inherit (lib) optionals optional optionalString concatStringsSep;
+  inherit (lib)
+    optionals
+    optional
+    optionalString
+    concatStringsSep
+    ;
   inherit (darwin.apple_sdk.frameworks) Security;
-in stdenv.mkDerivation (finalAttrs: {
+  useLLVM = stdenv.targetPlatform.useLLVM or false;
+in
+stdenv.mkDerivation (finalAttrs: {
   pname = "${targetPackages.stdenv.cc.targetPrefix}rustc";
   inherit version;
 
@@ -35,6 +58,12 @@ in stdenv.mkDerivation (finalAttrs: {
     passthru.isReleaseTarball = true;
   };
 
+  hardeningDisable = optionals stdenv.cc.isClang [
+    # remove once https://github.com/NixOS/nixpkgs/issues/318674 is
+    # addressed properly
+    "zerocallusedregs"
+  ];
+
   __darwinAllowLocalNetworking = true;
 
   # rustc complains about modified source files otherwise
@@ -53,110 +82,152 @@ in stdenv.mkDerivation (finalAttrs: {
   # but it does support checking these idiosyncratic PKG_CONFIG_${TRIPLE}
   # environment variables.
   # [1]: https://github.com/rust-lang/pkg-config-rs/issues/53
-  "PKG_CONFIG_${builtins.replaceStrings ["-"] ["_"] stdenv.buildPlatform.rust.rustcTarget}" =
+  "PKG_CONFIG_${
-    "${pkgsBuildHost.stdenv.cc.targetPrefix}pkg-config";
+    builtins.replaceStrings [ "-" ] [ "_" ] stdenv.buildPlatform.rust.rustcTarget
+  }" = "${pkgsBuildHost.stdenv.cc.targetPrefix}pkg-config";
 
   NIX_LDFLAGS = toString (
-       # when linking stage1 libstd: cc: undefined reference to `__cxa_begin_catch'
+    # when linking stage1 libstd: cc: undefined reference to `__cxa_begin_catch'
-       optional (stdenv.isLinux && !withBundledLLVM) "--push-state --as-needed -lstdc++ --pop-state"
+    # This doesn't apply to cross-building for FreeBSD because the host
+    # uses libstdc++, but the target (used for building std) uses libc++
+    optional (
+      stdenv.isLinux && !withBundledLLVM && !stdenv.targetPlatform.isFreeBSD && !useLLVM
+    ) "--push-state --as-needed -lstdc++ --pop-state"
+    ++
+      optional (stdenv.isLinux && !withBundledLLVM && !stdenv.targetPlatform.isFreeBSD && useLLVM)
+        "--push-state --as-needed -L${llvmPackages.libcxx}/lib -lc++ -lc++abi -lLLVM-${lib.versions.major llvmPackages.llvm.version} --pop-state"
     ++ optional (stdenv.isDarwin && !withBundledLLVM) "-lc++ -lc++abi"
-    ++ optional stdenv.isDarwin "-rpath ${llvmSharedForHost}/lib");
+    ++ optional stdenv.isFreeBSD "-rpath ${llvmPackages.libunwind}/lib"
+    ++ optional stdenv.isDarwin "-rpath ${llvmSharedForHost.lib}/lib"
+  );
 
   # Increase codegen units to introduce parallelism within the compiler.
   RUSTFLAGS = "-Ccodegen-units=10";
-
   RUSTDOCFLAGS = "-A rustdoc::broken-intra-doc-links";
 
   # 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
+  configureFlags =
-    prefixForStdenv = stdenv: "${stdenv.cc}/bin/${stdenv.cc.targetPrefix}";
+    let
-    ccPrefixForStdenv = stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang" else "cc"}";
+      prefixForStdenv = stdenv: "${stdenv.cc}/bin/${stdenv.cc.targetPrefix}";
-    cxxPrefixForStdenv = stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang++" else "c++"}";
+      ccPrefixForStdenv =
-    setBuild  = "--set=target.${stdenv.buildPlatform.rust.rustcTarget}";
+        stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang" else "cc"}";
-    setHost   = "--set=target.${stdenv.hostPlatform.rust.rustcTarget}";
+      cxxPrefixForStdenv =
-    setTarget = "--set=target.${stdenv.targetPlatform.rust.rustcTarget}";
+        stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang++" else "c++"}";
-    ccForBuild  = ccPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv;
+      setBuild = "--set=target.${stdenv.buildPlatform.rust.rustcTarget}";
-    cxxForBuild  = cxxPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv;
+      setHost = "--set=target.${stdenv.hostPlatform.rust.rustcTarget}";
-    ccForHost  = ccPrefixForStdenv pkgsBuildHost.targetPackages.stdenv;
+      setTarget = "--set=target.${stdenv.targetPlatform.rust.rustcTarget}";
-    cxxForHost  = cxxPrefixForStdenv pkgsBuildHost.targetPackages.stdenv;
+      ccForBuild = ccPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv;
-    ccForTarget  = ccPrefixForStdenv pkgsBuildTarget.targetPackages.stdenv;
+      cxxForBuild = cxxPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv;
-    cxxForTarget  = cxxPrefixForStdenv pkgsBuildTarget.targetPackages.stdenv;
+      ccForHost = ccPrefixForStdenv pkgsBuildHost.targetPackages.stdenv;
-  in [
+      cxxForHost = cxxPrefixForStdenv pkgsBuildHost.targetPackages.stdenv;
-    "--sysconfdir=${placeholder "out"}/etc"
+      ccForTarget = ccPrefixForStdenv pkgsBuildTarget.targetPackages.stdenv;
-    "--release-channel=stable"
+      cxxForTarget = cxxPrefixForStdenv pkgsBuildTarget.targetPackages.stdenv;
-    "--set=build.rustc=${rustc}/bin/rustc"
+    in
-    "--set=build.cargo=${cargo}/bin/cargo"
+    [
-  ] ++ lib.optionals (!(finalAttrs.src.passthru.isReleaseTarball or false)) [
+      "--sysconfdir=${placeholder "out"}/etc"
-    # release tarballs vendor the rustfmt source; when
+      "--release-channel=stable"
-    # git-bisect'ing from upstream's git repo we must prevent
+      "--set=build.rustc=${rustc}/bin/rustc"
-    # attempts to download the missing source tarball
+      "--set=build.cargo=${cargo}/bin/cargo"
-    "--set=build.rustfmt=${rustfmt}/bin/rustfmt"
+    ]
-  ] ++ [
+    ++ lib.optionals (!(finalAttrs.src.passthru.isReleaseTarball or false)) [
-    "--tools=rustc,rustdoc,rust-analyzer-proc-macro-srv"
+      # release tarballs vendor the rustfmt source; when
-    "--enable-rpath"
+      # git-bisect'ing from upstream's git repo we must prevent
-    "--enable-vendor"
+      # attempts to download the missing source tarball
-    "--build=${stdenv.buildPlatform.rust.rustcTargetSpec}"
+      "--set=build.rustfmt=${rustfmt}/bin/rustfmt"
-    "--host=${stdenv.hostPlatform.rust.rustcTargetSpec}"
+    ]
-    # std is built for all platforms in --target.
+    ++ [
-    "--target=${concatStringsSep "," ([
+      "--tools=rustc,rustdoc,rust-analyzer-proc-macro-srv"
-      stdenv.targetPlatform.rust.rustcTargetSpec
+      "--enable-rpath"
+      "--enable-vendor"
+      "--build=${stdenv.buildPlatform.rust.rustcTargetSpec}"
+      "--host=${stdenv.hostPlatform.rust.rustcTargetSpec}"
+      # std is built for all platforms in --target.
+      "--target=${
+        concatStringsSep "," (
+          [
+            stdenv.targetPlatform.rust.rustcTargetSpec
 
-    # Other targets that don't need any extra dependencies to build.
+            # Other targets that don't need any extra dependencies to build.
-    ] ++ optionals (!fastCross) [
+          ]
-      "wasm32-unknown-unknown"
+          ++ optionals (!fastCross) [
+            "wasm32-unknown-unknown"
 
-    # (build!=target): When cross-building a compiler we need to add
+            # (build!=target): When cross-building a compiler we need to add
-    # the build platform as well so rustc can compile build.rs
+            # the build platform as well so rustc can compile build.rs
-    # scripts.
+            # scripts.
-    ] ++ optionals (stdenv.buildPlatform != stdenv.targetPlatform && !fastCross) [
+          ]
-      stdenv.buildPlatform.rust.rustcTargetSpec
+          ++ optionals (stdenv.buildPlatform != stdenv.targetPlatform && !fastCross) [
+            stdenv.buildPlatform.rust.rustcTargetSpec
 
-    # (host!=target): When building a cross-targeting compiler we
+            # (host!=target): When building a cross-targeting compiler we
-    # need to add the host platform as well so rustc can compile
+            # need to add the host platform as well so rustc can compile
-    # build.rs scripts.
+            # build.rs scripts.
-    ] ++ optionals (stdenv.hostPlatform != stdenv.targetPlatform && !fastCross) [
+          ]
-      stdenv.hostPlatform.rust.rustcTargetSpec
+          ++ optionals (stdenv.hostPlatform != stdenv.targetPlatform && !fastCross) [
-    ])}"
+            stdenv.hostPlatform.rust.rustcTargetSpec
+          ]
+        )
+      }"
 
-    "${setBuild}.cc=${ccForBuild}"
+      "${setBuild}.cc=${ccForBuild}"
-    "${setHost}.cc=${ccForHost}"
+      "${setHost}.cc=${ccForHost}"
-    "${setTarget}.cc=${ccForTarget}"
+      "${setTarget}.cc=${ccForTarget}"
 
-    "${setBuild}.linker=${ccForBuild}"
+      "${setBuild}.linker=${ccForBuild}"
-    "${setHost}.linker=${ccForHost}"
+      "${setHost}.linker=${ccForHost}"
-    "${setTarget}.linker=${ccForTarget}"
+      "${setTarget}.linker=${ccForTarget}"
 
-    "${setBuild}.cxx=${cxxForBuild}"
+      "${setBuild}.cxx=${cxxForBuild}"
-    "${setHost}.cxx=${cxxForHost}"
+      "${setHost}.cxx=${cxxForHost}"
-    "${setTarget}.cxx=${cxxForTarget}"
+      "${setTarget}.cxx=${cxxForTarget}"
 
-    "${setBuild}.crt-static=${lib.boolToString stdenv.buildPlatform.isStatic}"
+      "${setBuild}.crt-static=${lib.boolToString stdenv.buildPlatform.isStatic}"
-    "${setHost}.crt-static=${lib.boolToString stdenv.hostPlatform.isStatic}"
+      "${setHost}.crt-static=${lib.boolToString stdenv.hostPlatform.isStatic}"
-    "${setTarget}.crt-static=${lib.boolToString stdenv.targetPlatform.isStatic}"
+      "${setTarget}.crt-static=${lib.boolToString stdenv.targetPlatform.isStatic}"
-  ] ++ optionals (!withBundledLLVM) [
+    ]
-    "--enable-llvm-link-shared"
+    ++ optionals (!withBundledLLVM) [
-    "${setBuild}.llvm-config=${llvmSharedForBuild.dev}/bin/llvm-config"
+      "--enable-llvm-link-shared"
-    "${setHost}.llvm-config=${llvmSharedForHost.dev}/bin/llvm-config"
+      "${setBuild}.llvm-config=${llvmSharedForBuild.dev}/bin/llvm-config"
-    "${setTarget}.llvm-config=${llvmSharedForTarget.dev}/bin/llvm-config"
+      "${setHost}.llvm-config=${llvmSharedForHost.dev}/bin/llvm-config"
-  ] ++ optionals (stdenv.isLinux && !stdenv.targetPlatform.isRedox) [
+      "${setTarget}.llvm-config=${llvmSharedForTarget.dev}/bin/llvm-config"
-    "--enable-profiler" # build libprofiler_builtins
+    ]
-  ] ++ optionals stdenv.buildPlatform.isMusl [
+    ++ optionals fastCross [
-    "${setBuild}.musl-root=${pkgsBuildBuild.targetPackages.stdenv.cc.libc}"
+      # Since fastCross only builds std, it doesn't make sense (and
-  ] ++ optionals stdenv.hostPlatform.isMusl [
+      # doesn't work) to build a linker.
-    "${setHost}.musl-root=${pkgsBuildHost.targetPackages.stdenv.cc.libc}"
+      "--disable-llvm-bitcode-linker"
-  ] ++ optionals stdenv.targetPlatform.isMusl [
+    ]
-    "${setTarget}.musl-root=${pkgsBuildTarget.targetPackages.stdenv.cc.libc}"
+    ++
-  ] ++ optionals stdenv.targetPlatform.rust.isNoStdTarget [
+      optionals
-    "--disable-docs"
+        (stdenv.isLinux && !stdenv.targetPlatform.isRedox && !(stdenv.targetPlatform.useLLVM or false))
-  ] ++ optionals (stdenv.isDarwin && stdenv.isx86_64) [
+        [
-    # https://github.com/rust-lang/rust/issues/92173
+          "--enable-profiler" # build libprofiler_builtins
-    "--set rust.jemalloc"
+        ]
-  ];
+    ++ 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.targetPlatform.rust.isNoStdTarget [ "--disable-docs" ]
+    ++ optionals (stdenv.isDarwin && stdenv.isx86_64) [
+      # https://github.com/rust-lang/rust/issues/92173
+      "--set rust.jemalloc"
+    ]
+    ++ optionals useLLVM [
+      # https://github.com/NixOS/nixpkgs/issues/311930
+      "--llvm-libunwind=${if withBundledLLVM then "in-tree" else "system"}"
+      "--enable-use-libcxx"
+    ];
 
   # if we already have a rust compiler for build just compile the target std
   # library and reuse compiler
-  buildPhase = if fastCross then "
+  buildPhase =
+    if fastCross then
+      "
     runHook preBuild
 
     mkdir -p build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-{std,rustc}/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/
@@ -168,88 +239,144 @@ in stdenv.mkDerivation (finalAttrs: {
     python ./x.py --keep-stage=0 --stage=1 build library
 
     runHook postBuild
-  " else null;
+  "
+    else
+      null;
 
-  installPhase = if fastCross then ''
+  installPhase =
-    runHook preInstall
+    if fastCross then
+      ''
+        runHook preInstall
 
-    python ./x.py --keep-stage=0 --stage=1 install library/std
+        python ./x.py --keep-stage=0 --stage=1 install library/std
-    mkdir -v $out/bin $doc $man
+        mkdir -v $out/bin $doc $man
-    ln -s ${rustc.unwrapped}/bin/{rustc,rustdoc} $out/bin
+        ln -s ${rustc.unwrapped}/bin/{rustc,rustdoc} $out/bin
-    ln -s ${rustc.unwrapped}/lib/rustlib/{manifest-rust-std-,}${stdenv.hostPlatform.rust.rustcTargetSpec} $out/lib/rustlib/
+        rm -rf -v $out/lib/rustlib/{manifest-rust-std-,}${stdenv.hostPlatform.rust.rustcTargetSpec}
-    echo rust-std-${stdenv.hostPlatform.rust.rustcTargetSpec} >> $out/lib/rustlib/components
+        ln -s ${rustc.unwrapped}/lib/rustlib/{manifest-rust-std-,}${stdenv.hostPlatform.rust.rustcTargetSpec} $out/lib/rustlib/
-    lndir ${rustc.doc} $doc
+        echo rust-std-${stdenv.hostPlatform.rust.rustcTargetSpec} >> $out/lib/rustlib/components
-    lndir ${rustc.man} $man
+        lndir ${rustc.doc} $doc
+        lndir ${rustc.man} $man
 
-    runHook postInstall
+        runHook postInstall
-  '' else null;
+      ''
+    else
+      null;
 
   # the rust build system complains that nix alters the checksums
   dontFixLibtool = true;
 
   inherit patches;
 
-  postPatch = ''
+  postPatch =
-    patchShebangs src/etc
+    ''
+      patchShebangs src/etc
 
-    ${optionalString (!withBundledLLVM) "rm -rf src/llvm"}
+      # rust-lld is the name rustup uses for its bundled lld, so that it
+      # doesn't conflict with any system lld.  This is not an
+      # appropriate default for Nixpkgs, where there is no rust-lld.
+      substituteInPlace compiler/rustc_target/src/spec/*/*.rs \
+        --replace-quiet '"rust-lld"' '"lld"'
 
-    # Useful debugging parameter
+      ${optionalString (!withBundledLLVM) "rm -rf src/llvm"}
-    # export VERBOSE=1
+
-  '' + lib.optionalString (stdenv.isDarwin && stdenv.isx86_64) ''
+      # Useful debugging parameter
-    # See https://github.com/jemalloc/jemalloc/issues/1997
+      # export VERBOSE=1
-    # Using a value of 48 should work on both emulated and native x86_64-darwin.
+    ''
-    export JEMALLOC_SYS_WITH_LG_VADDR=48
+    + lib.optionalString (stdenv.isDarwin && stdenv.isx86_64) ''
-  '' + lib.optionalString (!(finalAttrs.src.passthru.isReleaseTarball or false)) ''
+      # See https://github.com/jemalloc/jemalloc/issues/1997
-    mkdir .cargo
+      # Using a value of 48 should work on both emulated and native x86_64-darwin.
-    cat > .cargo/config <<\EOF
+      export JEMALLOC_SYS_WITH_LG_VADDR=48
-    [source.crates-io]
+    ''
-    replace-with = "vendored-sources"
+    + lib.optionalString (!(finalAttrs.src.passthru.isReleaseTarball or false)) ''
-    [source.vendored-sources]
+      mkdir .cargo
-    directory = "vendor"
+      cat > .cargo/config <<\EOF
-    EOF
+      [source.crates-io]
-  '';
+      replace-with = "vendored-sources"
+      [source.vendored-sources]
+      directory = "vendor"
+      EOF
+    ''
+    + lib.optionalString stdenv.isFreeBSD ''
+      # lzma-sys bundles an old version of xz that doesn't build
+      # on modern FreeBSD, use the system one instead
+      substituteInPlace src/bootstrap/src/core/build_steps/tool.rs \
+          --replace 'cargo.env("LZMA_API_STATIC", "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;
 
-  depsBuildBuild = [ pkgsBuildHost.stdenv.cc pkg-config ];
+  depsBuildBuild = [
+    pkgsBuildHost.stdenv.cc
+    pkg-config
+  ];
 
-  nativeBuildInputs = [
+  nativeBuildInputs =
-    file python3 rustc cmake
+    [
-    which libffi removeReferencesTo pkg-config xz
+      file
-  ]
+      python3
-    ++ optionals fastCross [ lndir makeWrapper ];
+      rustc
+      cmake
+      which
+      libffi
+      removeReferencesTo
+      pkg-config
+      xz
+    ]
+    ++ optionals fastCross [
+      lndir
+      makeWrapper
+    ];
 
-  buildInputs = [ openssl ]
+  buildInputs =
-    ++ optionals stdenv.isDarwin [ libiconv Security ]
+    [ openssl ]
-    ++ optional (!withBundledLLVM) llvmShared;
+    ++ optionals stdenv.isDarwin [
+      libiconv
+      Security
+      zlib
+    ]
+    ++ optional (!withBundledLLVM) llvmShared.lib
+    ++ optional (useLLVM && !withBundledLLVM) [
+      llvmPackages.libunwind
+      # Hack which is used upstream https://github.com/gentoo/gentoo/blob/master/dev-lang/rust/rust-1.78.0.ebuild#L284
+      (runCommandLocal "libunwind-libgcc" { } ''
+        mkdir -p $out/lib
+        ln -s ${llvmPackages.libunwind}/lib/libunwind.so $out/lib/libgcc_s.so
+        ln -s ${llvmPackages.libunwind}/lib/libunwind.so $out/lib/libgcc_s.so.1
+      '')
+    ];
 
-  outputs = [ "out" "man" "doc" ];
+  outputs = [
+    "out"
+    "man"
+    "doc"
+  ];
   setOutputFlags = false;
 
-  postInstall = lib.optionalString (enableRustcDev && !fastCross) ''
+  postInstall =
-    # install rustc-dev components. Necessary to build rls, clippy...
+    lib.optionalString (enableRustcDev && !fastCross) ''
-    python x.py dist rustc-dev
+      # install rustc-dev components. Necessary to build rls, clippy...
-    tar xf build/dist/rustc-dev*tar.gz
+      python x.py dist rustc-dev
-    cp -r rustc-dev*/rustc-dev*/lib/* $out/lib/
+      tar xf build/dist/rustc-dev*tar.gz
-    rm $out/lib/rustlib/install.log
+      cp -r rustc-dev*/rustc-dev*/lib/* $out/lib/
-    for m in $out/lib/rustlib/manifest-rust*
+      rm $out/lib/rustlib/install.log
-    do
+      for m in $out/lib/rustlib/manifest-rust*
-      sort --output=$m < $m
+      do
-    done
+        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
+      # remove references to llvm-config in lib/rustlib/x86_64-unknown-linux-gnu/codegen-backends/librustc_codegen_llvm-llvm.so
-    find $out/lib -name "*.so" -type f -exec remove-references-to -t ${llvmShared} '{}' '+'
+      # 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.
+      # remove uninstall script that doesn't really make sense for Nix.
-    rm $out/lib/rustlib/uninstall.sh
+      rm $out/lib/rustlib/uninstall.sh
-  '';
+    '';
 
-  configurePlatforms = [];
+  configurePlatforms = [ ];
 
   enableParallelBuilding = true;
 
@@ -260,29 +387,44 @@ in stdenv.mkDerivation (finalAttrs: {
   passthru = {
     llvm = llvmShared;
     inherit llvmPackages;
-    # tests = {
-    #   inherit fd ripgrep wezterm;
-    # } // lib.optionalAttrs stdenv.hostPlatform.isLinux { inherit firefox thunderbird; };
   };
 
-  meta = with lib; {
+  meta = {
     homepage = "https://www.rust-lang.org/";
-    description = "A safe, concurrent, practical language";
+    description = "Safe, concurrent, practical language";
-    maintainers = with maintainers; [ havvy ] ++ teams.rust.members;
+    maintainers = [ ];
-    license = [ licenses.mit licenses.asl20 ];
+    license = [
+      lib.licenses.mit
+      lib.licenses.asl20
+    ];
     platforms = [
       # Platforms with host tools from
       # https://doc.rust-lang.org/nightly/rustc/platform-support.html
-      "x86_64-darwin" "i686-darwin" "aarch64-darwin"
+      "x86_64-darwin"
-      "i686-freebsd" "x86_64-freebsd"
+      "i686-darwin"
+      "aarch64-darwin"
+      "i686-freebsd"
+      "x86_64-freebsd"
       "x86_64-solaris"
-      "aarch64-linux" "armv6l-linux" "armv7l-linux" "i686-linux"
+      "aarch64-linux"
-      "loongarch64-linux" "powerpc64-linux" "powerpc64le-linux"
+      "armv6l-linux"
-      "riscv64-linux" "s390x-linux" "x86_64-linux"
+      "armv7l-linux"
-      "aarch64-netbsd" "armv7l-netbsd" "i686-netbsd" "powerpc-netbsd"
+      "i686-linux"
+      "loongarch64-linux"
+      "powerpc64-linux"
+      "powerpc64le-linux"
+      "riscv64-linux"
+      "s390x-linux"
+      "x86_64-linux"
+      "aarch64-netbsd"
+      "armv7l-netbsd"
+      "i686-netbsd"
+      "powerpc-netbsd"
       "x86_64-netbsd"
-      "i686-openbsd" "x86_64-openbsd"
+      "i686-openbsd"
-      "i686-windows" "x86_64-windows"
+      "x86_64-openbsd"
+      "i686-windows"
+      "x86_64-windows"
     ];
   };
 })

pkgs/by-name/ru/rust/rustfmt.nix

@@ -1,6 +1,12 @@
-{ lib, stdenv, rustPlatform, rustc, Security, asNightly ? false }:
+{
-
+  lib,
-rustPlatform.buildRustPackage rec {
+  stdenv,
+  rustPlatform,
+  rustc,
+  Security,
+  asNightly ? false,
+}:
+rustPlatform.buildRustPackage {
   pname = "rustfmt" + lib.optionalString asNightly "-nightly";
   inherit (rustc) version src;
 
@@ -11,9 +17,7 @@ rustPlatform.buildRustPackage rec {
   # changes hash of vendor directory otherwise
   dontUpdateAutotoolsGnuConfigScripts = true;
 
-  buildInputs = [
+  buildInputs = [ rustc.llvm ] ++ lib.optional stdenv.isDarwin Security;
-    rustc.llvm
-  ] ++ lib.optional stdenv.isDarwin Security;
 
   # rustfmt uses the rustc_driver and std private libraries, and Rust's build process forces them to have
   # an install name of `@rpath/...` [0] [1] instead of the standard on macOS, which is an absolute path
@@ -34,11 +38,17 @@ rustPlatform.buildRustPackage rec {
   CFG_RELEASE = rustc.version;
   CFG_RELEASE_CHANNEL = if asNightly then "nightly" else "stable";
 
-  meta = with lib; {
+  meta = {
-    description = "A tool for formatting Rust code according to style guidelines";
+    description = "Tool for formatting Rust code according to style guidelines";
     homepage = "https://github.com/rust-lang-nursery/rustfmt";
-    license = with licenses; [ mit asl20 ];
+    license = with lib.licenses; [
+      mit
+      asl20
+    ];
     mainProgram = "rustfmt";
-    maintainers = with maintainers; [ globin basvandijk ];
+    maintainers = with lib.maintainers; [
+      globin
+      basvandijk
+    ];
   };
 }