Auto merge of #153753 - Zalathar:rollup-Dq0luud, r=Zalathar

bors · bors · commit 4e56d7cc6558 · 2026-03-12T04:11:11.000Z
Rollup of 4 pull requests Successful merges: - #153432 (Fix some comments about dataflow analysis.) - #153694 (fix(query): Pass Query Key to `value_from_cycle_error`) - #153736 (add test that an incomplete feature emits a warning) - #153750 (rustc-dev-guide subtree update)
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
@@ -257,6 +257,8 @@ declare_features! (
     (internal, rustc_attrs, "1.0.0", None),
     /// Allows using the `#[stable]` and `#[unstable]` attributes.
     (internal, staged_api, "1.0.0", None),
+    /// Perma-unstable, only used to test the `incomplete_features` lint.
+    (incomplete, test_incomplete_feature, "CURRENT_RUSTC_VERSION", None),
     /// Added for testing unstable lints; perma-unstable.
     (internal, test_unstable_lint, "1.60.0", None),
     /// Use for stable + negative coherence and strict coherence depending on trait's
diff --git a/compiler/rustc_middle/src/mir/basic_blocks.rs b/compiler/rustc_middle/src/mir/basic_blocks.rs
@@ -65,7 +65,7 @@ impl<'tcx> BasicBlocks<'tcx> {
 
     /// Returns basic blocks in a reverse postorder.
     ///
-    /// See [`traversal::reverse_postorder`]'s docs to learn what is preorder traversal.
+    /// See [`traversal::reverse_postorder`]'s docs to learn what is postorder traversal.
     ///
     /// [`traversal::reverse_postorder`]: crate::mir::traversal::reverse_postorder
     #[inline]
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
@@ -136,8 +136,12 @@ pub struct QueryVTable<'tcx, C: QueryCache> {
     /// For `no_hash` queries, this function pointer is None.
     pub hash_value_fn: Option<fn(&mut StableHashingContext<'_>, &C::Value) -> Fingerprint>,
 
-    pub value_from_cycle_error:
-        fn(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> C::Value,
+    pub value_from_cycle_error: fn(
+        tcx: TyCtxt<'tcx>,
+        key: C::Key,
+        cycle_error: CycleError,
+        guar: ErrorGuaranteed,
+    ) -> C::Value,
     pub format_value: fn(&C::Value) -> String,
 
     /// Formats a human-readable description of this query and its key, as
diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
@@ -109,21 +109,21 @@ impl<'tcx> MaybePlacesSwitchIntData<'tcx> {
 /// ```rust
 /// struct S;
 /// #[rustfmt::skip]
-/// fn foo(pred: bool) {                        // maybe-init:
-///                                             // {}
-///     let a = S; let mut b = S; let c; let d; // {a, b}
+/// fn foo(p: bool) {                           // maybe-init:
+///                                             // {p}
+///     let a = S; let mut b = S; let c; let d; // {p, a, b}
 ///
-///     if pred {
-///         drop(a);                            // {   b}
-///         b = S;                              // {   b}
+///     if p {
+///         drop(a);                            // {p,    b}
+///         b = S;                              // {p,    b}
 ///
 ///     } else {
-///         drop(b);                            // {a}
-///         d = S;                              // {a,       d}
+///         drop(b);                            // {p, a}
+///         d = S;                              // {p, a,       d}
 ///
-///     }                                       // {a, b,    d}
+///     }                                       // {p, a, b,    d}
 ///
-///     c = S;                                  // {a, b, c, d}
+///     c = S;                                  // {p, a, b, c, d}
 /// }
 /// ```
 ///
@@ -199,11 +199,11 @@ impl<'a, 'tcx> HasMoveData<'tcx> for MaybeInitializedPlaces<'a, 'tcx> {
 /// ```rust
 /// struct S;
 /// #[rustfmt::skip]
-/// fn foo(pred: bool) {                        // maybe-uninit:
+/// fn foo(p: bool) {                           // maybe-uninit:
 ///                                             // {a, b, c, d}
 ///     let a = S; let mut b = S; let c; let d; // {      c, d}
 ///
-///     if pred {
+///     if p {
 ///         drop(a);                            // {a,    c, d}
 ///         b = S;                              // {a,    c, d}
 ///
@@ -279,34 +279,36 @@ impl<'tcx> HasMoveData<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> {
     }
 }
 
-/// `EverInitializedPlaces` tracks all places that might have ever been
-/// initialized upon reaching a particular point in the control flow
-/// for a function, without an intervening `StorageDead`.
+/// `EverInitializedPlaces` tracks all initializations that may have occurred
+/// upon reaching a particular point in the control flow for a function,
+/// without an intervening `StorageDead`.
 ///
 /// This dataflow is used to determine if an immutable local variable may
 /// be assigned to.
 ///
 /// For example, in code like the following, we have corresponding
-/// dataflow information shown in the right-hand comments.
+/// dataflow information shown in the right-hand comments. Underscored indices
+/// are used to distinguish between multiple initializations of the same local
+/// variable, e.g. `b_0` and `b_1`.
 ///
 /// ```rust
 /// struct S;
 /// #[rustfmt::skip]
-/// fn foo(pred: bool) {                        // ever-init:
-///                                             // {          }
-///     let a = S; let mut b = S; let c; let d; // {a, b      }
+/// fn foo(p: bool) {                           // ever-init:
+///                                             // {p,                  }
+///     let a = S; let mut b = S; let c; let d; // {p, a, b_0,          }
 ///
-///     if pred {
-///         drop(a);                            // {a, b,     }
-///         b = S;                              // {a, b,     }
+///     if p {
+///         drop(a);                            // {p, a, b_0,          }
+///         b = S;                              // {p, a, b_0, b_1,     }
 ///
 ///     } else {
-///         drop(b);                            // {a, b,      }
-///         d = S;                              // {a, b,    d }
+///         drop(b);                            // {p, a, b_0, b_1,     }
+///         d = S;                              // {p, a, b_0, b_1,    d}
 ///
-///     }                                       // {a, b,    d }
+///     }                                       // {p, a, b_0, b_1,    d}
 ///
-///     c = S;                                  // {a, b, c, d }
+///     c = S;                                  // {p, a, b_0, b_1, c, d}
 /// }
 /// ```
 pub struct EverInitializedPlaces<'a, 'tcx> {
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
@@ -125,17 +125,18 @@ where
 fn mk_cycle<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
+    key: C::Key,
     cycle_error: CycleError,
 ) -> C::Value {
     let error = report_cycle(tcx.sess, &cycle_error);
     match query.cycle_error_handling {
         CycleErrorHandling::Error => {
             let guar = error.emit();
-            (query.value_from_cycle_error)(tcx, cycle_error, guar)
+            (query.value_from_cycle_error)(tcx, key, cycle_error, guar)
         }
         CycleErrorHandling::DelayBug => {
             let guar = error.delay_as_bug();
-            (query.value_from_cycle_error)(tcx, cycle_error, guar)
+            (query.value_from_cycle_error)(tcx, key, cycle_error, guar)
         }
     }
 }
@@ -219,6 +220,7 @@ where
 fn cycle_error<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
+    key: C::Key,
     try_execute: QueryJobId,
     span: Span,
 ) -> (C::Value, Option<DepNodeIndex>) {
@@ -229,7 +231,7 @@ fn cycle_error<'tcx, C: QueryCache>(
         .expect("failed to collect active queries");
 
     let error = find_cycle_in_stack(try_execute, job_map, &current_query_job(), span);
-    (mk_cycle(query, tcx, error.lift()), None)
+    (mk_cycle(query, tcx, key, error.lift()), None)
 }
 
 #[inline(always)]
@@ -274,7 +276,7 @@ fn wait_for_query<'tcx, C: QueryCache>(
 
             (v, Some(index))
         }
-        Err(cycle) => (mk_cycle(query, tcx, cycle.lift()), None),
+        Err(cycle) => (mk_cycle(query, tcx, key, cycle.lift()), None),
     }
 }
 
