From 1a17c170849215eb166a71396087cef7986f88f5 Mon Sep 17 00:00:00 2001 From: xmakro Date: Tue, 2 Jun 2026 17:15:00 -0700 Subject: [PATCH 1/2] rustc_query_impl: make parallel query-cycle reporting deterministic When the parallel front-end detects a query cycle, the deadlock handler collects the active query jobs in a nondeterministic order. process_cycle then picked entry_points[0], or the first entry point that has a waiter, so the query the cycle was anchored at changed from run to run and the reported cycle text was unstable. Order the entry points with a deterministic total order instead. The primary key is the incoming-edge span: the cycle stack records, for each query, the span where its predecessor in the cycle requested it. For the recursive-definition cycles these errors come from, the entry point with the latest incoming-edge span is the query the single-threaded path anchors at, so this keeps the parallel output matching the committed .stderr. Span ties prefer an entry point that has an outside waiter, so the "cycle used when ..." note is still produced, and any remaining ties are broken by the query's stable description so two entry points that share a span still resolve the same way on every run. This only changes process_cycle, which runs exclusively under the parallel front-end, so single-threaded output is unchanged. --- compiler/rustc_interface/src/util.rs | 12 ++++--- compiler/rustc_query_impl/src/job.rs | 52 ++++++++++++++++++++++++---- 2 files changed, 52 insertions(+), 12 deletions(-) diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs index d7d306918fd0d..f0fa906db5e1b 100644 --- a/compiler/rustc_interface/src/util.rs +++ b/compiler/rustc_interface/src/util.rs @@ -249,20 +249,22 @@ internal compiler error: query cycle handler thread panicked, aborting process"; tls::enter_context(&tls::ImplicitCtxt::new(gcx), || { tls::with(|tcx| { // Accessing session globals is sound as they outlive `GlobalCtxt`. - // They are needed to hash query keys containing spans or symbols. - let job_map = rustc_span::set_session_globals_then( + // They are needed to hash query keys containing spans or symbols, + // and to print query descriptions while breaking the cycle, so the + // whole cycle search runs inside this scope. + rustc_span::set_session_globals_then( unsafe { &*(session_globals as *const SessionGlobals) }, || { // Ensure there were no errors collecting all active jobs. // We need the complete map to ensure we find a cycle to // break. - collect_active_query_jobs( + let job_map = collect_active_query_jobs( tcx, CollectActiveJobsKind::FullNoContention, - ) + ); + break_query_cycle(tcx, job_map, ®istry); }, ); - break_query_cycle(job_map, ®istry); }) }) }); diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs index bf0493b29fd1e..6e3c12d0cbe81 100644 --- a/compiler/rustc_query_impl/src/job.rs +++ b/compiler/rustc_query_impl/src/job.rs @@ -230,7 +230,11 @@ fn connected_to_root<'tcx>( } /// Processes a found query cycle into a `Cycle` -fn process_cycle<'tcx>(job_map: &QueryJobMap<'tcx>, stack: Vec<(Span, QueryJobId)>) -> Cycle<'tcx> { +fn process_cycle<'tcx>( + tcx: TyCtxt<'tcx>, + job_map: &QueryJobMap<'tcx>, + stack: Vec<(Span, QueryJobId)>, +) -> Cycle<'tcx> { // The stack is a vector of pairs of spans and queries; reverse it so that // the earlier entries require later entries let (mut spans, queries): (Vec<_>, Vec<_>) = stack.into_iter().rev().unzip(); @@ -277,11 +281,40 @@ fn process_cycle<'tcx>(job_map: &QueryJobMap<'tcx>, stack: Vec<(Span, QueryJobId }) .collect::>(); - // Pick an entry point, preferring ones with waiters + // The query jobs in the cycle carry no useful span of their own here (it is + // `DUMMY_SP`), but the cycle stack records, for each query, its incoming edge: + // the span where its predecessor in the cycle requested it. + let stack_span = |query: QueryJobId| { + stack.iter().find(|(_, q)| *q == query).map_or(DUMMY_SP, |&(span, _)| span) + }; + + // Pick an entry point using a deterministic total order. The parallel + // deadlock handler collects active query jobs in a nondeterministic order, + // so both the order of `entry_points` and the original `entry_points[0]` + // fallback are racy, which made the reported cycle anchor change from run to + // run. + // + // For the recursive-definition cycles these errors come from, the entry + // point with the latest incoming-edge span is the query the single-threaded + // path anchors at (the one entered first), so ordering by that span keeps + // the parallel output matching the committed `.stderr`. Span ties prefer an + // entry point with an outside waiter, so the "cycle used when ..." note is + // still produced, and any remaining ties are broken by the query's stable + // description so the choice stays deterministic across runs even if two + // entry points share a span. + let description = |query: QueryJobId| job_map.tagged_key_of(query).description(tcx); let entry_point = entry_points .iter() - .find(|entry_point| entry_point.query_waiting_on_cycle.is_some()) - .unwrap_or(&entry_points[0]); + .max_by(|a, b| { + let (sa, sb) = (stack_span(a.query_in_cycle), stack_span(b.query_in_cycle)); + (sa.lo(), sa.hi()) + .cmp(&(sb.lo(), sb.hi())) + .then_with(|| { + a.query_waiting_on_cycle.is_some().cmp(&b.query_waiting_on_cycle.is_some()) + }) + .then_with(|| description(a.query_in_cycle).cmp(&description(b.query_in_cycle))) + }) + .expect("a query cycle must have at least one entry point"); // Shift the stack so that our entry point is first let entry_point_pos = stack.iter().position(|(_, query)| *query == entry_point.query_in_cycle); @@ -306,6 +339,7 @@ fn process_cycle<'tcx>(job_map: &QueryJobMap<'tcx>, stack: Vec<(Span, QueryJobId /// Looks for a query cycle starting at `query`. /// Returns a waiter to resume if a cycle is found. fn find_and_process_cycle<'tcx>( + tcx: TyCtxt<'tcx>, job_map: &QueryJobMap<'tcx>, query: QueryJobId, ) -> Option>> { @@ -315,7 +349,7 @@ fn find_and_process_cycle<'tcx>( find_cycle(job_map, query, DUMMY_SP, &mut stack, &mut visited) { // Create the cycle error - let error = process_cycle(job_map, stack); + let error = process_cycle(tcx, job_map, stack); // We unwrap `resumable` here since there must always be one // edge which is resumable / waited using a query latch @@ -341,12 +375,16 @@ fn find_and_process_cycle<'tcx>( /// There may be multiple cycles involved in a deadlock, but this only breaks one at a time so /// there will be multiple rounds through the deadlock handler if multiple cycles are present. #[allow(rustc::potential_query_instability)] -pub fn break_query_cycle<'tcx>(job_map: QueryJobMap<'tcx>, registry: &rustc_thread_pool::Registry) { +pub fn break_query_cycle<'tcx>( + tcx: TyCtxt<'tcx>, + job_map: QueryJobMap<'tcx>, + registry: &rustc_thread_pool::Registry, +) { // Look for a cycle starting at each query job let waiter = job_map .map .keys() - .find_map(|query| find_and_process_cycle(&job_map, *query)) + .find_map(|query| find_and_process_cycle(tcx, &job_map, *query)) .expect("unable to find a query cycle"); // Mark the thread we're about to wake up as unblocked. From f4a84eb51b23e13b58d41984eb7913d9c1359226 Mon Sep 17 00:00:00 2001 From: xmakro Date: Tue, 2 Jun 2026 17:15:08 -0700 Subject: [PATCH 2/2] tests: re-enable query-cycle UI tests under the parallel front-end These tests were marked ignore-parallel-frontend because the reported cycle anchor was nondeterministic. Now that process_cycle picks the entry point deterministically their output is stable, so drop the directive. Removing the directive line shifts the following source lines up by one, so the expected stderr is re-blessed to match. --- .../recursive-zst-static.default.stderr | 6 ++--- tests/ui/consts/recursive-zst-static.rs | 1 - .../recursive-zst-static.unleash.stderr | 6 ++--- tests/ui/cycle-trait/issue-12511.rs | 1 - tests/ui/cycle-trait/issue-12511.stderr | 2 +- .../ui/delegation/unsupported.current.stderr | 26 +++++++++---------- tests/ui/delegation/unsupported.next.stderr | 26 +++++++++---------- tests/ui/delegation/unsupported.rs | 1 - .../infinite-trait-alias-recursion.rs | 1 - .../infinite-trait-alias-recursion.stderr | 8 +++--- ...-alias-mutual-recursion.feature_new.stderr | 6 ++--- ...-alias-mutual-recursion.feature_old.stderr | 6 ++--- ...pe-alias-mutual-recursion.gated_new.stderr | 8 +++--- ...pe-alias-mutual-recursion.gated_old.stderr | 8 +++--- .../infinite-type-alias-mutual-recursion.rs | 1 - tests/ui/issues/issue-34373.rs | 1 - tests/ui/issues/issue-34373.stderr | 6 ++--- 17 files changed, 54 insertions(+), 60 deletions(-) diff --git a/tests/ui/consts/recursive-zst-static.default.stderr b/tests/ui/consts/recursive-zst-static.default.stderr index 589ff44ccff1f..636246ec52b4c 100644 --- a/tests/ui/consts/recursive-zst-static.default.stderr +++ b/tests/ui/consts/recursive-zst-static.default.stderr @@ -1,17 +1,17 @@ error[E0080]: encountered static that tried to access itself during initialization - --> $DIR/recursive-zst-static.rs:10:18 + --> $DIR/recursive-zst-static.rs:9:18 | LL | static FOO: () = FOO; | ^^^ evaluation of `FOO` failed here error[E0391]: cycle detected when evaluating initializer of static `A` - --> $DIR/recursive-zst-static.rs:13:1 + --> $DIR/recursive-zst-static.rs:12:1 | LL | static A: () = B; | ^^^^^^^^^^^^ | note: ...which requires evaluating initializer of static `B`... - --> $DIR/recursive-zst-static.rs:14:1 + --> $DIR/recursive-zst-static.rs:13:1 | LL | static B: () = A; | ^^^^^^^^^^^^ diff --git a/tests/ui/consts/recursive-zst-static.rs b/tests/ui/consts/recursive-zst-static.rs index 003707aeeab6f..6d5ed3c6ac69d 100644 --- a/tests/ui/consts/recursive-zst-static.rs +++ b/tests/ui/consts/recursive-zst-static.rs @@ -1,6 +1,5 @@ //@ revisions: default unleash //@[unleash]compile-flags: -Zunleash-the-miri-inside-of-you -//@ ignore-parallel-frontend query cycle // This test ensures that we do not allow ZST statics to initialize themselves without ever // actually creating a value of that type. This is important, as the ZST may have private fields // that users can reasonably expect to only get initialized by their own code. Thus unsafe code diff --git a/tests/ui/consts/recursive-zst-static.unleash.stderr b/tests/ui/consts/recursive-zst-static.unleash.stderr index 589ff44ccff1f..636246ec52b4c 100644 --- a/tests/ui/consts/recursive-zst-static.unleash.stderr +++ b/tests/ui/consts/recursive-zst-static.unleash.stderr @@ -1,17 +1,17 @@ error[E0080]: encountered static that tried to access itself during initialization - --> $DIR/recursive-zst-static.rs:10:18 + --> $DIR/recursive-zst-static.rs:9:18 | LL | static FOO: () = FOO; | ^^^ evaluation of `FOO` failed here error[E0391]: cycle detected when evaluating initializer of static `A` - --> $DIR/recursive-zst-static.rs:13:1 + --> $DIR/recursive-zst-static.rs:12:1 | LL | static A: () = B; | ^^^^^^^^^^^^ | note: ...which requires evaluating initializer of static `B`... - --> $DIR/recursive-zst-static.rs:14:1 + --> $DIR/recursive-zst-static.rs:13:1 | LL | static B: () = A; | ^^^^^^^^^^^^ diff --git a/tests/ui/cycle-trait/issue-12511.rs b/tests/ui/cycle-trait/issue-12511.rs index 1d33b03c57a2c..30a35bb5fc1d4 100644 --- a/tests/ui/cycle-trait/issue-12511.rs +++ b/tests/ui/cycle-trait/issue-12511.rs @@ -1,7 +1,6 @@ trait T1 : T2 { //~^ ERROR cycle detected } -//@ ignore-parallel-frontend query cycle trait T2 : T1 { } diff --git a/tests/ui/cycle-trait/issue-12511.stderr b/tests/ui/cycle-trait/issue-12511.stderr index 45fc86a74131f..1016860208739 100644 --- a/tests/ui/cycle-trait/issue-12511.stderr +++ b/tests/ui/cycle-trait/issue-12511.stderr @@ -5,7 +5,7 @@ LL | trait T1 : T2 { | ^^ | note: ...which requires computing the super predicates of `T2`... - --> $DIR/issue-12511.rs:5:12 + --> $DIR/issue-12511.rs:4:12 | LL | trait T2 : T1 { | ^^ diff --git a/tests/ui/delegation/unsupported.current.stderr b/tests/ui/delegation/unsupported.current.stderr index 88938cd8b362c..647d6fed46eed 100644 --- a/tests/ui/delegation/unsupported.current.stderr +++ b/tests/ui/delegation/unsupported.current.stderr @@ -1,43 +1,43 @@ -error[E0391]: cycle detected when computing type of `opaque::::opaque_ret::{anon_assoc#0}` - --> $DIR/unsupported.rs:30:25 +error[E0391]: cycle detected when computing type of `opaque::::opaque_ret::{anon_assoc#0}` + --> $DIR/unsupported.rs:29:25 | LL | reuse to_reuse::opaque_ret; | ^^^^^^^^^^ | note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process... - --> $DIR/unsupported.rs:30:25 + --> $DIR/unsupported.rs:29:25 | LL | reuse to_reuse::opaque_ret; | ^^^^^^^^^^ - = note: ...which again requires computing type of `opaque::::opaque_ret::{anon_assoc#0}`, completing the cycle -note: cycle used when checking assoc item `opaque::::opaque_ret` is compatible with trait definition - --> $DIR/unsupported.rs:30:25 + = note: ...which again requires computing type of `opaque::::opaque_ret::{anon_assoc#0}`, completing the cycle +note: cycle used when checking assoc item `opaque::::opaque_ret` is compatible with trait definition + --> $DIR/unsupported.rs:29:25 | LL | reuse to_reuse::opaque_ret; | ^^^^^^^^^^ = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information -error[E0391]: cycle detected when computing type of `opaque::::opaque_ret::{anon_assoc#0}` - --> $DIR/unsupported.rs:33:24 +error[E0391]: cycle detected when computing type of `opaque::::opaque_ret::{anon_assoc#0}` + --> $DIR/unsupported.rs:32:24 | LL | reuse ToReuse::opaque_ret; | ^^^^^^^^^^ | note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process... - --> $DIR/unsupported.rs:33:24 + --> $DIR/unsupported.rs:32:24 | LL | reuse ToReuse::opaque_ret; | ^^^^^^^^^^ - = note: ...which again requires computing type of `opaque::::opaque_ret::{anon_assoc#0}`, completing the cycle -note: cycle used when checking assoc item `opaque::::opaque_ret` is compatible with trait definition - --> $DIR/unsupported.rs:33:24 + = note: ...which again requires computing type of `opaque::::opaque_ret::{anon_assoc#0}`, completing the cycle +note: cycle used when checking assoc item `opaque::::opaque_ret` is compatible with trait definition + --> $DIR/unsupported.rs:32:24 | LL | reuse ToReuse::opaque_ret; | ^^^^^^^^^^ = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information error: delegation self type is not specified - --> $DIR/unsupported.rs:54:18 + --> $DIR/unsupported.rs:53:18 | LL | reuse Trait::foo; | ^^^ diff --git a/tests/ui/delegation/unsupported.next.stderr b/tests/ui/delegation/unsupported.next.stderr index 88938cd8b362c..647d6fed46eed 100644 --- a/tests/ui/delegation/unsupported.next.stderr +++ b/tests/ui/delegation/unsupported.next.stderr @@ -1,43 +1,43 @@ -error[E0391]: cycle detected when computing type of `opaque::::opaque_ret::{anon_assoc#0}` - --> $DIR/unsupported.rs:30:25 +error[E0391]: cycle detected when computing type of `opaque::::opaque_ret::{anon_assoc#0}` + --> $DIR/unsupported.rs:29:25 | LL | reuse to_reuse::opaque_ret; | ^^^^^^^^^^ | note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process... - --> $DIR/unsupported.rs:30:25 + --> $DIR/unsupported.rs:29:25 | LL | reuse to_reuse::opaque_ret; | ^^^^^^^^^^ - = note: ...which again requires computing type of `opaque::::opaque_ret::{anon_assoc#0}`, completing the cycle -note: cycle used when checking assoc item `opaque::::opaque_ret` is compatible with trait definition - --> $DIR/unsupported.rs:30:25 + = note: ...which again requires computing type of `opaque::::opaque_ret::{anon_assoc#0}`, completing the cycle +note: cycle used when checking assoc item `opaque::::opaque_ret` is compatible with trait definition + --> $DIR/unsupported.rs:29:25 | LL | reuse to_reuse::opaque_ret; | ^^^^^^^^^^ = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information -error[E0391]: cycle detected when computing type of `opaque::::opaque_ret::{anon_assoc#0}` - --> $DIR/unsupported.rs:33:24 +error[E0391]: cycle detected when computing type of `opaque::::opaque_ret::{anon_assoc#0}` + --> $DIR/unsupported.rs:32:24 | LL | reuse ToReuse::opaque_ret; | ^^^^^^^^^^ | note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process... - --> $DIR/unsupported.rs:33:24 + --> $DIR/unsupported.rs:32:24 | LL | reuse ToReuse::opaque_ret; | ^^^^^^^^^^ - = note: ...which again requires computing type of `opaque::::opaque_ret::{anon_assoc#0}`, completing the cycle -note: cycle used when checking assoc item `opaque::::opaque_ret` is compatible with trait definition - --> $DIR/unsupported.rs:33:24 + = note: ...which again requires computing type of `opaque::::opaque_ret::{anon_assoc#0}`, completing the cycle +note: cycle used when checking assoc item `opaque::::opaque_ret` is compatible with trait definition + --> $DIR/unsupported.rs:32:24 | LL | reuse ToReuse::opaque_ret; | ^^^^^^^^^^ = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information error: delegation self type is not specified - --> $DIR/unsupported.rs:54:18 + --> $DIR/unsupported.rs:53:18 | LL | reuse Trait::foo; | ^^^ diff --git a/tests/ui/delegation/unsupported.rs b/tests/ui/delegation/unsupported.rs index 3349c4ec27ab1..af4a6394c1138 100644 --- a/tests/ui/delegation/unsupported.rs +++ b/tests/ui/delegation/unsupported.rs @@ -3,7 +3,6 @@ //@ ignore-compare-mode-next-solver (explicit revisions) //@[next] compile-flags: -Znext-solver //@ check-fail -//@ ignore-parallel-frontend query cycle // Next solver revision included because of trait-system-refactor-initiative#234. // If we end up in a query cycle, it should be okay as long as results are the same. diff --git a/tests/ui/infinite/infinite-trait-alias-recursion.rs b/tests/ui/infinite/infinite-trait-alias-recursion.rs index df884cca22b77..ed065c9595a1e 100644 --- a/tests/ui/infinite/infinite-trait-alias-recursion.rs +++ b/tests/ui/infinite/infinite-trait-alias-recursion.rs @@ -1,5 +1,4 @@ #![feature(trait_alias)] -//@ ignore-parallel-frontend query cycle trait T1 = T2; //~^ ERROR cycle detected when computing the implied predicates of `T1` diff --git a/tests/ui/infinite/infinite-trait-alias-recursion.stderr b/tests/ui/infinite/infinite-trait-alias-recursion.stderr index fa51914415d25..8542f751e18e9 100644 --- a/tests/ui/infinite/infinite-trait-alias-recursion.stderr +++ b/tests/ui/infinite/infinite-trait-alias-recursion.stderr @@ -1,23 +1,23 @@ error[E0391]: cycle detected when computing the implied predicates of `T1` - --> $DIR/infinite-trait-alias-recursion.rs:3:12 + --> $DIR/infinite-trait-alias-recursion.rs:2:12 | LL | trait T1 = T2; | ^^ | note: ...which requires computing the implied predicates of `T2`... - --> $DIR/infinite-trait-alias-recursion.rs:6:12 + --> $DIR/infinite-trait-alias-recursion.rs:5:12 | LL | trait T2 = T3; | ^^ note: ...which requires computing the implied predicates of `T3`... - --> $DIR/infinite-trait-alias-recursion.rs:8:12 + --> $DIR/infinite-trait-alias-recursion.rs:7:12 | LL | trait T3 = T1 + T3; | ^^ = note: ...which again requires computing the implied predicates of `T1`, completing the cycle = note: trait aliases cannot be recursive note: cycle used when checking that `T1` is well-formed - --> $DIR/infinite-trait-alias-recursion.rs:3:1 + --> $DIR/infinite-trait-alias-recursion.rs:2:1 | LL | trait T1 = T2; | ^^^^^^^^ diff --git a/tests/ui/infinite/infinite-type-alias-mutual-recursion.feature_new.stderr b/tests/ui/infinite/infinite-type-alias-mutual-recursion.feature_new.stderr index 1d6ace580951b..844da1b4a62ca 100644 --- a/tests/ui/infinite/infinite-type-alias-mutual-recursion.feature_new.stderr +++ b/tests/ui/infinite/infinite-type-alias-mutual-recursion.feature_new.stderr @@ -1,17 +1,17 @@ error[E0271]: type mismatch resolving `X3 normalizes-to _` - --> $DIR/infinite-type-alias-mutual-recursion.rs:12:1 + --> $DIR/infinite-type-alias-mutual-recursion.rs:11:1 | LL | type X1 = X2; | ^^^^^^^ types differ error[E0271]: type mismatch resolving `X1 normalizes-to _` - --> $DIR/infinite-type-alias-mutual-recursion.rs:16:1 + --> $DIR/infinite-type-alias-mutual-recursion.rs:15:1 | LL | type X2 = X3; | ^^^^^^^ types differ error[E0271]: type mismatch resolving `X2 normalizes-to _` - --> $DIR/infinite-type-alias-mutual-recursion.rs:19:1 + --> $DIR/infinite-type-alias-mutual-recursion.rs:18:1 | LL | type X3 = X1; | ^^^^^^^ types differ diff --git a/tests/ui/infinite/infinite-type-alias-mutual-recursion.feature_old.stderr b/tests/ui/infinite/infinite-type-alias-mutual-recursion.feature_old.stderr index c7adc3af02fab..e20ed835d557e 100644 --- a/tests/ui/infinite/infinite-type-alias-mutual-recursion.feature_old.stderr +++ b/tests/ui/infinite/infinite-type-alias-mutual-recursion.feature_old.stderr @@ -1,5 +1,5 @@ error[E0275]: overflow normalizing the type alias `X2` - --> $DIR/infinite-type-alias-mutual-recursion.rs:12:1 + --> $DIR/infinite-type-alias-mutual-recursion.rs:11:1 | LL | type X1 = X2; | ^^^^^^^ @@ -7,7 +7,7 @@ LL | type X1 = X2; = note: in case this is a recursive type alias, consider using a struct, enum, or union instead error[E0275]: overflow normalizing the type alias `X3` - --> $DIR/infinite-type-alias-mutual-recursion.rs:16:1 + --> $DIR/infinite-type-alias-mutual-recursion.rs:15:1 | LL | type X2 = X3; | ^^^^^^^ @@ -15,7 +15,7 @@ LL | type X2 = X3; = note: in case this is a recursive type alias, consider using a struct, enum, or union instead error[E0275]: overflow normalizing the type alias `X1` - --> $DIR/infinite-type-alias-mutual-recursion.rs:19:1 + --> $DIR/infinite-type-alias-mutual-recursion.rs:18:1 | LL | type X3 = X1; | ^^^^^^^ diff --git a/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated_new.stderr b/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated_new.stderr index 888e1d18dea77..21d5123ff42b4 100644 --- a/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated_new.stderr +++ b/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated_new.stderr @@ -1,16 +1,16 @@ error[E0391]: cycle detected when expanding type alias `X1` - --> $DIR/infinite-type-alias-mutual-recursion.rs:12:11 + --> $DIR/infinite-type-alias-mutual-recursion.rs:11:11 | LL | type X1 = X2; | ^^ | note: ...which requires expanding type alias `X2`... - --> $DIR/infinite-type-alias-mutual-recursion.rs:16:11 + --> $DIR/infinite-type-alias-mutual-recursion.rs:15:11 | LL | type X2 = X3; | ^^ note: ...which requires expanding type alias `X3`... - --> $DIR/infinite-type-alias-mutual-recursion.rs:19:11 + --> $DIR/infinite-type-alias-mutual-recursion.rs:18:11 | LL | type X3 = X1; | ^^ @@ -19,7 +19,7 @@ LL | type X3 = X1; = help: consider using a struct, enum, or union instead to break the cycle = help: see for more information note: cycle used when checking that `X1` is well-formed - --> $DIR/infinite-type-alias-mutual-recursion.rs:12:1 + --> $DIR/infinite-type-alias-mutual-recursion.rs:11:1 | LL | type X1 = X2; | ^^^^^^^ diff --git a/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated_old.stderr b/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated_old.stderr index 888e1d18dea77..21d5123ff42b4 100644 --- a/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated_old.stderr +++ b/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated_old.stderr @@ -1,16 +1,16 @@ error[E0391]: cycle detected when expanding type alias `X1` - --> $DIR/infinite-type-alias-mutual-recursion.rs:12:11 + --> $DIR/infinite-type-alias-mutual-recursion.rs:11:11 | LL | type X1 = X2; | ^^ | note: ...which requires expanding type alias `X2`... - --> $DIR/infinite-type-alias-mutual-recursion.rs:16:11 + --> $DIR/infinite-type-alias-mutual-recursion.rs:15:11 | LL | type X2 = X3; | ^^ note: ...which requires expanding type alias `X3`... - --> $DIR/infinite-type-alias-mutual-recursion.rs:19:11 + --> $DIR/infinite-type-alias-mutual-recursion.rs:18:11 | LL | type X3 = X1; | ^^ @@ -19,7 +19,7 @@ LL | type X3 = X1; = help: consider using a struct, enum, or union instead to break the cycle = help: see for more information note: cycle used when checking that `X1` is well-formed - --> $DIR/infinite-type-alias-mutual-recursion.rs:12:1 + --> $DIR/infinite-type-alias-mutual-recursion.rs:11:1 | LL | type X1 = X2; | ^^^^^^^ diff --git a/tests/ui/infinite/infinite-type-alias-mutual-recursion.rs b/tests/ui/infinite/infinite-type-alias-mutual-recursion.rs index 24e1318ca3d7d..352fbe6b765cf 100644 --- a/tests/ui/infinite/infinite-type-alias-mutual-recursion.rs +++ b/tests/ui/infinite/infinite-type-alias-mutual-recursion.rs @@ -1,5 +1,4 @@ //@ revisions: feature_old gated_old feature_new gated_new -//@ ignore-parallel-frontend query cycle //@ ignore-compare-mode-next-solver (explicit revisions) //@ [feature_new] compile-flags: -Znext-solver //@ [gated_new] compile-flags: -Znext-solver diff --git a/tests/ui/issues/issue-34373.rs b/tests/ui/issues/issue-34373.rs index 02e1048e5a330..9475bc83646d6 100644 --- a/tests/ui/issues/issue-34373.rs +++ b/tests/ui/issues/issue-34373.rs @@ -1,5 +1,4 @@ #![allow(warnings)] -//@ ignore-parallel-frontend query cycle trait Trait { fn foo(_: T) {} } diff --git a/tests/ui/issues/issue-34373.stderr b/tests/ui/issues/issue-34373.stderr index 995f2f4022b62..9064e2da8b130 100644 --- a/tests/ui/issues/issue-34373.stderr +++ b/tests/ui/issues/issue-34373.stderr @@ -1,17 +1,17 @@ error[E0391]: cycle detected when computing type of `Foo::T` - --> $DIR/issue-34373.rs:7:34 + --> $DIR/issue-34373.rs:6:34 | LL | pub struct Foo>>; | ^^^^^^^^^^ | note: ...which requires expanding type alias `DefaultFoo`... - --> $DIR/issue-34373.rs:9:19 + --> $DIR/issue-34373.rs:8:19 | LL | type DefaultFoo = Foo; | ^^^ = note: ...which again requires computing type of `Foo::T`, completing the cycle note: cycle used when checking that `Foo` is well-formed - --> $DIR/issue-34373.rs:7:1 + --> $DIR/issue-34373.rs:6:1 | LL | pub struct Foo>>; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^