commit e3e57b8f1885bf1dc4787728479711f46a4171cc · pyrox.dev/nixpkgs

+98 -2

lib/systems/default.nix

···

       43
       43
        
         elaborate = args': let

     

       44
       44
        
           args = if lib.isString args' then { system = args'; }

     

       45
       45
        
                  else args';

     

       46
       46
       +
       

     

       47
       47
       +
           # TODO: deprecate args.rustc in favour of args.rust after 23.05 is EOL.

     

       48
       48
       +
           rust = assert !(args ? rust && args ? rustc); args.rust or args.rustc or {};

     

       49
       49
       +
       

     

       46
       50
        
           final = {

     

       47
       51
        
             # Prefer to parse `config` as it is strictly more informative.

     

       48
       52
        
             parsed = parse.mkSystemFromString (if args ? config then args.config else args.system);

     
···

       159
       163
        
               ({

     

       160
       164
        
                 linux-kernel = args.linux-kernel or {};

     

       161
       165
        
                 gcc = args.gcc or {};

     

       162
       162
       -
                 rustc = args.rustc or {};

     

       163
       166
        
               } // platforms.select final)

     

       164
       164
       -
               linux-kernel gcc rustc;

     

       167
       167
       +
               linux-kernel gcc;

     

       168
       168
       +
       

     

       169
       169
       +
             # TODO: remove after 23.05 is EOL, with an error pointing to the rust.* attrs.

     

       170
       170
       +
             rustc = args.rustc or {};

     

       171
       171
       +
       

     

       172
       172
       +
             rust = rust // {

     

       173
       173
       +
               # Once args.rustc.platform.target-family is deprecated and

     

       174
       174
       +
               # removed, there will no longer be any need to modify any

     

       175
       175
       +
               # values from args.rust.platform, so we can drop all the

     

       176
       176
       +
               # "args ? rust" etc. checks, and merge args.rust.platform in

     

       177
       177
       +
               # /after/.

     

       178
       178
       +
               platform = rust.platform or {} // {

     

       179
       179
       +
                 # https://doc.rust-lang.org/reference/conditional-compilation.html#target_arch

     

       180
       180
       +
                 arch =

     

       181
       181
       +
                   /**/ if rust ? platform then rust.platform.arch

     

       182
       182
       +
                   else if final.isAarch32 then "arm"

     

       183
       183
       +
                   else if final.isMips64  then "mips64"     # never add "el" suffix

     

       184
       184
       +
                   else if final.isPower64 then "powerpc64"  # never add "le" suffix

     

       185
       185
       +
                   else final.parsed.cpu.name;

     

       186
       186
       +
       

     

       187
       187
       +
                 # https://doc.rust-lang.org/reference/conditional-compilation.html#target_os

     

       188
       188
       +
                 os =

     

       189
       189
       +
                   /**/ if rust ? platform then rust.platform.os or "none"

     

       190
       190
       +
                   else if final.isDarwin then "macos"

     

       191
       191
       +
                   else final.parsed.kernel.name;

     

       192
       192
       +
       

     

       193
       193
       +
                 # https://doc.rust-lang.org/reference/conditional-compilation.html#target_family

     

       194
       194
       +
                 target-family =

     

       195
       195
       +
                   /**/ if args ? rust.platform.target-family then args.rust.platform.target-family

     

       196
       196
       +
                   else if args ? rustc.platform.target-family

     

       197
       197
       +
                   then

     

       198
       198
       +
                     (

     

       199
       199
       +
                       # Since https://github.com/rust-lang/rust/pull/84072

     

       200
       200
       +
                       # `target-family` is a list instead of single value.

     

       201
       201
       +
                       let

     

       202
       202
       +
                         f = args.rustc.platform.target-family;

     

       203
       203
       +
                       in

     

       204
       204
       +
                         if builtins.isList f then f else [ f ]

     

       205
       205
       +
                     )

     

       206
       206
       +
                   else lib.optional final.isUnix "unix"

     

       207
       207
       +
                        ++ lib.optional final.isWindows "windows";

     

       208
       208
       +
       

     

       209
       209
       +
                 # https://doc.rust-lang.org/reference/conditional-compilation.html#target_vendor

     

       210
       210
       +
                 vendor = let

     

       211
       211
       +
                   inherit (final.parsed) vendor;

     

       212
       212
       +
                 in rust.platform.vendor or {

     

       213
       213
       +
                   "w64" = "pc";

     

       214
       214
       +
                 }.${vendor.name} or vendor.name;

     

       215
       215
       +
               };

     

       216
       216
       +
       

     

       217
       217
       +
               # The name of the rust target, even if it is custom. Adjustments are

     

       218
       218
       +
               # because rust has slightly different naming conventions than we do.

     

       219
       219
       +
               rustcTarget = let

     

       220
       220
       +
                 inherit (final.parsed) cpu kernel abi;

     

       221
       221
       +
                 cpu_ = rust.platform.arch or {

     

       222
       222
       +
                   "armv7a" = "armv7";

     

       223
       223
       +
                   "armv7l" = "armv7";

     

       224
       224
       +
                   "armv6l" = "arm";

     

       225
       225
       +
                   "armv5tel" = "armv5te";

     

       226
       226
       +
                   "riscv64" = "riscv64gc";

     

       227
       227
       +
                 }.${cpu.name} or cpu.name;

     

       228
       228
       +
                 vendor_ = final.rust.platform.vendor;

     

       229
       229
       +
               in rust.config

     

       230
       230
       +
                 or "${cpu_}-${vendor_}-${kernel.name}${lib.optionalString (abi.name != "unknown") "-${abi.name}"}";

     

       231
       231
       +
       

     

       232
       232
       +
               # The name of the rust target if it is standard, or the json file

     

       233
       233
       +
               # containing the custom target spec.

     

       234
       234
       +
               rustcTargetSpec =

     

       235
       235
       +
                 /**/ if rust ? platform

     

       236
       236
       +
                 then builtins.toFile (final.rust.rustcTarget + ".json") (builtins.toJSON rust.platform)

     

       237
       237
       +
                 else final.rust.rustcTarget;

     

       238
       238
       +
       

     

       239
       239
       +
               # The name of the rust target if it is standard, or the

     

       240
       240
       +
               # basename of the file containing the custom target spec,

     

       241
       241
       +
               # without the .json extension.

     

       242
       242
       +
               #

     

       243
       243
       +
               # This is the name used by Cargo for target subdirectories.

     

       244
       244
       +
               cargoShortTarget =

     

       245
       245
       +
                 lib.removeSuffix ".json" (baseNameOf "${final.rust.rustcTargetSpec}");

     

       246
       246
       +
       

     

       247
       247
       +
               # When used as part of an environment variable name, triples are

     

       248
       248
       +
               # uppercased and have all hyphens replaced by underscores:

     

       249
       249
       +
               #

     

       250
       250
       +
               # https://github.com/rust-lang/cargo/pull/9169

     

       251
       251
       +
               # https://github.com/rust-lang/cargo/issues/8285#issuecomment-634202431

     

       252
       252
       +
               cargoEnvVarTarget =

     

       253
       253
       +
                 lib.strings.replaceStrings ["-"] ["_"]

     

       254
       254
       +
                   (lib.strings.toUpper final.rust.cargoShortTarget);

     

       255
       255
       +
       

     

       256
       256
       +
               # True if the target is no_std

     

       257
       257
       +
               # https://github.com/rust-lang/rust/blob/2e44c17c12cec45b6a682b1e53a04ac5b5fcc9d2/src/bootstrap/config.rs#L415-L421

     

       258
       258
       +
               isNoStdTarget =

     

       259
       259
       +
                 builtins.any (t: lib.hasInfix t final.rust.rustcTarget) ["-none" "nvptx" "switch" "-uefi"];

     

       260
       260
       +
             };

     

       165
       261
        
       

     

       166
       262
        
             linuxArch =

     

       167
       263
        
               if final.isAarch32 then "arm"

+2 -2

pkgs/applications/blockchains/zcash/default.nix

···

       1
       1
        
       { autoreconfHook, boost180, cargo, coreutils, curl, cxx-rs, db62, fetchFromGitHub

     

       2
       2
       -
       , git, hexdump, lib, libevent, libsodium, makeWrapper, rust, rustPlatform

     

       2
       2
       +
       , git, hexdump, lib, libevent, libsodium, makeWrapper, rustPlatform

     

       3
       3
        
       , pkg-config, Security, stdenv, testers, tl-expected, utf8cpp, util-linux, zcash, zeromq

     

       4
       4
        
       }:

     

       5
       5
        
       

     
···

       57
       57
        
         configureFlags = [

     

       58
       58
        
           "--disable-tests"

     

       59
       59
        
           "--with-boost-libdir=${lib.getLib boost180}/lib"

     

       60
       60
       -
           "RUST_TARGET=${rust.toRustTargetSpec stdenv.hostPlatform}"

     

       60
       60
       +
           "RUST_TARGET=${stdenv.hostPlatform.rust.rustcTargetSpec}"

     

       61
       61
        
         ];

     

       62
       62
        
       

     

       63
       63
        
         enableParallelBuilding = true;

+1 -2

pkgs/applications/misc/effitask/default.nix