@@ -337,7 +339,7 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
 
                         // If we are single-threaded we know that we have cycle error,
                         // so we just return the error.
-                        cycle_error(query, tcx, id, span)
+                        cycle_error(query, tcx, key, id, span)
                     }
                 }
                 ActiveKeyStatus::Poisoned => FatalError.raise(),
diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -15,34 +15,34 @@ use rustc_middle::query::erase::erase_val;
 use rustc_middle::ty::layout::{LayoutError, TyAndLayout};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
-use rustc_span::def_id::LocalDefId;
+use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::{ErrorGuaranteed, Span};
 
 use crate::job::report_cycle;
 
 pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
     vtables.type_of.value_from_cycle_error =
-        |tcx, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
+        |tcx, _, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
 
     vtables.type_of_opaque_hir_typeck.value_from_cycle_error =
-        |tcx, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
+        |tcx, _, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
 
     vtables.erase_and_anonymize_regions_ty.value_from_cycle_error =
-        |tcx, _, guar| erase_val(Ty::new_error(tcx, guar));
+        |tcx, _, _, guar| erase_val(Ty::new_error(tcx, guar));
 
-    vtables.fn_sig.value_from_cycle_error = |tcx, cycle, guar| erase_val(fn_sig(tcx, cycle, guar));
+    vtables.fn_sig.value_from_cycle_error = |tcx, key, _, guar| erase_val(fn_sig(tcx, key, guar));
 
     vtables.check_representability.value_from_cycle_error =
