From cbe4a4829197cebdd36ffd87087d91c4b2104c7f Mon Sep 17 00:00:00 2001 From: Alec Scott Date: Thu, 22 Jun 2023 14:03:52 -0700 Subject: rust: Add v1.70.0 and simplify package bootstrap (#38311) * Add rust v1.70.0 and simplify package logic by moving bootstrap to dedicated package * Fix formatting of rust-bootstrap package file * Re-enable Rust as extendable * Add nightly version to rust and rust-bootstrap * Manually inject openssl certs into environment * Add master and beta versions to rust * Add additional documentation for using rust development releases * Remove @AndrewGaspar as maintainer --- .../builtin/packages/rust-bootstrap/package.py | 107 +++++ var/spack/repos/builtin/packages/rust/package.py | 461 +++++---------------- 2 files changed, 209 insertions(+), 359 deletions(-) create mode 100644 var/spack/repos/builtin/packages/rust-bootstrap/package.py diff --git a/var/spack/repos/builtin/packages/rust-bootstrap/package.py b/var/spack/repos/builtin/packages/rust-bootstrap/package.py new file mode 100644 index 0000000000..84100bf242 --- /dev/null +++ b/var/spack/repos/builtin/packages/rust-bootstrap/package.py @@ -0,0 +1,107 @@ +# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other +# Spack Project Developers. See the top-level COPYRIGHT file for details. +# +# SPDX-License-Identifier: (Apache-2.0 OR MIT) +import platform +import re + +from spack.package import * + + +class RustBootstrap(Package): + """Binary bootstrap Rust compiler.""" + + homepage = "https://www.rust-lang.org" + url = "https://static.rust-lang.org/dist/rust-1.65.0-aarch64-apple-darwin.tar.gz" + + maintainers("alecbcs") + + # List binary rust releases for multiple operating systems and architectures. + # These binary versions are not intended to stay up-to-date. Instead we + # should update these binary releases as bootstrapping requirements are + # modified by new releases of Rust. + rust_releases = { + "1.70.0": { + "darwin": { + "x86_64": "e5819fdbfc7f1a4d5d82cb4c3b7662250748450b45a585433bfb75648bc45547", + "aarch64": "75cbc356a06c9b2daf6b9249febda0f0c46df2a427f7cc8467c7edbd44636e53", + }, + "linux": { + "x86_64": "8499c0b034dd881cd9a880c44021632422a28dc23d7a81ca0a97b04652245982", + "aarch64": "3aa012fc4d9d5f17ca30af41f87e1c2aacdac46b51adc5213e7614797c6fd24c", + "powerpc64le": "ba8cb5e3078b1bc7c6b27ab53cfa3af14001728db9a047d0bdf29b8f05a4db34", + }, + }, + "1.65.0": { + "darwin": { + "x86_64": "139087a3937799415fd829e5a88162a69a32c23725a44457f9c96b98e4d64a7c", + "aarch64": "7ddc335bd10fc32d3039ef36248a5d0c4865db2437c8aad20a2428a6cf41df09", + }, + "linux": { + "x86_64": "8f754fdd5af783fe9020978c64e414cb45f3ad0a6f44d045219bbf2210ca3cb9", + "aarch64": "f406136010e6a1cdce3fb6573506f00d23858af49dd20a46723c3fa5257b7796", + "powerpc64le": "3f1d0d5bb13213348dc65e373f8c412fc0a12ee55abc1c864f7e0300932fc687", + }, + }, + "1.60.0": { + "darwin": { + "x86_64": "0b10dc45cddc4d2355e38cac86d71a504327cb41d41d702d4050b9847ad4258c", + "aarch64": "b532672c278c25683ca63d78e82bae829eea1a32308e844954fb66cfe34ad222", + }, + "linux": { + "x86_64": "b8a4c3959367d053825e31f90a5eb86418eb0d80cacda52bfa80b078e18150d5", + "aarch64": "99c419c2f35d4324446481c39402c7baecd7a8baed7edca9f8d6bbd33c05550c", + "powerpc64le": "80125e90285b214c2b1f56ab86a09c8509aa17aec9d7127960a86a7008e8f7de", + }, + }, + } + + # Normalize architectures returned by platform to those used by the + # Rust project. + rust_targets = { + "aarch64": "aarch64", + "amd64": "x86_64", + "arm64": "aarch64", + "powerpc64le": "powerpc64le", + "ppc64le": "powerpc64le", + "x86_64": "x86_64", + } + + # Convert operating system names into the format used for Rust + # download server. + rust_os = {"darwin": "apple-darwin", "linux": "unknown-linux-gnu"} + + # Determine system os and architecture/target. + os = platform.system().lower() + target = rust_targets[platform.machine().lower()] + + # Pre-release versions of the bootstrap compiler. + # Note: These versions are unchecksumed since they will change + # periodically as new versions are released. + version("beta") + version("nightly") + + # Stable releases of the bootstrap compiler. + # Construct releases for current system configuration. + for release in rust_releases: + if os in rust_releases[release] and target in rust_releases[release][os]: + version(release, sha256=rust_releases[release][os][target]) + + def url_for_version(self, version): + # Allow maintainers to checksum multiple architectures via + # `spack checksum rust-bootstrap@1.70.0-darwin-aarch64`. + match = re.search(r"(\S+)-(\S+)-(\S+)", str(version)) + if match: + version = match.group(1) + os = self.rust_os[match.group(2)] + target = self.rust_targets[match.group(3)] + else: + os = self.rust_os[self.os] + target = self.target + + url = "https://static.rust-lang.org/dist/rust-{0}-{1}-{2}.tar.gz" + return url.format(version, target, os) + + def install(self, spec, prefix): + install_script = Executable("./install.sh") + install_script(f"--prefix={prefix}") diff --git a/var/spack/repos/builtin/packages/rust/package.py b/var/spack/repos/builtin/packages/rust/package.py index aec30c1118..abf73a01af 100644 --- a/var/spack/repos/builtin/packages/rust/package.py +++ b/var/spack/repos/builtin/packages/rust/package.py @@ -9,241 +9,76 @@ from spack.package import * class Rust(Package): - """The Rust programming language toolchain - - This package can bootstrap any version of the Rust compiler since Rust - 1.23. It does this by downloading the platform-appropriate binary - distribution of the desired version of the rust compiler, and then building - that compiler from source. - """ + """The Rust programming language toolchain.""" homepage = "https://www.rust-lang.org" url = "https://static.rust-lang.org/dist/rustc-1.42.0-src.tar.gz" git = "https://github.com/rust-lang/rust.git" - maintainers("AndrewGaspar") - - phases = ["configure", "build", "install"] + maintainers("alecbcs") - extendable = True + # Core dependencies + depends_on("cmake@3.13.4:", type="build") + depends_on("curl+nghttp2") + depends_on("libgit2") + depends_on("ninja", type="build") + depends_on("openssl") + depends_on("pkgconfig", type="build") + depends_on("python", type="build") + + # Compiling Rust requires a previous version of Rust. + # The easiest way to bootstrap a Rust environment is to + # download the binary distribution of the compiler and build with that. + depends_on("rust-bootstrap", type="build") + + # Pre-release version dependencies + depends_on("rust-bootstrap@beta", type="build", when="@beta") + depends_on("rust-bootstrap@nightly", type="build", when="@master") + depends_on("rust-bootstrap@nightly", type="build", when="@nightly") + + # Stable version dependencies + depends_on("rust-bootstrap@1.59:1.60", type="build", when="@1.60") + depends_on("rust-bootstrap@1.64:1.65", type="build", when="@1.65") + depends_on("rust-bootstrap@1.69:1.70", type="build", when="@1.70") + + # When adding a version of Rust you may need to add an additional version + # to rust-bootstrap as the minimum bootstrapping requirements increase. + # As a general rule of thumb Rust can be built with either the previous major + # version or the current version of the compiler as shown above. + + # Pre-release versions. + # Note: If you plan to use these versions remember to install with + # `-n` to prevent Spack from failing due to failed checksums. + # + # $ spack install -n rust@pre-release-version + # + version("beta") + version("master", branch="master", submodules=True) + version("nightly") - variant("rustfmt", default=True, description="Formatting tool for Rust code") + # Stable versions. + version("1.70.0", sha256="b2bfae000b7a5040e4ec4bbc50a09f21548190cb7570b0ed77358368413bd27c") + version("1.65.0", sha256="5828bb67f677eabf8c384020582b0ce7af884e1c84389484f7f8d00dd82c0038") + version("1.60.0", sha256="20ca826d1cf674daf8e22c4f8c4b9743af07973211c839b85839742314c838b7") variant( "analysis", - default=True, - description="Outputs code analysis that can be consumed by other tools", - ) - - variant("clippy", default=True, description="Linting tool for Rust") - - variant( - "rls", default=False, - description="The Rust Language Server can be used for IDE integration", + description="Outputs code analysis that can be consumed by other tools", ) - - variant("src", default=True, description="Install Rust source files") variant( - "extra_targets", - default="none", - multi=True, - description="Triples for extra targets to enable. For supported targets, see: https://doc.rust-lang.org/nightly/rustc/platform-support.html", + "clippy", + default=True, + description="A bunch of lints to catch common mistakes and improve your Rust code.", ) + variant("docs", default=False, description="Build Rust documentation.") + variant("rustfmt", default=True, description="Formatting tool for Rust code.") + variant("src", default=True, description="Include standard library source files.") - depends_on("python@2.7:", type="build") - depends_on("gmake@3.81:", type="build") - depends_on("cmake@3.4.3:", type="build") - depends_on("ninja", when="@1.48.0:", type="build") - depends_on("pkgconfig", type="build") - # TODO: openssl@3.x should be supported in later versions - depends_on("openssl@:1") - # Cargo itself needs libcurl with nghttp2. If not found with pkg-config - # it will build vendored versions of libcurl, nghttp2, and openssl. - depends_on("curl+nghttp2") - depends_on("libssh2") - # https://github.com/rust-lang/cargo/issues/10446 - depends_on("libgit2@:1.3", when="@0:1.60") - depends_on("libgit2") - - # Pre-release Versions - version("master", branch="master", submodules=True) - - # These version strings are officially supported, but aren't explicitly - # listed because there's no stable checksum for them. - version("nightly") - # version('beta') + extendable = True + executables = ["^rustc$", "^cargo$"] - # Version Notes: - # Here's some information on why your favorite Rust version may be missing. - # - # < 1.23: - # Rust seems to eagerly search for ar next to cc. Spack makes wrappers for - # cc and c++, but not for ar, so no ar is found. In future versions, ar - # can be specified in the config. - # - # < 1.17: - # The `x.py` bootstrapping script did not exist prior to Rust 1.17. It - # would be possible to support both, but for simplicitly, we only support - # Rust 1.17 and newer - version("1.65.0", sha256="5828bb67f677eabf8c384020582b0ce7af884e1c84389484f7f8d00dd82c0038") - version("1.60.0", sha256="20ca826d1cf674daf8e22c4f8c4b9743af07973211c839b85839742314c838b7") - version("1.58.1", sha256="a839afdd3625d6f3f3c4c10b79813675d1775c460d14be1feaf33a6c829c07c7") - version("1.51.0", sha256="7a6b9bafc8b3d81bbc566e7c0d1f17c9f499fd22b95142f7ea3a8e4d1f9eb847") - version("1.48.0", sha256="0e763e6db47d5d6f91583284d2f989eacc49b84794d1443355b85c58d67ae43b") - version("1.47.0", sha256="3185df064c4747f2c8b9bb8c4468edd58ff4ad6d07880c879ac1b173b768d81d") - version("1.46.0", sha256="2d6a3b7196db474ba3f37b8f5d50a1ecedff00738d7846840605b42bfc922728") - version("1.45.1", sha256="ea53e6424e3d1fe56c6d77a00e72c5d594b509ec920c5a779a7b8e1dbd74219b") - version("1.44.1", sha256="7e2e64cb298dd5d5aea52eafe943ba0458fa82f2987fdcda1ff6f537b6f88473") - version("1.44.0", sha256="bf2df62317e533e84167c5bc7d4351a99fdab1f9cd6e6ba09f51996ad8561100") - - # The Rust bootstrapping process requires a bootstrapping compiler. The - # easiest way to do this is to download the binary distribution of the - # same version of the compiler and build with that. - # - # This dictionary contains a version: hash dictionary for each supported - # Rust target. - rust_releases = { - "1.65.0": { - "x86_64-unknown-linux-gnu": "8f754fdd5af783fe9020978c64e414cb45f3ad0a6f44d045219bbf2210ca3cb9", - "powerpc64le-unknown-linux-gnu": "3f1d0d5bb13213348dc65e373f8c412fc0a12ee55abc1c864f7e0300932fc687", - "aarch64-unknown-linux-gnu": "f406136010e6a1cdce3fb6573506f00d23858af49dd20a46723c3fa5257b7796", - "x86_64-apple-darwin": "139087a3937799415fd829e5a88162a69a32c23725a44457f9c96b98e4d64a7c", - "aarch64-apple-darwin": "7ddc335bd10fc32d3039ef36248a5d0c4865db2437c8aad20a2428a6cf41df09", - }, - "1.60.0": { - "x86_64-unknown-linux-gnu": "b8a4c3959367d053825e31f90a5eb86418eb0d80cacda52bfa80b078e18150d5", - "powerpc64le-unknown-linux-gnu": "80125e90285b214c2b1f56ab86a09c8509aa17aec9d7127960a86a7008e8f7de", - "aarch64-unknown-linux-gnu": "99c419c2f35d4324446481c39402c7baecd7a8baed7edca9f8d6bbd33c05550c", - "x86_64-apple-darwin": "0b10dc45cddc4d2355e38cac86d71a504327cb41d41d702d4050b9847ad4258c", - "aarch64-apple-darwin": "b532672c278c25683ca63d78e82bae829eea1a32308e844954fb66cfe34ad222", - }, - "1.58.1": { - "x86_64-unknown-linux-gnu": "4fac6df9ea49447682c333e57945bebf4f9f45ec7b08849e507a64b2ccd5f8fb", - "powerpc64le-unknown-linux-gnu": "b15baef702cbd6f0ea2bef7bf98ca7ce5644f2beb219028e8a12e7053da4c849", - "aarch64-unknown-linux-gnu": "ce557516593e4526709b0f33c2e1d7c932b3ddf76af94c2417d8d667921ce90c", - "x86_64-apple-darwin": "d0044680fc132a721481b130a0a4282a444867f423efdb890fe13e447966412f", - }, - "1.51.0": { - "x86_64-unknown-linux-gnu": "9e125977aa13f012a68fdc6663629c685745091ae244f0587dd55ea4e3a3e42f", - "powerpc64le-unknown-linux-gnu": "7362f561104d7be4836507d3a53cd39444efcdf065813d559beb1f54ce9f7680", - "aarch64-unknown-linux-gnu": "fd31c78fffad52c03cac5a7c1ee5db3f34b2a77d7bc862707c0f71e209180a84", - "x86_64-apple-darwin": "765212098a415996b767d1e372ce266caf94027402b269fec33291fffc085ca4", - }, - "1.48.0": { - "x86_64-unknown-linux-gnu": "950420a35b2dd9091f1b93a9ccd5abc026ca7112e667f246b1deb79204e2038b", - "powerpc64le-unknown-linux-gnu": "e6457a0214f3b1b04bd5b2618bba7e3826e254216420dede2971b571a1c13bb1", - "aarch64-unknown-linux-gnu": "c4769418d8d89f432e4a3a21ad60f99629e4b13bbfc29aef7d9d51c4e8ee8a8a", - "x86_64-apple-darwin": "f30ce0162b39dc7cf877020cec64d4826cad50467af493d180b5b28cf5eb50b3", - }, - "1.47.0": { - "x86_64-unknown-linux-gnu": "d0e11e1756a072e8e246b05d54593402813d047d12e44df281fbabda91035d96", - "powerpc64le-unknown-linux-gnu": "5760c3b1897ea70791320c2565f3eef700a3d54059027b84bbe6b8d6157f81c8", - "aarch64-unknown-linux-gnu": "753c905e89a714ab9bce6fe1397b721f29c0760c32f09d2f328af3d39919c8e6", - "x86_64-apple-darwin": "84e5be6c5c78734deba911dcf80316be1e4c7da2c59413124d039ad96620612f", - }, - "1.46.0": { - "x86_64-unknown-linux-gnu": "e3b98bc3440fe92817881933f9564389eccb396f5f431f33d48b979fa2fbdcf5", - "powerpc64le-unknown-linux-gnu": "89e2f4761d257f017a4b6aa427f36ac0603195546fa2cfded8c899789832941c", - "aarch64-unknown-linux-gnu": "f0c6d630f3dedb3db69d69ed9f833aa6b472363096f5164f1068c7001ca42aeb", - "x86_64-apple-darwin": "82d61582a3772932432a99789c3b3bd4abe6baca339e355048ca9efb9ea5b4db", - }, - "1.45.1": { - "x86_64-unknown-linux-gnu": "76dc9f05b3bfd0465d6e6d22bc9fd5db0b473e3548e8b3d266ecfe4d9e5dca16", - "powerpc64le-unknown-linux-gnu": "271846e4f5adc9a33754794c2ffab851f9e0313c8c1315264e7db5c8f63ab7ab", - "aarch64-unknown-linux-gnu": "d17fd560e8d5d12304835b71a7e22ac2c3babf4b9768db6a0e89868b4444f728", - "x86_64-apple-darwin": "7334c927e4d2d12d209bf941b97ba309e548413e241d2d263c39c6e12b3ce154", - }, - "1.44.1": { - "x86_64-unknown-linux-gnu": "a41df89a461a580536aeb42755e43037556fba2e527dd13a1e1bb0749de28202", - "powerpc64le-unknown-linux-gnu": "22deeca259459db31065af7c862fcab7fbfb623200520c65002ed2ba93d87ad2", - "aarch64-unknown-linux-gnu": "a2d74ebeec0b6778026b6c37814cdc91d14db3b0d8b6d69d036216f4d9cf7e49", - "x86_64-apple-darwin": "a5464e7bcbce9647607904a4afa8362382f1fc55d39e7bbaf4483ac00eb5d56a", - }, - "1.44.0": { - "x86_64-unknown-linux-gnu": "eaa34271b4ac4d2c281831117d4d335eed0b37fe7a34477d9855a6f1d930a624", - "powerpc64le-unknown-linux-gnu": "97038ea935c7a5b21f5aaaaad409c514e2b2ae8ea55994ba39645f453e98bc9f", - "aarch64-unknown-linux-gnu": "bcc916003cb9c7ff44f5f9af348020b422dbc5bd4fe49bdbda2de6ce0a1bb745", - "x86_64-apple-darwin": "f20388b80b2b0a8b122d89058f785a2cf3b14e93bcac53471d60fdb4106ffa35", - }, - } - - # This dictionary maps Rust target architectures to Spack constraints that - # match that target. - rust_archs = { - "x86_64-unknown-linux-gnu": [ - {"platform": "linux", "target": "x86_64:"}, - {"platform": "cray", "target": "x86_64:"}, - ], - "powerpc64le-unknown-linux-gnu": [ - {"platform": "linux", "target": "ppc64le:"}, - {"platform": "cray", "target": "ppc64le:"}, - ], - "aarch64-unknown-linux-gnu": [ - {"platform": "linux", "target": "aarch64:"}, - {"platform": "cray", "target": "aarch64:"}, - ], - "x86_64-apple-darwin": [{"platform": "darwin", "target": "x86_64:"}], - "aarch64-apple-darwin": [{"platform": "darwin", "target": "aarch64:"}], - } - - # Specifies the strings which represent a pre-release Rust version. These - # always bootstrap with the latest beta release. - # - # NOTE: These are moving targets, and therefore have no stable checksum. Be - # sure to specify "-n" or "--no-checksum" when installing these versions. - rust_prerelease_versions = ["beta", "nightly", "master"] - - for prerelease_version in rust_prerelease_versions: - for rust_target, rust_arch_list in rust_archs.items(): - for rust_arch in rust_arch_list: - # All pre-release builds are built with the latest beta - # compiler. - resource( - name="rust-beta-{target}".format(target=rust_target), - url="https://static.rust-lang.org/dist/rust-beta-{target}.tar.gz".format( - target=rust_target - ), - # Fake SHA - checksums should never be checked for - # pre-release builds, anyway - sha256="0000000000000000000000000000000000000000000000000000000000000000", - destination="spack_bootstrap_stage", - when="@{version} platform={platform} target={target}".format( - version=prerelease_version, - platform=rust_arch["platform"], - target=rust_arch["target"], - ), - ) - - # This loop generates resources for each binary distribution, and maps - # them to the version of the compiler they bootstrap. This is in place - # of listing each resource explicitly, which would be potentially even - # more verbose. - # - # NOTE: This loop should technically specify the architecture to be the - # _host_ architecture, not the target architecture, in order to support - # cross compiling. I'm not sure Spack provides a way to specify a - # distinction in the when clause, though. - for rust_version, rust_targets in rust_releases.items(): - for rust_target, rust_sha256 in rust_targets.items(): - for rust_arch in rust_archs[rust_target]: - resource( - name="rust-{version}-{target}".format( - version=rust_version, target=rust_target - ), - url="https://static.rust-lang.org/dist/rust-{version}-{target}.tar.gz".format( - version=rust_version, target=rust_target - ), - sha256=rust_sha256, - destination="spack_bootstrap_stage", - when="@{ver} platform={platform} target={target}".format( - ver=rust_version, - platform=rust_arch["platform"], - target=rust_arch["target"], - ), - ) - - executables = ["^rustc$"] + phases = ["configure", "build", "install"] @classmethod def determine_version(csl, exe): @@ -251,155 +86,63 @@ class Rust(Package): match = re.match(r"rustc (\S+)", output) return match.group(1) if match else None - # This routine returns the target architecture we intend to build for. - def get_rust_target(self): - if "platform=linux" in self.spec or "platform=cray" in self.spec: - if "target=x86_64:" in self.spec: - return "x86_64-unknown-linux-gnu" - elif "target=ppc64le:" in self.spec: - return "powerpc64le-unknown-linux-gnu" - elif "target=aarch64:" in self.spec: - return "aarch64-unknown-linux-gnu" - elif "platform=darwin" in self.spec: - if "target=x86_64:" in self.spec: - return "x86_64-apple-darwin" - elif "target=aarch64:" in self.spec: - return "aarch64-apple-darwin" - - raise InstallError("rust is not supported for '{0}'".format(self.spec.architecture)) - - def check_newer(self, version): - if "@master" in self.spec or "@beta" in self.spec or "@nightly" in self.spec: - return True - - return "@{0}:".format(version) in self.spec - - def patch(self): - if self.spec.satisfies("@1.51.0"): - # see 31c93397bde7 upstream - filter_file( - "panic!(out);", 'panic!("{}", out);', "src/bootstrap/builder.rs", string=True - ) + def setup_build_environment(self, env): + # Manually inject the path of ar for build. + ar = which("ar", required=True) + env.set("AR", ar.path) + + # Manually inject the path of openssl's certs for build. + certs = join_path(self.spec["openssl"].prefix, "etc/openssl/cert.pem") + env.set("CARGO_HTTP_CAINFO", certs) def configure(self, spec, prefix): - target = self.get_rust_target() - - # Bootstrapping compiler selection: - # Pre-release compilers use the latest beta release for the - # bootstrapping compiler. - # Versioned releases bootstrap themselves. - if "@beta" in spec or "@nightly" in spec or "@master" in spec: - bootstrap_version = "beta" - else: - bootstrap_version = spec.version - # See the NOTE above the resource loop - should be host architecture, - # not target aarchitecture if we're to support cross-compiling. - bootstrapping_install = Executable( - "./spack_bootstrap_stage/rust-{version}-{target}/install.sh".format( - version=bootstrap_version, target=target - ) - ) - # install into the staging area - bootstrapping_install( - "--prefix={0}".format(join_path(self.stage.source_path, "spack_bootstrap")) - ) - - boot_bin = join_path(self.stage.source_path, "spack_bootstrap/bin") - - # Always build rustc and cargo - tools = ["rustc", "cargo"] - # Only make additional components available in 'rust-bootstrap' - if "+rustfmt" in self.spec: - tools.append("rustfmt") - if "+analysis" in self.spec: + opts = [] + + # Set prefix to install into spack prefix. + opts.append(f"install.prefix={prefix}") + + # Set relative path to put system configuration files + # under the Spack package prefix. + opts.append("install.sysconfdir=etc") + + # Build extended suite of tools so dependent packages + # packages can build using cargo. + opts.append("build.extended=true") + + # Build docs if specified by the +docs variant. + opts.append(f"build.docs={str(spec.satisfies('+docs')).lower()}") + + # Set binary locations for bootstrap rustc and cargo. + opts.append(f"build.cargo={spec['rust-bootstrap'].prefix.bin.cargo}") + opts.append(f"build.rustc={spec['rust-bootstrap'].prefix.bin.rustc}") + + # Convert opts to '--set key=value' format. + flags = [flag for opt in opts for flag in ("--set", opt)] + + # Include both cargo and rustdoc in minimal install to match + # standard download of rust. + tools = ["cargo", "rustdoc"] + + # Add additional tools as directed by the package variants. + if spec.satisfies("+analysis"): tools.append("analysis") - if "@1.33: +clippy" in self.spec: + + if spec.satisfies("+clippy"): tools.append("clippy") - if "+rls" in self.spec: - tools.append("rls") - if "+src" in self.spec: + + if spec.satisfies("+src"): tools.append("src") - ar = which("ar", required=True) + if spec.satisfies("+rustfmt"): + tools.append("rustfmt") + + # Compile tools into flag for configure. + flags.append(f"--tools={','.join(tools)}") - extra_targets = [] - if not self.spec.satisfies("extra_targets=none"): - extra_targets = list(self.spec.variants["extra_targets"].value) - - targets = [self.get_rust_target()] + extra_targets - target_spec = "target=[" + ",".join('"{0}"'.format(target) for target in targets) + "]" - target_specs = "\n".join( - '[target.{0}]\nar = "{1}"\n'.format(target, ar.path) for target in targets - ) - - # build.tools was introduced in Rust 1.25 - tools_spec = "tools={0}".format(tools) if self.check_newer("1.25") else "" - # This is a temporary fix due to rust 1.42 breaking self bootstrapping - # See: https://github.com/rust-lang/rust/issues/69953 - # - # In general, this should be safe because bootstrapping typically - # ensures everything but the bootstrapping script is warning free for - # the latest set of warning. - deny_warnings_spec = "deny-warnings = false" if "@1.42.0" in self.spec else "" - - # "Nightly" and master builds want a path to rustfmt - otherwise, it - # will try to download rustfmt from the Internet. We'll give it rustfmt - # for the bootstrapping compiler, but it ultimately shouldn't matter - # because this package never invokes it. To be clear, rustfmt from the - # bootstrapping compiler is probably incorrect. See: src/stage0.txt in - # Rust to see what the current "official" rustfmt version for Rust is. - if "@master" in spec or "@nightly" in spec: - rustfmt_spec = 'rustfmt="{0}"'.format(join_path(boot_bin, "rustfmt")) - else: - rustfmt_spec = "" - - with open("config.toml", "w") as out_file: - out_file.write( - """\ -[build] -cargo = "{cargo}" -rustc = "{rustc}" -docs = false -vendor = true -extended = true -verbose = 2 -{target_spec} -{tools_spec} -{rustfmt_spec} - -[rust] -channel = "stable" -rpath = true -{deny_warnings_spec} - -{target_specs} - -[install] -prefix = "{prefix}" -sysconfdir = "etc" -""".format( - cargo=join_path(boot_bin, "cargo"), - rustc=join_path(boot_bin, "rustc"), - prefix=prefix, - deny_warnings_spec=deny_warnings_spec, - target_spec=target_spec, - target_specs=target_specs, - tools_spec=tools_spec, - rustfmt_spec=rustfmt_spec, - ) - ) + configure(*flags) def build(self, spec, prefix): - python( - "./x.py", - "build", - extra_env={ - # vendored libgit2 wasn't correctly building (couldn't find the - # vendored libssh2), so let's just have spack build it - "LIBSSH2_SYS_USE_PKG_CONFIG": "1", - "LIBGIT2_SYS_USE_PKG_CONFIG": "1", - }, - ) + python("./x.py", "build") def install(self, spec, prefix): python("./x.py", "install") -- cgit v1.2.3-70-g09d2