···

       5
       5
        
       , openssl

     

       6
       6
        
       , gtk3

     

       7
       7
        
       , stdenv

     

       8
       8
       -
       , rust

     

       9
       8
        
       }:

     

       10
       9
        
       

     

       11
       10
        
       rustPlatform.buildRustPackage rec {

     
···

       28
       27
        
         # default installPhase don't install assets

     

       29
       28
        
         installPhase = ''

     

       30
       29
        
           runHook preInstall

     

       31
       31
       -
           make install PREFIX="$out" TARGET="target/${rust.toRustTarget stdenv.hostPlatform}/release/effitask"

     

       30
       30
       +
           make install PREFIX="$out" TARGET="target/${stdenv.hostPlatform.rust.rustcTarget}/release/effitask"

     

       32
       31
        
           runHook postInstall

     

       33
       32
        
         '';

     

       34
       33

+3 -3

pkgs/applications/window-managers/cosmic/applets/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, rust, rustPlatform

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, rustPlatform

     

       2
       2
        
       , cargo, just, pkg-config, util-linuxMinimal

     

       3
       3
        
       , dbus, glib, libxkbcommon, pulseaudio, wayland

     

       4
       4
        
       }:

     
···

       41
       41
        
       

     

       42
       42
        
         justFlags = [

     

       43
       43
        
           "--set" "prefix" (placeholder "out")

     

       44
       44
       -
           "--set" "target" "${rust.lib.toRustTargetSpecShort stdenv.hostPlatform}/release"

     

       44
       44
       +
           "--set" "target" "${stdenv.hostPlatform.rust.cargoShortTarget}/release"

     

       45
       45
        
         ];

     

       46
       46
        
       

     

       47
       47
        
         # Force linking to libwayland-client, which is always dlopen()ed.

     

       48
       48
       -
         "CARGO_TARGET_${rust.toRustTargetForUseInEnvVars stdenv.hostPlatform}_RUSTFLAGS" =

     

       48
       48
       +
         "CARGO_TARGET_${stdenv.hostPlatform.rust.cargoEnvVarTarget}_RUSTFLAGS" =

     

       49
       49
        
           map (a: "-C link-arg=${a}") [

     

       50
       50
        
             "-Wl,--push-state,--no-as-needed"

     

       51
       51
        
             "-lwayland-client"

+3 -3

pkgs/applications/window-managers/cosmic/panel/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, cargo, just, pkg-config, rust, rustPlatform

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, cargo, just, pkg-config, rustPlatform

     

       2
       2
        
       , libglvnd, libxkbcommon, wayland

     

       3
       3
        
       }:

     

       4
       4
        
       

     