-        |tcx, cycle, guar| check_representability(tcx, cycle, guar);
+        |tcx, _, cycle, guar| check_representability(tcx, cycle, guar);
 
     vtables.check_representability_adt_ty.value_from_cycle_error =
-        |tcx, cycle, guar| check_representability(tcx, cycle, guar);
+        |tcx, _, cycle, guar| check_representability(tcx, cycle, guar);
 
     vtables.variances_of.value_from_cycle_error =
-        |tcx, cycle, guar| erase_val(variances_of(tcx, cycle, guar));
+        |tcx, _, cycle, guar| erase_val(variances_of(tcx, cycle, guar));
 
     vtables.layout_of.value_from_cycle_error =
-        |tcx, cycle, guar| erase_val(layout_of(tcx, cycle, guar));
+        |tcx, _, cycle, guar| erase_val(layout_of(tcx, cycle, guar));
 }
 
 pub(crate) fn default<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError, query_name: &str) -> ! {
@@ -57,15 +57,12 @@ pub(crate) fn default<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError, query_na
 
 fn fn_sig<'tcx>(
     tcx: TyCtxt<'tcx>,
-    cycle_error: CycleError,
+    def_id: DefId,
     guar: ErrorGuaranteed,
 ) -> ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>> {
     let err = Ty::new_error(tcx, guar);
 
-    let arity = if let Some(info) = cycle_error.cycle.get(0)
-        && info.frame.dep_kind == DepKind::fn_sig
-        && let Some(def_id) = info.frame.def_id
-        && let Some(node) = tcx.hir_get_if_local(def_id)
+    let arity = if let Some(node) = tcx.hir_get_if_local(def_id)
         && let Some(sig) = node.fn_sig()
     {
         sig.decl.inputs.len()
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
@@ -487,7 +487,7 @@ macro_rules! define_queries {
                     #[cfg(not($cache_on_disk))]
                     is_loadable_from_disk_fn: |_tcx, _key, _index| false,
 
-                    value_from_cycle_error: |tcx, cycle, _| {
+                    value_from_cycle_error: |tcx, _, cycle, _| {
                         $crate::from_cycle_error::default(tcx, cycle, stringify!($name))
                     },
 
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -2006,6 +2006,7 @@ symbols! {
         test_2018_feature,
         test_accepted_feature,
         test_case,
+        test_incomplete_feature,
         test_removed_feature,
         test_runner,
         test_unstable_lint,
diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-c78a29473a68f07012904af11c92ecffa68fcc75
+eda4fc7733ee89e484d7120cafbd80dcb2fce66e
diff --git a/src/doc/rustc-dev-guide/src/autodiff/installation.md b/src/doc/rustc-dev-guide/src/autodiff/installation.md
@@ -1,6 +1,50 @@
 # Installation
 
-In the near future, `std::autodiff` should become available in nightly builds for users. As a contributor however, you will still need to build rustc from source. Please be aware that the msvc target is not supported at the moment, all other tier 1 targets should work. Please open an issue if you encounter any problems on a supported tier 1 target, or if you successfully build this project on a tier2/tier3 target.
+In the near future, `std::autodiff` should become available for users via rustup. As a rustc/enzyme/autodiff contributor however, you will still need to build rustc from source. 
+For the meantime, you can download up-to-date builds to enable `std::autodiff` on your latest nightly toolchain, if you are using either of:  
+**Linux**, with `x86_64-unknown-linux-gnu` or `aarch64-unknown-linux-gnu`  
+**Windows**, with `x86_64-llvm-mingw` or `aarch64-llvm-mingw`  
+
+You can also download slightly outdated builds for **Apple** (aarch64-apple), which should generally work for now. 
+
+If you need any other platform, you can build rustc including autodiff from source. Please open an issue if you want to help enabling automatic builds for your prefered target.
+
+## Installation guide
+
+If you want to use `std::autodiff` and don't plan to contribute PR's to the project, then we recommend to just use your existing nightly installation and download the missing component. In the future, rustup will be able to do it for you.
+For now, you'll have to manually download and copy it.
+
+1) On our github repository, find the last merged PR: [`Repo`]
+2) Scroll down to the lower end of the PR, where you'll find a rust-bors message saying `Test successful` with a `CI` link. 
+3) Click on the `CI` link, and grep for your target. E.g. `dist-x86_64-linux` or `dist-aarch64-llvm-mingw` and click `Load summary`. 
+4) Under the `CI artifacts` section, find the `enzyme-nightly` artifact, download, and unpack it.
+5) Copy the artifact (libEnzyme-22.so for linux, libEnzyme-22.dylib for apple, etc.), which should be in a folder named `enzyme-preview`, to your rust toolchain directory. E.g. for linux: `cp  ~/Downloads/enzyme-nightly-x86_64-unknown-linux-gnu/enzyme-preview/lib/rustlib/x86_64-unknown-linux-gnu/lib/libEnzyme-22.so ~/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib`
+
+Apple support was temporarily reverted, due to downstream breakages. If you want to download autodiff for apple, please look at the artifacts from this [`run`].
+
+## Installation guide for Nix user.
+
+This setup was recommended by a nix and autodiff user. It uses [`Overlay`]. Please verify for yourself if you are comfortable using that repository.
+In that case you might use the following nix configuration to get a rustc that supports `std::autodiff`.
+```nix
+{
+  enzymeLib = pkgs.fetchzip {
+    url = "https://ci-artifacts.rust-lang.org/rustc-builds/ec818fda361ca216eb186f5cf45131bd9c776bb4/enzyme-nightly-x86_64-unknown-linux-gnu.tar.xz";
+    sha256 = "sha256-Rnrop44vzS+qmYNaRoMNNMFyAc3YsMnwdNGYMXpZ5VY=";
+  };
+  
+  rustToolchain = pkgs.symlinkJoin {
+    name = "rust-with-enzyme";
+    paths = [pkgs.rust-bin.nightly.latest.default];
+    nativeBuildInputs = [pkgs.makeWrapper];
+    postBuild = ''
+      libdir=$out/lib/rustlib/x86_64-unknown-linux-gnu/lib
+      cp ${enzymeLib}/enzyme-preview/lib/rustlib/x86_64-unknown-linux-gnu/lib/libEnzyme-22.so $libdir/
+      wrapProgram $out/bin/rustc --add-flags "--sysroot $out"
+    '';
+  };
+}
+```
 
 ## Build instructions
 
