feat: Use hidden rust packages from main channel

1 files changed, 1 insertions, 670 deletions

diff --git a/johnlepikhin/packages/rust.scm b/johnlepikhin/packages/rust.scm
index ef1a1a8..603a1f5 100644
--- a/johnlepikhin/packages/rust.scm
+++ b/johnlepikhin/packages/rust.scm
@@ -50,6 +50,7 @@
   #:use-module (gnu packages ninja)
   #:use-module (gnu packages pkg-config)
   #:use-module (gnu packages python)
+  #:use-module (gnu packages rust)
   #:use-module (gnu packages ssh)
   #:use-module (gnu packages tls)
   #:use-module (gnu packages)
@@ -155,676 +156,6 @@
           (substitute* (find-files "." "Makefile")
             (("-g ") "")))))))
 
-;;; Rust 1.54 is special in that it is built with mrustc, which shortens the
-;;; bootstrap path.
-(define rust-bootstrap
-  (package
-    (name "rust")
-    (version "1.54.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (rust-uri version))
-       (sha256 (base32 "0xk9dhfff16caambmwij67zgshd8v9djw6ha0fnnanlv7rii31dc"))
-       (modules '((guix build utils)))
-       (snippet
-        '(begin
-           (for-each delete-file-recursively
-                     '("src/llvm-project"))
-           ;; Remove vendored dynamically linked libraries.
-           ;; find . -not -type d -executable -exec file {} \+ | grep ELF
-           (delete-file "vendor/vte/vim10m_match")
-           (delete-file "vendor/vte/vim10m_table")
-           ;; Also remove the bundled (mostly Windows) libraries.
-           ;; find vendor -not -type d -exec file {} \+ | grep PE32
-           (for-each delete-file
-                     (find-files "vendor" ".*\\.(a|dll|exe|lib)$"))))
-       (patches (search-patches "rustc-1.54.0-src.patch"))
-       (patch-flags '("-p0"))))         ;default is -p1
-    (outputs '("out" "cargo"))
-    (properties '((timeout . 72000)           ;20 hours
-                  (max-silent-time . 18000))) ;5 hours (for armel)
-    (build-system gnu-build-system)
-    (inputs
-     `(("libcurl" ,curl)
-       ("llvm" ,llvm-13)
-       ("openssl" ,openssl-1.1)
-       ("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
-       ;; Most of the build is single-threaded. This also improves the
-       ;; build time on machines with "only" 8GB of RAM.
-       #:parallel-build? ,(target-x86-64?)
-       #:make-flags
-       (list ,(string-append "RUSTC_TARGET="
-                             (or (%current-target-system)
-                                 (nix-system->gnu-triplet-for-rust)))
-             ,(string-append "RUSTC_VERSION=" version)
-             ,(string-append "MRUSTC_TARGET_VER="
-                             (version-major+minor version))
-             ;; mrustc expects a C11 compatible compiler. Use the default
-             ;; C language dialect from the GCC-10 compiler.
-             ;; This is necessary for some architectures.
-             "CFLAGS=-std=gnu11"
-             "OUTDIR_SUF=")           ;do not add version suffix to output dir
-       #: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 'setup-mrustc-sources
-           (lambda* (#:key inputs #:allow-other-keys)
-             (copy-recursively (assoc-ref inputs "mrustc-source") "../mrustc")
-             ;; The Makefile of mrustc expects the sources directory of rustc
-             ;; to be at this location, and it simplifies things to make it
-             ;; so.
-             (symlink (getcwd)
-                      (string-append "../mrustc/rustc-" ,version "-src"))
-             (with-output-to-file "dl-version"
-               (lambda _
-                 (format #t "~a~%"
-                         ,version)))))
-         (add-after 'setup-mrustc-sources 'patch-makefiles
-           ;; This disables building the (unbundled) LLVM.
-           (lambda* (#:key inputs parallel-build? #:allow-other-keys)
-             (let ((llvm (assoc-ref inputs "llvm")))
-               (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")))
-                 (substitute* "minicargo.mk"
-                   ;; Do not try to fetch sources from the Internet.
-                   (("@curl.*") ""))
-                 (substitute* "Makefile"
-                   ;; Patch date and git obtained version information.
-                   ((" -D VERSION_GIT_FULLHASH=.*")
-                    (string-append
-                     " -D VERSION_GIT_FULLHASH=\\\"" ,%mrustc-commit "\\\""
-                     " -D VERSION_GIT_BRANCH=\\\"master\\\""
-                     " -D VERSION_GIT_SHORTHASH=\\\""
-                     ,(string-take %mrustc-commit 7) "\\\""
-                     " -D VERSION_BUILDTIME="
-                     "\"\\\"Thu, 01 Jan 1970 00:00:01 +0000\\\"\""
-                     " -D VERSION_GIT_ISDIRTY=0\n")))
-                 (substitute* "minicargo.mk"
-                   ;; Do not try to fetch sources from the Internet.
-                   (("\\$\\(MINICARGO\\) \\$\\(RUSTC_SRC_DL\\)")
-                    "$(MINICARGO)"))
-                 (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
-                   (("#!/bin/sh")
-                    (string-append "#!" (which "sh"))))
-                 (substitute* "run_rustc/rustc_proxy.sh"
-                   (("#!/bin/sh")
-                    (string-append "#!" (which "sh"))))))))
-         (add-after 'patch-generated-file-shebangs 'patch-cargo-checksums
-           (lambda* _
-             (substitute* "Cargo.lock"
-               (("(checksum = )\".*\"" all name)
-                (string-append name "\"" ,%cargo-reference-hash "\"")))
-             (generate-all-checksums "vendor")))
-         (add-before 'configure 'configure-cargo-home
-           (lambda _
-             (let ((cargo-home (string-append (getcwd) "/.cargo")))
-               (mkdir-p cargo-home)
-               (setenv "CARGO_HOME" cargo-home))))
-         (replace 'configure
-           (lambda _
-             (setenv "CC" "gcc")
-             (setenv "CXX" "g++")
-             ;; The Guix LLVM package installs only shared libraries.
-             (setenv "LLVM_LINK_SHARED" "1")
-             ;; rustc still insists on having 'cc' on PATH in some places
-             ;; (e.g. when building the 'test' library crate).
-             (mkdir-p "/tmp/bin")
-             (symlink (which "gcc") "/tmp/bin/cc")
-             (setenv "PATH" (string-append "/tmp/bin:" (getenv "PATH")))))
-         (delete 'patch-generated-file-shebangs)
-         (replace 'build
-           (lambda* (#:key make-flags parallel-build? #:allow-other-keys)
-             (let* ((src-root (getcwd))
-                    (job-count (if parallel-build?
-                                   (parallel-job-count)
-                                   1)))
-               ;; Adapted from:
-               ;; https://github.com/dtolnay/bootstrap/blob/master/build-1.54.0.sh.
-               (chdir "../mrustc")
-               ;; Use PARLEVEL since both minicargo and mrustc use it
-               ;; to set the level of parallelism.
-               (setenv "PARLEVEL" (number->string job-count))
-               (display "Building mrustc...\n")
-               (apply invoke "make" make-flags)
-
-               ;; This doesn't seem to build anything, but it
-               ;; sets additional minicargo flags.
-               (display "Building RUSTCSRC...\n")
-               (apply invoke "make" "RUSTCSRC" make-flags)
-
-               ;; This probably doesn't need to be called explicitly.
-               (display "Building LIBS...\n")
-               (apply invoke "make" "-f" "minicargo.mk" "LIBS" make-flags)
-
-               (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)
-
-               ;; This one isn't listed in the build script.
-               (display "Rebuilding stdlib with rustc...\n")
-               (apply invoke "make" "-C" "run_rustc" 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"))
-                    (src (string-append lib "rustlib/src/rust"))
-                    (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 src)
-               (copy-recursively "run_rustc/output/prefix/lib" lib)
-               (copy-recursively "library" (string-append src "/library"))
-               (copy-recursively "src" (string-append src "/src"))
-               (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")
-
-    ;; The intermediate generated code is known to be inefficient and
-    ;; therefore the build process needs 8GB of RAM while building.
-    ;; It may support i686 soon:
-    ;; <https://github.com/thepowersgang/mrustc/issues/78>.
-    ;; XXX: The rust bootstrap is currently broken on riscv64,
-    ;; remove it until this is fixed.
-    (supported-systems '("x86_64-linux" "aarch64-linux"))
-
-    ;; Dual licensed.
-    (license (list license:asl2.0 license:expat))))
-
-(define rust-1.55
-  (package
-    (name "rust")
-    (version "1.55.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (rust-uri version))
-       (sha256 (base32 "07l28f7grdmi65naq71pbmvdd61hwcpi40ry7kp7dy7m233rldxj"))
-       (modules '((guix build utils)))
-       (snippet
-        '(begin
-           (for-each delete-file-recursively
-                     '("src/llvm-project"
-                       "vendor/tikv-jemalloc-sys/jemalloc"))
-           ;; Remove vendored dynamically linked libraries.
-           ;; find . -not -type d -executable -exec file {} \+ | grep ELF
-           (delete-file "vendor/vte/vim10m_match")
-           (delete-file "vendor/vte/vim10m_table")
-           ;; Also remove the bundled (mostly Windows) libraries.
-           ;; find vendor -not -type d -exec file {} \+ | grep PE32
-           (for-each delete-file
-                     (find-files "vendor" ".*\\.(a|dll|exe|lib)$"))
-           ;; Add support for riscv64-linux.
-           (substitute* "vendor/tikv-jemallocator/src/lib.rs"
-             (("    target_arch = \"s390x\"," all)
-              (string-append all "\n    target_arch = \"riscv64\",")))))))
-    (outputs '("out" "cargo"))
-    (properties '((timeout . 72000)           ;20 hours
-                  (max-silent-time . 18000))) ;5 hours (for armel)
-    (build-system gnu-build-system)
-    (arguments
-     `(#:validate-runpath? #f
-       ;; 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 cargo-utils)
-                  (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" (search-input-file inputs "/bin/gcc"))
-             ;; The Guix LLVM package installs only shared libraries.
-             (setenv "LLVM_LINK_SHARED" "1")))
-         (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\");"))))
-         (add-after 'unpack 'add-cc-shim-to-path
-           (lambda _
-             (mkdir-p "/tmp/bin")
-             (symlink (which "gcc") "/tmp/bin/cc")
-             (setenv "PATH" (string-append "/tmp/bin:" (getenv "PATH")))))
-         (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")))
-               ;; 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.
-               (setenv "JEMALLOC_OVERRIDE"
-                       (search-input-file inputs
-                                          "/lib/libjemalloc_pic.a"))
-               (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]
-debug=false
-jemalloc=true
-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" "\"
-[dist]
-") port))))))
-         (replace 'build
-           ;; The standard library source location moved in this release.
-           (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" "--stage=1"
-                       "library/std"
-                       "src/tools/cargo"))))
-         (replace 'install
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let* ((out (assoc-ref outputs "out"))
-                    (cargo-out (assoc-ref outputs "cargo"))
-                    (gnu-triplet ,(or (%current-target-system)
-                                      (nix-system->gnu-triplet-for-rust)))
-                    (build (string-append "build/" gnu-triplet)))
-               ;; Manually do the installation instead of calling './x.py
-               ;; install', as that is slow and needlessly rebuilds some
-               ;; things.
-               (install-file (string-append build "/stage1/bin/rustc")
-                             (string-append out "/bin"))
-               (copy-recursively (string-append build "/stage1/lib")
-                                 (string-append out "/lib"))
-               (install-file (string-append build "/stage1-tools-bin/cargo")
-                             (string-append cargo-out "/bin")))))
-         (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-bootstrap)
-       ("cargo-bootstrap" ,rust-bootstrap "cargo")
-       ("which" ,which)))
-    (inputs
-     `(("jemalloc" ,jemalloc)
-       ("llvm" ,llvm-13)
-       ("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 "i586-gnu" %supported-systems))
-    (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://www.rust-lang.org")
-    ;; Dual licensed.
-    (license (list license:asl2.0 license:expat))))
-
-(define rust-1.56
-  (let ((base-rust (rust-bootstrapped-package
-                    rust-1.55 "1.56.1"
-                    "04cmqx7nn63hzz7z27b2b0dj2qx18rck9ifvip43s6dampx8v2f3")))
-    (package
-      (inherit base-rust)
-      (arguments
-       (substitute-keyword-arguments (package-arguments base-rust)
-         ((#:validate-runpath? _ #t)
-          #t)
-         ((#:phases phases)
-          `(modify-phases ,phases
-             (delete 'add-cc-shim-to-path)
-             (add-after 'patch-generated-file-shebangs 'patch-cargo-checksums
-               (lambda* _
-                 (substitute* "Cargo.lock"
-                   (("(checksum = )\".*\"" all name)
-                    (string-append name "\"" ,%cargo-reference-hash "\"")))
-                 (generate-all-checksums "vendor"))))))))))
-
-(define rust-1.57
-  (rust-bootstrapped-package
-   ;; Verified that it *doesn't* build with 1.55. e.g.:
-   ;; * feature `edition2021` is required
-   rust-1.56 "1.57.0" "06jw8ka2p3kls8p0gd4p0chhhb1ia1mlvj96zn78n7qvp71zjiim"))
-
-(define rust-1.58
-  (rust-bootstrapped-package
-   ;; Verified that it *doesn't* build with 1.56. e.g.:
-   ;; * error: attributes starting with `rustc` are reserved for use by the
-   ;;   `rustc` compiler
-   ;; * error: cannot find attribute `rustc_do_not_const_check` in this scope
-   ;; * error[E0522]: definition of an unknown language item:
-   ;;   `const_eval_select_ct`
-   rust-1.57 "1.58.1" "1iq7kj16qfpkx8gvw50d8rf7glbm6s0pj2y1qkrz7mi56vfsyfd8"))
-
-(define rust-1.59
-  (let ((base-rust
-          (rust-bootstrapped-package
-            ;; Verified that it *doesn't* build with 1.57. e.g.:
-            ;; * error: `doc(primitive)` should never have been stable
-            ;; * error[E0522]: definition of an unknown language item:
-            ;;   `generator_return`
-            ;; * error[E0206]: the trait `Copy` may not be implemented for this type
-            rust-1.58 "1.59.0" "1yc5bwcbmbwyvpfq7zvra78l0r8y3lbv60kbr62fzz2vx2pfxj57")))
-    (package
-      (inherit base-rust)
-        (arguments
-         (if (target-riscv64?)
-           (substitute-keyword-arguments (package-arguments base-rust)
-             ((#:phases phases)
-              `(modify-phases ,phases
-                 (add-after 'unpack 'revert-riscv-pause-instruction
-                   (lambda _
-                     ;; This fails with:
-                     ;; error: unknown directive, referring to '.insn'.
-                     ;; This is due to building with llvm < 14.
-                     ;; https://github.com/rust-lang/stdarch/issues/1291
-                     ;; Partial roll-back from this commit:
-                     ;; https://github.com/rust-lang/stdarch/pull/1271
-                     (substitute*
-                       "library/stdarch/crates/core_arch/src/riscv_shared/mod.rs"
-                       (("\\.insn i 0x0F, 0, x0, x0, 0x010") ".word 0x0100000F")))))))
-           (package-arguments base-rust))))))
-
-(define rust-1.60
-  (rust-bootstrapped-package
-   ;; Verified that it *doesn't* build with 1.58. e.g.:
-   ;; * error: unknown codegen option: `symbol-mangling-version`
-   rust-1.59 "1.60.0" "1drqr0a26x1rb2w3kj0i6abhgbs3jx5qqkrcwbwdlx7n3inq5ji0"))
-
-(define rust-1.61
-  (let ((base-rust
-          (rust-bootstrapped-package
-           rust-1.60 "1.61.0" "1vfs05hkf9ilk19b2vahqn8l6k17pl9nc1ky9kgspaascx8l62xd")))
-    (package
-      (inherit base-rust)
-      (source
-        (origin
-          (inherit (package-source base-rust))
-          (snippet
-           '(begin
-              (for-each delete-file-recursively
-                        '("src/llvm-project"
-                          "vendor/tikv-jemalloc-sys/jemalloc"))
-              ;; Remove vendored dynamically linked libraries.
-              ;; find . -not -type d -executable -exec file {} \+ | grep ELF
-              (delete-file "vendor/vte/vim10m_match")
-              (delete-file "vendor/vte/vim10m_table")
-              ;; Also remove the bundled (mostly Windows) libraries.
-              (for-each delete-file
-                        (find-files "vendor" ".*\\.(a|dll|exe|lib)$")))))))))
-
-(define rust-1.62
-  (rust-bootstrapped-package
-   rust-1.61 "1.62.1" "0gqkg34ic77dcvsz69qbdng6g3zfhl6hnhx7ha1mjkyrzipvxb3j"))
-
-(define rust-1.63
-  (rust-bootstrapped-package
-   rust-1.62 "1.63.0" "1l4rrbzhxv88pnfq94nbyb9m6lfnjwixma3mwjkmvvs2aqlq158z"))
-
-(define-public rust-1.64
-  (let ((base-rust
-         (rust-bootstrapped-package
-          rust-1.63 "1.64.0" "018j720b2n12slp4xk64jc6shkncd46d621qdyzh2a8s3r49zkdk")))
-    (package
-      (inherit base-rust)
-      (source
-       (origin
-         (inherit (package-source base-rust))
-         (patches (search-patches "rust-1.64-fix-riscv64-bootstrap.patch"))
-         (patch-flags '("-p1" "--reverse"))))
-      (arguments
-       (substitute-keyword-arguments (package-arguments base-rust)
-         ((#:phases phases)
-          `(modify-phases ,phases
-             (replace 'patch-cargo-checksums
-               (lambda _
-                 (substitute* '("Cargo.lock"
-                                "src/bootstrap/Cargo.lock"
-                                "src/tools/rust-analyzer/Cargo.lock")
-                   (("(checksum = )\".*\"" all name)
-                    (string-append name "\"" ,%cargo-reference-hash "\"")))
-                 (generate-all-checksums "vendor"))))))))))
-
-(define rust-1.65
-  (let ((base-rust
-         (rust-bootstrapped-package
-          rust-1.64 "1.65.0" "0f005kc0vl7qyy298f443i78ibz71hmmh820726bzskpyrkvna2q")))
-    (package
-      (inherit base-rust)
-      (source
-       (origin
-         (inherit (package-source base-rust))
-         (patches '())
-         (patch-flags '("-p1")))))))
-
-(define rust-1.66
-  (rust-bootstrapped-package
-   rust-1.65 "1.66.1" "1fjr94gsicsxd2ypz4zm8aad1zdbiccr7qjfbmq8f8f7jhx96g2v"))
-
-(define rust-1.67
-  (let ((base-rust
-          (rust-bootstrapped-package
-           rust-1.66 "1.67.1" "0vpzv6rm3w1wbni17ryvcw83k5klhghklylfdza3nnp8blz3sj26")))
-    (package
-      (inherit base-rust)
-      (inputs (modify-inputs (package-inputs base-rust)
-                             (replace "llvm" llvm-15))))))
-
-(define rust-1.68
-  (rust-bootstrapped-package
-   rust-1.67 "1.68.2" "15ifyd5jj8rd979dkakp887hgmhndr68pqaqvd2hqkfdywirqcwk"))
-
-(define rust-1.69
-  (let ((base-rust
-          (rust-bootstrapped-package
-           rust-1.68 "1.69.0" "03zn7kx5bi5mdfsqfccj4h8gd6abm7spj0kjsfxwlv5dcwc9f1gv")))
-    (package
-      (inherit base-rust)
-      (source
-        (origin
-          (inherit (package-source base-rust))
-          (snippet
-           '(begin
-              (for-each delete-file-recursively
-                        '("src/llvm-project"
-                          "vendor/tikv-jemalloc-sys/jemalloc"))
-              ;; Also remove the bundled (mostly Windows) libraries.
-              (for-each delete-file
-                        (find-files "vendor" ".*\\.(a|dll|exe|lib)$")))))))))
-
-(define rust-1.70
- (let ((base-rust
-         (rust-bootstrapped-package
-          rust-1.69 "1.70.0" "0z6j7d0ni0rmfznv0w3mrf882m11kyh51g2bxkj40l3s1c0axgxj")))
-   (package
-     (inherit base-rust)
-     (source
-      (origin
-        (inherit (package-source base-rust))
-        ;; Rust 1.70 adds the rustix library which depends on the vendored fd-lock
-        ;; crate. The fd-lock crate uses Outline assembly which expects a precompiled
-        ;; static library. Enabling the "cc" feature tells the build.rs script to
-        ;; compile the assembly files instead of searching for a precompiled library.
-        (patches
-         (parameterize
-             ((%patch-path
-               (map (lambda (directory)
-                      (string-append directory "/johnlepikhin/packages/patches"))
-                    %load-path)))
-           (search-patches "rust-1.70-fix-rustix-build.patch")))
-        (patch-flags '("-p1")))))))
-
-(define rust-1.71
-  (let ((base-rust
-          (rust-bootstrapped-package
-           rust-1.70 "1.71.1" "0bj79syjap1kgpg9pc0r4jxc0zkxwm6phjf3digsfafms580vabg")))
-    (package
-      (inherit base-rust)
-      (arguments
-       (substitute-keyword-arguments (package-arguments base-rust)
-         ((#:phases phases)
-          `(modify-phases ,phases
-             (replace 'patch-cargo-checksums
-               (lambda _
-                 (substitute* (cons* "Cargo.lock"
-                                     "src/bootstrap/Cargo.lock"
-                                     (find-files "src/tools" "Cargo.lock"))
-                   (("(checksum = )\".*\"" all name)
-                    (string-append name "\"" ,%cargo-reference-hash "\"")))
-                 (generate-all-checksums "vendor"))))))))))
-
-(define rust-1.72
-  (let ((base-rust
-          (rust-bootstrapped-package
-           rust-1.71 "1.72.1" "15gqd1jzhnc16a7gjmav4x1v83jjbzyjh1gvcdfvpkajd9gq8j3z")))
-    (package
-      (inherit base-rust)
-      (source
-        (origin
-          (inherit (package-source base-rust))
-          (snippet
-           '(begin
-              (for-each delete-file-recursively
-                        '("src/llvm-project"
-                          "vendor/tikv-jemalloc-sys/jemalloc"))
-              ;; Remove vendored dynamically linked libraries.
-              ;; find . -not -type d -executable -exec file {} \+ | grep ELF
-              ;; Also remove the bundled (mostly Windows) libraries.
-              (for-each delete-file
-                        (find-files "vendor" "\\.(a|dll|exe|lib)$"))
-              ;; Adjust rustc_driver to explicitly use rustix with libc backend.
-              (substitute* "compiler/rustc_driver/Cargo.toml"
-                (("rustix = \"=0.37.11\"")
-                 (string-append "rustix = { version = \"=0.37.11\","
-                                " features = [\"use-libc\"] }"))))))))))
-
-(define rust-1.73
-  (let ((base-rust
-          (rust-bootstrapped-package
-           rust-1.72 "1.73.0" "0fmvn7vg3qg9xprgfwv10g3ygy8i4j4bkcxcr1xdy89d3xnjxmln")))
-    (package
-      (inherit base-rust)
-      (source
-       (origin
-         (inherit (package-source base-rust))
-         (snippet
-          '(begin
-             (for-each delete-file-recursively
-                       '("src/llvm-project"
-                         "vendor/tikv-jemalloc-sys/jemalloc"))
-             ;; Remove vendored dynamically linked libraries.
-             ;; find . -not -type d -executable -exec file {} \+ | grep ELF
-             ;; Also remove the bundled (mostly Windows) libraries.
-             (for-each delete-file
-                       (find-files "vendor" "\\.(a|dll|exe|lib)$"))
-             ;; Adjust vendored dependency to explicitly use rustix with libc backend.
-             (substitute* "vendor/tempfile-3.6.0/Cargo.toml"
-               (("features = \\[\"fs\"" all)
-                (string-append all ", \"use-libc\""))))))))))
-
 (define rust-1.74
   (let ((base-rust
           (rust-bootstrapped-package