bryan-minimal · Oct 10, 2026 · Oct 4, 2026 · Oct 4, 2026 · coderabbitai · Oct 4, 2026
@@ -15,8 +15,6 @@ extended = true
 # No "src": the rust-src install step is gated on `extended && tools.contains("src")`, and a
 # bundled rust-src is what x.py would compile instead of the in-tree source.
 tools = ["cargo", "clippy", "rustfmt", "rust-analyzer"]
-# Use libtest built from the source tree instead of the precompiled one from stage 0.
-compiletest-use-stage0-libtest = false
 
 docs = false
 

@@ -12,8 +12,8 @@ let libffi = import "../libffi/build.ncl" in
 let libssh2 = import "../libssh2/build.ncl" in
 let toolchain = import "../toolchain/build.ncl" in
 let gcc = import "../gcc/build.ncl" in
-let rustc-1-97-1 = import "../rustc-1.97.1/build.ncl" in # the stage0
-let version = "1.98.1" in
+let rustc-1-98-1 = import "../rustc-1.98.1/build.ncl" in # the stage0
+let version = "1.99.0" in
 {
   name = "rust",
   build_deps =
@@ -22,7 +22,7 @@ let version = "1.98.1" in
       { file = "build.sh" } | Local,
       {
         url = "gs://minimal-staging-archives/rustc-%{version}-src.tar.xz",
-        sha256 = "be1816e7f6c40abb90245ad6e024bed2a7e88d7dda4561e4d5470207df616b9f",
+        sha256 = "cc41916a8c84f5d9ec4f55561b44e39f43b647b133f8a6f51be9ea13c83f7036",
         extract = true,
         strip_prefix = "rustc-%{version}-src",
       } | Source,
@@ -35,28 +35,12 @@ let version = "1.98.1" in
       python,
       toolchain,
     ]