···

       33
       33
        
       

     

       34
       34
        
         justFlags = [

     

       35
       35
        
           "--set" "prefix" (placeholder "out")

     

       36
       36
       -
           "--set" "bin-src" "target/${rust.lib.toRustTargetSpecShort stdenv.hostPlatform}/release/cosmic-panel"

     

       36
       36
       +
           "--set" "bin-src" "target/${stdenv.hostPlatform.rust.cargoShortTarget}/release/cosmic-panel"

     

       37
       37
        
         ];

     

       38
       38
        
       

     

       39
       39
        
         # Force linking to libEGL, which is always dlopen()ed.

     

       40
       40
       -
         "CARGO_TARGET_${rust.toRustTargetForUseInEnvVars stdenv.hostPlatform}_RUSTFLAGS" =

     

       40
       40
       +
         "CARGO_TARGET_${stdenv.hostPlatform.rust.cargoEnvVarTarget}_RUSTFLAGS" =

     

       41
       41
        
           map (a: "-C link-arg=${a}") [

     

       42
       42
        
             "-Wl,--push-state,--no-as-needed"

     

       43
       43
        
             "-lEGL"

+1 -1

pkgs/applications/window-managers/cosmic/settings/default.nix

···

       61
       61
        
           (placeholder "out")

     

       62
       62
        
           "--set"

     

       63
       63
        
           "bin-src"

     

       64
       64
       -
           "target/${rust.lib.toRustTargetSpecShort stdenv.hostPlatform}/release/cosmic-settings"

     

       64
       64
       +
           "target/${stdenv.hostPlatform.rust.cargoShortTarget}/release/cosmic-settings"

     

       65
       65
        
         ];

     

       66
       66
        
       

     

       67
       67
        
         meta = with lib; {

+1 -2

pkgs/build-support/rust/build-rust-crate/build-crate.nix

···

       1
       1
        
       { lib, stdenv

     

       2
       2
        
       , mkRustcDepArgs, mkRustcFeatureArgs, needUnstableCLI

     

       3
       3
       -
       , rust

     

       4
       3
        
       }:

     

       5
       4
        
       

     

       6
       5
        
       { crateName,

     
···

       21
       20
        
               (mkRustcDepArgs dependencies crateRenames)

     

       22
       21
        
               (mkRustcFeatureArgs crateFeatures)

     

       23
       22
        
             ] ++ lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [

     

       24
       24
       -
               "--target" (rust.toRustTargetSpec stdenv.hostPlatform)

     

       23
       23
       +
               "--target" stdenv.hostPlatform.rust.rustcTargetSpec

     

       25
       24
        
             ] ++ lib.optionals (needUnstableCLI dependencies) [

     

       26
       25
        
               "-Z" "unstable-options"

     

       27
       26
        
             ] ++ extraRustcOpts

+5 -5

pkgs/build-support/rust/build-rust-crate/configure-crate.nix

···

       1
       1
       -
       { lib, stdenv, rust, echo_colored, noisily, mkRustcDepArgs, mkRustcFeatureArgs }:

     

       1
       1
       +
       { lib, stdenv, echo_colored, noisily, mkRustcDepArgs, mkRustcFeatureArgs }:

     

       2
       2
        
       {

     

       3
       3
        
         build

     

       4
       4
        
       , buildDependencies

     
···

       124
       124
        
         export CARGO_PKG_AUTHORS="${authors}"

     

       125
       125
        
         export CARGO_PKG_DESCRIPTION="${crateDescription}"

     

       126
       126
        
       

     

       127
       127
       -
         export CARGO_CFG_TARGET_ARCH=${rust.toTargetArch stdenv.hostPlatform}

     

       128
       128
       -
         export CARGO_CFG_TARGET_OS=${rust.toTargetOs stdenv.hostPlatform}

     

       127
       127
       +
         export CARGO_CFG_TARGET_ARCH=${stdenv.hostPlatform.rust.platform.arch}

     

       128
       128
       +
         export CARGO_CFG_TARGET_OS=${stdenv.hostPlatform.rust.platform.os}

     

       129
       129
        
         export CARGO_CFG_TARGET_FAMILY="unix"

     

       130
       130
        
         export CARGO_CFG_UNIX=1

     

       131
       131
        
         export CARGO_CFG_TARGET_ENV="gnu"

     
···

       136
       136
        
         export CARGO_MANIFEST_DIR=$(pwd)

     

       137
       137
        
         export DEBUG="${toString (!release)}"

     

       138
       138
        
         export OPT_LEVEL="${toString optLevel}"

     

       139
       139
       -
         export TARGET="${rust.toRustTargetSpec stdenv.hostPlatform}"

     

       140
       140
       -
         export HOST="${rust.toRustTargetSpec stdenv.buildPlatform}"

     

       139
       139
       +
         export TARGET="${stdenv.hostPlatform.rust.rustcTargetSpec}"

     

       140
       140
       +
         export HOST="${stdenv.buildPlatform.rust.rustcTargetSpec}"

     

       141
       141
        
         export PROFILE=${if release then "release" else "debug"}

     

       142
       142
        
         export OUT_DIR=$(pwd)/target/build/${crateName}.out

     

       143
       143
        
         export CARGO_PKG_VERSION_MAJOR=${lib.elemAt version 0}

+3 -8

pkgs/build-support/rust/build-rust-crate/default.nix

···

       10
       10
        
       , fetchCrate

     

       11
       11
        
       , pkgsBuildBuild

     

       12
       12
        
       , rustc

     

       13
       13
       -
       , rust

     

       14
       13
        
       , cargo

     

       15
       14
        
       , jq

     

       16
       15
        
       , libiconv

     
···

       71
       70
        
         inherit (import ./log.nix { inherit lib; }) noisily echo_colored;

     

       72
       71
        
       

     

       73
       72
        
         configureCrate = import ./configure-crate.nix {

     

       74
       74
       -
           inherit lib stdenv rust echo_colored noisily mkRustcDepArgs mkRustcFeatureArgs;

     

       73
       73
       +
           inherit lib stdenv echo_colored noisily mkRustcDepArgs mkRustcFeatureArgs;

     

       75
       74
        
         };

     

       76
       75
        
       

     

       77
       76
        
         buildCrate = import ./build-crate.nix {

     

       78
       78
       -
           inherit lib stdenv mkRustcDepArgs mkRustcFeatureArgs needUnstableCLI rust;

     

       77
       77
       +
           inherit lib stdenv mkRustcDepArgs mkRustcFeatureArgs needUnstableCLI;

     

       79
       78
        
         };

     

       80
       79
        
       

     

       81
       80
        
         installCrate = import ./install-crate.nix { inherit stdenv; };

     

       82
       82
       -
       

     

       83
       83
       -
         # Allow access to the rust attribute set from inside buildRustCrate, which

     

       84
       84
       -
         # has a parameter that shadows the name.

     

       85
       85
       -
         rustAttrs = rust;

     

       86
       81
        
       in

     

       87
       82
        
       

     

       88
       83
        
         /* The overridable pkgs.buildRustCrate function.

     
···

       310
       305
        
                 depsMetadata = lib.foldl' (str: dep: str + dep.metadata) "" (dependencies ++ buildDependencies);

     

       311
       306
        
                 hashedMetadata = builtins.hashString "sha256"

     

       312
       307
        
                   (crateName + "-" + crateVersion + "___" + toString (mkRustcFeatureArgs crateFeatures) +

     

       313
       313
       -
                     "___" + depsMetadata + "___" + rustAttrs.toRustTarget stdenv.hostPlatform);

     

       308
       308
       +
                     "___" + depsMetadata + "___" + stdenv.hostPlatform.rust.rustcTarget);

     

       314
       309
        
               in

     

       315
       310
        
               lib.substring 0 10 hashedMetadata;

     

       316
       311

+2 -3

pkgs/build-support/rust/build-rust-package/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , importCargoLock

     

       3
       3
        
       , fetchCargoTarball

     

       4
       4
       -
       , rust

     

       5
       4
        
       , stdenv

     

       6
       5
        
       , callPackage

     

       7
       6
        
       , cargoBuildHook

     
···

       78
       77
        
             sha256 = args.cargoSha256;

     

       79
       78
        
           } // depsExtraArgs);

     

       80
       79
        
       

     

       81
       81
       -
         target = rust.toRustTargetSpec stdenv.hostPlatform;

     

       80
       80
       +
         target = stdenv.hostPlatform.rust.rustcTargetSpec;

     

       82
       81
        
         targetIsJSON = lib.hasSuffix ".json" target;

     

       83
       82
        
         useSysroot = targetIsJSON && !__internal_dontAddSysroot;

     

       84
       83
        
       

     

       85
       84
        
         sysroot = callPackage ./sysroot { } {

     

       86
       85
        
           inherit target;

     

       87
       87
       -
           shortTarget = rust.lib.toRustTargetSpecShort stdenv.hostPlatform;

     

       86
       86
       +
           shortTarget = stdenv.hostPlatform.rust.cargoShortTarget;

     

       88
       87
        
           RUSTFLAGS = args.RUSTFLAGS or "";

     

       89
       88
        
           originalCargoToml = src + /Cargo.toml; # profile info is later extracted

     

       90
       89
        
         };

+2 -2

pkgs/build-support/rust/build-rust-package/sysroot/default.nix

···

       1
       1
       -
       { lib, stdenv, rust, rustPlatform, buildPackages }:

     

       1
       1
       +
       { lib, stdenv, rustPlatform, buildPackages }:

     

       2
       2
        
       

     

       3
       3
        
       { shortTarget, originalCargoToml, target, RUSTFLAGS }:

     

       4
       4
        
       

     
···

       26
       26
        
           done

     

       27
       27
        
       

     

       28
       28
        
           export RUST_SYSROOT=$(rustc --print=sysroot)

     

       29
       29
       -
           host=${rust.toRustTarget stdenv.buildPlatform}

     

       29
       29
       +
           host=${stdenv.buildPlatform.rust.rustcTarget}

     

       30
       30
        
           cp -r $RUST_SYSROOT/lib/rustlib/$host $out

     

       31
       31
        
         '';

     

       32
       32

+3 -3

pkgs/build-support/rust/hooks/default.nix

···

       13
       13
        
       # This confusingly-named parameter indicates the *subdirectory of

     

       14
       14
        
       # `target/` from which to copy the build artifacts.  It is derived

     

       15
       15
        
       # from a stdenv platform (or a JSON file).

     

       16
       16
       -
       , target ? rust.lib.toRustTargetSpecShort stdenv.hostPlatform

     

       16
       16
       +
       , target ? stdenv.hostPlatform.rust.cargoShortTarget

     

       17
       17
        
       }:

     

       18
       18
        
       

     

       19
       19
        
       {

     
···

       65
       65
        
               diff = "${lib.getBin buildPackages.diffutils}/bin/diff";

     

       66
       66
        
       

     

       67
       67
        
               cargoConfig = ''

     

       68
       68
       -
                 [target."${rust.toRustTarget stdenv.buildPlatform}"]

     

       68
       68
       +
                 [target."${stdenv.buildPlatform.rust.rustcTarget}"]

     

       69
       69
        
                 "linker" = "${rust.envVars.ccForBuild}"

     

       70
       70
        
                 ${lib.optionalString (stdenv.buildPlatform.config != stdenv.hostPlatform.config) ''

     

       71
       71
       -
                   [target."${rust.toRustTarget stdenv.hostPlatform}"]

     

       71
       71
       +
                   [target."${stdenv.hostPlatform.rust.rustcTarget}"]

     

       72
       72
        
                   "linker" = "${rust.envVars.ccForHost}"

     

       73
       73
        
                 ''}

     

       74
       74
        
                 "rustflags" = [ "-C", "target-feature=${if stdenv.hostPlatform.isStatic then "+" else "-"}crt-static" ]

+29 -98

pkgs/build-support/rust/lib/default.nix

···

       5
       5
        
       }:

     

       6
       6
        
       

     

       7
       7
        
       rec {

     

       8
       8
       -
         # https://doc.rust-lang.org/reference/conditional-compilation.html#target_arch

     

       9
       9
       -
         toTargetArch = platform:

     

       10
       10
       -
           /**/ if platform ? rustc.platform then platform.rustc.platform.arch

     

       11
       11
       -
           else if platform.isAarch32 then "arm"

     

       12
       12
       -
           else if platform.isMips64  then "mips64"     # never add "el" suffix

     

       13
       13
       -
           else if platform.isPower64 then "powerpc64"  # never add "le" suffix

     

       14
       14
       -
           else platform.parsed.cpu.name;

     

       15
       15
       -
       

     

       16
       16
       -
         # https://doc.rust-lang.org/reference/conditional-compilation.html#target_os

     

       17
       17
       -
         toTargetOs = platform:

     

       18
       18
       -
           /**/ if platform ? rustc.platform then platform.rustc.platform.os or "none"

     

       19
       19
       -
           else if platform.isDarwin then "macos"

     

       20
       20
       -
           else platform.parsed.kernel.name;

     

       21
       21
       -
       

     

       22
       22
       -
         # https://doc.rust-lang.org/reference/conditional-compilation.html#target_family

     

       23
       23
       -
         toTargetFamily = platform:

     

       24
       24
       -
           if platform ? rustc.platform.target-family

     

       25
       25
       -
           then

     

       26
       26
       -
             (

     

       27
       27
       -
               # Since https://github.com/rust-lang/rust/pull/84072

     

       28
       28
       -
               # `target-family` is a list instead of single value.

     

       29
       29
       -
               let

     

       30
       30
       -
                 f = platform.rustc.platform.target-family;

     

       31
       31
       -
               in

     

       32
       32
       -
               if builtins.isList f then f else [ f ]

     

       33
       33
       -
             )

     

       34
       34
       -
           else lib.optional platform.isUnix "unix"

     

       35
       35
       -
             ++ lib.optional platform.isWindows "windows";

     

       36
       36
       -
       

     

       37
       37
       -
         # https://doc.rust-lang.org/reference/conditional-compilation.html#target_vendor

     

       38
       38
       -
         toTargetVendor = platform: let

     

       39
       39
       -
           inherit (platform.parsed) vendor;

     

       40
       40
       -
         in platform.rustc.platform.vendor or {

     

       41
       41
       -
           "w64" = "pc";

     

       42
       42
       -
         }.${vendor.name} or vendor.name;

     

       43
       43
       -
       

     

       44
       44
       -
         # Returns the name of the rust target, even if it is custom. Adjustments are

     

       45
       45
       -
         # because rust has slightly different naming conventions than we do.

     

       46
       46
       -
         toRustTarget = platform: let

     

       47
       47
       -
           inherit (platform.parsed) cpu kernel abi;

     

       48
       48
       -
           cpu_ = platform.rustc.platform.arch or {

     

       49
       49
       -
             "armv7a" = "armv7";

     

       50
       50
       -
             "armv7l" = "armv7";

     

       51
       51
       -
             "armv6l" = "arm";

     

       52
       52
       -
             "armv5tel" = "armv5te";

     

       53
       53
       -
             "riscv64" = "riscv64gc";

     

       54
       54
       -
           }.${cpu.name} or cpu.name;

     

       55
       55
       -
           vendor_ = toTargetVendor platform;

     

       56
       56
       -
         in platform.rustc.config

     

       57
       57
       -
           or "${cpu_}-${vendor_}-${kernel.name}${lib.optionalString (abi.name != "unknown") "-${abi.name}"}";

     

       58
       58
       -
       

     

       59
       59
       -
         # Returns the name of the rust target if it is standard, or the json file

     

       60
       60
       -
         # containing the custom target spec.

     

       61
       61
       -
         toRustTargetSpec = platform:

     

       62
       62
       -
           if platform ? rustc.platform

     

       63
       63
       -
           then builtins.toFile (toRustTarget platform + ".json") (builtins.toJSON platform.rustc.platform)

     

       64
       64
       -
           else toRustTarget platform;

     

       65
       65
       -
       

     

       66
       66
       -
         # Returns the name of the rust target if it is standard, or the

     

       67
       67
       -
         # basename of the file containing the custom target spec, without

     

       68
       68
       -
         # the .json extension.

     

       69
       69
       -
         #

     

       70
       70
       -
         # This is the name used by Cargo for target subdirectories.

     

       71
       71
       -
         toRustTargetSpecShort = platform:

     

       72
       72
       -
           lib.removeSuffix ".json"

     

       73
       73
       -
             (baseNameOf "${toRustTargetSpec platform}");

     

       74
       74
       -
       

     

       75
       75
       -
         # When used as part of an environment variable name, triples are

     

       76
       76
       -
         # uppercased and have all hyphens replaced by underscores:

     

       77
       77
       -
         #

     

       78
       78
       -
         # https://github.com/rust-lang/cargo/pull/9169

     

       79
       79
       -
         # https://github.com/rust-lang/cargo/issues/8285#issuecomment-634202431

     

       80
       80
       -
         #

     

       81
       81
       -
         toRustTargetForUseInEnvVars = platform:

     

       82
       82
       -
           lib.strings.replaceStrings ["-"] ["_"]

     

       83
       83
       -
             (lib.strings.toUpper

     

       84
       84
       -
               (toRustTargetSpecShort platform));

     

       85
       85
       -
       

     

       86
       86
       -
         # Returns true if the target is no_std

     

       87
       87
       -
         # https://github.com/rust-lang/rust/blob/2e44c17c12cec45b6a682b1e53a04ac5b5fcc9d2/src/bootstrap/config.rs#L415-L421

     

       88
       88
       -
         IsNoStdTarget = platform: let rustTarget = toRustTarget platform; in

     

       89
       89
       -
           builtins.any (t: lib.hasInfix t rustTarget) ["-none" "nvptx" "switch" "-uefi"];

     

       90
       90
       -
       

     

       91
       8
        
         # These environment variables must be set when using `cargo-c` and

     

       92
       9
        
         # several other tools which do not deal well with cross

     

       93
       10
        
         # compilation.  The symptom of the problem they fix is errors due

     
···

       107
       24
        
           ccForTarget = "${targetPackages.stdenv.cc}/bin/${targetPackages.stdenv.cc.targetPrefix}cc";

     

       108
       25
        
           cxxForTarget = "${targetPackages.stdenv.cc}/bin/${targetPackages.stdenv.cc.targetPrefix}c++";

     

       109
       26
        
       

     

       110
       110
       -
           rustBuildPlatform = toRustTarget stdenv.buildPlatform;

     

       111
       111
       -
           rustBuildPlatformSpec = toRustTargetSpec stdenv.buildPlatform;

     

       112
       112
       -
           rustHostPlatform = toRustTarget stdenv.hostPlatform;

     

       113
       113
       -
           rustHostPlatformSpec = toRustTargetSpec stdenv.hostPlatform;

     

       114
       114
       -
           rustTargetPlatform = toRustTarget stdenv.targetPlatform;

     

       115
       115
       -
           rustTargetPlatformSpec = toRustTargetSpec stdenv.targetPlatform;

     

       27
       27
       +
           rustBuildPlatform = stdenv.buildPlatform.rust.rustcTarget;

     

       28
       28
       +
           rustBuildPlatformSpec = stdenv.buildPlatform.rust.rustcTargetSpec;

     

       29
       29
       +
           rustHostPlatform = stdenv.hostPlatform.rust.rustcTarget;

     

       30
       30
       +
           rustHostPlatformSpec = stdenv.hostPlatform.rust.rustcTargetSpec;

     

       31
       31
       +
           rustTargetPlatform = stdenv.targetPlatform.rust.rustcTarget;

     

       32
       32
       +
           rustTargetPlatformSpec = stdenv.targetPlatform.rust.rustcTargetSpec;

     

       116
       33
        
         in {

     

       117
       34
        
           inherit

     

       118
       35
        
             ccForBuild  cxxForBuild  rustBuildPlatform   rustBuildPlatformSpec

     
···

       131
       48
        
           # the following lines when rustTargetPlatform collides with

     

       132
       49
        
           # rustHostPlatform.

     

       133
       50
        
           + lib.optionalString (rustTargetPlatform != rustHostPlatform) ''

     

       134
       134
       -
             "CC_${toRustTargetForUseInEnvVars stdenv.targetPlatform}=${ccForTarget}" \

     

       135
       135
       -
             "CXX_${toRustTargetForUseInEnvVars stdenv.targetPlatform}=${cxxForTarget}" \

     

       136
       136
       -
             "CARGO_TARGET_${toRustTargetForUseInEnvVars stdenv.targetPlatform}_LINKER=${ccForTarget}" \

     

       51
       51
       +
             "CC_${stdenv.targetPlatform.rust.cargoEnvVarTarget}=${ccForTarget}" \

     

       52
       52
       +
             "CXX_${stdenv.targetPlatform.rust.cargoEnvVarTarget}=${cxxForTarget}" \

     

       53
       53
       +
             "CARGO_TARGET_${stdenv.targetPlatform.rust.cargoEnvVarTarget}_LINKER=${ccForTarget}" \

     

       137
       54
        
           '' + ''

     

       138
       138
       -
             "CC_${toRustTargetForUseInEnvVars stdenv.hostPlatform}=${ccForHost}" \

     

       139
       139
       -
             "CXX_${toRustTargetForUseInEnvVars stdenv.hostPlatform}=${cxxForHost}" \

     

       140
       140
       -
             "CARGO_TARGET_${toRustTargetForUseInEnvVars stdenv.hostPlatform}_LINKER=${ccForHost}" \

     

       55
       55
       +
             "CC_${stdenv.hostPlatform.rust.cargoEnvVarTarget}=${ccForHost}" \

     

       56
       56
       +
             "CXX_${stdenv.hostPlatform.rust.cargoEnvVarTarget}=${cxxForHost}" \

     

       57
       57
       +
             "CARGO_TARGET_${stdenv.hostPlatform.rust.cargoEnvVarTarget}_LINKER=${ccForHost}" \

     

       141
       58
        
           '' + ''

     

       142
       142
       -
             "CC_${toRustTargetForUseInEnvVars stdenv.buildPlatform}=${ccForBuild}" \

     

       143
       143
       -
             "CXX_${toRustTargetForUseInEnvVars stdenv.buildPlatform}=${cxxForBuild}" \

     

       144
       144
       -
             "CARGO_TARGET_${toRustTargetForUseInEnvVars stdenv.buildPlatform}_LINKER=${ccForBuild}" \

     

       59
       59
       +
             "CC_${stdenv.buildPlatform.rust.cargoEnvVarTarget}=${ccForBuild}" \

     

       60
       60
       +
             "CXX_${stdenv.buildPlatform.rust.cargoEnvVarTarget}=${cxxForBuild}" \

     

       61
       61
       +
             "CARGO_TARGET_${stdenv.buildPlatform.rust.cargoEnvVarTarget}_LINKER=${ccForBuild}" \

     

       145
       62
        
             "CARGO_BUILD_TARGET=${rustBuildPlatform}" \

     

       146
       63
        
             "HOST_CC=${buildPackages.stdenv.cc}/bin/cc" \

     

       147
       64
        
             "HOST_CXX=${buildPackages.stdenv.cc}/bin/c++" \

     

       148
       65
        
           '';

     

       149
       66
        
         };

     

       67
       67
       +
       } // lib.mapAttrs (old: new: platform:

     

       68
       68
       +
         # TODO: enable warning after 23.05 is EOL.

     

       69
       69
       +
         # lib.warn "`rust.${old} platform` is deprecated. Use `platform.rust.${new}` instead."

     

       70
       70
       +
           lib.getAttrFromPath new platform.rust)

     

       71
       71
       +
       {

     

       72
       72
       +
         toTargetArch = [ "platform" "arch" ];

     

       73
       73
       +
         toTargetOs = [ "platform" "os" ];

     

       74
       74
       +
         toTargetFamily = [ "platform" "target-family" ];

     

       75
       75
       +
         toTargetVendor = [ "platform" "vendor" ];

     

       76
       76
       +
         toRustTarget = [ "rustcTarget" ];

     

       77
       77
       +
         toRustTargetSpec = [ "rustcTargetSpec" ];

     

       78
       78
       +
         toRustTargetSpecShort = [ "cargoShortTarget" ];

     

       79
       79
       +
         toRustTargetForUseInEnvVars = [ "cargoEnvVarTarget" ];

     

       80
       80
       +
         IsNoStdTarget = [ "isNoStdTarget" ];

     

       150
       81
        
       }

