commit d3d55bcc8174e13371f0bf7eb1974fc183481be7 · pyrox.dev/nixpkgs

+5 -6

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

···

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

     

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

     

       2
       2
        
       {

     

       3
       3
        
         build

     

       4
       4
        
       , buildDependencies

     
···

       17
       17
        
       , libName

     

       18
       18
        
       , libPath

     

       19
       19
        
       , release

     

       20
       20
       -
       , target_os

     

       21
       20
        
       , verbose

     

       22
       21
        
       , workspace_member }:

     

       23
       22
        
       let version_ = lib.splitString "-" crateVersion;

     
···

       124
       123
        
         export CARGO_PKG_AUTHORS="${authors}"

     

       125
       124
        
         export CARGO_PKG_DESCRIPTION="${crateDescription}"

     

       126
       125
        
       

     

       127
       127
       -
         export CARGO_CFG_TARGET_ARCH=${stdenv.hostPlatform.parsed.cpu.name}

     

       128
       128
       -
         export CARGO_CFG_TARGET_OS=${target_os}

     

       126
       126
       +
         export CARGO_CFG_TARGET_ARCH=${rust.toTargetArch stdenv.hostPlatform}

     

       127
       127
       +
         export CARGO_CFG_TARGET_OS=${rust.toTargetOs stdenv.hostPlatform}

     

       129
       128
        
         export CARGO_CFG_TARGET_FAMILY="unix"

     

       130
       129
        
         export CARGO_CFG_UNIX=1

     

       131
       130
        
         export CARGO_CFG_TARGET_ENV="gnu"

     
···

       136
       135
        
         export CARGO_MANIFEST_DIR=$(pwd)

     

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

     

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

     

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

     

       140
       140
       -
         export HOST="${stdenv.hostPlatform.config}"

     

       138
       138
       +
         export TARGET="${rust.toRustTarget stdenv.hostPlatform}"

     

       139
       139
       +
         export HOST="${rust.toRustTarget stdenv.buildPlatform}"

     

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

     

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

     

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

+2 -8

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

···

       8
       8
        
       , cargo, jq }:

     

       9
       9
        
       

     

       10
       10
        
       let

     

       11
       11
       -
           # This doesn't appear to be officially documented anywhere yet.

     

       12
       12
       -
           # See https://github.com/rust-lang-nursery/rust-forge/issues/101.

     

       13
       13
       -
           target_os = if stdenv.hostPlatform.isDarwin

     

       14
       14
       -
             then "macos"

     

       15
       15
       -
             else stdenv.hostPlatform.parsed.kernel.name;

     

       16
       16
       -
       

     

       17
       11
        
           # Create rustc arguments to link against the given list of dependencies

     

       18
       12
        
           # and renames.

     

       19
       13
        
           #

     
