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. 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>>; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^