@@ -87,3 +131,6 @@ ninja
 ```
 This will build Enzyme, and you can find it in `Enzyme/enzyme/build/lib/<LLD/Clang/LLVM/lib>Enzyme.so`. (Endings might differ based on your OS).
 
+[`Repo`]: https://github.com/rust-lang/rust/
+[`run`]: https://github.com/rust-lang/rust/pull/153026#issuecomment-3950046599
+[`Overlay`]: https://github.com/oxalica/rust-overlay
diff --git a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
@@ -6,7 +6,12 @@ Rust supports building against multiple LLVM versions:
 * Tip-of-tree for the current LLVM development branch is usually supported within a few days.
   PRs for such fixes are tagged with `llvm-main`.
 * The latest released major version is always supported.
-* The one or two preceding major versions are usually supported.
+* The one or two preceding major versions are usually supported in the sense that they are expected
+  to build successfully and pass most tests.
+  However, fixes for miscompilations often do not get
+  backported to past LLVM versions, so using rustc with older versions of LLVM comes with an
+  increased risk of soundness bugs.
+  We strongly recommend using the latest version of LLVM.
 
 By default, Rust uses its own fork in the [rust-lang/llvm-project repository].
 This fork is based on a `release/$N.x` branch of the upstream project, where
diff --git a/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
@@ -110,7 +110,6 @@ Also, using `x` rather than `x.py` is recommended as:
 Notice that this is not absolute.
 For instance, using Nushell in VSCode on Win10,
 typing `x` or `./x` still opens `x.py` in an editor rather than invoking the program.
-:)
 
 In the rest of this guide, we use `x` rather than `x.py` directly.
 The following command:
diff --git a/src/doc/rustc-dev-guide/src/conventions.md b/src/doc/rustc-dev-guide/src/conventions.md
@@ -139,6 +139,8 @@ if foo {
 }
 ```
 
