How to use fenix + rustPlatform + callPackage?

[bburdette]

I'm trying to make a dev environment flake that pulls in the latest version of Tauri. That requires rust 1.74 or newer.

The tauri.nix I copied from nixpkgs, updating the version. Its a fairly straightforward rustPlatform.buildRustPackage.

tauri.nix

{ lib
, stdenv
, rustPlatform
, fetchFromGitHub
, pkg-config
, glibc
, libsoup
, cairo
, gtk3
, webkitgtk
, darwin
}:

let
  inherit (darwin.apple_sdk.frameworks) CoreServices Security;
in
rustPlatform.buildRustPackage rec {
  pname = "tauri";
  version = "2.0.0-beta.14";

  src = fetchFromGitHub {
    owner = "tauri-apps";
    repo = pname;
    rev = "tauri-v${version}";
    sha256 = "sha256-Z6ZxqjpzcmW8Ma6RY+2atbTf8Hj3sB2JlFIkyGYFMTo=";
  };

  # Manually specify the sourceRoot since this crate depends on other crates in the workspace. Relevant info at
  # https://discourse.nixos.org/t/difficulty-using-buildrustpackage-with-a-src-containing-multiple-cargo-workspaces/10202
  sourceRoot = "source/tooling/cli";

  cargoHash = "sha256-TGb6+2frLuKLiMO//GhU1PvLLX0gCDu/QStt+M7AGeY=";

  buildInputs = lib.optionals stdenv.isLinux [ glibc libsoup cairo gtk3 webkitgtk ]
    ++ lib.optionals stdenv.isDarwin [ CoreServices Security ];
  nativeBuildInputs = [ pkg-config ];

  meta = with lib; {
    description = "Build smaller, faster, and more secure desktop applications with a web frontend";
    homepage = "https://tauri.app/";
    license = with licenses; [ asl20 /* or */ mit ];
    maintainers = with maintainers; [ dit7ya ];
  };
}

In my dev environment flake, I'm pulling in monthly fenix:

    fenix = {
      url = "github:nix-community/fenix/monthly";
      # url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };

And then I'm attempting to substitute a fenix-ified rustPlatform when I callPackage the tauri nix file:

        # fenix stuff for adding other compile targets
        mkToolchain = fenix.packages.${system}.combine;
        toolchain = fenix.packages.${system}.default;
        target1 = fenix.packages.${system}.targets."aarch64-linux-android".stable;
        target2 = fenix.packages.${system}.targets."armv7-linux-androideabi".stable;
        target3 = fenix.packages.${system}.targets."i686-linux-android".stable;
        target4 = fenix.packages.${system}.targets."x86_64-linux-android".stable;

        mobileTargets = mkToolchain (with toolchain; [
          cargo
          rustc
          target1.rust-std
          target2.rust-std
          target3.rust-std
          target4.rust-std
        ]);

        # am I doing this right??
        pkgs = import nixpkgs {
          config.android_sdk.accept_license = true;
          config.allowUnfree = true;
          system = "${system}";
          rustPlatform = nixpkgs.makeRustPlatform { cargo = toolchain; rust = toolchain; };
        };

        my-tauri = pkgs.callPackage ./tauri/my-tauri.nix { };

I'm including mobileTargets in my nativeBuildInputs. If I comment out the my-tauri stuff, that gives me rust 1.77 in my dev env.

But adding in my-tauri gives me the usual error of error: package clap_builder v4.5.1 cannot be built because it requires rustc 1.74 or newer, while the currently active rustc version is 1.73.0.

So modifying rustPlatform this way didn't work. What's the correct way to do it?

[rgoulter]

Instead of:

my-tauri = pkgs.callPackage ./tauri/my-tauri.nix { };

perhaps you could try passing rustPlatform directly to when you call package.

my-tauri = pkgs.callPackage ./tauri/my-tauri.nix {
   rustPlatform = nixpkgs.makeRustPlatform { cargo = toolchain; rust = toolchain; };
}

For replacing the value of pkgs.rustPlatform, I think you'd need an overlay, (passed as in import nixpkgs { .... overlays = [...] }).

[bburdette]

Ok cool, it seems to actually use that expression this time, I changed it to rustc instead of rust:

        my-tauri = pkgs.callPackage ./tauri/my-tauri.nix { 
          rustPlatform = pkgs.makeRustPlatform { cargo = toolchain; rustc = toolchain; };
        };

However, it seems that maybe the rustc coming from fenix doesn't have this 'meta' attribute:

       error: attribute 'meta' missing
       at /nix/store/4x11z78x84bvvx740jx16d312bvz82pv-source/pkgs/build-support/rust/build-rust-package/default.nix:154:17:
          153|     # default to Rust's platforms
          154|     platforms = rustc.meta.platforms ++ [
             |                 ^
          155|       # Platforms without host tools from

overlay

I'd be glad to use an overlay, but it doesn't seem to affect rustPlatform. I did this:

        pkgs = import nixpkgs {
          config.android_sdk.accept_license = true;
          config.allowUnfree = true;
          system = "${system}";
          # ha, way too naive
          # overlays = [ (self: super: super // { cargo = toolchain.cargo; rustc = toolchain.rustc; }) ]; 

          # doesn't seem to affect rustPlatform.
          # overlays = [ fenix.overlays.default ]; 

          # apparently has no effect.
          # rustPlatform = nixpkgs.makeRustPlatform { cargo = toolchain; rustc = toolchain; };
        };

[bburdette]

Sort-of solved. I copied this syntax out of all-packages.nix, and it allows me to upgrade the compiler from 1.73 to 1.76, since there happens to be a rustPackages_1_76 in nixpkgs 23.11.

        my-tauri = pkgs.callPackage ./tauri/my-tauri.nix {
          inherit (pkgs.rustPackages_1_76) rustPlatform;
        };

Tauri needs 1.74 or greater so that works. Would be nice to be able to use arbitrary versions of rust to make a rustPlatform, but I don't need that today.