rust-analyzer shipped broken without rust-src

Hello Guix,

The rust-analyzer package depends on having a local copy of the rust compiler (rustc) source code available in order for it to function.

Currently, neither the rust-analyzer nor the rust package include rust-src, which means rust-analyzer is broken by default.

On non-guix systems the rustc source code is usually installed using `rustup component add rust-src`.

The workaround I'm currently using is to run `guix build --source rust` followed by adding `export RUST_SRC_PATH=/home/$user/rustc-$version-src/library` to ~/.profile following every rust upgrade.

rust-analyzer is a crucial tool for many rust developers, so this experience should definitely be improved or at least documented.

I am not very familiar with guix and therefore cannot recommend a good way to solve this.

What would possible solutions to this issue be?

Kind regards,

Nicholas

Just to get the ball rolling, here is a possible idea.

It might makes sense to add an additional output to the rust package `src` and then require this by the rust-analyzer package as `rust:src`.

In the rust-analyzer package we could then copy a thing from `icedove-wayland`:

``

(arguments

'(#:modules ((guix build utils))

#:builder

(begin

(use-modules (guix build utils))

(let* ((bash (assoc-ref %build-inputs "bash"))

(icedove (assoc-ref %build-inputs "icedove"))

(out (assoc-ref %outputs "out"))

(exe (string-append out "/bin/icedove")))

(mkdir-p (dirname exe))

(call-with-output-file exe

(lambda (port)

(format port "#!~a

;; This style of overriding environment variables could be used for

;; RUST_SRC_PATH, although I am not sure if this is the idiomatic

;; way to do it.

MOZ_ENABLE_WAYLAND=1 exec ~a $@"

(string-append bash "/bin/bash")

(string-append icedove "/bin/icedove"))))

...

((icedove) out))

#t))))

``

Nicholas von Klitzing schreef op vr 26-11-2021 om 09:42 [+0000]:

I'd use a native-search-path instead of a wrapper setting the

environment variable, such that rust-analyzer can be used with any

version of rust and the user can override the source code used.

'wrap-program' could be used here, instead of manually making shell

scripts.

Greetings,

Maxime

That's definitely a much better solution.

I'm having trouble finding documentation about both native-search-paths and wrap-program, so let me know if I understand your suggestions and how to apply them correctly.

The rust-1.18 package has a native-search-paths declaration:

``

(native-search-paths

(list (search-path-specification

(variable "C_INCLUDE_PATH")

(files '("include")))

(search-path-specification

(variable "CPLUS_INCLUDE_PATH")

(files '("include/c++" "include")))

(search-path-specification

(variable "LIBRARY_PATH")

(files '("lib" "lib64")))

;; Do you mean add something along the lines of

;; this to every rust-xx package?

(search-path-specification

(variable "RUST_SRC_PATH")

(files '("library"))))) ;; I'm not sure what arguments this takes

``

The directory structure of the rust repository, changes over time, so the paths would need to be adjusted depending on the version. Would I also need to add an additional build step to copy over the source and register it as an output?

And for the rust-analyzer package we then add something along the lines of?

``

(add-after

'install 'wrap-rust-analyzer

(lambda* (#:key inputs outputs #:allow-other-keys)

(let ((out (assoc-ref outputs "out"))

(rust-src-path (getenv "RUST_SRC_PATH")))

(wrap-program (string-append out "/bin/rust-analyzer")

`("RUST_SRC_PATH" ":" prefix (,rust-src-path))))

#t))

``

I'd appreciate your feedback, since I'm mostly clueless :)

Kind regards,

Nicholas

??????? Original Message ???????

On Friday, November 26th, 2021 at 2:21 PM, Maxime Devos <maximedevos@telenet.be> wrote:

Nicholas von Klitzing schreef op vr 26-11-2021 om 17:40 [+0000]:

The package that is using RUST_SRC_PATH is rust-analyzer, not

rust@some-version. As such, the search path should be added to rust-

analyzer, not rust.

Search paths are added to the consumer, not the producer, as I've seen

it described somewhere.

Probably (separator #f) should be added, because I don't think rust-

analyzer supports using source code of multiple rusts at once.

The idea is to copy the unpacked source code to some output (let's call

it "source"). We would have to choose some subdirectory. Looking at the

package definition of rust-analyzer, it appears to like

‘lib/rustlib/src/rust’, so the source code could be copied to (string-

append #$output:src "/lib/rustlib/src/rust").

If that directory is used, files would be set to

'("lib/rustlib/src/rust").

Both wrapping and a search path wouldn't make much sense: the wrapping

would effectively override the search path, basically hard-coding the

source code used. Either go for a wrapper, a search path, or a wrapper

only setting the environment variable if it wasn't set already (*)(such

that the wrapper only sets a default).

(*) see docstring of wrap-program for how to do this, and whether it is

actually possible.

If you go for a wrapper instead of native-search-path, then

RUST_SRC_PATH would be unset in the build environment, so the (getenv

...) would need to be replaced with (search-input-directory (or native-

inputs inputs) "lib/rustlib/src/rust")).

Greetings,

Maxime