863 lines
38 KiB
Scheme
863 lines
38 KiB
Scheme
;;; GNU Guix --- Functional package management for GNU
|
|
;;; Copyright © 2016 David Craven <david@craven.ch>
|
|
;;; Copyright © 2016 Eric Le Bihan <eric.le.bihan.dev@free.fr>
|
|
;;; Copyright © 2016 Nikita <nikita@n0.is>
|
|
;;; Copyright © 2017 Ben Woodcroft <donttrustben@gmail.com>
|
|
;;; Copyright © 2017, 2018 Nikolai Merinov <nikolai.merinov@member.fsf.org>
|
|
;;; Copyright © 2017, 2019, 2020, 2021 Efraim Flashner <efraim@flashner.co.il>
|
|
;;; Copyright © 2018, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
|
|
;;; Copyright © 2018 Danny Milosavljevic <dannym+a@scratchpost.org>
|
|
;;; Copyright © 2019 Ivan Petkov <ivanppetkov@gmail.com>
|
|
;;; Copyright © 2020, 2021 Jakub Kądziołka <kuba@kadziolka.net>
|
|
;;; Copyright © 2020 Pierre Langlois <pierre.langlois@gmx.com>
|
|
;;; Copyright © 2020 Matthew Kraai <kraai@ftbfs.org>
|
|
;;; Copyright © 2021 Maxim Cournoyer <maxim.cournoyer@gmail.com>
|
|
;;;
|
|
;;; This file is part of GNU Guix.
|
|
;;;
|
|
;;; GNU Guix is free software; you can redistribute it and/or modify it
|
|
;;; under the terms of the GNU General Public License as published by
|
|
;;; the Free Software Foundation; either version 3 of the License, or (at
|
|
;;; your option) any later version.
|
|
;;;
|
|
;;; GNU Guix is distributed in the hope that it will be useful, but
|
|
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
;;; GNU General Public License for more details.
|
|
;;;
|
|
;;; You should have received a copy of the GNU General Public License
|
|
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
(define-module (gnu packages rust)
|
|
#:use-module (gnu packages base)
|
|
#:use-module (gnu packages bison)
|
|
#:use-module (gnu packages bootstrap)
|
|
#:use-module (gnu packages cmake)
|
|
#:use-module (gnu packages compression)
|
|
#:use-module (gnu packages curl)
|
|
#:use-module (gnu packages elf)
|
|
#:use-module (gnu packages flex)
|
|
#:use-module (gnu packages gcc)
|
|
#:use-module (gnu packages gdb)
|
|
#:use-module (gnu packages jemalloc)
|
|
#:use-module (gnu packages linux)
|
|
#:use-module (gnu packages llvm)
|
|
#:use-module (gnu packages pkg-config)
|
|
#:use-module (gnu packages python)
|
|
#:use-module (gnu packages ssh)
|
|
#:use-module (gnu packages tls)
|
|
#:use-module (gnu packages)
|
|
#:use-module (guix build-system cargo)
|
|
#:use-module (guix build-system gnu)
|
|
#:use-module (guix build-system trivial)
|
|
#:use-module (guix download)
|
|
#:use-module (guix git-download)
|
|
#:use-module ((guix licenses) #:prefix license:)
|
|
#:use-module (guix packages)
|
|
#:use-module ((guix build utils) #:select (alist-replace))
|
|
#:use-module (guix utils)
|
|
#:use-module (ice-9 match)
|
|
#:use-module (srfi srfi-26))
|
|
|
|
;; This is the hash for the empty file, and the reason it's relevant is not
|
|
;; the most obvious.
|
|
;;
|
|
;; The root of the problem is that Cargo keeps track of a file called
|
|
;; Cargo.lock, that contains the hash of the tarball source of each dependency.
|
|
;;
|
|
;; However, tarball sources aren't handled well by Guix because of the need to
|
|
;; patch shebangs in any helper scripts. This is why we use Cargo's vendoring
|
|
;; capabilities, where instead of the tarball, a directory is provided in its
|
|
;; place. (In the case of rustc, the source code already ships with vendored
|
|
;; dependencies, but crates built with cargo-build-system undergo vendoring
|
|
;; during the build.)
|
|
;;
|
|
;; To preserve the advantages of checksumming, vendored dependencies contain
|
|
;; a file called .cargo-checksum.json, which contains the hash of the tarball,
|
|
;; as well as the list of files in it, with the hash of each file.
|
|
;;
|
|
;; The patch-cargo-checksums phase of cargo-build-system runs after
|
|
;; any Guix-specific patches to the vendored dependencies and regenerates the
|
|
;; .cargo-checksum.json files, but it's hard to know the tarball checksum that
|
|
;; should be written to the file - and taking care of any unhandled edge case
|
|
;; would require rebuilding everything that depends on rust. This is why we lie,
|
|
;; and say that the tarball has the hash of an empty file. It's not a problem
|
|
;; because cargo-build-system removes the Cargo.lock file. We can't do that
|
|
;; for rustc because of a quirk of its build system, so we modify the lock file
|
|
;; to substitute the hash.
|
|
(define %cargo-reference-hash
|
|
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
|
|
|
|
(define* (nix-system->gnu-triplet-for-rust
|
|
#:optional (system (%current-system)))
|
|
(match system
|
|
("x86_64-linux" "x86_64-unknown-linux-gnu")
|
|
("i686-linux" "i686-unknown-linux-gnu")
|
|
("armhf-linux" "armv7-unknown-linux-gnueabihf")
|
|
("aarch64-linux" "aarch64-unknown-linux-gnu")
|
|
("mips64el-linux" "mips64el-unknown-linux-gnuabi64")
|
|
(_ (nix-system->gnu-triplet system))))
|
|
|
|
(define* (rust-uri version #:key (dist "static"))
|
|
(string-append "https://" dist ".rust-lang.org/dist/"
|
|
"rustc-" version "-src.tar.gz"))
|
|
|
|
(define* (rust-bootstrapped-package base-rust version checksum)
|
|
"Bootstrap rust VERSION with source checksum CHECKSUM using BASE-RUST."
|
|
(package
|
|
(inherit base-rust)
|
|
(version version)
|
|
(source
|
|
(origin
|
|
(inherit (package-source base-rust))
|
|
(uri (rust-uri version))
|
|
(sha256 (base32 checksum))))
|
|
(native-inputs
|
|
(alist-replace "cargo-bootstrap" (list base-rust "cargo")
|
|
(alist-replace "rustc-bootstrap" (list base-rust)
|
|
(package-native-inputs base-rust))))))
|
|
|
|
;;; Note: mrustc's only purpose is to be able to bootstap Rust; it's designed
|
|
;;; to be used in source form.
|
|
(define %mrustc-source
|
|
(let ((name "mrustc")
|
|
(version "0.9"))
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/thepowersgang/mrustc")
|
|
(commit (string-append "v" version))))
|
|
(file-name (git-file-name name version))
|
|
(sha256
|
|
(base32
|
|
"194ny7vsks5ygiw7d8yxjmp1qwigd71ilchis6xjl6bb2sj97rd2")))))
|
|
|
|
;;; Rust 1.29 is special in that it is built with mrustc, which shortens the
|
|
;;; bootstrap path. Note: the build is non-deterministic.
|
|
(define-public rust-1.29
|
|
(package
|
|
(name "rust")
|
|
(version "1.29.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (rust-uri version))
|
|
(sha256 (base32 "1jb787080z754caa2w3w1amsygs4qlzj9rs1vy64firfmabfg22h"))
|
|
(modules '((guix build utils)))
|
|
(snippet '(for-each delete-file-recursively
|
|
'("src/jemalloc"
|
|
"src/llvm"
|
|
"src/llvm-emscripten")))
|
|
(patches (search-patches "rust-reproducible-builds.patch"))))
|
|
(outputs '("out" "cargo"))
|
|
(properties '((timeout . 72000) ;20 hours
|
|
(max-silent-time . 18000))) ;5 hours (for armel)
|
|
(build-system gnu-build-system)
|
|
(inputs
|
|
`(("libcurl" ,curl)
|
|
("libssh2" ,libssh2)
|
|
;; Use llvm-7, which enables rust to be built reproducibly.
|
|
;; Versions newer than 7 fail to compile.
|
|
("llvm" ,llvm-7)
|
|
("openssl" ,openssl)
|
|
("zlib" ,zlib)))
|
|
(native-inputs
|
|
`(("bison" ,bison)
|
|
("flex" ,flex)
|
|
("pkg-config" ,pkg-config)
|
|
;; Required for the libstd sources.
|
|
("mrustc-source" ,%mrustc-source)))
|
|
(arguments
|
|
`(#:imported-modules ,%cargo-utils-modules ;for `generate-all-checksums'
|
|
#:modules ((guix build cargo-utils)
|
|
(guix build utils)
|
|
(guix build gnu-build-system))
|
|
#:test-target "test"
|
|
;; Rust's own .so library files are not found in any RUNPATH, but
|
|
;; that doesn't seem to cause issues.
|
|
#:validate-runpath? #f
|
|
#:make-flags
|
|
(list ,(string-append "RUSTC_TARGET="
|
|
(or (%current-target-system)
|
|
(nix-system->gnu-triplet-for-rust)))
|
|
,(string-append "RUSTCSRC=../"))
|
|
#:phases
|
|
(modify-phases %standard-phases
|
|
(add-after 'unpack 'patch-reference-to-cc
|
|
;; This prevents errors like 'error: linker `cc` not found' when
|
|
;; "cc" is not found on PATH.
|
|
(lambda* (#:key inputs #:allow-other-keys)
|
|
(let ((gcc (assoc-ref inputs "gcc")))
|
|
(substitute* (find-files "." "^link.rs$")
|
|
(("\"cc\".as_ref")
|
|
(format #f "~s.as_ref" (string-append gcc "/bin/gcc")))))))
|
|
(add-after 'unpack 'copy-mrustc-and-patch
|
|
(lambda* (#:key inputs #:allow-other-keys)
|
|
(copy-recursively (assoc-ref inputs "mrustc-source") "mrustc")
|
|
(invoke "patch" "-p0" "-i" "mrustc/rustc-1.29.0-src.patch")))
|
|
(add-after 'copy-mrustc-and-patch 'patch-makefiles
|
|
;; This disables building the (unbundled) LLVM.
|
|
(lambda* (#:key inputs parallel-build? #:allow-other-keys)
|
|
(let ((llvm (assoc-ref inputs "llvm"))
|
|
(job-spec (format #f "-j~a"
|
|
(if parallel-build?
|
|
(number->string (parallel-job-count))
|
|
"1"))))
|
|
(with-directory-excursion "mrustc"
|
|
(substitute* '("minicargo.mk"
|
|
"run_rustc/Makefile")
|
|
;; Use the system-provided LLVM.
|
|
(("LLVM_CONFIG := .*")
|
|
(string-append "LLVM_CONFIG := " llvm "/bin/llvm-config\n"))
|
|
(("\\$\\(LLVM_CONFIG\\): .*")
|
|
"$(LLVM_CONFIG):\n")
|
|
(("\\$Vcd \\$\\(RUSTCSRC\\)build && \\$\\(MAKE\\).*")
|
|
"true\n"))
|
|
;; Patch date.
|
|
(substitute* "Makefile"
|
|
(("shell date")
|
|
"shell date -d @1"))
|
|
(substitute* "run_rustc/Makefile"
|
|
(("[$]Vtime ")
|
|
"$V ")
|
|
;; Unlock the number of parallel jobs for cargo.
|
|
(("-j [[:digit:]]+ ")
|
|
"")
|
|
;; Patch the shebang of a generated wrapper for rustc, and
|
|
;; make sure that \n newline escapes get interpreted
|
|
;; correctly, specifying the '-e' option of echo.
|
|
(("echo '#!/bin/sh")
|
|
(string-append "echo -e '#!" (which "sh"))))))))
|
|
(add-after 'patch-source-shebangs 'patch-cargo-checksums
|
|
(lambda* _
|
|
(substitute* "src/Cargo.lock"
|
|
(("(\"checksum .* = )\".*\"" all name)
|
|
(string-append name "\"" ,%cargo-reference-hash "\"")))
|
|
(generate-all-checksums "src/vendor")))
|
|
(replace 'configure
|
|
(lambda _
|
|
(setenv "CC" "gcc")
|
|
(setenv "CXX" "g++")
|
|
;; The Guix LLVM package installs only shared libraries.
|
|
(setenv "LLVM_LINK_SHARED" "1")
|
|
;; This is a workaround for
|
|
;; https://github.com/thepowersgang/mrustc/issues/138.
|
|
(setenv "LIBSSH2_SYS_USE_PKG_CONFIG" "yes")))
|
|
(delete 'patch-generated-file-shebangs)
|
|
(replace 'build
|
|
(lambda* (#:key make-flags parallel-build? #:allow-other-keys)
|
|
(let* ((job-count (if parallel-build?
|
|
(parallel-job-count)
|
|
1))
|
|
(job-spec (string-append "-j" (number->string job-count)))
|
|
(make-flags* (cons job-spec make-flags)))
|
|
;; Adapted from:
|
|
;; https://github.com/dtolnay/bootstrap/blob/master/build.sh.
|
|
(chdir "mrustc")
|
|
(setenv "MINICARGO_FLAGS" job-spec)
|
|
(setenv "CARGO_BUILD_JOBS" (number->string job-count))
|
|
(display "Building rustc...\n")
|
|
(apply invoke "make" "-f" "minicargo.mk" "output/rustc"
|
|
make-flags*)
|
|
(display "Building cargo...\n")
|
|
(apply invoke "make" "-f" "minicargo.mk" "output/cargo"
|
|
make-flags*)
|
|
(display "Rebuilding stdlib with rustc...\n")
|
|
(with-directory-excursion "run_rustc"
|
|
(apply invoke "make" "RUST_SRC=../../src/" make-flags*)))))
|
|
(replace 'install
|
|
(lambda* (#:key inputs outputs #:allow-other-keys)
|
|
(let* ((out (assoc-ref outputs "out"))
|
|
(cargo (assoc-ref outputs "cargo"))
|
|
(bin (string-append out "/bin"))
|
|
(rustc (string-append bin "/rustc"))
|
|
(cargo-bin (string-append cargo "/bin"))
|
|
(lib (string-append out "/lib"))
|
|
(gnu-triplet ,(or (%current-target-system)
|
|
(nix-system->gnu-triplet-for-rust)))
|
|
(system-lib-prefix (string-append lib "/rustlib/"
|
|
gnu-triplet "/lib")))
|
|
(mkdir-p (dirname rustc))
|
|
(copy-file "run_rustc/output/prefix/bin/rustc_binary" rustc)
|
|
(wrap-program rustc
|
|
`("LD_LIBRARY_PATH" = (,system-lib-prefix)))
|
|
(mkdir-p lib)
|
|
(copy-recursively "run_rustc/output/prefix/lib" lib)
|
|
(install-file "run_rustc/output/prefix/bin/cargo" cargo-bin)))))))
|
|
(synopsis "Compiler for the Rust programming language")
|
|
(description "Rust is a systems programming language that provides memory
|
|
safety and thread safety guarantees.")
|
|
(home-page "https://github.com/thepowersgang/mrustc")
|
|
;; Dual licensed.
|
|
(license (list license:asl2.0 license:expat))))
|
|
|
|
(define-public rust-1.30
|
|
(package
|
|
(name "rust")
|
|
(version "1.30.1")
|
|
(source (origin
|
|
(inherit (package-source rust-1.29))
|
|
(uri (rust-uri version))
|
|
(sha256
|
|
(base32 "0aavdc1lqv0cjzbqwl5n59yd0bqdlhn0zas61ljf38yrvc18k8rn"))
|
|
(snippet '(for-each delete-file-recursively
|
|
'("src/jemalloc"
|
|
"src/llvm"
|
|
"src/llvm-emscripten"
|
|
"src/tools/clang"
|
|
"src/tools/lldb")))))
|
|
(outputs '("out" "cargo"))
|
|
(properties '((timeout . 72000) ;20 hours
|
|
(max-silent-time . 18000))) ;5 hours (for armel)
|
|
(build-system gnu-build-system)
|
|
(arguments
|
|
;; Only the final Rust is tested, not the intermediate bootstrap ones,
|
|
;; for performance and simplicity.
|
|
`(#:tests? #f
|
|
#:imported-modules ,%cargo-utils-modules ;for `generate-all-checksums'
|
|
#:modules ((guix build utils)
|
|
(guix build gnu-build-system)
|
|
(ice-9 match)
|
|
(srfi srfi-1))
|
|
#:phases
|
|
(modify-phases %standard-phases
|
|
(add-after 'unpack 'set-env
|
|
(lambda* (#:key inputs #:allow-other-keys)
|
|
(setenv "SHELL" (which "sh"))
|
|
(setenv "CONFIG_SHELL" (which "sh"))
|
|
(setenv "CC" (string-append (assoc-ref inputs "gcc") "/bin/gcc"))
|
|
;; The Guix LLVM package installs only shared libraries.
|
|
(setenv "LLVM_LINK_SHARED" "1")))
|
|
(add-after 'unpack 'neuter-tidy
|
|
;; We often need to patch tests with various Guix-specific paths.
|
|
;; This often increases the line length and makes tidy, rustc's
|
|
;; style checker, complain. We could insert additional newlines or
|
|
;; add an "// ignore-tidy-linelength" comment, but as an ignore
|
|
;; comment must be used, both approaches are fragile due to
|
|
;; upstream formatting changes. As such, disable running the
|
|
;; linter during tests, since it's intended for rustc developers
|
|
;; anyway.
|
|
(lambda _
|
|
(substitute* "src/bootstrap/builder.rs"
|
|
((".*::Tidy,.*")
|
|
""))))
|
|
(add-after 'patch-generated-file-shebangs 'patch-cargo-checksums
|
|
(lambda* _
|
|
(use-modules (guix build cargo-utils))
|
|
(substitute* "src/Cargo.lock"
|
|
(("(\"checksum .* = )\".*\"" all name)
|
|
(string-append name "\"" ,%cargo-reference-hash "\"")))
|
|
(generate-all-checksums "src/vendor")))
|
|
(replace 'configure
|
|
(lambda* (#:key inputs outputs #:allow-other-keys)
|
|
(let* ((out (assoc-ref outputs "out"))
|
|
(gcc (assoc-ref inputs "gcc"))
|
|
(python (assoc-ref inputs "python"))
|
|
(binutils (assoc-ref inputs "binutils"))
|
|
(rustc (assoc-ref inputs "rustc-bootstrap"))
|
|
(cargo (assoc-ref inputs "cargo-bootstrap"))
|
|
(llvm (assoc-ref inputs "llvm"))
|
|
(jemalloc (assoc-ref inputs "jemalloc")))
|
|
(call-with-output-file "config.toml"
|
|
(lambda (port)
|
|
(display (string-append "
|
|
[llvm]
|
|
[build]
|
|
cargo = \"" cargo "/bin/cargo" "\"
|
|
rustc = \"" rustc "/bin/rustc" "\"
|
|
docs = false
|
|
python = \"" python "/bin/python" "\"
|
|
vendor = true
|
|
submodules = false
|
|
[install]
|
|
prefix = \"" out "\"
|
|
sysconfdir = \"etc\"
|
|
[rust]
|
|
default-linker = \"" gcc "/bin/gcc" "\"
|
|
channel = \"stable\"
|
|
rpath = true
|
|
[target." ,(nix-system->gnu-triplet-for-rust) "]
|
|
llvm-config = \"" llvm "/bin/llvm-config" "\"
|
|
cc = \"" gcc "/bin/gcc" "\"
|
|
cxx = \"" gcc "/bin/g++" "\"
|
|
ar = \"" binutils "/bin/ar" "\"
|
|
jemalloc = \"" jemalloc "/lib/libjemalloc_pic.a" "\"
|
|
[dist]
|
|
") port))))))
|
|
(replace 'build
|
|
(lambda* (#:key parallel-build? #:allow-other-keys)
|
|
(let ((job-spec (string-append
|
|
"-j" (if parallel-build?
|
|
(number->string (parallel-job-count))
|
|
"1"))))
|
|
(invoke "./x.py" job-spec "build")
|
|
(invoke "./x.py" job-spec "build" "src/tools/cargo"))))
|
|
(replace 'install
|
|
(lambda* (#:key outputs #:allow-other-keys)
|
|
(let ((out (assoc-ref outputs "out"))
|
|
(cargo-out (assoc-ref outputs "cargo")))
|
|
(mkdir-p out)
|
|
(invoke "./x.py" "install")
|
|
(substitute* "config.toml"
|
|
;; Adjust the prefix to the 'cargo' output.
|
|
(("prefix = \"[^\"]*\"")
|
|
(format #f "prefix = ~s" cargo-out)))
|
|
(mkdir-p cargo-out)
|
|
(invoke "./x.py" "install" "cargo"))))
|
|
(add-after 'install 'delete-install-logs
|
|
(lambda* (#:key outputs #:allow-other-keys)
|
|
(for-each (lambda (f)
|
|
(false-if-exception (delete-file f)))
|
|
(append-map (lambda (output)
|
|
(find-files (string-append
|
|
output "/lib/rustlib")
|
|
"(^install.log$|^manifest-)"))
|
|
(map cdr outputs)))))
|
|
(add-after 'install 'wrap-rustc
|
|
(lambda* (#:key inputs outputs #:allow-other-keys)
|
|
(let ((out (assoc-ref outputs "out"))
|
|
(libc (assoc-ref inputs "libc"))
|
|
(ld-wrapper (assoc-ref inputs "ld-wrapper")))
|
|
;; Let gcc find ld and libc startup files.
|
|
(wrap-program (string-append out "/bin/rustc")
|
|
`("PATH" ":" prefix (,(string-append ld-wrapper "/bin")))
|
|
`("LIBRARY_PATH" ":"
|
|
suffix (,(string-append libc "/lib"))))))))))
|
|
(native-inputs
|
|
`(("cmake" ,cmake-minimal)
|
|
("pkg-config" ,pkg-config) ; For "cargo"
|
|
("python" ,python-wrapper)
|
|
("rustc-bootstrap" ,rust-1.29)
|
|
("cargo-bootstrap" ,rust-1.29 "cargo")
|
|
("which" ,which)))
|
|
(inputs
|
|
`(("jemalloc" ,jemalloc-4.5.0)
|
|
("llvm" ,llvm-7)
|
|
("openssl" ,openssl)
|
|
("libssh2" ,libssh2) ; For "cargo"
|
|
("libcurl" ,curl))) ; For "cargo"
|
|
;; rustc invokes gcc, so we need to set its search paths accordingly.
|
|
;; Note: duplicate its value here to cope with circular dependencies among
|
|
;; modules (see <https://bugs.gnu.org/31392>).
|
|
(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")))))
|
|
(supported-systems
|
|
(delete "i686-linux" ; fails to build, see bug #35519
|
|
%supported-systems))
|
|
(synopsis "Compiler for the Rust progamming language")
|
|
(description "Rust is a systems programming language that provides memory
|
|
safety and thread safety guarantees.")
|
|
(home-page "https://www.rust-lang.org")
|
|
;; Dual licensed.
|
|
(license (list license:asl2.0 license:expat))))
|
|
|
|
(define-public rust-1.31
|
|
(rust-bootstrapped-package
|
|
rust-1.30 "1.31.1" "0sk84ff0cklybcp0jbbxcw7lk7mrm6kb6km5nzd6m64dy0igrlli"))
|
|
|
|
(define-public rust-1.32
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.31 "1.32.0"
|
|
"0ji2l9xv53y27xy72qagggvq47gayr5lcv2jwvmfirx029vlqnac")))
|
|
(package
|
|
(inherit base-rust)
|
|
(source
|
|
(origin
|
|
(inherit (package-source base-rust))
|
|
(snippet '(for-each delete-file-recursively
|
|
'("src/llvm"
|
|
"src/llvm-emscripten"
|
|
"src/tools/clang"
|
|
"src/tools/lldb"
|
|
"vendor/jemalloc-sys/jemalloc")))
|
|
;; the vendor directory has moved to the root of
|
|
;; the tarball, so we have to strip an extra prefix
|
|
(patch-flags '("-p2"))))
|
|
(arguments
|
|
(substitute-keyword-arguments (package-arguments base-rust)
|
|
;; The test suite fails due to LLVM 7, required for the build to be
|
|
;; reproducible.
|
|
((#:tests? _ #t)
|
|
#f)
|
|
((#:phases phases)
|
|
`(modify-phases ,phases
|
|
;; Cargo.lock and the vendor/ directory have been moved to the
|
|
;; root of the rust tarball
|
|
(replace 'patch-cargo-checksums
|
|
(lambda* _
|
|
(use-modules (guix build cargo-utils))
|
|
(substitute* "Cargo.lock"
|
|
(("(\"checksum .* = )\".*\"" all name)
|
|
(string-append name "\"" ,%cargo-reference-hash "\"")))
|
|
(generate-all-checksums "vendor")))
|
|
(add-after 'configure 'override-jemalloc
|
|
(lambda* (#:key inputs #:allow-other-keys)
|
|
;; The compiler is no longer directly built against jemalloc,
|
|
;; but rather via the jemalloc-sys crate (which vendors the
|
|
;; jemalloc source). To use jemalloc we must enable linking to
|
|
;; it (otherwise it would use the system allocator), and set
|
|
;; an environment variable pointing to the compiled jemalloc.
|
|
(substitute* "config.toml"
|
|
(("^jemalloc =.*$") "")
|
|
(("[[]rust[]]") "\n[rust]\njemalloc=true\n"))
|
|
(setenv "JEMALLOC_OVERRIDE"
|
|
(string-append (assoc-ref inputs "jemalloc")
|
|
"/lib/libjemalloc_pic.a")))))))))))
|
|
|
|
(define-public rust-1.33
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.32 "1.33.0"
|
|
"152x91mg7bz4ygligwjb05fgm1blwy2i70s2j03zc9jiwvbsh0as")))
|
|
(package
|
|
(inherit base-rust)
|
|
(source
|
|
(origin
|
|
(inherit (package-source base-rust))
|
|
(patches '())
|
|
(patch-flags '("-p1"))))
|
|
(inputs
|
|
;; Upgrade jemalloc.
|
|
(alist-replace "jemalloc" (list jemalloc) (package-inputs base-rust))))))
|
|
|
|
(define-public rust-1.34
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.33 "1.34.1"
|
|
"19s09k7y5j6g3y4d2rk6kg9pvq6ml94c49w6b72dmq8p9lk8bixh")))
|
|
(package
|
|
(inherit base-rust)
|
|
(source
|
|
(origin
|
|
(inherit (package-source base-rust))
|
|
(snippet '(for-each delete-file-recursively
|
|
'("src/llvm-emscripten"
|
|
"src/llvm-project"
|
|
"vendor/jemalloc-sys/jemalloc"))))))))
|
|
|
|
(define-public rust-1.35
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.34 "1.35.0"
|
|
"0bbizy6b7002v1rdhrxrf5gijclbyizdhkglhp81ib3bf5x66kas")))
|
|
(package
|
|
(inherit base-rust)
|
|
(arguments
|
|
(substitute-keyword-arguments (package-arguments base-rust)
|
|
((#:phases phases)
|
|
`(modify-phases ,phases
|
|
(delete 'disable-codegen-tests))))))))
|
|
|
|
(define-public rust-1.36
|
|
(rust-bootstrapped-package
|
|
rust-1.35 "1.36.0" "06xv2p6zq03lidr0yaf029ii8wnjjqa894nkmrm6s0rx47by9i04"))
|
|
|
|
(define-public rust-1.37
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.36 "1.37.0"
|
|
"1hrqprybhkhs6d9b5pjskfnc5z9v2l2gync7nb39qjb5s0h703hj")))
|
|
(package
|
|
(inherit base-rust)
|
|
(arguments
|
|
(substitute-keyword-arguments (package-arguments base-rust)
|
|
((#:phases phases)
|
|
`(modify-phases ,phases
|
|
(add-before 'configure 'configure-cargo-home
|
|
(lambda _
|
|
(let ((cargo-home (string-append (getcwd) "/.cargo")))
|
|
(mkdir-p cargo-home)
|
|
(setenv "CARGO_HOME" cargo-home)))))))))))
|
|
|
|
(define-public rust-1.38
|
|
(rust-bootstrapped-package
|
|
rust-1.37 "1.38.0" "101dlpsfkq67p0hbwx4acqq6n90dj4bbprndizpgh1kigk566hk4"))
|
|
|
|
(define-public rust-1.39
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.38 "1.39.0"
|
|
"0mwkc1bnil2cfyf6nglpvbn2y0zfbv44zfhsd5qg4c9rm6vgd8dl")))
|
|
(package
|
|
(inherit base-rust)
|
|
(arguments
|
|
(substitute-keyword-arguments (package-arguments base-rust)
|
|
((#:phases phases)
|
|
`(modify-phases ,phases
|
|
(replace 'patch-cargo-checksums
|
|
;; The Cargo.lock format changed.
|
|
(lambda* _
|
|
(use-modules (guix build cargo-utils))
|
|
(substitute* "Cargo.lock"
|
|
(("(checksum = )\".*\"" all name)
|
|
(string-append name "\"" ,%cargo-reference-hash "\"")))
|
|
(generate-all-checksums "vendor"))))))))))
|
|
|
|
(define-public rust-1.40
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.39 "1.40.0"
|
|
"1ba9llwhqm49w7sz3z0gqscj039m53ky9wxzhaj11z6yg1ah15yx")))
|
|
(package
|
|
(inherit base-rust)
|
|
(source
|
|
(origin
|
|
(inherit (package-source base-rust))
|
|
;; llvm-emscripten is no longer bundled, as that codegen backend
|
|
;; got removed.
|
|
(snippet '(for-each delete-file-recursively
|
|
'("src/llvm-project"
|
|
"vendor/jemalloc-sys/jemalloc")))))
|
|
;; Rust 1.40 does not ship rustc-internal libraries by default (see
|
|
;; rustc-dev-split). This means that librustc_driver.so is no longer
|
|
;; available in lib/rustlib/$target/lib, which is the directory
|
|
;; included in the runpath of librustc_codegen_llvm-llvm.so. This is
|
|
;; detected by our validate-runpath phase as an error, but it is
|
|
;; harmless as the codegen backend is loaded by librustc_driver.so
|
|
;; itself, which must at that point have been already loaded. As such,
|
|
;; we skip validating the runpath for Rust 1.40. Rust 1.41 stopped
|
|
;; putting the codegen backend in a separate library, which makes this
|
|
;; workaround only necessary for this release.
|
|
(arguments (substitute-keyword-arguments (package-arguments base-rust)
|
|
((#:validate-runpath? _ #f)
|
|
#f))))))
|
|
|
|
(define-public rust-1.41
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.40 "1.41.1"
|
|
"0ws5x0fxv57fyllsa6025h3q6j9v3m8nb3syl4x0hgkddq0kvj9q")))
|
|
(package
|
|
(inherit base-rust)
|
|
(arguments
|
|
(substitute-keyword-arguments (package-arguments base-rust)
|
|
((#:validate-runpath? _ #t)
|
|
#t))))))
|
|
|
|
(define-public rust-1.42
|
|
(rust-bootstrapped-package
|
|
rust-1.41 "1.42.0" "0x9lxs82may6c0iln0b908cxyn1cv7h03n5cmbx3j1bas4qzks6j"))
|
|
|
|
(define-public rust-1.43
|
|
(rust-bootstrapped-package
|
|
rust-1.42 "1.43.0" "18akhk0wz1my6y9vhardriy2ysc482z0fnjdcgs9gy59kmnarxkm"))
|
|
|
|
;; This version needs llvm >= 8.0 and NOT 11
|
|
(define-public rust-1.44
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.43 "1.44.1"
|
|
"0ww4z2v3gxgn3zddqzwqya1gln04p91ykbrflnpdbmcd575n8bky")))
|
|
(package
|
|
(inherit base-rust)
|
|
(inputs
|
|
(alist-replace "llvm" (list llvm-10) (package-inputs base-rust))))))
|
|
|
|
(define-public rust-1.45
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.44 "1.45.2"
|
|
"0273a1g3f59plyi1n0azf21qjzwml1yqdnj5z472crz37qggr8xp")))
|
|
(package
|
|
(inherit base-rust)
|
|
(arguments
|
|
(substitute-keyword-arguments (package-arguments base-rust)
|
|
((#:phases phases)
|
|
`(modify-phases ,phases
|
|
(add-after 'unpack 'set-linker-locale-to-utf8
|
|
(lambda _
|
|
(substitute* (find-files "." "^linker.rs$")
|
|
(("linker.env\\(\"LC_ALL\", \"C\"\\);")
|
|
"linker.env(\"LC_ALL\", \"en_US.UTF-8\");")))))))))))
|
|
|
|
(define-public rust-1.46
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.45 "1.46.0"
|
|
"0a17jby2pd050s24cy4dfc0gzvgcl585v3vvyfilniyvjrqknsid")))
|
|
(package
|
|
(inherit base-rust)
|
|
(outputs (cons "rustfmt" (package-outputs base-rust)))
|
|
(arguments
|
|
(substitute-keyword-arguments (package-arguments base-rust)
|
|
((#:phases phases)
|
|
`(modify-phases ,phases
|
|
(replace 'build
|
|
;; Phase overridden to also build rustfmt.
|
|
(lambda* (#:key parallel-build? #:allow-other-keys)
|
|
(let ((job-spec (string-append
|
|
"-j" (if parallel-build?
|
|
(number->string (parallel-job-count))
|
|
"1"))))
|
|
(invoke "./x.py" job-spec "build")
|
|
(invoke "./x.py" job-spec "build" "src/tools/cargo")
|
|
(invoke "./x.py" job-spec "build" "src/tools/rustfmt"))))
|
|
(replace 'check
|
|
;; Phase overridden to also test rustfmt.
|
|
(lambda* (#:key tests? parallel-build? #:allow-other-keys)
|
|
(when tests?
|
|
(let ((job-spec (string-append
|
|
"-j" (if parallel-build?
|
|
(number->string (parallel-job-count))
|
|
"1"))))
|
|
(invoke "./x.py" job-spec "test" "-vv")
|
|
(invoke "./x.py" job-spec "test" "src/tools/cargo")
|
|
(invoke "./x.py" job-spec "test" "src/tools/rustfmt")))))
|
|
(replace 'install
|
|
;; Phase overridden to also install rustfmt.
|
|
(lambda* (#:key outputs #:allow-other-keys)
|
|
(invoke "./x.py" "install")
|
|
(substitute* "config.toml"
|
|
;; Adjust the prefix to the 'cargo' output.
|
|
(("prefix = \"[^\"]*\"")
|
|
(format #f "prefix = ~s" (assoc-ref outputs "cargo"))))
|
|
(invoke "./x.py" "install" "cargo")
|
|
(substitute* "config.toml"
|
|
;; Adjust the prefix to the 'rustfmt' output.
|
|
(("prefix = \"[^\"]*\"")
|
|
(format #f "prefix = ~s" (assoc-ref outputs "rustfmt"))))
|
|
(invoke "./x.py" "install" "rustfmt"))))))))))
|
|
|
|
(define-public rust-1.47
|
|
(rust-bootstrapped-package
|
|
rust-1.46 "1.47.0" "07fqd2vp7cf1ka3hr207dnnz93ymxml4935vp74g4is79h3dz19i"))
|
|
|
|
(define-public rust-1.48
|
|
(rust-bootstrapped-package
|
|
rust-1.47 "1.48.0" "0fz4gbb5hp5qalrl9lcl8yw4kk7ai7wx511jb28nypbxninkwxhf"))
|
|
|
|
(define-public rust-1.49
|
|
(let ((base-rust (rust-bootstrapped-package
|
|
rust-1.48 "1.49.0"
|
|
"0yf7kll517398dgqsr7m3gldzj0iwsp3ggzxrayckpqzvylfy2mm")))
|
|
(package
|
|
(inherit base-rust)
|
|
(outputs (cons "doc" (package-outputs base-rust)))
|
|
(arguments
|
|
(substitute-keyword-arguments (package-arguments base-rust)
|
|
((#:tests? _ #f)
|
|
#t)
|
|
((#:phases phases)
|
|
`(modify-phases ,phases
|
|
(add-after 'unpack 'relax-gdb-auto-load-safe-path
|
|
;; Allow GDB to load binaries from any location, otherwise the
|
|
;; gdbinfo tests fail. This is only useful when testing with a
|
|
;; GDB version newer than 8.2.
|
|
(lambda _
|
|
(setenv "HOME" (getcwd))
|
|
(with-output-to-file (string-append (getenv "HOME") "/.gdbinit")
|
|
(lambda _
|
|
(format #t "set auto-load safe-path /~%")))
|
|
;; Do not launch gdb with '-nx' which causes it to not execute
|
|
;; any init file.
|
|
(substitute* "src/tools/compiletest/src/runtest.rs"
|
|
(("\"-nx\".as_ref\\(\\), ")
|
|
""))))
|
|
(add-after 'unpack 'patch-cargo-env-shebang
|
|
(lambda _
|
|
(substitute* '("src/tools/cargo/tests/testsuite/build.rs"
|
|
"src/tools/cargo/tests/testsuite/fix.rs")
|
|
;; The cargo *_wrapper tests set RUSTC.*WRAPPER environment
|
|
;; variable which points to /usr/bin/env. Since it's not a
|
|
;; shebang, it needs to be manually patched.
|
|
(("/usr/bin/env")
|
|
(which "env")))))
|
|
(add-after 'unpack 'disable-tests-requiring-git
|
|
(lambda _
|
|
(substitute* "src/tools/cargo/tests/testsuite/new.rs"
|
|
(("fn author_prefers_cargo")
|
|
"#[ignore]\nfn author_prefers_cargo")
|
|
(("fn finds_author_git")
|
|
"#[ignore]\nfn finds_author_git")
|
|
(("fn finds_local_author_git")
|
|
"#[ignore]\nfn finds_local_author_git"))))
|
|
(add-after 'unpack 'patch-command-exec-tests
|
|
;; This test suite includes some tests that the stdlib's
|
|
;; `Command` execution properly handles in situations where
|
|
;; the environment or PATH variable are empty, but this fails
|
|
;; since we don't have `echo` available at its usual FHS
|
|
;; location.
|
|
(lambda _
|
|
(substitute* (match (find-files "." "^command-exec.rs$")
|
|
((file) file))
|
|
(("Command::new\\(\"echo\"\\)")
|
|
(format #f "Command::new(~s)" (which "echo"))))))
|
|
(add-after 'unpack 'patch-command-uid-gid-test
|
|
(lambda _
|
|
(substitute* (match (find-files "." "^command-uid-gid.rs$")
|
|
((file) file))
|
|
(("/bin/sh")
|
|
(which "sh")))))
|
|
(add-after 'unpack 'skip-shebang-tests
|
|
;; This test make sure that the parser behaves properly when a
|
|
;; source file starts with a shebang. Unfortunately, the
|
|
;; patch-shebangs phase changes the meaning of these edge-cases.
|
|
;; We skip the test since it's drastically unlikely Guix's
|
|
;; packaging will introduce a bug here.
|
|
(lambda _
|
|
(delete-file "src/test/ui/parser/shebang/sneaky-attrib.rs")))
|
|
(add-after 'unpack 'patch-process-tests
|
|
(lambda* (#:key inputs #:allow-other-keys)
|
|
(let ((bash (assoc-ref inputs "bash")))
|
|
(substitute* "library/std/src/process/tests.rs"
|
|
(("\"/bin/sh\"")
|
|
(string-append "\"" bash "/bin/sh\"")))
|
|
(substitute* "library/std/src/sys/unix/process/process_common/tests.rs"
|
|
(("fn test_process_mask")
|
|
"#[allow(unused_attributes)]
|
|
#[ignore]
|
|
fn test_process_mask")))))
|
|
(add-after 'unpack 'disable-interrupt-tests
|
|
(lambda _
|
|
;; This test hangs in the build container; disable it.
|
|
(substitute* (match (find-files "." "^freshness.rs$")
|
|
((file) file))
|
|
(("fn linking_interrupted")
|
|
"#[ignore]\nfn linking_interrupted"))
|
|
;; Likewise for the ctrl_c_kills_everyone test.
|
|
(substitute* (match (find-files "." "^death.rs$")
|
|
((file) file))
|
|
(("fn ctrl_c_kills_everyone")
|
|
"#[ignore]\nfn ctrl_c_kills_everyone"))))
|
|
(add-after 'configure 'enable-docs
|
|
(lambda _
|
|
(substitute* "config.toml"
|
|
(("docs = false")
|
|
"docs = true"))))
|
|
(add-after 'configure 'add-gdb-to-config
|
|
(lambda* (#:key inputs #:allow-other-keys)
|
|
(let ((gdb (assoc-ref inputs "gdb")))
|
|
(substitute* "config.toml"
|
|
(("^python =.*" all)
|
|
(string-append all
|
|
"gdb = \"" gdb "/bin/gdb\"\n"))))))))))
|
|
;; Add test inputs.
|
|
(native-inputs (cons*
|
|
;; The tests fail when using GDB 10 (see:
|
|
;; https://github.com/rust-lang/rust/issues/79009).
|
|
`("gdb" ,gdb-9.2)
|
|
`("procps" ,procps)
|
|
(package-native-inputs base-rust))))))
|
|
|
|
(define-public rust-1.50
|
|
(rust-bootstrapped-package rust-1.49 "1.50.0"
|
|
"0pjs7j62maiyvkmhp9zrxl528g2n0fphp4rq6ap7aqdv0a6qz5wm"))
|
|
|
|
(define-public rust-1.51
|
|
(rust-bootstrapped-package rust-1.50 "1.51.0"
|
|
"0ixqkqglv3isxbvl4ldr4byrkx692wghsz3fasy1pn5kr2prnsvs"))
|
|
|
|
(define-public rust-1.52
|
|
(let ((base-rust
|
|
(rust-bootstrapped-package rust-1.51 "1.52.1"
|
|
"165zs3xzp9dravybwslqs1qhn35agp6wacmzpymqg3qfdni26vrs")))
|
|
(package
|
|
(inherit base-rust)
|
|
(inputs
|
|
(alist-replace "llvm" (list llvm-12)
|
|
(package-inputs base-rust))))))
|
|
|
|
;;; Note: Only the latest versions of Rust are supported and tested. The
|
|
;;; intermediate rusts are built for bootstrapping purposes and should not
|
|
;;; be relied upon. This is to ease maintenance and reduce the time
|
|
;;; required to build the full Rust bootstrap chain.
|
|
(define-public rust rust-1.49)
|