+If you want to leave a note in the codebase, use `// FIXME` instead.
+
 <a id="cio"></a>
 
 ## Using crates from crates.io
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/translation.md b/src/doc/rustc-dev-guide/src/diagnostics/translation.md
@@ -31,8 +31,7 @@ There are two ways of writing translatable diagnostics:
    ("Simple" diagnostics being those that don't require a lot of logic in
    deciding to emit subdiagnostics and can therefore be represented as diagnostic structs).
    See [the diagnostic and subdiagnostic structs documentation](./diagnostic-structs.md).
-2. Using typed identifiers with `Diag` APIs (in
-   `Diagnostic` or `Subdiagnostic` implementations).
+2. Using typed identifiers with `Diag` APIs (in `Diagnostic` or `Subdiagnostic` implementations).
 
 When adding or changing a translatable diagnostic,
 you don't need to worry about the translations.
diff --git a/src/doc/rustc-dev-guide/src/feature-gate-check.md b/src/doc/rustc-dev-guide/src/feature-gate-check.md
@@ -8,7 +8,7 @@ nightly-only `#![feature(...)]` opt-in.
 This chapter documents the implementation
 of feature gating: where gates are defined, how they are enabled, and how usage is verified.
 
-<!-- data-check: Feb 2026 -->
+<!-- date-check: Feb 2026 -->
 
 ## Feature Definitions
 
diff --git a/src/doc/rustc-dev-guide/src/git.md b/src/doc/rustc-dev-guide/src/git.md
diff --git a/src/doc/rustc-dev-guide/src/query.md b/src/doc/rustc-dev-guide/src/query.md
diff --git a/src/doc/rustc-dev-guide/src/tracing.md b/src/doc/rustc-dev-guide/src/tracing.md
diff --git a/tests/ui/feature-gates/incomplete-features.rs b/tests/ui/feature-gates/incomplete-features.rs
diff --git a/tests/ui/feature-gates/incomplete-features.warn.stderr b/tests/ui/feature-gates/incomplete-features.warn.stderr
diff --git a/tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.rs b/tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.rs
diff --git a/tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.stderr b/tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.stderr