-    # stage0 = the rustc-1.97.1 rung (1.98.1's src/stage0 pins 1.97.1), built by the chain
-    # gcc-15.2.0 -> mrustc 0.12.0 -> rustc-1.90.0 -> 1.91.1 -> ... -> 1.97.1.  amd64 takes the
-    # rung build_dep; arm64 takes a sha-pinned tarball of the same rung.  build.sh injects it
-    # into bootstrap.toml [build] rustc/cargo; x.py never downloads a stage0.
-    @ (
-      match {
-        { arch = 'Amd64, .. } => [rustc-1-97-1],
-        { arch = 'Arm64, .. } =>
-          [
-            # arm64 stage0: rustc-1.97.1 built by the same rung recipes on arm64 hardware.  The
-            # tarball bundles the libLLVM.so.21.1 it links (built with all targets; the llvm
-            # package here omits experimental ones) and that library's non-glibc dependencies,
-            # each with an $ORIGIN RUNPATH.  `extract = true` unpacks it to ./rustc-1.97.1-aarch64
-            # inside the source root; build.sh points bootstrap.toml [build] rustc/cargo at it.
-            {
-              url = "gs://minimal-staging-archives/prebuilts/bedrock/sha256/de0724a4bf882c5f4641dc6edd6284ee0fa565a405d4ea264a4f305e3bfe5e6e/rustc-1.97.1-aarch64.tar.zst",
-              sha256 = "de0724a4bf882c5f4641dc6edd6284ee0fa565a405d4ea264a4f305e3bfe5e6e",
-              extract = true,
-            } | Source,
-          ],
-      } target
-    ),
+    # stage0 = the rustc-1.98.1 rung on BOTH arches (1.99.0's src/stage0 pins 1.98.0; x.py's
+    # check_stage0_version accepts any 1.98.x).  amd64: built by the chain gcc-15.2.0 -> mrustc
+    # 0.12.0 -> rustc-1.90.0 -> ... -> 1.97.1 -> 1.98.1.  arm64: the rung builds from the sha-pinned
+    # rustc-1.97.1 bedrock tarball, so no new hand-built prebuilt is needed.  build.sh injects it into
+    # bootstrap.toml [build] rustc/cargo; x.py never downloads a stage0.
+    @ [rustc-1-98-1],
   # The build itself is offline (build.sh stubs curl/wget/git and fails on any attempt). The flags stay
   # because the builder grants a package network access when ANY of its dependencies declares it, and
   # the Rust programs that depend on this package still fetch their crates during their own builds.

@@ -17,24 +17,19 @@ export CFLAGS="$MARCH -O2 -pipe -gno-record-gcc-switches -ffile-prefix-map=$(pwd
 export LDFLAGS="-Wl,--build-id=none"
 export CXXFLAGS="${CFLAGS}"
 
-# stage0 = the rustc-1.97.1 rung (1.98.1's src/stage0 pins 1.97.1).  amd64: the rung build_dep,
-# hydrated read-only at /usr/lib/rustc-1.97.1.  arm64: the sha-pinned tarball Source from
-# build.ncl, extracted to ./rustc-1.97.1-aarch64 inside the source root.  The stage0 is injected
-# into bootstrap.toml [build] rustc/cargo below; x.py never downloads one, and a missing stage0
-# is fatal.
-if [ "$(uname -m)" = aarch64 ]; then
-  STAGE0_PREFIX="$(pwd)/rustc-1.97.1-aarch64"
-else
-  STAGE0_PREFIX=/usr/lib/rustc-1.97.1
-fi
+# stage0 = the rustc-1.98.1 rung on both arches (1.99.0's src/stage0 pins 1.98.0; x.py accepts any
+# 1.98.x), hydrated read-only at /usr/lib/rustc-1.98.1.  The stage0 is injected into bootstrap.toml
+# [build] rustc/cargo below; x.py never downloads one, and a missing stage0 fails the build.
+STAGE0_PREFIX=/usr/lib/rustc-1.98.1
 SEED_RUSTC="${STAGE0_PREFIX}/bin/rustc"
 SEED_CARGO="${STAGE0_PREFIX}/bin/cargo"
-[ -x "$SEED_RUSTC" ] || { echo "rust: FATAL stage0 rustc missing at $SEED_RUSTC — the rustc-1.97.1 package is required" >&2; exit 1; }
+[ -x "$SEED_RUSTC" ] || { echo "rust: FATAL stage0 rustc missing at $SEED_RUSTC — the rustc-1.98.1 package is required" >&2; exit 1; }
 [ -x "$SEED_CARGO" ] || { echo "rust: FATAL stage0 cargo missing at $SEED_CARGO" >&2; exit 1; }
-# x.py checks the stage0 release against the src/stage0 pin; equal to the pin is accepted.
+# x.py's check_stage0_version accepts the same or the previous MINOR (patch is not compared), so the
+# 1.98.1 rung passes for 1.99.0's 1.98.0 pin.
 S0V="$("$SEED_RUSTC" --version 2>&1 || true)"
-echo "$S0V" | grep -qF "1.97.1" || { echo "rust: FATAL stage0 rustc --version = '$S0V', expected 1.97.1" >&2; exit 1; }
-echo "rust stage0: rustc-1.97.1 -> $S0V"
+echo "$S0V" | grep -qF "1.98.1" || { echo "rust: FATAL stage0 rustc --version = '$S0V', expected 1.98.1" >&2; exit 1; }
+echo "rust stage0: rustc-1.98.1 -> $S0V"
 
 # Drop the stage0's bundled rust-src: x.py compiles that stale copy of rustc_macros instead of the
 # in-tree source (E0433 on the renamed proc_macro::tracked_env API).  The hydrated stage0 is

@@ -0,0 +1,62 @@
+# packages/rustc-1.98.1
+
+Builds rustc 1.98.1 (with cargo and std) from the upstream `rustc-1.98.1-src.tar.xz`, using the
+`rustc-1.97.1` package as x.py's stage0, with no network access, and installs it to the private prefix
+`/usr/lib/rustc-1.98.1` (`bin/`, `lib/` and `BUILDINFO` only). `packages/rust` consumes that prefix as its
+stage0 the same way.
+
+## Stage0 wiring
+
+`build.sh` generates `bootstrap.toml` with `[build] rustc`/`cargo` pointing at
+`/usr/lib/rustc-1.97.1/bin/{rustc,cargo}`, so x.py uses those binaries instead of downloading the
+`src/stage0` snapshot. Before building it asserts the stage0 runs (`--version` contains 1.97.1,
+`--print sysroot` equals the prefix) and that the extracted source is the right one
+(`src/version` is 1.98.1 and `src/stage0` pins the stage0's version).
+
+## arm64
+
+Unlike the earlier rungs (empty on arm64), this one BUILDS on arm64 too, so that `packages/rust`
+1.99 can take a 1.98.1 stage0 on both arches from the builder instead of a new hand-built prebuilt.
+Its arm64 stage0 is the same sha-pinned `rustc-1.97.1-aarch64` bedrock tarball `packages/rust` 1.98.1
+used, extracted to `${BUILDROOT}/rustc-1.97.1-aarch64`; amd64 is unchanged (the rustc-1.97.1 rung).
+
+## Offline mechanism
+
+- Crates: the source tarball ships `.cargo/config.toml` redirecting crates-io to its bundled `vendor/`.
+- Stage0 download: disabled by the `[build] rustc`/`cargo` pins.
+- LLVM: external `llvm-config = /usr/bin/llvm-config` (packages/llvm, LLVM 21) with `[llvm] link-shared`.
+- `curl`/`wget`: stubs that exit non-zero and record a tripwire. `git`: a stub that allows local
+  read-only verbs and fails on network verbs.
+- Vendored `curl-sys`/`libssh2-sys`: an empty `.git` marker in each bundled submodule dir keeps
+  their `build.rs` from running `git submodule update --init`.
+- An ambient `.cargo/` above the build root fails the build, since cargo would merge it.
+
+## Gates (run on the installed binaries)
+
+1. `rustc --version` contains 1.98.1.
+2. An rlib is emitted.
+3. Ten std constructs compile and run; the exit code is their computed sum (42), each with its own failure code (111-120).
+4. A proc-macro crate is built as a dylib, loaded and expanded by rustc, and the result runs (42).
+5. cargo builds a proc-macro crate plus a `#[derive]` consumer offline, and the binary runs (42).
+6. `bin/rustc` has a glibc interpreter and the network tripwire is still clean.
+
+## Files
+
+| file | role |
+|---|---|
+| `build.ncl` | spec: stage0 build_dep, source, system LLVM, one `OutputData` glob over `usr/lib/rustc-1.98.1/**`; empty on arm64 |
-| `build.ncl` | spec: stage0 build_dep, source, system LLVM, one `OutputData` glob over `usr/lib/rustc-1.98.1/**`; empty on arm64 |
+| `build.ncl` | spec: stage0 build_dep (rustc-1.97.1 rung on amd64, bedrock tarball on arm64), source, system LLVM, one `OutputData` glob over `usr/lib/rustc-1.98.1/**` |
-| `build.ncl` | spec: stage0 build_dep, source, system LLVM, one `OutputData` glob over `usr/lib/rustc-1.98.1/**`; empty on arm64 |
+| `build.ncl` | spec: stage0 build_dep (rustc-1.97.1 rung on amd64, bedrock tarball on arm64), source, system LLVM, one `OutputData` glob over `usr/lib/rustc-1.98.1/**` |
+| `build.sh` | preconditions, offline stubs, submodule markers, `bootstrap.toml`, `x.py build`, install, gates, seal |
+| `gatelib.rs`, `gatestd.rs`, `gate_pm.rs`, `gate_pm_use.rs` | readable copies of the gate sources heredoc'd in `build.sh` |
+| `rustc-1.98.1.answers` | sha256 pins for `bin/rustc` and `bin/cargo`; none yet, so the seal check is skipped |
+
+Per-rung values: `VERSION`/`STAGE0_VERSION` in `build.sh`; `version`, `stage0_version`, the stage0
+import and the Source `sha256` in `build.ncl`; the `.answers` filename and its two pin paths.
+
+This rung's newer bootstrap needs four more things to stay offline, all in `build.sh`:
+- it bootstraps from a copy of the stage0 with any bundled `rust-src` removed, since x.py would
+  otherwise compile pre-rename `proc_macro::tracked_env` code against it;
+- `bootstrap.toml` sets `build.vendor = false`, `dist.vendor = false`, `dist.src-tarball = false`,
+  `rust.remap-debuginfo = false` and an explicit `tools` list without `src`;
+- bootstrap's `vendor.rs` is patched to skip the generate-copyright vendoring when
+  `BOOTSTRAP_SKIP_VENDOR` is set (build tooling only, nothing shipped);
+- `x.py install` names its components instead of installing everything.
@@ -0,0 +1,100 @@
+let { subsetOf, Attrs, BuildSpec, Local, OutputData, Source, .. } = import "minimal.ncl" in
+let { target, .. } = import "config.ncl" in
+# rustc-1.98.1: builds rustc 1.98.1 from the upstream -src tarball with the rustc-1.97.1 package as
+# x.py's stage0, strictly offline, installed to /usr/lib/rustc-1.98.1 (bin/ + lib/ only).
+# packages/rust consumes this rung as its stage0.
+# Same recipe as every rustc-1.9x rung: only version, stage0_version, the stage0 import and the
+# Source sha256 differ in this file; VERSION and STAGE0_VERSION differ in build.sh.  See README.md.
+let rustc-1-97-1 = import "../rustc-1.97.1/build.ncl" in # the stage0 (amd64)
+let base = import "../base/build.ncl" in
+let cmake = import "../cmake/build.ncl" in
+let curl = import "../curl/build.ncl" in
+let llvm = import "../llvm/build.ncl" in
+let openssl = import "../openssl/build.ncl" in
+let pkgconf = import "../pkgconf/build.ncl" in
+let python = import "../python/build.ncl" in
+let sqlite = import "../sqlite/build.ncl" in
+let libffi = import "../libffi/build.ncl" in
+let libssh2 = import "../libssh2/build.ncl" in
+let toolchain = import "../toolchain/build.ncl" in
+let gcc = import "../gcc/build.ncl" in
+
+# pkgmgr: bootstrap_rung = "rust"
+let version = "1.98.1" in
+let stage0_version = "1.97.1" in
+# stage0 by arch.  amd64: the rustc-1.97.1 rung.  arm64: the rung chain is amd64-only, so take the
+# same sha-pinned rustc-1.97.1 bedrock tarball packages/rust 1.98.1 used; build.sh points at its
+# extracted ./rustc-1.97.1-aarch64.  This rung builds on BOTH arches so packages/rust 1.99 gets a
+# 1.98.1 stage0 from the builder on arm64 too, with no new hand-built prebuilt.
+let stage0 =
+  match {
+    { arch = 'Amd64, .. } => rustc-1-97-1,
+    { arch = 'Arm64, .. } =>
+      {
+        url = "gs://minimal-staging-archives/prebuilts/bedrock/sha256/de0724a4bf882c5f4641dc6edd6284ee0fa565a405d4ea264a4f305e3bfe5e6e/rustc-1.97.1-aarch64.tar.zst",
+        sha256 = "de0724a4bf882c5f4641dc6edd6284ee0fa565a405d4ea264a4f305e3bfe5e6e",
+        extract = true,
+      } | Source,
+  } target
+in
+let spec =
+  {
+    name = "rustc-%{version}",
+    build_deps = [
+      { file = "build.sh" } | Local,
+      { file = "rustc-1.98.1.answers" } | Local, # sha256 pins for the seal check in build.sh; unpinned today
+      # The -src tarball ships .cargo/config.toml (crates-io -> vendored-sources) and vendor/, so no
+      # cargo-vendor input is needed.  build.sh asserts src/version and the src/stage0 pairing.
+      {
+        url = "gs://minimal-staging-archives/rustc-%{version}-src.tar.xz",
+        sha256 = "be1816e7f6c40abb90245ad6e024bed2a7e88d7dda4561e4d5470207df616b9f",
+        extract = true,
+        strip_prefix = "rustc-%{version}-src",
+      } | Source,
+      # stage0: the previous rung's installed prefix, /usr/lib/rustc-<stage0_version>/bin/{rustc,cargo}
+      # + lib/rustlib/<triple>/lib.  build.sh pins bootstrap.toml [build] rustc/cargo at it.
+      stage0,
+      base, # userland; xz extracts the source
+      cmake, # some vendored -sys build scripts; also pulls in a real curl, shadowed by build.sh's stub
+      curl, # libcurl for curl-sys (pkg-config path or the marked vendored submodule)
+      libssh2, # LIBSSH2_SYS_USE_PKG_CONFIG=1 makes libssh2-sys use the system lib
+      pkgconf, # pkg-config for the -sys probes
+      python, # x.py
+      toolchain, # gcc/binutils/glibc/linux_headers: clang's sysroot
+    ],
+    runtime_deps = [
+      libffi,
+      llvm, # clang, clang++, llvm-config and libLLVM-21.so; also present at build time
+      openssl,
+      sqlite,
+      subsetOf gcc ["libgcc", "libstdcpp"],
+    ],
+    # no `needs` block: the rung must be strictly offline.
+
+    cmd = "./build.sh",
+    outputs = {
+      # One recursive OutputData glob over the private prefix: the toolchain is consumed as data by
+      # the next rung via absolute path and must not land on /usr/bin.  build.sh prunes the prefix
+      # to bin/ + lib/ + BUILDINFO so nothing is left uncaptured.
+      toolchain = { glob = "usr/lib/rustc-%{version}/**", allow_executable = true } | OutputData,
+    },
+
+    attrs =
+      {
+        upstream_version = version,
+        license_spdx = "MIT OR Apache-2.0",
+        source_provenance = {
+          category = 'GithubRepo,
+          owner = "rust-lang",
+          repo = "rust",
+        },
+        env_state_wiring = {
+          env_var = "CARGO_HOME",
+          prefix = "cargo",
+        },
+        # system LLVM + clang, comparable to packages/rust
+        build_cost_multiple = 4,
+      } | Attrs,
+  } | BuildSpec
+in
+spec