Decouple self-dependencies and impl lib.mkRustBin interface (#177)

.github/workflows/ci.yaml

@@ -138,12 +138,16 @@ jobs:
         [[ "$(< out)" == *"warning: this loop never actually loops"* ]]
 
   test-cross-examples:
-    name: Test cross compilation examples
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
         example: [cross-aarch64, cross-wasi, cross-mingw]
+        kind: [shell]
+        include:
+          - example: cross-aarch64
+            kind: flake
+    name: Test cross compilation examples (${{ matrix.kind }})
 
     steps:
     - name: Checkout
@@ -158,15 +162,23 @@ jobs:
     - name: Don't let ~/.cargo/bin mess things up
       run: rm -rf ~/.cargo/bin
 
-    - name: Prepare nix-shell
+    - name: Prepare dev env
       run: |
         cd examples/${{ matrix.example }}
-        nix-shell --pure --command true
+        if [[ ${{ matrix.kind }} == 'shell' ]]; then
+          nix-shell --pure --command true
+        else
+          nix develop --ignore-environment --override-input rust-overlay ../..
+        fi
 
     - name: Build and run example
       run: |
         cd examples/${{ matrix.example }}
         set -o pipefail
-        # No --pure since it requires CA cert access for crates downloading.
-        nix-shell --command "make run" | tee out
+        if [[ ${{ matrix.kind }} == 'shell' ]]; then
+          # No --pure since it requires CA cert access for crates downloading.
+          nix-shell --pure --command "make run" | tee out
+        else
+          nix develop --ignore-environment --override-input rust-overlay ../.. --command make run | tee out
+        fi
         [[ "$(< out)" == *"Hello, world!"* ]]

.gitignore

@@ -2,3 +2,5 @@ target
 result
 result-*
 *.tmp
+
+examples/cross-aarch64/flake.lock

README.md

@@ -3,20 +3,32 @@
 [![CI status](https://github.com/oxalica/rust-overlay/workflows/CI/badge.svg)](https://github.com/oxalica/rust-overlay/actions/workflows/ci.yaml)
 [![sync-channels status](https://github.com/oxalica/rust-overlay/workflows/sync-channels/badge.svg)](https://github.com/oxalica/rust-overlay/actions/workflows/sync-channels.yaml)
 
-*Pure and reproducible* overlay for binary distributed rust toolchains.
-A compatible but better replacement for rust overlay of [nixpkgs-mozilla].
+*Pure and reproducible* packaging of binary distributed rust toolchains.
+A compatible but better replacement for rust overlay of [nixpkgs-mozilla],
+with also non-overlay and [Nix Flake][flake] interfaces (despite the project name).
 
-Hashes of toolchain components are pre-fetched in tree, so the evaluation is *pure* and
-no need to have network access. It also works well with [Nix Flakes](https://nixos.wiki/wiki/Flakes).
+[flake]: https://wiki.nixos.org/wiki/Flakes
+
+For migration from [nixpkgs-mozilla], see [this section](#migration-from-nixpkgs-mozilla).
+
+Features:
+
+- Hashes of toolchain components are pre-fetched in tree, so the evaluation is
+  *pure* and no need to have network access.
+
+- These hashes are auto-updated daily using GitHub Actions.
 
-- The toolchain hashes are auto-updated daily using GitHub Actions.
 - Current oldest supported version is stable 1.29.0 and beta/nightly 2018-09-13
   (which are randomly picked and may change over time).
 
-rust-overlay targets nixos-unstable and supported releases of NixOS, on x86_64-linux.
-They are tested on CI. It may also work on other channels but is not guarenteed.
+- We targets nixos-unstable and supported releases of NixOS, on x86\_64-linux.
+  They are tested on CI. Other platforms and nixpkgs channels may also work but
+  is not guaranteed.
 
-For migration from [nixpkgs-mozilla], see [this section](#migration-from-nixpkgs-mozilla).
+Documentations:
+
+- [API References](docs/reference.md)
+- [Cross compilation](docs/cross_compilation.md)
 
 ## Installation
 
@@ -41,8 +53,6 @@ And then feel free to use it anywhere like
 
 ### Nix Flakes
 
-This repository already has flake support.
-
 **Warning: Only the output `overlay`/`overlays` are currently stable. Use other outputs at your own risk!**
 
 For a quick play, just use `nix shell` to bring the latest stable rust toolchain into scope.
@@ -218,11 +228,6 @@ Running `nix develop` will create a shell with the default beta Rust toolchain i
 
 - There also an cross-compilation example in [`examples/cross-aarch64`].
 
-## More documentations
-
-- [Reference of all public attributes](docs/reference.md)
-- [Cross compilation](docs/cross_compilation.md)
-
 ## License
 
 MIT licensed.

default.nix

@@ -1,2 +1,72 @@
+# Overlay interface for non-flake Nix.
 final: prev:
-(import ./rust-overlay.nix final) (prev // (import ./manifest.nix final prev))
+let
+  inherit (builtins) mapAttrs readFile;
+
+  inherit (final) lib rust-bin;
+  inherit (rust-bin._internal) toolchainFromManifest selectManifest;
+
+  # Same as `toolchainFromManifest` but read from a manifest file.
+  toolchainFromManifestFile = path: toolchainFromManifest (fromTOML (readFile path));
+
+  # Override all pkgs of a toolchain set.
+  overrideToolchain = attrs: mapAttrs (name: pkg: pkg.override attrs);
+
+  # This is eagerly evaluated and disallow overriding. Get this from `final`
+  # will easily encounter infinite recursion without manually expand all attrs
+  # from `rust-bin.nix` output like `mkIf` does.
+  # This is considered internal anyway.
+  manifests = import ./lib/manifests.nix {
+    inherit lib;
+    inherit (rust-bin) distRoot;
+  };
+
+in {
+  rust-bin = (prev.rust-bin or { }) // {
+    # The overridable dist url for fetching.
+    distRoot = import ./lib/dist-root.nix;
+  } // import ./lib/rust-bin.nix {
+    inherit lib manifests;
+    inherit (final.rust) toRustTarget;
+    inherit (rust-bin) nightly;
+    pkgs = final;
+  };
+
+  # All attributes below are for compatibility with mozilla overlay.
+
+  lib = (prev.lib or { }) // {
+    rustLib = (prev.lib.rustLib or { }) // {
+      manifest_v2_url = throw ''
+        `manifest_v2_url` is not supported.
+        Select a toolchain from `rust-bin` or using `rustChannelOf` instead.
+        See also README at https://github.com/oxalica/rust-overlay
+      '';
+      fromManifest = throw ''
+        `fromManifest` is not supported due to network access during evaluation.
+        Select a toolchain from `rust-bin` or using `rustChannelOf` instead.
+        See also README at https://github.com/oxalica/rust-overlay
+      '';
+      fromManifestFile = manifestFilePath: { stdenv, fetchurl, patchelf }@deps: builtins.trace ''
+        `fromManifestFile` is deprecated.
+        Select a toolchain from `rust-bin` or using `rustChannelOf` instead.
+        See also README at https://github.com/oxalica/rust-overlay
+      '' (overrideToolchain deps (toolchainFromManifestFile manifestFilePath));
+    };
+  };
+
+  rustChannelOf = manifestArgs: toolchainFromManifest (selectManifest manifestArgs);
+
+  latest = (prev.latest or {}) // {
+    rustChannels = {
+      stable = rust-bin.stable.latest;
+      beta = rust-bin.beta.latest;
+      nightly = rust-bin.nightly.latest;
+    };
+  };
+
+  rustChannelOfTargets = channel: date: targets:
+    (final.rustChannelOf { inherit channel date; })
+      .rust.override { inherit targets; };
+
+  rustChannels = final.latest.rustChannels;
+}

docs/cross_compilation.md

@@ -1,5 +1,7 @@
 # Cross compilation with `rust-overlay`
 
+## `shell.nix` and `nix shell` development environment
+
 There are examples for cross compilation in [`example` directory](../examples).
 To try examples,
 1. `cd` into `example/cross-aarch64` (or other directory).
@@ -42,7 +44,7 @@ mkShell {
   # See: https://github.com/NixOS/nixpkgs/pull/146583
   depsBuildBuild = [ qemu ];
 
-  # Run-time dependencies. build = your-matchine, host = target = aarch64
+  # Run-time dependencies. build = your-machine, host = target = aarch64
   # Usually are libraries to be linked.
   buildInputs = [ openssl ];
 
@@ -57,4 +59,34 @@ mkShell {
 ```
 
 For more details about these different kinds of dependencies,
-see also [Nix Wiki - Cross Compiling](https://nixos.wiki/wiki/Cross_Compiling#How_to_specify_dependencies).
+see also [Nix Wiki - Cross Compiling][wiki-cross]
+
+## Flakes and `nix develop` development environment
+
+Unfortunately flake output layout does not natively support cross-compilation
+(see [NixOS/nix#5157][flake-cross-issue]). We provide `mkRustBin` to allow
+construction of `rust-bin` on an existing nixpkgs to leverage flake benefits of
+not-importing nixpkgs again, with the cost of re-instantiating `rust-bin` for
+each host-target tuples.
+
+Pass the spliced packages for your cross-compilation target to `mkRustBin` to
+get corresponding compiler toolchains for them.
+
+```nix
+let
+  pkgs = nixpkgs.legacyPackages.x86_64-linux.pkgsCross.aarch64-multiplatform;
+  rust-bin = rust-overlay.lib.mkRustBin { } pkgs.buildPackages;
+in pkgs.mkShell {
+  nativeBuildInputs = [ rust-bin.stable.latest.minimal ];
+}
+```
+
+The full example can be seen in
+[`examples/cross-aarch64/flake.nix`](../examples/cross-aarch64/flake.nix).
+To try it,
+1. `cd` into `example/cross-aarch64`.
+2. `nix develop` to enter the development environment.
+3. `make run` to build and run the program in an emulator.
+
+[wiki-cross]: https://wiki.nixos.org/wiki/Cross_Compiling#How_to_specify_dependencies
+[flake-cross-issue]: https://github.com/NixOS/nix/issues/5157