Original file line number	Diff line number	Diff line change
`@@ -125,17 +125,18 @@ where`
`125`	`125`	`fn mk_cycle<'tcx, C: QueryCache>(`
`126`	`126`	`query: &'tcx QueryVTable<'tcx, C>,`
`127`	`127`	`tcx: TyCtxt<'tcx>,`
	`128`	`+ key: C::Key,`
`128`	`129`	`cycle_error: CycleError,`
`129`	`130`	`) -> C::Value {`
`130`	`131`	`let error = report_cycle(tcx.sess, &cycle_error);`
`131`	`132`	`match query.cycle_error_handling {`
`132`	`133`	`CycleErrorHandling::Error => {`
`133`	`134`	`let guar = error.emit();`
`134`		`- (query.value_from_cycle_error)(tcx, cycle_error, guar)`
	`135`	`+ (query.value_from_cycle_error)(tcx, key, cycle_error, guar)`
`135`	`136`	`}`
`136`	`137`	`CycleErrorHandling::DelayBug => {`
`137`	`138`	`let guar = error.delay_as_bug();`
`138`		`- (query.value_from_cycle_error)(tcx, cycle_error, guar)`
	`139`	`+ (query.value_from_cycle_error)(tcx, key, cycle_error, guar)`
`139`	`140`	`}`
`140`	`141`	`}`
`141`	`142`	`}`
`@@ -219,6 +220,7 @@ where`
`219`	`220`	`fn cycle_error<'tcx, C: QueryCache>(`
`220`	`221`	`query: &'tcx QueryVTable<'tcx, C>,`
`221`	`222`	`tcx: TyCtxt<'tcx>,`
	`223`	`+ key: C::Key,`
`222`	`224`	`try_execute: QueryJobId,`
`223`	`225`	`span: Span,`
`224`	`226`	`) -> (C::Value, Option<DepNodeIndex>) {`
`@@ -229,7 +231,7 @@ fn cycle_error<'tcx, C: QueryCache>(`
`229`	`231`	`.expect("failed to collect active queries");`
`230`	`232`
`231`	`233`	`let error = find_cycle_in_stack(try_execute, job_map, &current_query_job(), span);`
`232`		`- (mk_cycle(query, tcx, error.lift()), None)`
	`234`	`+ (mk_cycle(query, tcx, key, error.lift()), None)`
`233`	`235`	`}`
`234`	`236`
`235`	`237`	`#[inline(always)]`
`@@ -274,7 +276,7 @@ fn wait_for_query<'tcx, C: QueryCache>(`
`274`	`276`
`275`	`277`	`(v, Some(index))`
`276`	`278`	`}`
`277`		`- Err(cycle) => (mk_cycle(query, tcx, cycle.lift()), None),`
	`279`	`+ Err(cycle) => (mk_cycle(query, tcx, key, cycle.lift()), None),`
`278`	`280`	`}`
`279`	`281`	`}`
`280`	`282`
`@@ -337,7 +339,7 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(`
`337`	`339`
`338`	`340`	`// If we are single-threaded we know that we have cycle error,`
`339`	`341`	`// so we just return the error.`
`340`		`- cycle_error(query, tcx, id, span)`
	`342`	`+ cycle_error(query, tcx, key, id, span)`
`341`	`343`	`}`
`342`	`344`	`}`
`343`	`345`	`ActiveKeyStatus::Poisoned => FatalError.raise(),`
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-c78a29473a68f07012904af11c92ecffa68fcc75`
	`1`	`+eda4fc7733ee89e484d7120cafbd80dcb2fce66e`