+1 -2

pkgs/desktops/gnome/core/gnome-tour/default.nix

···

       17
       17
        
       , libadwaita

     

       18
       18
        
       , librsvg

     

       19
       19
        
       , rustc

     

       20
       20
       -
       , rust

     

       21
       20
        
       , writeText

     

       22
       21
        
       , cargo

     

       23
       22
        
       }:

     
···

       65
       64
        
             # ERROR: 'rust' compiler binary not defined in cross or native file

     

       66
       65
        
             crossFile = writeText "cross-file.conf" ''

     

       67
       66
        
               [binaries]

     

       68
       68
       -
               rust = [ 'rustc', '--target', '${rust.toRustTargetSpec stdenv.hostPlatform}' ]

     

       67
       67
       +
               rust = [ 'rustc', '--target', '${stdenv.hostPlatform.rust.rustcTargetSpec}' ]

     

       69
       68
        
             '';

     

       70
       69
        
           in

     

       71
       70
        
           lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [ "--cross-file=${crossFile}" ];

+2 -4

pkgs/development/compilers/mrustc/bootstrap.nix

···

       2
       2
        
       , fetchurl

     

       3
       3
        
       , mrustc

     

       4
       4
        
       , mrustc-minicargo

     

       5
       5
       -
       , rust

     

       6
       5
        
       , llvm_12

     

       7
       6
        
       , llvmPackages_12

     

       8
       7
        
       , libffi

     