···

       52
       46
        
          inherit (import ./log.nix { inherit lib; }) noisily echo_colored;

     

       53
       47
        
       

     

       54
       48
        
          configureCrate = import ./configure-crate.nix {

     

       55
       55
       -
            inherit lib stdenv echo_colored noisily mkRustcDepArgs mkRustcFeatureArgs;

     

       49
       49
       +
            inherit lib stdenv rust echo_colored noisily mkRustcDepArgs mkRustcFeatureArgs;

     

       56
       50
        
          };

     

       57
       51
        
       

     

       58
       52
        
          buildCrate = import ./build-crate.nix {

     
···

       284
       278
        
             inherit crateName buildDependencies completeDeps completeBuildDeps crateDescription

     

       285
       279
        
                     crateFeatures crateRenames libName build workspace_member release libPath crateVersion

     

       286
       280
        
                     extraLinkFlags extraRustcOpts

     

       287
       287
       -
                     crateAuthors crateHomepage verbose colors target_os;

     

       281
       281
       +
                     crateAuthors crateHomepage verbose colors;

     

       288
       282
        
           };

     

       289
       283
        
           buildPhase = buildCrate {

     

       290
       284
        
             inherit crateName dependencies

+33 -20

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

···

       1
       1
        
       { lib

     

       2
       2
       +
       , buildPackages

     

       2
       3
        
       , buildRustCrate

     

       3
       4
        
       , callPackage

     

       4
       5
        
       , releaseTools

     
···

       10
       11
        
       }:

     

       11
       12
        
       

     

       12
       13
        
       let

     

       13
       13
       -
         mkCrate = args: let

     

       14
       14
       +
         mkCrate = buildRustCrate: args: let

     

       14
       15
        
           p = {

     

       15
       16
        
             crateName = "nixtestcrate";

     

       16
       17
        
             version = "0.1.0";

     

       17
       18
        
             authors = [ "Test <test@example.com>" ];

     

       18
       19
        
           } // args;

     

       19
       20
        
         in buildRustCrate p;

     

       21
       21
       +
         mkHostCrate = mkCrate buildRustCrate;

     

       20
       22
        
       

     

       21
       23
        
         mkCargoToml =

     

       22
       24
        
           { name, crateVersion ? "0.1.0", path ? "Cargo.toml" }:

     
···

       68
       70
        
         mkLib = name: mkFile name "pub fn test() -> i32 { return 23; }";

     

       69
       71
        
       

     

       70
       72
        
         mkTest = crateArgs: let

     

       71
       71
       -
           crate = mkCrate (builtins.removeAttrs crateArgs ["expectedTestOutput"]);

     

       73
       73
       +
           crate = mkHostCrate (builtins.removeAttrs crateArgs ["expectedTestOutput"]);

     

       72
       74
        
           hasTests = crateArgs.buildTests or false;

     

       73
       75
        
           expectedTestOutputs = crateArgs.expectedTestOutputs or null;

     

       74
       74
       -
           binaries = map (v: ''"${v.name}"'') (crateArgs.crateBin or []);

     

       76
       76
       +
           binaries = map (v: lib.escapeShellArg v.name) (crateArgs.crateBin or []);

     

       75
       77
        
           isLib = crateArgs ? libName || crateArgs ? libPath;

     

       76
       78
        
           crateName = crateArgs.crateName or "nixtestcrate";

     

       77
       79
        
           libName = crateArgs.libName or crateName;

     

       78
       80
        
       

     

       79
       79
       -
           libTestBinary = if !isLib then null else mkCrate {

     

       81
       81
       +
           libTestBinary = if !isLib then null else mkHostCrate {

     

       80
       82
        
             crateName = "run-test-${crateName}";

     

       81
       83
        
             dependencies = [ crate ];

     

       82
       84
        
             src = mkBinExtern "src/main.rs" libName;

     
···

       89
       91
        
             runCommand "run-buildRustCrate-${crateName}-test" {

     

       90
       92
        
               nativeBuildInputs = [ crate ];

     

       91
       93
        
             } (if !hasTests then ''

     

       92
       92
       -
                 ${lib.concatStringsSep "\n" binaries}

     

       94
       94
       +
                 ${lib.concatMapStringsSep "\n" (binary:

     

       95
       95
       +
                   # Can't actually run the binary when cross-compiling

     

       96
       96
       +
                   (lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) "type ") + binary

     

       97
       97
       +
                 ) binaries}

     

       93
       98
        
                 ${lib.optionalString isLib ''

     

       94
       99
        
                     test -e ${crate}/lib/*.rlib || exit 1

     

       95
       95
       -
                     ${libTestBinary}/bin/run-test-${crateName}

     

       100
       100
       +
                     ${lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) "test -x "} \

     

       101
       101
       +
                       ${libTestBinary}/bin/run-test-${crateName}

     

       96
       102
        
                 ''}

     

       97
       103
        
                 touch $out

     

       98
       98
       -
               '' else ''

     

       104
       104
       +
               '' else if stdenv.hostPlatform == stdenv.buildPlatform then ''

     

       99
       105
        
                 for file in ${crate}/tests/*; do

     

       100
       106
        
                   $file 2>&1 >> $out

     

       101
       107
        
                 done

     

       102
       108
        
                 set -e

     

       103
       109
        
                 ${lib.concatMapStringsSep "\n" (o: "grep '${o}' $out || {  echo 'output \"${o}\" not found in:'; cat $out; exit 23; }") expectedTestOutputs}

     

       110
       110
       +
               '' else ''

     

       111
       111
       +
                 for file in ${crate}/tests/*; do

     

       112
       112
       +
                   test -x "$file"

     

       113
       113
       +
                 done

     

       114
       114
       +
                 touch "$out"

     

       104
       115
        
               ''

     

       105
       116
        
             );

     

       106
       117
        
       

     
···

       109
       120
        
       

     

       110
       121
        
              `name` is used as part of the derivation name that performs the checking.

     

       111
       122
        
       

     

       112
       112
       -
              `crateArgs` is passed to `mkCrate` to build the crate with `buildRustCrate`.

     

       123
       123
       +
              `crateArgs` is passed to `mkHostCrate` to build the crate with `buildRustCrate`.

     

       113
       124
        
       

     

       114
       125
        
              `expectedFiles` contains a list of expected file paths in the output. E.g.

     

       115
       126
        
              `[ "./bin/my_binary" ]`.

     
···

       124
       135
        
             assert (builtins.isList expectedFiles);

     

       125
       136
        
       

     

       126
       137
        
             let

     

       127
       127
       -
               crate = mkCrate (builtins.removeAttrs crateArgs ["expectedTestOutput"]);

     

       138
       138
       +
               crate = mkHostCrate (builtins.removeAttrs crateArgs ["expectedTestOutput"]);

     

       128
       139
        
               crateOutput = if output == null then crate else crate."${output}";

     

       129
       140
        
               expectedFilesFile = writeTextFile {

     

       130
       141
        
                 name = "expected-files-${name}";

     
···

       188
       199
        
             crateBinRename1 = {

     

       189
       200
        
               crateBin = [{ name = "my-binary-rename1"; }];

     

       190
       201
        
               src = mkBinExtern "src/main.rs" "foo_renamed";

     

       191
       191
       -
               dependencies = [ (mkCrate { crateName = "foo"; src = mkLib "src/lib.rs"; }) ];

     

       202
       202
       +
               dependencies = [ (mkHostCrate { crateName = "foo"; src = mkLib "src/lib.rs"; }) ];

     

       192
       203
        
               crateRenames = { "foo" = "foo_renamed"; };

     

       193
       204
        
             };

     

       194
       205
        
             crateBinRename2 = {

     

       195
       206
        
               crateBin = [{ name = "my-binary-rename2"; }];

     

       196
       207
        
               src = mkBinExtern "src/main.rs" "foo_renamed";

     

       197
       197
       -
               dependencies = [ (mkCrate { crateName = "foo"; libName = "foolib"; src = mkLib "src/lib.rs"; }) ];

     

       208
       208
       +
               dependencies = [ (mkHostCrate { crateName = "foo"; libName = "foolib"; src = mkLib "src/lib.rs"; }) ];

     

       198
       209
        
               crateRenames = { "foo" = "foo_renamed"; };

     

       199
       210
        
             };

     

       200
       211
        
             crateBinRenameMultiVersion = let

     

       201
       201
       -
               crateWithVersion = version: mkCrate {

     

       212
       212
       +
               crateWithVersion = version: mkHostCrate {

     

       202
       213
        
                 crateName = "my_lib";

     

       203
       214
        
                 inherit version;

     

       204
       215
        
                 src = mkFile "src/lib.rs" ''

     
···

       307
       318
        
                 fn main() {}

     

       308
       319
        
               '';

     

       309
       320
        
               dependencies = [

     

       310
       310
       -
                 (mkCrate {

     

       321
       321
       +
                 (mkHostCrate {

     

       311
       322
        
                   crateName = "somerlib";

     

       312
       323
        
                   type = [ "rlib" ];

     

       313
       324
        
                   src = mkLib "src/lib.rs";

     
···

       315
       326
        
               ];

     

       316
       327
        
             };

     

       317
       328
        
             buildScriptDeps = let

     

       318
       318
       -
               depCrate = boolVal: mkCrate {

     

       329
       329
       +
               depCrate = buildRustCrate: boolVal: mkCrate buildRustCrate {

     

       319
       330
        
                 crateName = "bar";

     

       320
       331
        
                 src = mkFile "src/lib.rs" ''

     

       321
       332
        
                   pub const baz: bool = ${boolVal};

     
···

       339
       350
        
                   '')

     

       340
       351
        
                 ];

     

       341
       352
        
               };

     

       342
       342
       -
               buildDependencies = [ (depCrate "true") ];

     

       343
       343
       -
               dependencies = [ (depCrate "false") ];

     

       353
       353
       +
               buildDependencies = [ (depCrate buildPackages.buildRustCrate "true") ];

     

       354
       354
       +
               dependencies = [ (depCrate buildRustCrate "false") ];

     

       344
       355
        
               buildTests = true;

     

       345
       356
        
               expectedTestOutputs = [ "test baz_false ... ok" ];

     

       346
       357
        
             };

     
···

       373
       384
        
             # Regression test for https://github.com/NixOS/nixpkgs/pull/88054

     

       374
       385
        
             # Build script output should be rewritten as valid env vars.

     

       375
       386
        
             buildScriptIncludeDirDeps = let

     

       376
       376
       -
               depCrate = mkCrate {

     

       387
       387
       +
               depCrate = mkHostCrate {

     

       377
       388
        
                 crateName = "bar";

     

       378
       389
        
                 src = symlinkJoin {

     

       379
       390
        
                   name = "build-script-and-include-dir-bar";

     
···

       460
       471
        
                   mkdir -p $out/lib

     

       461
       472
        
                   # Note: On darwin (which defaults to clang) we have to add

     

       462
       473
        
                   # `-undefined dynamic_lookup` as otherwise the compilation fails.

     

       463
       463
       -
                   cc -shared \

     

       474
       474
       +
                   $CC -shared \

     

       464
       475
        
                     ${lib.optionalString stdenv.isDarwin "-undefined dynamic_lookup"} \

     

       465
       476
        
                     -o $out/lib/${name}${stdenv.hostPlatform.extensions.sharedLibrary} ${src}

     

       466
       477
        
                 '';

     
···

       609
       620
        
             pkg = brotliCrates.brotli_2_5_0 {};

     

       610
       621
        
           in runCommand "run-brotli-test-cmd" {

     

       611
       622
        
             nativeBuildInputs = [ pkg ];

     

       612
       612
       -
           } ''

     

       623
       623
       +
           } (if stdenv.hostPlatform == stdenv.buildPlatform then ''

     

       613
       624
        
             ${pkg}/bin/brotli -c ${pkg}/bin/brotli > /dev/null && touch $out

     

       614
       614
       -
           '';

     

       625
       625
       +
           '' else ''

     

       626
       626
       +
             test -x '${pkg}/bin/brotli' && touch $out

     

       627
       627
       +
           '');

     

       615
       628
        
           allocNoStdLibTest = let

     

       616
       629
        
             pkg = brotliCrates.alloc_no_stdlib_1_3_0 {};

     

       617
       630
        
           in runCommand "run-alloc-no-stdlib-test-cmd" {

+13 -2

pkgs/development/compilers/rust/default.nix

···

       13
       13
        
       , llvmPackages_5

     

       14
       14
        
       , pkgsBuildTarget, pkgsBuildBuild

     

       15
       15
        
       }: rec {

     

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

     

       17
       17
       +
         toTargetArch = platform:

     

       18
       18
       +
           if platform.isAarch32 then "arm"

     

       19
       19
       +
           else platform.parsed.cpu.name;

     

       20
       20
       +
       

     

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

     

       22
       22
       +
         toTargetOs = platform:

     

       23
       23
       +
           if platform.isDarwin then "macos"

     

       24
       24
       +
           else platform.parsed.kernel.name;

     

       25
       25
       +
       

     

       26
       26
       +
         # Target triple. Rust has slightly different naming conventions than we use.

     

       16
       27
        
         toRustTarget = platform: with platform.parsed; let

     

       17
       17
       -
           cpu_ = {

     

       28
       28
       +
           cpu_ = platform.rustc.arch or {

     

       18
       29
        
             "armv7a" = "armv7";

     

       19
       30
        
             "armv7l" = "armv7";

     

       20
       31
        
             "armv6l" = "arm";

     

       21
       21
       -
           }.${cpu.name} or platform.rustc.arch or cpu.name;

     

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

     

       22
       33
        
         in platform.rustc.config

     

       23
       34
        
           or "${cpu_}-${vendor.name}-${kernel.name}${lib.optionalString (abi.name != "unknown") "-${abi.name}"}";

     

       24
       35