diff --git a/pkgs/by-name/ru/rust/1_77.nix b/pkgs/by-name/ru/rust/1_77.nix deleted file mode 100644 index ec65c85..0000000 --- a/pkgs/by-name/ru/rust/1_77.nix +++ /dev/null @@ -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//.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"]) diff --git a/pkgs/by-name/ru/rust/1_80.nix b/pkgs/by-name/ru/rust/1_80.nix new file mode 100644 index 0000000..e182929 --- /dev/null +++ b/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//.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" + ] + ) diff --git a/pkgs/by-name/ru/rust/binary.nix b/pkgs/by-name/ru/rust/binary.nix index c546e27..3b24fd9 100644 --- a/pkgs/by-name/ru/rust/binary.nix +++ b/pkgs/by-name/ru/rust/binary.nix @@ -1,23 +1,26 @@ -{ lib, stdenv, makeWrapper, wrapRustc, bash, curl, darwin, zlib -, autoPatchelfHook, gcc -, version -, src -, platform -, versionType +{ + lib, + stdenv, + makeWrapper, + wrapRustc, + bash, + darwin, + zlib, + autoPatchelfHook, + gcc, + 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") - ; + installComponents = "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 ]; - description = "A safe, concurrent, practical language"; - maintainers = with maintainers; [ qknight ]; - license = [ licenses.mit licenses.asl20 ]; + sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ]; + description = "Safe, concurrent, practical language"; + maintainers = [ ]; + license = [ + lib.licenses.mit + lib.licenses.asl20 + ]; }; nativeBuildInputs = lib.optional (!stdenv.isDarwin) autoPatchelfHook; - buildInputs = [ bash ] - ++ lib.optionals (!stdenv.isDarwin) [ gcc.cc.lib zlib ] + buildInputs = + [ 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 ] - ++ lib.optional (!stdenv.isDarwin) autoPatchelfHook; - buildInputs = [ bash ] - ++ lib.optional (!stdenv.isDarwin) gcc.cc.lib + nativeBuildInputs = [ makeWrapper ] ++ lib.optional (!stdenv.isDarwin) autoPatchelfHook; + buildInputs = + [ bash ] + ++ lib.optional (!stdenv.isDarwin && !stdenv.isFreeBSD) gcc.cc.lib ++ lib.optional stdenv.isDarwin Security; postPatch = '' diff --git a/pkgs/by-name/ru/rust/cargo-auditable.nix b/pkgs/by-name/ru/rust/cargo-auditable.nix index 1cf765b..82b2e7d 100644 --- a/pkgs/by-name/ru/rust/cargo-auditable.nix +++ b/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 - preConfigure = '' - cargo update --offline - ''; - - meta = with lib; { - description = "A tool to make production Rust binaries auditable"; + meta = { + description = "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 ]; - maintainers = with maintainers; [ figsoda ]; + license = with lib.licenses; [ + mit # or + asl20 + ]; + maintainers = with lib.maintainers; [ figsoda ]; broken = stdenv.hostPlatform != stdenv.buildPlatform; }; }; rustPlatform = makeRustPlatform { inherit (buildPackages) rustc; - cargo = buildPackages.cargo.override { - auditable = false; - }; + cargo = buildPackages.cargo.override { auditable = false; }; }; - bootstrap = rustPlatform.buildRustPackage (args // { - auditable = false; - }); + bootstrap = rustPlatform.buildRustPackage (args // { auditable = false; }); in -rustPlatform.buildRustPackage.override { cargo-auditable = bootstrap; } (args // { - nativeBuildInputs = [ - installShellFiles - ]; +rustPlatform.buildRustPackage.override { cargo-auditable = bootstrap; } ( + args + // { + nativeBuildInputs = [ installShellFiles ]; - postInstall = '' - installManPage cargo-auditable/cargo-auditable.1 - ''; + postInstall = '' + installManPage cargo-auditable/cargo-auditable.1 + ''; - passthru = { - inherit bootstrap; - }; -}) + passthru = { + inherit bootstrap; + }; + } +) diff --git a/pkgs/by-name/ru/rust/cargo.nix b/pkgs/by-name/ru/rust/cargo.nix index b0c40c5..5517bcd 100644 --- a/pkgs/by-name/ru/rust/cargo.nix +++ b/pkgs/by-name/ru/rust/cargo.nix @@ -1,85 +1,114 @@ -{ lib, stdenv, pkgsBuildHost, pkgsHostHost -, file, curl, pkg-config, python3, openssl, cmake, zlib -, installShellFiles, makeWrapper, rustPlatform, rustc -, CoreFoundation, Security -, auditable ? !cargo-auditable.meta.broken -, cargo-auditable -, pkgsBuildBuild +{ + lib, + stdenv, + pkgsHostHost, + file, + curl, + pkg-config, + python3, + openssl, + cmake, + zlib, + installShellFiles, + makeWrapper, + rustPlatform, + rustc, + CoreFoundation, + Security, + auditable ? !cargo-auditable.meta.broken, + cargo-auditable, + pkgsBuildBuild, }: -rustPlatform.buildRustPackage.override { - cargo-auditable = cargo-auditable.bootstrap; -} ({ - pname = "cargo"; - inherit (rustc.unwrapped) version src; +rustPlatform.buildRustPackage.override { cargo-auditable = cargo-auditable.bootstrap; } ( + { + pname = "cargo"; + inherit (rustc.unwrapped) version src; - # the rust source tarball already has all the dependencies vendored, no need to fetch them again - cargoVendorDir = "vendor"; - buildAndTestSubdir = "src/tools/cargo"; + # the rust source tarball already has all the dependencies vendored, no need to fetch them again + cargoVendorDir = "vendor"; + buildAndTestSubdir = "src/tools/cargo"; - inherit auditable; + inherit auditable; - passthru = { - rustc = rustc; - inherit (rustc.unwrapped) tests; - }; + passthru = { + rustc = rustc; + inherit (rustc.unwrapped) tests; + }; - # changes hash of vendor directory otherwise - dontUpdateAutotoolsGnuConfigScripts = true; + # changes hash of vendor directory otherwise + dontUpdateAutotoolsGnuConfigScripts = true; - nativeBuildInputs = [ - pkg-config cmake installShellFiles makeWrapper - (lib.getDev pkgsHostHost.curl) - zlib - ]; - buildInputs = [ file curl python3 openssl zlib ] - ++ lib.optionals stdenv.isDarwin [ CoreFoundation Security ]; + nativeBuildInputs = [ + pkg-config + cmake + installShellFiles + makeWrapper + (lib.getDev pkgsHostHost.curl) + 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 - # is not compatible with the current version in nixpkgs. - #LIBGIT2_SYS_USE_PKG_CONFIG = 1; + # 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; + # fixes: the cargo feature `edition` requires a nightly version of Cargo, but this is the `stable` channel + RUSTC_BOOTSTRAP = 1; - postInstall = '' - wrapProgram "$out/bin/cargo" --suffix PATH : "${rustc}/bin" + postInstall = '' + 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 \ - src/tools/cargo/src/etc/cargo.bashcomp.sh + installShellCompletion --bash --name cargo \ + 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 = '' - # Disable cross compilation tests - export CFG_DISABLE_CROSS_TESTS=1 - cargo test - ''; + 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; + # Disable check phase as there are failures (4 tests fail) + doCheck = false; - doInstallCheck = !stdenv.hostPlatform.isStatic && stdenv.hostPlatform.isElf; - installCheckPhase = '' - runHook preInstallCheck - readelf -a $out/bin/.cargo-wrapped | grep -F 'Shared library: [libcurl.so' - runHook postInstallCheck - ''; + doInstallCheck = !stdenv.hostPlatform.isStatic && stdenv.hostPlatform.isElf; + 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"; - mainProgram = "cargo"; - maintainers = teams.rust.members; - license = [ licenses.mit licenses.asl20 ]; - platforms = platforms.unix; - # https://github.com/alexcrichton/nghttp2-rs/issues/2 - broken = stdenv.hostPlatform.isx86 && stdenv.buildPlatform != stdenv.hostPlatform; - }; -} -// lib.optionalAttrs (stdenv.buildPlatform.rust.rustcTarget != stdenv.hostPlatform.rust.rustcTarget) { - HOST_PKG_CONFIG_PATH="${pkgsBuildBuild.pkg-config}/bin/pkg-config"; -}) + meta = { + homepage = "https://crates.io"; + description = "Downloads your Rust project's dependencies and builds your project"; + mainProgram = "cargo"; + maintainers = [ ]; + license = [ + lib.licenses.mit + lib.licenses.asl20 + ]; + platforms = lib.platforms.unix; + # https://github.com/alexcrichton/nghttp2-rs/issues/2 + broken = stdenv.hostPlatform.isx86 && stdenv.buildPlatform != stdenv.hostPlatform; + }; + } + // lib.optionalAttrs ( + stdenv.buildPlatform.rust.rustcTarget != stdenv.hostPlatform.rust.rustcTarget + ) { HOST_PKG_CONFIG_PATH = "${pkgsBuildBuild.pkg-config}/bin/pkg-config"; } +) diff --git a/pkgs/by-name/ru/rust/clippy.nix b/pkgs/by-name/ru/rust/clippy.nix index d9506a4..d1319e6 100644 --- a/pkgs/by-name/ru/rust/clippy.nix +++ b/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 ] - ++ lib.optionals stdenv.isDarwin [ Security ]; + buildInputs = [ rustc.llvm ] ++ 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; - license = with licenses; [ mit asl20 ]; - platforms = platforms.unix; + maintainers = with lib.maintainers; [ basvandijk ] ++ teams.rust.members; + license = with lib.licenses; [ + mit + asl20 + ]; + platforms = lib.platforms.unix; }; } diff --git a/pkgs/by-name/ru/rust/default.nix b/pkgs/by-name/ru/rust/default.nix index 77f1cd9..3795a0a 100644 --- a/pkgs/by-name/ru/rust/default.nix +++ b/pkgs/by-name/ru/rust/default.nix @@ -1,41 +1,61 @@ -{ rustcVersion -, rustcSha256 -, enableRustcDev ? true -, bootstrapVersion -, bootstrapHashes -, selectRustPackage -, rustcPatches ? [] -, llvmShared -, llvmSharedForBuild -, llvmSharedForHost -, llvmSharedForTarget -, llvmPackages # Exposed through rustc for LTO in Firefox +{ + rustcVersion, + rustcSha256, + enableRustcDev ? true, + bootstrapVersion, + bootstrapHashes, + selectRustPackage, + rustcPatches ? [ ], + llvmShared, + llvmSharedForBuild, + llvmSharedForHost, + llvmSharedForTarget, + llvmPackages, # Exposed through rustc for LTO in Firefox }: -{ stdenv, lib -, newScope, callPackage -, CoreFoundation, Security, SystemConfiguration -, pkgsBuildBuild -, pkgsBuildHost -, pkgsBuildTarget -, pkgsTargetTarget -, makeRustPlatform -, wrapRustcWith -, path +{ + stdenv, + lib, + newScope, + callPackage, + CoreFoundation, + Security, + SystemConfiguration, + pkgsBuildBuild, + 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 - # 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 = if fastCross - then pkgsBuildBuild.rustPackages - else - self.buildRustPackages.overrideScope (_: _: - lib.optionalAttrs (stdenv.buildPlatform == stdenv.hostPlatform) - (selectRustPackage pkgsBuildHost).packages.prebuilt); - bootRustPlatform = makeRustPlatform bootstrapRustPackages; - in { - # Packages suitable for build-time, e.g. `build.rs`-type stuff. - buildRustPackages = (selectRustPackage pkgsBuildHost).packages.stable // { __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; + 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 = + if fastCross then + pkgsBuildBuild.rustPackages + else + self.buildRustPackages.overrideScope ( + _: _: + lib.optionalAttrs (stdenv.buildPlatform == stdenv.hostPlatform) + (selectRustPackage pkgsBuildHost).packages.prebuilt + ); + bootRustPlatform = makeRustPlatform bootstrapRustPackages; + in + { + # Packages suitable for build-time, e.g. `build.rs`-type stuff. + buildRustPackages = (selectRustPackage pkgsBuildHost).packages.stable // { + # 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 - inherit (bootstrapRustPackages) cargo rustc rustfmt; - }); - rustc = wrapRustcWith { - inherit (self) rustc-unwrapped; - sysroot = if fastCross then self.rustc-unwrapped else null; - }; - rustfmt = self.callPackage ./rustfmt.nix { - inherit Security; - inherit (self.buildRustPackages) rustc; - }; - cargo = if (!fastCross) then self.callPackage ./cargo.nix { - # Use boot package set to break cycle - rustPlatform = bootRustPlatform; - inherit CoreFoundation Security; - } else self.callPackage ./cargo_cross.nix {}; - cargo-auditable = self.callPackage ./cargo-auditable.nix { }; - cargo-auditable-cargo-wrapper = self.callPackage ./cargo-auditable-cargo-wrapper.nix { }; - clippy = self.callPackage ./clippy.nix { - # 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; - }; - }); + # Use boot package set to break cycle + inherit (bootstrapRustPackages) cargo rustc rustfmt; + }; + rustc = wrapRustcWith { + inherit (self) rustc-unwrapped; + sysroot = if fastCross then self.rustc-unwrapped else null; + }; + rustfmt = self.callPackage ./rustfmt.nix { + inherit Security; + inherit (self.buildRustPackages) rustc; + }; + cargo = + if (!fastCross) then + self.callPackage ./cargo.nix { + # Use boot package set to break cycle + rustPlatform = bootRustPlatform; + inherit CoreFoundation Security; + } + else + self.callPackage ./cargo_cross.nix { }; + cargo-auditable = self.callPackage ./cargo-auditable.nix { }; + cargo-auditable-cargo-wrapper = self.callPackage ./cargo-auditable-cargo-wrapper.nix { }; + clippy = self.callPackage ./clippy.nix { + # 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; + }; + } + ); }; } diff --git a/pkgs/by-name/ru/rust/make-rust-platform.nix b/pkgs/by-name/ru/rust/make-rust-platform.nix index 3e5dfbd..3b913cc 100644 --- a/pkgs/by-name/ru/rust/make-rust-platform.nix +++ b/pkgs/by-name/ru/rust/make-rust-platform.nix @@ -1,10 +1,19 @@ -{ lib, buildPackages, callPackage, callPackages, cargo-auditable, stdenv, runCommand, path }@prev: - -{ rustc -, cargo -, cargo-auditable ? prev.cargo-auditable -, stdenv ? prev.stdenv -, ... +{ + lib, + buildPackages, + callPackage, + callPackages, + 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") { - git = buildPackages.gitMinimal; - inherit cargo; - }; + fetchCargoTarball = + buildPackages.callPackage (path + "/pkgs/build-support/rust/fetch-cargo-tarball") + { + git = buildPackages.gitMinimal; + inherit cargo; + }; buildRustPackage = callPackage (path + "/pkgs/build-support/rust/build-rust-package") { - inherit stdenv cargoBuildHook cargoCheckHook cargoInstallHook cargoNextestHook cargoSetupHook - fetchCargoTarball importCargoLock rustc cargo cargo-auditable; + inherit + 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 { - inherit runCommand rustc; - }; + rustcSrc = callPackage ./rust-src.nix { inherit runCommand rustc; }; - rustLibSrc = callPackage ./rust-lib-src.nix { - inherit runCommand rustc; - }; + rustLibSrc = callPackage ./rust-lib-src.nix { inherit runCommand rustc; }; # Hooks - inherit (callPackages (path + "/pkgs/build-support/rust/hooks") { - inherit stdenv cargo rustc; - }) cargoBuildHook cargoCheckHook cargoInstallHook cargoNextestHook cargoSetupHook maturinBuildHook bindgenHook; + inherit (callPackages (path + "/pkgs/build-support/rust/hooks") { inherit stdenv cargo rustc; }) + cargoBuildHook + cargoCheckHook + cargoInstallHook + cargoNextestHook + cargoSetupHook + maturinBuildHook + bindgenHook + ; } diff --git a/pkgs/by-name/ru/rust/packages.nix b/pkgs/by-name/ru/rust/packages.nix index 1f27823..7789303 100644 --- a/pkgs/by-name/ru/rust/packages.nix +++ b/pkgs/by-name/ru/rust/packages.nix @@ -1,18 +1,24 @@ { ... }: res: pkgs: super: -with pkgs; -{ - rust_1_77 = callPackage ./1_77.nix { +with pkgs; { + rust_1_80 = callPackage ./1_80.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 = rustPackages_1_77; + rustPackages_1_80 = rust_1_80.packages.stable; + 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 { }; } diff --git a/pkgs/by-name/ru/rust/rustc.nix b/pkgs/by-name/ru/rust/rustc.nix index 6c84dde..6e4ae74 100644 --- a/pkgs/by-name/ru/rust/rustc.nix +++ b/pkgs/by-name/ru/rust/rustc.nix @@ -1,30 +1,53 @@ -{ lib, stdenv, removeReferencesTo, pkgsBuildBuild, pkgsBuildHost, pkgsBuildTarget, targetPackages -, llvmShared, llvmSharedForBuild, llvmSharedForHost, llvmSharedForTarget, llvmPackages -, fetchurl, file, python3 -, darwin, cargo, cmake, rustc, rustfmt -, pkg-config, openssl, xz -, libiconv -, which, libffi -, withBundledLLVM ? false -, enableRustcDev ? true -, version -, sha256 -, patches ? [] -# , fd -# , ripgrep -# , wezterm -# , firefox -# , thunderbird -# This only builds std for target and reuses the rustc from build. -, fastCross -, lndir -, makeWrapper +{ + lib, + stdenv, + removeReferencesTo, + pkgsBuildBuild, + pkgsBuildHost, + pkgsBuildTarget, + targetPackages, + llvmShared, + llvmSharedForBuild, + llvmSharedForHost, + llvmSharedForTarget, + llvmPackages, + runCommandLocal, + fetchurl, + file, + python3, + darwin, + cargo, + cmake, + 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}" = - "${pkgsBuildHost.stdenv.cc.targetPrefix}pkg-config"; + "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' - optional (stdenv.isLinux && !withBundledLLVM) "--push-state --as-needed -lstdc++ --pop-state" + # when linking stage1 libstd: cc: undefined reference to `__cxa_begin_catch' + # 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 - prefixForStdenv = stdenv: "${stdenv.cc}/bin/${stdenv.cc.targetPrefix}"; - ccPrefixForStdenv = stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang" else "cc"}"; - cxxPrefixForStdenv = stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang++" else "c++"}"; - setBuild = "--set=target.${stdenv.buildPlatform.rust.rustcTarget}"; - setHost = "--set=target.${stdenv.hostPlatform.rust.rustcTarget}"; - setTarget = "--set=target.${stdenv.targetPlatform.rust.rustcTarget}"; - ccForBuild = ccPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv; - cxxForBuild = cxxPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv; - ccForHost = ccPrefixForStdenv pkgsBuildHost.targetPackages.stdenv; - cxxForHost = cxxPrefixForStdenv pkgsBuildHost.targetPackages.stdenv; - ccForTarget = ccPrefixForStdenv pkgsBuildTarget.targetPackages.stdenv; - cxxForTarget = cxxPrefixForStdenv pkgsBuildTarget.targetPackages.stdenv; - in [ - "--sysconfdir=${placeholder "out"}/etc" - "--release-channel=stable" - "--set=build.rustc=${rustc}/bin/rustc" - "--set=build.cargo=${cargo}/bin/cargo" - ] ++ lib.optionals (!(finalAttrs.src.passthru.isReleaseTarball or false)) [ - # release tarballs vendor the rustfmt source; when - # git-bisect'ing from upstream's git repo we must prevent - # attempts to download the missing source tarball - "--set=build.rustfmt=${rustfmt}/bin/rustfmt" - ] ++ [ - "--tools=rustc,rustdoc,rust-analyzer-proc-macro-srv" - "--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 + configureFlags = + let + prefixForStdenv = stdenv: "${stdenv.cc}/bin/${stdenv.cc.targetPrefix}"; + ccPrefixForStdenv = + stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang" else "cc"}"; + cxxPrefixForStdenv = + stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang++" else "c++"}"; + setBuild = "--set=target.${stdenv.buildPlatform.rust.rustcTarget}"; + setHost = "--set=target.${stdenv.hostPlatform.rust.rustcTarget}"; + setTarget = "--set=target.${stdenv.targetPlatform.rust.rustcTarget}"; + ccForBuild = ccPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv; + cxxForBuild = cxxPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv; + ccForHost = ccPrefixForStdenv pkgsBuildHost.targetPackages.stdenv; + cxxForHost = cxxPrefixForStdenv pkgsBuildHost.targetPackages.stdenv; + ccForTarget = ccPrefixForStdenv pkgsBuildTarget.targetPackages.stdenv; + cxxForTarget = cxxPrefixForStdenv pkgsBuildTarget.targetPackages.stdenv; + in + [ + "--sysconfdir=${placeholder "out"}/etc" + "--release-channel=stable" + "--set=build.rustc=${rustc}/bin/rustc" + "--set=build.cargo=${cargo}/bin/cargo" + ] + ++ lib.optionals (!(finalAttrs.src.passthru.isReleaseTarball or false)) [ + # release tarballs vendor the rustfmt source; when + # git-bisect'ing from upstream's git repo we must prevent + # attempts to download the missing source tarball + "--set=build.rustfmt=${rustfmt}/bin/rustfmt" + ] + ++ [ + "--tools=rustc,rustdoc,rust-analyzer-proc-macro-srv" + "--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. - ] ++ optionals (!fastCross) [ - "wasm32-unknown-unknown" + # Other targets that don't need any extra dependencies to build. + ] + ++ optionals (!fastCross) [ + "wasm32-unknown-unknown" - # (build!=target): When cross-building a compiler we need to add - # the build platform as well so rustc can compile build.rs - # scripts. - ] ++ optionals (stdenv.buildPlatform != stdenv.targetPlatform && !fastCross) [ - stdenv.buildPlatform.rust.rustcTargetSpec + # (build!=target): When cross-building a compiler we need to add + # the build platform as well so rustc can compile build.rs + # scripts. + ] + ++ optionals (stdenv.buildPlatform != stdenv.targetPlatform && !fastCross) [ + stdenv.buildPlatform.rust.rustcTargetSpec - # (host!=target): When building a cross-targeting compiler we - # need to add the host platform as well so rustc can compile - # build.rs scripts. - ] ++ optionals (stdenv.hostPlatform != stdenv.targetPlatform && !fastCross) [ - stdenv.hostPlatform.rust.rustcTargetSpec - ])}" + # (host!=target): When building a cross-targeting compiler we + # need to add the host platform as well so rustc can compile + # build.rs scripts. + ] + ++ optionals (stdenv.hostPlatform != stdenv.targetPlatform && !fastCross) [ + stdenv.hostPlatform.rust.rustcTargetSpec + ] + ) + }" - "${setBuild}.cc=${ccForBuild}" - "${setHost}.cc=${ccForHost}" - "${setTarget}.cc=${ccForTarget}" + "${setBuild}.cc=${ccForBuild}" + "${setHost}.cc=${ccForHost}" + "${setTarget}.cc=${ccForTarget}" - "${setBuild}.linker=${ccForBuild}" - "${setHost}.linker=${ccForHost}" - "${setTarget}.linker=${ccForTarget}" + "${setBuild}.linker=${ccForBuild}" + "${setHost}.linker=${ccForHost}" + "${setTarget}.linker=${ccForTarget}" - "${setBuild}.cxx=${cxxForBuild}" - "${setHost}.cxx=${cxxForHost}" - "${setTarget}.cxx=${cxxForTarget}" + "${setBuild}.cxx=${cxxForBuild}" + "${setHost}.cxx=${cxxForHost}" + "${setTarget}.cxx=${cxxForTarget}" - "${setBuild}.crt-static=${lib.boolToString stdenv.buildPlatform.isStatic}" - "${setHost}.crt-static=${lib.boolToString stdenv.hostPlatform.isStatic}" - "${setTarget}.crt-static=${lib.boolToString stdenv.targetPlatform.isStatic}" - ] ++ 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.targetPlatform.rust.isNoStdTarget [ - "--disable-docs" - ] ++ optionals (stdenv.isDarwin && stdenv.isx86_64) [ - # https://github.com/rust-lang/rust/issues/92173 - "--set rust.jemalloc" - ]; + "${setBuild}.crt-static=${lib.boolToString stdenv.buildPlatform.isStatic}" + "${setHost}.crt-static=${lib.boolToString stdenv.hostPlatform.isStatic}" + "${setTarget}.crt-static=${lib.boolToString stdenv.targetPlatform.isStatic}" + ] + ++ 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 fastCross [ + # Since fastCross only builds std, it doesn't make sense (and + # doesn't work) to build a linker. + "--disable-llvm-bitcode-linker" + ] + ++ + optionals + (stdenv.isLinux && !stdenv.targetPlatform.isRedox && !(stdenv.targetPlatform.useLLVM or false)) + [ + "--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.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 '' - runHook preInstall + installPhase = + if fastCross then + '' + runHook preInstall - python ./x.py --keep-stage=0 --stage=1 install library/std - mkdir -v $out/bin $doc $man - 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/ - echo rust-std-${stdenv.hostPlatform.rust.rustcTargetSpec} >> $out/lib/rustlib/components - lndir ${rustc.doc} $doc - lndir ${rustc.man} $man + python ./x.py --keep-stage=0 --stage=1 install library/std + mkdir -v $out/bin $doc $man + ln -s ${rustc.unwrapped}/bin/{rustc,rustdoc} $out/bin + rm -rf -v $out/lib/rustlib/{manifest-rust-std-,}${stdenv.hostPlatform.rust.rustcTargetSpec} + ln -s ${rustc.unwrapped}/lib/rustlib/{manifest-rust-std-,}${stdenv.hostPlatform.rust.rustcTargetSpec} $out/lib/rustlib/ + echo rust-std-${stdenv.hostPlatform.rust.rustcTargetSpec} >> $out/lib/rustlib/components + lndir ${rustc.doc} $doc + lndir ${rustc.man} $man - runHook postInstall - '' else null; + runHook postInstall + '' + else + null; # the rust build system complains that nix alters the checksums dontFixLibtool = true; inherit patches; - postPatch = '' - patchShebangs src/etc + postPatch = + '' + 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 - # export VERBOSE=1 - '' + lib.optionalString (stdenv.isDarwin && stdenv.isx86_64) '' - # See https://github.com/jemalloc/jemalloc/issues/1997 - # Using a value of 48 should work on both emulated and native x86_64-darwin. - export JEMALLOC_SYS_WITH_LG_VADDR=48 - '' + lib.optionalString (!(finalAttrs.src.passthru.isReleaseTarball or false)) '' - mkdir .cargo - cat > .cargo/config <<\EOF - [source.crates-io] - replace-with = "vendored-sources" - [source.vendored-sources] - directory = "vendor" - EOF - ''; + ${optionalString (!withBundledLLVM) "rm -rf src/llvm"} + + # Useful debugging parameter + # export VERBOSE=1 + '' + + lib.optionalString (stdenv.isDarwin && stdenv.isx86_64) '' + # See https://github.com/jemalloc/jemalloc/issues/1997 + # Using a value of 48 should work on both emulated and native x86_64-darwin. + export JEMALLOC_SYS_WITH_LG_VADDR=48 + '' + + lib.optionalString (!(finalAttrs.src.passthru.isReleaseTarball or false)) '' + mkdir .cargo + cat > .cargo/config <<\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 = [ - file python3 rustc cmake - which libffi removeReferencesTo pkg-config xz - ] - ++ optionals fastCross [ lndir makeWrapper ]; + nativeBuildInputs = + [ + file + python3 + rustc + cmake + which + libffi + removeReferencesTo + pkg-config + xz + ] + ++ optionals fastCross [ + lndir + makeWrapper + ]; - buildInputs = [ openssl ] - ++ optionals stdenv.isDarwin [ libiconv Security ] - ++ optional (!withBundledLLVM) llvmShared; + buildInputs = + [ openssl ] + ++ 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) '' - # 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 + postInstall = + lib.optionalString (enableRustcDev && !fastCross) '' + # 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 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 - ''; + # remove uninstall script that doesn't really make sense for Nix. + 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"; - maintainers = with maintainers; [ havvy ] ++ teams.rust.members; - license = [ licenses.mit licenses.asl20 ]; + description = "Safe, concurrent, practical language"; + maintainers = [ ]; + 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" - "i686-freebsd" "x86_64-freebsd" + "x86_64-darwin" + "i686-darwin" + "aarch64-darwin" + "i686-freebsd" + "x86_64-freebsd" "x86_64-solaris" - "aarch64-linux" "armv6l-linux" "armv7l-linux" "i686-linux" - "loongarch64-linux" "powerpc64-linux" "powerpc64le-linux" - "riscv64-linux" "s390x-linux" "x86_64-linux" - "aarch64-netbsd" "armv7l-netbsd" "i686-netbsd" "powerpc-netbsd" + "aarch64-linux" + "armv6l-linux" + "armv7l-linux" + "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-windows" "x86_64-windows" + "i686-openbsd" + "x86_64-openbsd" + "i686-windows" + "x86_64-windows" ]; }; }) diff --git a/pkgs/by-name/ru/rust/rustfmt.nix b/pkgs/by-name/ru/rust/rustfmt.nix index 9cc8df5..4ffa08e 100644 --- a/pkgs/by-name/ru/rust/rustfmt.nix +++ b/pkgs/by-name/ru/rust/rustfmt.nix @@ -1,6 +1,12 @@ -{ lib, stdenv, rustPlatform, rustc, Security, asNightly ? false }: - -rustPlatform.buildRustPackage rec { +{ + lib, + 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 = [ - rustc.llvm - ] ++ lib.optional stdenv.isDarwin Security; + buildInputs = [ 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; { - description = "A tool for formatting Rust code according to style guidelines"; + meta = { + 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 + ]; }; }