···

       74
       73
        
           "MRUSTC=${mrustc}/bin/mrustc"

     

       75
       74
        
           #"MINICARGO=${mrustc-minicargo}/bin/minicargo"  # FIXME: we need to rebuild minicargo locally so --manifest-overrides is applied

     

       76
       75
        
           "LLVM_CONFIG=${llvm_12.dev}/bin/llvm-config"

     

       77
       77
       -
           "RUSTC_TARGET=${rust.toRustTarget stdenv.targetPlatform}"

     

       76
       76
       +
           "RUSTC_TARGET=${stdenv.targetPlatform.rust.rustcTarget}"

     

       78
       77
        
         ];

     

       79
       78
        
       

     

       80
       79
        
         buildPhase = ''

     
···

       129
       128
        
           cp run_rustc/${outputDir}/prefix/bin/rustc_binary $out/bin/rustc

     

       130
       129
        
       

     

       131
       130
        
           cp -r run_rustc/${outputDir}/prefix/lib/* $out/lib/

     

       132
       132
       -
           cp $out/lib/rustlib/${rust.toRustTarget stdenv.targetPlatform}/lib/*.so $out/lib/

     

       131
       131
       +
           cp $out/lib/rustlib/${stdenv.targetPlatform.rust.rustcTarget}/lib/*.so $out/lib/

     

       133
       132
        
           runHook postInstall

     

       134
       133
        
         '';

     

       135
       134
        
       

     
···

       146
       145
        
           platforms = [ "x86_64-linux" ];

     

       147
       146
        
         };

     

       148
       147
        
       }

     

       149
       149
       -

+2 -2

pkgs/development/compilers/rust/bootstrap.nix

···

       1
       1
       -
       { stdenv, fetchurl, rust, callPackage, version, hashes }:

     

       1
       1
       +
       { stdenv, fetchurl, callPackage, version, hashes }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         platform = rust.toRustTarget stdenv.hostPlatform;

     

       4
       4
       +
         platform = stdenv.hostPlatform.rust.rustcTarget;

     

       5
       5
        
       

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
            url = "https://static.rust-lang.org/dist/rust-${version}-${platform}.tar.gz";

+2 -2

pkgs/development/compilers/rust/cargo.nix

···

       1
       1
        
       { lib, stdenv, pkgsBuildHost, pkgsHostHost

     

       2
       2
        
       , file, curl, pkg-config, python3, openssl, cmake, zlib

     

       3
       3
       -
       , installShellFiles, makeWrapper, rustPlatform, rust, rustc

     

       3
       3
       +
       , installShellFiles, makeWrapper, rustPlatform, rustc

     

       4
       4
        
       , CoreFoundation, Security

     

       5
       5
        
       , auditable ? !cargo-auditable.meta.broken

     

       6
       6
        
       , cargo-auditable

     
···

       116
       116
        
           broken = stdenv.hostPlatform.isx86 && stdenv.buildPlatform != stdenv.hostPlatform;

     

       117
       117
        
         };

     

       118
       118
        
       }

     

       119
       119
       -
       // lib.optionalAttrs (rust.toRustTarget stdenv.buildPlatform != rust.toRustTarget stdenv.hostPlatform) {

     

       119
       119
       +
       // lib.optionalAttrs (stdenv.buildPlatform.rust.rustcTarget != stdenv.hostPlatform.rust.rustcTarget) {

     

       120
       120
        
         HOST_PKG_CONFIG_PATH="${pkgsBuildBuild.pkg-config}/bin/pkg-config";

     

       121
       121
        
       })

+19 -19

pkgs/development/compilers/rust/rustc.nix

···

       1
       1
        
       { lib, stdenv, removeReferencesTo, pkgsBuildBuild, pkgsBuildHost, pkgsBuildTarget, targetPackages

     

       2
       2
        
       , llvmShared, llvmSharedForBuild, llvmSharedForHost, llvmSharedForTarget, llvmPackages

     

       3
       3
        
       , fetchurl, file, python3

     

       4
       4
       -
       , darwin, cargo, cmake, rust, rustc

     

       4
       4
       +
       , darwin, cargo, cmake, rustc

     

       5
       5
        
       , pkg-config, openssl, xz

     

       6
       6
        
       , libiconv

     

       7
       7
        
       , which, libffi

     
···

       51
       51
        
         # but it does support checking these idiosyncratic PKG_CONFIG_${TRIPLE}

     

       52
       52
        
         # environment variables.

     

       53
       53
        
         # [1]: https://github.com/rust-lang/pkg-config-rs/issues/53

     

       54
       54
       -
         "PKG_CONFIG_${builtins.replaceStrings ["-"] ["_"] (rust.toRustTarget stdenv.buildPlatform)}" =

     

       54
       54
       +
         "PKG_CONFIG_${builtins.replaceStrings ["-"] ["_"] stdenv.buildPlatform.rust.rustcTarget}" =

     

       55
       55
        
           "${pkgsBuildHost.stdenv.cc.targetPrefix}pkg-config";

     

       56
       56
        
       

     

       57
       57
        
         NIX_LDFLAGS = toString (

     
···

       69
       69
        
           prefixForStdenv = stdenv: "${stdenv.cc}/bin/${stdenv.cc.targetPrefix}";

     

       70
       70
        
           ccPrefixForStdenv = stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang" else "cc"}";

     

       71
       71
        
           cxxPrefixForStdenv = stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang++" else "c++"}";

     

       72
       72
       -
           setBuild  = "--set=target.${rust.toRustTarget stdenv.buildPlatform}";

     

       73
       73
       -
           setHost   = "--set=target.${rust.toRustTarget stdenv.hostPlatform}";

     

       74
       74
       -
           setTarget = "--set=target.${rust.toRustTarget stdenv.targetPlatform}";

     

       72
       72
       +
           setBuild  = "--set=target.${stdenv.buildPlatform.rust.rustcTarget}";

     

       73
       73
       +
           setHost   = "--set=target.${stdenv.hostPlatform.rust.rustcTarget}";

     

       74
       74
       +
           setTarget = "--set=target.${stdenv.targetPlatform.rust.rustcTarget}";

     

       75
       75
        
           ccForBuild  = ccPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv;

     

       76
       76
        
           cxxForBuild  = cxxPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv;

     

       77
       77
        
           ccForHost  = ccPrefixForStdenv pkgsBuildHost.targetPackages.stdenv;

     
···

       85
       85
        
           "--tools=rustc,rust-analyzer-proc-macro-srv"

     

       86
       86
        
           "--enable-rpath"

     

       87
       87
        
           "--enable-vendor"

     

       88
       88
       -
           "--build=${rust.toRustTargetSpec stdenv.buildPlatform}"

     

       89
       89
       -
           "--host=${rust.toRustTargetSpec stdenv.hostPlatform}"

     

       88
       88
       +
           "--build=${stdenv.buildPlatform.rust.rustcTargetSpec}"

     

       89
       89
       +
           "--host=${stdenv.hostPlatform.rust.rustcTargetSpec}"

     

       90
       90
        
           # std is built for all platforms in --target.

     

       91
       91
        
           "--target=${concatStringsSep "," ([

     

       92
       92
       -
             (rust.toRustTargetSpec stdenv.targetPlatform)

     

       92
       92
       +
             stdenv.targetPlatform.rust.rustcTargetSpec

     

       93
       93
        
       

     

       94
       94
        
           # (build!=target): When cross-building a compiler we need to add

     

       95
       95
        
           # the build platform as well so rustc can compile build.rs

     

       96
       96
        
           # scripts.

     

       97
       97
        
           ] ++ optionals (stdenv.buildPlatform != stdenv.targetPlatform && !fastCross) [

     

       98
       98
       -
             (rust.toRustTargetSpec stdenv.buildPlatform)

     

       98
       98
       +
             stdenv.buildPlatform.rust.rustcTargetSpec

     

       99
       99
        
       

     

       100
       100
        
           # (host!=target): When building a cross-targeting compiler we

     

       101
       101
        
           # need to add the host platform as well so rustc can compile

     

       102
       102
        
           # build.rs scripts.

     

       103
       103
        
           ] ++ optionals (stdenv.hostPlatform != stdenv.targetPlatform && !fastCross) [

     

       104
       104
       -
             (rust.toRustTargetSpec stdenv.hostPlatform)

     

       104
       104
       +
             stdenv.hostPlatform.rust.rustcTargetSpec

     

       105
       105
        
           ])}"

     

       106
       106
        
       

     

       107
       107
        
           "${setBuild}.cc=${ccForBuild}"

     
···

       132
       132
        
           "${setHost}.musl-root=${pkgsBuildHost.targetPackages.stdenv.cc.libc}"

     

       133
       133
        
         ] ++ optionals stdenv.targetPlatform.isMusl [

     

       134
       134
        
           "${setTarget}.musl-root=${pkgsBuildTarget.targetPackages.stdenv.cc.libc}"

     

       135
       135
       -
         ] ++ optionals (rust.IsNoStdTarget stdenv.targetPlatform) [

     

       135
       135
       +
         ] ++ optionals stdenv.targetPlatform.rust.isNoStdTarget [

     

       136
       136
        
           "--disable-docs"

     

       137
       137
        
         ] ++ optionals (stdenv.isDarwin && stdenv.isx86_64) [

     

       138
       138
        
           # https://github.com/rust-lang/rust/issues/92173

     
···

       144
       144
        
         buildPhase = if fastCross then "

     

       145
       145
        
           runHook preBuild

     

       146
       146
        
       

     

       147
       147
       -
           mkdir -p build/${rust.toRustTargetSpec stdenv.hostPlatform}/stage0-{std,rustc}/${rust.toRustTargetSpec stdenv.hostPlatform}/release/

     

       148
       148
       -
           ln -s ${rustc}/lib/rustlib/${rust.toRustTargetSpec stdenv.hostPlatform}/libstd-*.so build/${rust.toRustTargetSpec stdenv.hostPlatform}/stage0-std/${rust.toRustTargetSpec stdenv.hostPlatform}/release/libstd.so

     

       149
       149
       -
           ln -s ${rustc}/lib/rustlib/${rust.toRustTargetSpec stdenv.hostPlatform}/librustc_driver-*.so build/${rust.toRustTargetSpec stdenv.hostPlatform}/stage0-rustc/${rust.toRustTargetSpec stdenv.hostPlatform}/release/librustc.so

     

       150
       150
       -
           ln -s ${rustc}/bin/rustc build/${rust.toRustTargetSpec stdenv.hostPlatform}/stage0-rustc/${rust.toRustTargetSpec stdenv.hostPlatform}/release/rustc-main

     

       151
       151
       -
           touch build/${rust.toRustTargetSpec stdenv.hostPlatform}/stage0-std/${rust.toRustTargetSpec stdenv.hostPlatform}/release/.libstd.stamp

     

       152
       152
       -
           touch build/${rust.toRustTargetSpec stdenv.hostPlatform}/stage0-rustc/${rust.toRustTargetSpec stdenv.hostPlatform}/release/.librustc.stamp

     

       147
       147
       +
           mkdir -p build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-{std,rustc}/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/

     

       148
       148
       +
           ln -s ${rustc}/lib/rustlib/${stdenv.hostPlatform.rust.rustcTargetSpec}/libstd-*.so build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-std/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/libstd.so

     

       149
       149
       +
           ln -s ${rustc}/lib/rustlib/${stdenv.hostPlatform.rust.rustcTargetSpec}/librustc_driver-*.so build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-rustc/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/librustc.so

     

       150
       150
       +
           ln -s ${rustc}/bin/rustc build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-rustc/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/rustc-main

     

       151
       151
       +
           touch build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-std/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/.libstd.stamp

     

       152
       152
       +
           touch build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-rustc/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/.librustc.stamp

     

       153
       153
        
           python ./x.py --keep-stage=0 --stage=1 build library/std

     

       154
       154
        
       

     

       155
       155
        
           runHook postBuild

     
···

       162
       162
        
           mkdir -v $out/bin $doc $man

     

       163
       163
        
           makeWrapper ${rustc}/bin/rustc $out/bin/rustc --add-flags "--sysroot $out"

     

       164
       164
        
           makeWrapper ${rustc}/bin/rustdoc $out/bin/rustdoc --add-flags "--sysroot $out"

     

       165
       165
       -
           ln -s ${rustc}/lib/rustlib/{manifest-rust-std-,}${rust.toRustTargetSpec stdenv.hostPlatform} $out/lib/rustlib/

     

       166
       166
       -
           echo rust-std-${rust.toRustTargetSpec stdenv.hostPlatform} >> $out/lib/rustlib/components

     

       165
       165
       +
           ln -s ${rustc}/lib/rustlib/{manifest-rust-std-,}${stdenv.hostPlatform.rust.rustcTargetSpec} $out/lib/rustlib/

     

       166
       166
       +
           echo rust-std-${stdenv.hostPlatform.rust.rustcTargetSpec} >> $out/lib/rustlib/components

     

       167
       167
        
           lndir ${rustc.doc} $doc

     

       168
       168
        
           lndir ${rustc.man} $man

     

       169
       169

+3 -5

pkgs/development/interpreters/python/hooks/default.nix

···

       183
       183
        
             };

     

       184
       184
        
           } ./setuptools-check-hook.sh) {};

     

       185
       185
        
       

     

       186
       186
       -
           setuptoolsRustBuildHook = callPackage ({ makePythonHook, setuptools-rust, rust }:

     

       186
       186
       +
           setuptoolsRustBuildHook = callPackage ({ makePythonHook, setuptools-rust }:

     

       187
       187
        
             makePythonHook {

     

       188
       188
        
               name = "setuptools-rust-setup-hook";

     

       189
       189
        
               propagatedBuildInputs = [ setuptools-rust ];

     

       190
       190
        
               substitutions = {

     

       191
       191
        
                 pyLibDir = "${python}/lib/${python.libPrefix}";

     

       192
       192
       -
                 cargoBuildTarget = rust.toRustTargetSpec stdenv.hostPlatform;

     

       193
       193
       -
                 cargoLinkerVar = lib.toUpper (

     

       194
       194
       -
                     builtins.replaceStrings ["-"] ["_"] (

     

       195
       195
       -
                       rust.toRustTarget stdenv.hostPlatform));

     

       192
       192
       +
                 cargoBuildTarget = stdenv.hostPlatform.rust.rustcTargetSpec;

     

       193
       193
       +
                 cargoLinkerVar = stdenv.hostPlatform.rust.cargoEnvVarTarget;

     

       196
       194
        
                 targetLinker = "${stdenv.cc}/bin/${stdenv.cc.targetPrefix}cc";

     

       197
       195
        
               };

     

       198
       196
        
             } ./setuptools-rust-hook.sh) {};

+1 -2

pkgs/development/libraries/gstreamer/rs/default.nix

···

       8
       8
        
       , ninja

     

       9
       9
        
       , python3

     

       10
       10
        
       , pkg-config

     

       11
       11
       -
       , rust

     

       12
       11
        
       , rustc

     

       13
       12
        
       , cargo

     

       14
       13
        
       , cargo-c

     
···

       208
       207
        
         ] ++ (let

     

       209
       208
        
           crossFile = writeText "cross-file.conf" ''

     

       210
       209
        
             [binaries]

     

       211
       211
       -
             rust = [ 'rustc', '--target', '${rust.toRustTargetSpec stdenv.hostPlatform}' ]

     

       210
       210
       +
             rust = [ 'rustc', '--target', '${stdenv.hostPlatform.rust.rustcTargetSpec}' ]

     

       212
       211
        
           '';

     

       213
       212
        
         in lib.optionals (stdenv.buildPlatform != stdenv.hostPlatform) [

     

       214
       213
        
           "--cross-file=${crossFile}"

+4 -6

pkgs/development/libraries/libdovi/default.nix

···

       5
       5
        
       , rust

     

       6
       6
        
       , stdenv

     

       7
       7
        
       }:

     

       8
       8
       -
       let

     

       9
       9
       -
         rustTargetPlatformSpec = rust.toRustTargetSpec stdenv.hostPlatform;

     

       10
       10
       -
       in

     

       8
       8
       +
       

     

       11
       9
        
       rustPlatform.buildRustPackage rec {

     

       12
       10
        
         pname = "libdovi";

     

       13
       11
        
         version = "3.1.2";

     
···

       28
       26
        
       

     

       29
       27
        
         buildPhase = ''

     

       30
       28
        
           runHook preBuild

     

       31
       31
       -
           ${rust.envVars.setEnv} cargo cbuild -j $NIX_BUILD_CORES --release --frozen --prefix=${placeholder "out"} --target ${rustTargetPlatformSpec}

     

       29
       29
       +
           ${rust.envVars.setEnv} cargo cbuild -j $NIX_BUILD_CORES --release --frozen --prefix=${placeholder "out"} --target ${stdenv.hostPlatform.rust.rustcTarget}

     

       32
       30
        
           runHook postBuild

     

       33
       31
        
         '';

     

       34
       32
        
       

     

       35
       33
        
         installPhase = ''

     

       36
       34
        
           runHook preInstall

     

       37
       37
       -
           ${rust.envVars.setEnv} cargo cinstall -j $NIX_BUILD_CORES --release --frozen --prefix=${placeholder "out"} --target ${rustTargetPlatformSpec}

     

       35
       35
       +
           ${rust.envVars.setEnv} cargo cinstall -j $NIX_BUILD_CORES --release --frozen --prefix=${placeholder "out"} --target ${stdenv.hostPlatform.rust.rustcTarget}

     

       38
       36
        
           runHook postInstall

     

       39
       37
        
         '';

     

       40
       38
        
       

     

       41
       39
        
         checkPhase = ''

     

       42
       40
        
           runHook preCheck

     

       43
       43
       -
           ${rust.envVars.setEnv} cargo ctest -j $NIX_BUILD_CORES --release --frozen --prefix=${placeholder "out"} --target ${rustTargetPlatformSpec}

     

       41
       41
       +
           ${rust.envVars.setEnv} cargo ctest -j $NIX_BUILD_CORES --release --frozen --prefix=${placeholder "out"} --target ${stdenv.hostPlatform.rust.rustcTarget}

     

       44
       42
        
           runHook postCheck

     

       45
       43
        
         '';

     

       46
       44

+2 -5

pkgs/development/libraries/libimagequant/default.nix

···

       1
       1
        
       { lib, stdenv, fetchFromGitHub, fetchurl, rust, rustPlatform, cargo-c, python3 }:

     

       2
       2
        
       

     

       3
       3
       -
       let

     

       4
       4
       -
         rustTargetPlatformSpec = rust.toRustTargetSpec stdenv.hostPlatform;

     

       5
       5
       -
       in

     

       6
       3
        
       rustPlatform.buildRustPackage rec {

     

       7
       4
        
         pname = "libimagequant";

     

       8
       5
        
         version = "4.2.2";

     
···

       26
       23
        
       

     

       27
       24
        
         postBuild = ''

     

       28
       25
        
           pushd imagequant-sys

     

       29
       29
       -
           ${rust.envVars.setEnv} cargo cbuild --release --frozen --prefix=${placeholder "out"} --target ${rustTargetPlatformSpec}

     

       26
       26
       +
           ${rust.envVars.setEnv} cargo cbuild --release --frozen --prefix=${placeholder "out"} --target ${stdenv.hostPlatform.rust.rustcTarget}

     

       30
       27
        
           popd

     

       31
       28
        
         '';

     

       32
       29
        
       

     

       33
       30
        
         postInstall = ''

     

       34
       31
        
           pushd imagequant-sys

     

       35
       35
       -
           ${rust.envVars.setEnv} cargo cinstall --release --frozen --prefix=${placeholder "out"} --target ${rustTargetPlatformSpec}

     

       32
       32
       +
           ${rust.envVars.setEnv} cargo cinstall --release --frozen --prefix=${placeholder "out"} --target ${stdenv.hostPlatform.rust.rustcTarget}

     

       36
       33
        
           popd

     

       37
       34
        
         '';

     

       38
       35

+1 -2

pkgs/development/libraries/librsvg/default.nix

···

       15
       15
        
       , libobjc

     

       16
       16
        
       , rustPlatform

     

       17
       17
        
       , rustc

     

       18
       18
       -
       , rust

     

       19
       18
        
       , cargo-auditable-cargo-wrapper

     

       20
       19
        
       , gi-docgen

     

       21
       20
        
       , python3Packages

     
···

       106
       105
        
       

     

       107
       106
        
           "--enable-always-build-tests"

     

       108
       107
        
         ] ++ lib.optional stdenv.isDarwin "--disable-Bsymbolic"

     

       109
       109
       -
           ++ lib.optional (stdenv.buildPlatform != stdenv.hostPlatform) "RUST_TARGET=${rust.toRustTarget stdenv.hostPlatform}";

     

       108
       108
       +
           ++ lib.optional (stdenv.buildPlatform != stdenv.hostPlatform) "RUST_TARGET=${stdenv.hostPlatform.rust.rustcTarget}";

     

       110
       109
        
       

     

       111
       110
        
         doCheck = false; # all tests fail on libtool-generated rsvg-convert not being able to find coreutils

     

       112
       111

+1 -1

pkgs/development/libraries/relibc/default.nix

···

       64
       64
        
         '';

     

       65
       65
        
       

     

       66
       66
        
         # TODO: should be hostPlatform

     

       67
       67
       -
         TARGET = buildPackages.rust.toRustTargetSpec stdenvNoCC.targetPlatform;

     

       67
       67
       +
         TARGET = stdenvNoCC.targetPlatform.rust.rustcTargetSpec;

     

       68
       68
        
       

     

       69
       69
        
         cargoLock = {

     

       70
       70
        
           lockFile = ./Cargo.lock;

+2 -2

pkgs/development/libraries/rustc-demangle/default.nix

···

       1
       1
       -
       { rustPlatform, fetchFromGitHub, rust, lib, stdenv }:

     

       1
       1
       +
       { rustPlatform, fetchFromGitHub, lib, stdenv }:

     

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "rustc-demangle";

     
···

       24
       24
        
       

     

       25
       25
        
         postInstall = ''

     

       26
       26
        
           mkdir -p $out/lib

     

       27
       27
       -
           cp target/${rust.toRustTargetSpec stdenv.hostPlatform}/release/librustc_demangle.so $out/lib

     

       27
       27
       +
           cp target/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/librustc_demangle.so $out/lib

     

       28
       28
        
           cp -R crates/capi/include $out

     

       29
       29
        
         '';

     

       30
       30

+1 -2

pkgs/development/tools/lalrpop/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , rustPlatform

     

       3
       3
       -
       , rust

     

       4
       3
        
       , fetchFromGitHub

     

       5
       4
        
       , substituteAll

     

       6
       5
        
       , stdenv

     
···

       24
       23
        
         patches = [

     

       25
       24
        
           (substituteAll {

     

       26
       25
        
             src = ./use-correct-binary-path-in-tests.patch;

     

       27
       27
       -
             target_triple = rust.toRustTarget stdenv.hostPlatform;

     

       26
       26
       +
             target_triple = stdenv.hostPlatform.rust.rustcTarget;

     

       28
       27
        
           })

     

       29
       28
        
         ];

     

       30
       29

+1 -2

pkgs/development/tools/rust/cargo-benchcmp/default.nix

···

       2
       2
        
       , rustPlatform

     

       3
       3
        
       , fetchFromGitHub

     

       4
       4
        
       , substituteAll

     

       5
       5
       -
       , rust

     

       6
       5
        
       , stdenv

     

       7
       6
        
       }:

     

       8
       7
        
       

     
···

       23
       22
        
           # patch the binary path so tests can find the binary when `--target` is present

     

       24
       23
        
           (substituteAll {

     

       25
       24
        
             src = ./fix-test-binary-path.patch;

     

       26
       26
       -
             shortTarget = rust.toRustTarget stdenv.hostPlatform;

     

       25
       25
       +
             shortTarget = stdenv.hostPlatform.rust.rustcTarget;

     

       27
       26
        
           })

     

       28
       27
        
         ];

     

       29
       28

+1 -2

pkgs/development/tools/rust/cargo-watch/default.nix

···

       5
       5
        
       , Cocoa

     

       6
       6
        
       , CoreServices

     

       7
       7
        
       , Foundation

     

       8
       8
       -
       , rust

     

       9
       8
        
       , libiconv

     

       10
       9
        
       }:

     

       11
       10
        
       

     
···

       27
       26
        
         # `test with_cargo` tries to call cargo-watch as a cargo subcommand

     

       28
       27
        
         # (calling cargo-watch with command `cargo watch`)

     

       29
       28
        
         preCheck = ''

     

       30
       30
       -
           export PATH="$(pwd)/target/${rust.toRustTarget stdenv.hostPlatform}/release:$PATH"

     

       29
       29
       +
           export PATH="$(pwd)/target/${stdenv.hostPlatform.rust.rustcTarget}/release:$PATH"

     

       31
       30
        
         '';

     

       32
       31
        
       

     

       33
       32
        
         meta = with lib; {

+2 -3

pkgs/development/web/deno/librusty_v8.nix

···

       1
       1
        
       # auto-generated file -- DO NOT EDIT!

     

       2
       2
       -
       { rust, stdenv, fetchurl }:

     

       2
       2
       +
       { stdenv, fetchurl }:

     

       3
       3
        
       

     

       4
       4
        
       let

     

       5
       5
       -
         arch = rust.toRustTarget stdenv.hostPlatform;

     

       6
       5
        
         fetch_librusty_v8 = args: fetchurl {

     

       7
       6
        
           name = "librusty_v8-${args.version}";

     

       8
       8
       -
           url = "https://github.com/denoland/rusty_v8/releases/download/v${args.version}/librusty_v8_release_${arch}.a";

     

       7
       7
       +
           url = "https://github.com/denoland/rusty_v8/releases/download/v${args.version}/librusty_v8_release_${stdenv.hostPlatform.rust.rustcTarget}.a";

     

       9
       8
        
           sha256 = args.shas.${stdenv.hostPlatform.system};

     

       10
       9
        
           meta = { inherit (args) version; };

     

       11
       10
        
         };

+2 -3

pkgs/development/web/deno/update/librusty_v8.ts

···

       40
       40
        
       

     

       41
       41
        
       const templateDeps = (version: string, deps: PrefetchResult[]) =>

     

       42
       42
        
         `# auto-generated file -- DO NOT EDIT!

     

       43
       43
       -
       { rust, stdenv, fetchurl }:

     

       43
       43
       +
       { stdenv, fetchurl }:

     

       44
       44
        
       

     

       45
       45
        
       let

     

       46
       46
       -
         arch = rust.toRustTarget stdenv.hostPlatform;

     

       47
       46
        
         fetch_librusty_v8 = args: fetchurl {

     

       48
       47
        
           name = "librusty_v8-\${args.version}";

     

       49
       49
       -
           url = "https://github.com/denoland/rusty_v8/releases/download/v\${args.version}/librusty_v8_release_\${arch}.a";

     

       48
       48
       +
           url = "https://github.com/denoland/rusty_v8/releases/download/v\${args.version}/librusty_v8_release_\${stdenv.hostPlatform.rust.rustcTarget}.a";

     

       50
       49
        
           sha256 = args.shas.\${stdenv.hostPlatform.system};

     

       51
       50
        
           meta = { inherit (args) version; };

     

       52
       51
        
         };

+2 -3

pkgs/development/web/edge-runtime/librusty_v8.nix

···

       1
       1
        
       # auto-generated file -- DO NOT EDIT!

     

       2
       2
       -
       { rust, stdenv, fetchurl }:

     

       2
       2
       +
       { stdenv, fetchurl }:

     

       3
       3
        
       

     

       4
       4
        
       let

     

       5
       5
       -
         arch = rust.toRustTarget stdenv.hostPlatform;

     

       6
       5
        
         fetch_librusty_v8 = args: fetchurl {

     

       7
       6
        
           name = "librusty_v8-${args.version}";

     

       8
       8
       -
           url = "https://github.com/denoland/rusty_v8/releases/download/v${args.version}/librusty_v8_release_${arch}.a";

     

       7
       7
       +
           url = "https://github.com/denoland/rusty_v8/releases/download/v${args.version}/librusty_v8_release_${stdenv.hostPlatform.rust.rustcTarget}.a";

     

       9
       8
        
           sha256 = args.shas.${stdenv.hostPlatform.system};

     

       10
       9
        
           meta = { inherit (args) version; };

     

       11
       10
        
         };

+2 -3

pkgs/servers/http/router/librusty_v8.nix

···

       1
       1
       -
       { rust, stdenv, fetchurl }:

     

       1
       1
       +
       { stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         arch = rust.toRustTarget stdenv.hostPlatform;

     

       5
       4
        
         fetch_librusty_v8 = args: fetchurl {

     

       6
       5
        
           name = "librusty_v8-${args.version}";

     

       7
       7
       -
           url = "https://github.com/denoland/rusty_v8/releases/download/v${args.version}/librusty_v8_release_${arch}.a";

     

       6
       6
       +
           url = "https://github.com/denoland/rusty_v8/releases/download/v${args.version}/librusty_v8_release_${stdenv.hostPlatform.rust.rustcTarget}.a";

     

       8
       7
        
           sha256 = args.shas.${stdenv.hostPlatform.system};

     

       9
       8
        
           meta = { inherit (args) version; };

     

       10
       9
        
         };

+1 -2

pkgs/servers/matrix-synapse/matrix-hookshot/default.nix

···

       5
       5
        
       , makeWrapper

     

       6
       6
        
       , matrix-sdk-crypto-nodejs

     

       7
       7
        
       , mkYarnPackage

     

       8
       8
       -
       , rust

     

       9
       8
        
       , cargo

     

       10
       9
        
       , rustPlatform

     

       11
       10
        
       , rustc

     
···

       60
       59
        
         buildPhase = ''

     

       61
       60
        
           runHook preBuild

     

       62
       61
        
           cd deps/${pname}

     

       63
       63
       -
           napi build --target ${rust.toRustTargetSpec stdenv.targetPlatform} --dts ../src/libRs.d.ts --release ./lib

     

       62
       62
       +
           napi build --target ${stdenv.targetPlatform.rust.rustcTargetSpec} --dts ../src/libRs.d.ts --release ./lib

     

       64
       63
        
           yarn run build:app:fix-defs

     

       65
       64
        
           yarn run build:app

     

       66
       65
        
           yarn run build:web

+1 -3

pkgs/servers/windmill/default.nix

···

       16
       16
        
       , pixman

     

       17
       17
        
       , pkg-config

     

       18
       18
        
       , python3

     

       19
       19
       -
       , rust

     

       20
       19
        
       , rustfmt

     

       21
       20
        
       , stdenv

     

       22
       21
        
       , swagger-cli

     
···

       70
       69
        
           SQLX_OFFLINE = "true";

     

       71
       70
        
           RUSTY_V8_ARCHIVE =

     

       72
       71
        
             let

     

       73
       73
       -
               arch = rust.toRustTarget stdenv.hostPlatform;

     

       74
       72
        
               fetch_librusty_v8 = args:

     

       75
       73
        
                 fetchurl {

     

       76
       74
        
                   name = "librusty_v8-${args.version}";

     

       77
       77
       -
                   url = "https://github.com/denoland/rusty_v8/releases/download/v${args.version}/librusty_v8_release_${arch}.a";

     

       75
       75
       +
                   url = "https://github.com/denoland/rusty_v8/releases/download/v${args.version}/librusty_v8_release_${stdenv.hostPlatform.rust.rustcTarget}.a";

     

       78
       76
        
                   sha256 = args.shas.${stdenv.hostPlatform.system} or (throw "Unsupported platform ${stdenv.hostPlatform.system}");

     

       79
       77
        
                   meta = { inherit (args) version; };

     

       80
       78
        
                 };

+1 -2

pkgs/tools/misc/halp/default.nix

···

       5
       5
        
       , stdenv

     

       6
       6
        
       , darwin

     

       7
       7
        
       , unixtools

     

       8
       8
       -
       , rust

     

       9
       8
        
       }:

     

       10
       9
        
       

     

       11
       10
        
       rustPlatform.buildRustPackage rec {

     
···

       48
       47
        
       

     

       49
       48
        
         postPatch = ''

     

       50
       49
        
           substituteInPlace src/helper/args/mod.rs \

     

       51
       51
       -
             --subst-var-by releaseDir target/${rust.toRustTargetSpec stdenv.hostPlatform}/$cargoCheckType

     

       50
       50
       +
             --subst-var-by releaseDir target/${stdenv.hostPlatform.rust.rustcTargetSpec}/$cargoCheckType

     

       52
       51
        
         '';

     

       53
       52
        
       

     

       54
       53
        
         preCheck = ''

+1 -2

pkgs/tools/system/zram-generator/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , stdenv

     

       3
       3
        
       , fetchFromGitHub

     

       4
       4
       -
       , rust

     

       5
       4
        
       , rustPlatform

     

       6
       5
        
       , pkg-config

     

       7
       6
        
       , ronn

     
···

       28
       27
        
         postPatch = ''

     

       29
       28
        
           cp ${./Cargo.lock} Cargo.lock

     

       30
       29
        
           substituteInPlace Makefile \

     

       31
       31
       -
             --replace 'target/$(BUILDTYPE)' 'target/${rust.toRustTargetSpec stdenv.hostPlatform}/$(BUILDTYPE)'

     

       30
       30
       +
             --replace 'target/$(BUILDTYPE)' 'target/${stdenv.hostPlatform.rust.rustcTargetSpec}/$(BUILDTYPE)'

     

       32
       31
        
           substituteInPlace src/generator.rs \

     

       33
       32
        
             --replace 'Command::new("systemd-detect-virt")' 'Command::new("${systemd}/bin/systemd-detect-virt")' \

     

       34
       33
        
             --replace 'Command::new("modprobe")' 'Command::new("${kmod}/bin/modprobe")'

+3 -6

pkgs/tools/video/rav1e/default.nix

···

       13
       13
        
       , buildPackages

     

       14
       14
        
       }:

     

       15
       15
        
       

     

       16
       16
       -
       let

     

       17
       17
       -
         rustTargetPlatformSpec = rust.toRustTargetSpec stdenv.hostPlatform;

     

       18
       18
       -
       

     

       19
       19
       -
       in rustPlatform.buildRustPackage rec {

     

       16
       16
       +
       rustPlatform.buildRustPackage rec {

     

       20
       17
        
         pname = "rav1e";

     

       21
       18
        
         version = "0.6.6";

     

       22
       19
        
       

     
···

       47
       44
        
         checkType = "debug";

     

       48
       45
        
       

     

       49
       46
        
         postBuild =  ''

     

       50
       50
       -
           ${rust.envVars.setEnv} cargo cbuild --release --frozen --prefix=${placeholder "out"} --target ${rustTargetPlatformSpec}

     

       47
       47
       +
           ${rust.envVars.setEnv} cargo cbuild --release --frozen --prefix=${placeholder "out"} --target ${stdenv.hostPlatform.rust.rustcTarget}

     

       51
       48
        
         '';

     

       52
       49
        
       

     

       53
       50
        
         postInstall = ''

     

       54
       54
       -
           ${rust.envVars.setEnv} cargo cinstall --release --frozen --prefix=${placeholder "out"} --target ${rustTargetPlatformSpec}

     

       51
       51
       +
           ${rust.envVars.setEnv} cargo cinstall --release --frozen --prefix=${placeholder "out"} --target ${stdenv.hostPlatform.rust.rustcTarget}

     

       55
       52
        
         '';

     

       56
       53
        
       

     

       57
       54
        
         meta = with lib; {