jiebi/CodeConvo huggingface dataset:
Change:
<!-- ICE: Rustc '' 'error: internal compiler error: unexpected coroutine type Pin<&mut {async fn 3:2}', 'error: internal compiler error: unexpected coroutine type Pin<&mut {async fn 3:2}' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details
regression in ping

Discussion:
let args = args.as_coroutine(); let yield_ty = args.yield_ty(); let return_ty = args.return_ty(); <del> let self_ty = Ty::new_adt( tcx, tcx.adt_def(tcx.lang_items().pin_type().unwrap()), tcx.mk_args(&[Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, coroutine_ty).into()]), ); let coroutine_state = Ty::new_adt( tcx, tcx.adt_def(tcx.lang_items().coroutine_state().unwrap()), tcx.mk_args(&[yield_ty.into(), return_ty.into()]), ); (vec![self_ty, args.resume_ty()], coroutine_state, Some(yield_ty)) </del> <ins> (vec![coroutine_ty, args.resume_ty()], return_ty, Some(yield_ty)) </ins> } dk => bug!("{:?} is not a body: {:?}", def_id, dk), };

<ins> // edition: 2021 async fn asyncfn() { let binding = match true {}; //~^ ERROR non-exhaustive patterns: type `bool` is non-empty } fn main() {} </ins>

<ins> error[E0004]: non-exhaustive patterns: type `bool` is non-empty --> $DIR/build-async-error-body-correctly.rs:4:25 | LL |     let binding = match true {}; |                         ^^^^ | = note: the matched value is of type `bool` help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown | LL ~     let binding = match true { LL +         _ => todo!(), LL ~     }; | error: aborting due to previous error For more information about this error, try `rustc --explain E0004`. </ins>
Change:
<!-- ICE: Rustc '' 'thread 'rustc' panicked at 'index out of bounds: the len is 0 but the index is 0'', 'thread 'rustc' panicked at 'index out of bounds: the len is 0 but the index is 0'' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details
/ ping

Discussion:
{ let def_kind_descr = tcx.def_kind_descr(item.kind.as_def_kind(), item.def_id); let item_name = item.ident(tcx); <del> let rcvr_ref = tcx.fn_sig(item.def_id).skip_binder().skip_binder().inputs()[0] .ref_mutability() </del> <ins> let rcvr_ref = tcx.fn_sig(item.def_id) .skip_binder() .skip_binder() .inputs() .get(0) .and_then(|ty| ty.ref_mutability()) </ins> .map_or("", |mutbl| mutbl.ref_prefix_str()); let args = format!( "({}{})",

<ins> struct Qux; trait Foo { fn foo(); } trait FooBar { fn foo() {} } fn main() { Qux.foo(); //~^ ERROR no method named `foo` found for struct `Qux` in the current scope } </ins>

<ins> error[E0599]: no method named `foo` found for struct `Qux` in the current scope --> $DIR/method-ambiguity-no-rcvr.rs:12:9 | LL | struct Qux; | ---------- method `foo` not found for this struct ... LL |     Qux.foo(); |         ^^^ this is an associated function, not a method | = note: found the following associated functions; to be used as methods, functions must have a `self` parameter note: candidate #1 is defined in the trait `Foo` --> $DIR/method-ambiguity-no-rcvr.rs:4:5 | LL |     fn foo(); |     ^^^^^^^^^ note: candidate #2 is defined in the trait `FooBar` --> $DIR/method-ambiguity-no-rcvr.rs:8:5 | LL |     fn foo() {} |     ^^^^^^^^ help: disambiguate the associated function for candidate #1 | LL |     <Qux as Foo>::foo(Qux); |     ~~~~~~~~~~~~~~~~~~~~~~ help: disambiguate the associated function for candidate #2 | LL |     <Qux as FooBar>::foo(Qux); |     ~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to previous error For more information about this error, try `rustc --explain E0599`. </ins>
Change:
Reproduces with on commit Remove and add to get a lot of ICEs like this:
So, looks like we should either allow StorageLive on an already live local, or we need to ensure that all locals are explicitly marked StorageDead before returning. No idea how realistic it is to achieve the latter. Cc

Discussion:
resume_arg }; <ins> let storage_liveness: GrowableBitSet<Local> = self.storage_liveness[block].clone().unwrap().into(); for i in 0..self.always_live_locals.domain_size() { let l = Local::new(i); let needs_storage_dead = storage_liveness.contains(l) && !self.remap.contains_key(&l) && !self.always_live_locals.contains(l); if needs_storage_dead { data.statements .push(Statement { source_info, kind: StatementKind::StorageDead(l) }); } } </ins> self.suspension_points.push(SuspensionPoint { state, resume, resume_arg, drop, <del> storage_liveness: self.storage_liveness[block].clone().unwrap().into(), </del> <ins> storage_liveness, </ins> }); VariantIdx::new(state)

// Create StorageLive instructions for locals with live storage for i in 0..(body.local_decls.len()) { <del> if i == 2 { // The resume argument is live on function entry. Don't insert a // `StorageLive`, or the following `Assign` will read from uninitialized // memory. continue; } </del> let l = Local::new(i); let needs_storage_live = point.storage_liveness.contains(l) && !transform.remap.contains_key(&l)

StorageLive(_20); _20 = (); _0 = Poll::<()>::Pending; <ins> StorageDead(_3); StorageDead(_4); StorageDead(_19); StorageDead(_20); </ins> discriminant((*(_1.0: &mut {async fn body@$DIR/async_await.rs:15:18: 18:2}))) = 3; return; }

StorageLive(_36); _36 = (); _0 = Poll::<()>::Pending; <ins> StorageDead(_21); StorageDead(_35); StorageDead(_36); </ins> discriminant((*(_1.0: &mut {async fn body@$DIR/async_await.rs:15:18: 18:2}))) = 4; return; }

StorageLive(_7); _7 = (); _0 = CoroutineState::<(), ()>::Yielded(move _7); <ins> StorageDead(_4); StorageDead(_6); StorageDead(_7); </ins> discriminant((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:20:16: 20:24}))) = 3; return; }

+ +     bb6: { +         _1 = CoroutineState::<i32, bool>::Yielded(move _8); <ins> +         StorageDead(_8); </ins> +         discriminant((*_6)) = 3; +         goto -> bb2; +     }

+ +     bb8: { +         _1 = CoroutineState::<i32, bool>::Yielded(move _8); <ins> +         StorageDead(_8); </ins> +         discriminant((*_6)) = 3; +         goto -> bb4; +     }
Change:
<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read "Rust Bug Minimization Patterns" for how to create smaller examples. --I have tried to measure on a 32 core machine and got this ice after several tries. Steps to reproduce: I have got it 2 times in a row, so it should be reproducible. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:
searched nightlies: from nightly-2023-11-03 to nightly-2023-11-09 regressed nightly: nightly-2023-11-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details
modify labels: +A-parallel-queries
modify labels: +WG-compiler-parallel
Can you reproduce this bug using the latest nightly version to get the new error output?
I can build rustc from the sources if you need to check something.
That's all right. It's a same error with other issues

Discussion:
let debugger_visualizers = stat!("debugger-visualizers", || self.encode_debugger_visualizers()); <del> // Encode exported symbols info. This is prefetched in `encode_metadata` so we encode // this as late as possible to give the prefetching as much time as possible to complete. </del> <ins> // Encode exported symbols info. This is prefetched in `encode_metadata`. </ins> let exported_symbols = stat!("exported-symbols", || { self.encode_exported_symbols(tcx.exported_symbols(LOCAL_CRATE)) });

// there's no need to do dep-graph tracking for any of it. tcx.dep_graph.assert_ignored(); <del> join( || encode_metadata_impl(tcx, path), || { if tcx.sess.threads() == 1 { return; } // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); }, ); } </del> <ins> if tcx.sess.threads() != 1 { // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); } </ins> <del> fn encode_metadata_impl(tcx: TyCtxt<'_>, path: &Path) { </del> let mut encoder = opaque::FileEncoder::new(path) .unwrap_or_else(|err| tcx.sess.emit_fatal(FailCreateFileEncoder { err })); encoder.emit_raw_bytes(METADATA_HEADER);
Change:
I just tried out the new parallelization feature of the compiler and it randomly panicked because a deadlock was detected. I tried a couple of times and could not reproduce it unfortunately. : <details<summary<strongBacktrace</strong</summary<p</p</details
Could you provide the minimal example causes the ICE?
The project I compiled was huge and I was not able to consistently reproduce it so reducing my case to a minimal example might take forever. Buy I noticed the issue you linked already contains a fairly small example code so it's probably alright to close my ticket since it seems to be a duplicate of that other ticket anyway.
Can you reproduce this bug using the latest nightly version to get the new error output?
Yes. It appears to be the same issue (albeit while compiling a different dependency but that probably doesn't matter):
BTW with the latest nightly the compiler always and immediately panics and produces multiple back traces. version: nightly-aarch64-apple-darwin unchanged - rustc 1.76.0-nightly ( 2023-12-05) <details<summarycompiler error</summary</details
It would be fixed by

Discussion:
let debugger_visualizers = stat!("debugger-visualizers", || self.encode_debugger_visualizers()); <del> // Encode exported symbols info. This is prefetched in `encode_metadata` so we encode // this as late as possible to give the prefetching as much time as possible to complete. </del> <ins> // Encode exported symbols info. This is prefetched in `encode_metadata`. </ins> let exported_symbols = stat!("exported-symbols", || { self.encode_exported_symbols(tcx.exported_symbols(LOCAL_CRATE)) });

// there's no need to do dep-graph tracking for any of it. tcx.dep_graph.assert_ignored(); <del> join( || encode_metadata_impl(tcx, path), || { if tcx.sess.threads() == 1 { return; } // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); }, ); } </del> <ins> if tcx.sess.threads() != 1 { // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); } </ins> <del> fn encode_metadata_impl(tcx: TyCtxt<'_>, path: &Path) { </del> let mut encoder = opaque::FileEncoder::new(path) .unwrap_or_else(|err| tcx.sess.emit_fatal(FailCreateFileEncoder { err })); encoder.emit_raw_bytes(METADATA_HEADER);
Change:
<!-- ICE: Rustc '' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details
Regression in nightly-2022-02-02 found 9 bors merge commits in the specified range commit[0] 2022-01-31: Auto merge of - spastorino:fix-perf-overlap-mode2, r=nikomatsakis commit[1] 2022-01-31: Auto merge of - tmiasko:is-self-recursive, r=ecstatic-morse commit[2] 2022-02-01: Auto merge of - WaffleLapkin:rustcmustimplementoneofchecktarget, r=nagisa commit[3] 2022-02-01: Auto merge of - eddyb:diagbld-scalar-pair, r=jackh726 commit[4] 2022-02-01: Auto merge of - ehuss:rollup-9ecozo9, r=ehuss commit[5] 2022-02-01: Auto merge of - thomcc:chunky-splitz-says-no-checking, r=the8472 commit[6] 2022-02-01: Auto merge of - eholk:disable-drop-range-analysis, r=pnkfelix commit[7] 2022-02-01: Auto merge of - matthiaskrgr:rollup-f7dkn3p, r=matthiaskrgr commit[8] 2022-02-01: Auto merge of - yaahc:Termination-abstraction, r=Mark-Simulacrum ERROR: no CI builds available between and within last 167 days
Actually reduced
Might have been caused by
Ah yes, the assert was there ping :)

Discussion:
trait_ref: ty::TraitRef<'tcx>, impl_def_id: LocalDefId, ) { <del> assert_eq!(trait_ref.args.len(), 1); </del> <ins> if trait_ref.args.len() != 1 { tcx.sess.diagnostic().delay_span_bug( tcx.def_span(impl_def_id), "auto traits cannot have generic parameters", ); return; } </ins> let self_ty = trait_ref.self_ty(); let (self_type_did, args) = match self_ty.kind() { ty::Adt(def, args) => (def.did(), args),

<ins> #![deny(suspicious_auto_trait_impls)] auto trait Trait<P> {} //~ ERROR auto traits cannot have generic parameters //~^ ERROR auto traits are experimental and possibly buggy impl<P> Trait<P> for () {} fn main() {} </ins>

<ins> error[E0567]: auto traits cannot have generic parameters --> $DIR/issue-117789.rs:3:17 | LL | auto trait Trait<P> {} |            -----^^^ help: remove the parameters |            | |            auto trait cannot have generic parameters error[E0658]: auto traits are experimental and possibly buggy --> $DIR/issue-117789.rs:3:1 | LL | auto trait Trait<P> {} | ^^^^^^^^^^^^^^^^^^^^^^ | = note: see issue #13231 <https://github.com/rust-lang/rust/issues/13231> for more information = help: add `#![feature(auto_traits)]` to the crate attributes to enable error: aborting due to 2 previous errors Some errors have detailed explanations: E0567, E0658. For more information about an error, try `rustc --explain E0567`. </ins>
Change:
<!-- [31mICE[0m: Rustc '' 'thread 'rustc' panicked at ', 'thread 'rustc' panicked at ' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details
Regression in nightly-2023-11-08 / ping
This should be fixed by
I'm intrigued as to why you believe could rectify this problem. The issue can be distilled as follows: It results in a panic at due to the closure utilizing the type from its outermost function, eventually returning . This issue appears to be unrelated to .
You're provably correct, and I am likely wrong about the root cause of the issue. I will look tomorrow. Feel free to claim this issue if you've already found a solution in the process of investigation.

Discussion:
let mir_opaque_ty = tcx.mir_borrowck(owner_def_id).concrete_opaque_types.get(&def_id).copied(); if let Some(mir_opaque_ty) = mir_opaque_ty { <ins> if mir_opaque_ty.references_error() { return mir_opaque_ty.ty; } </ins> let scope = tcx.local_def_id_to_hir_id(owner_def_id); debug!(?scope); let mut locator = RpitConstraintChecker { def_id, tcx, found: mir_opaque_ty };

<ins> trait Foo {} trait T { fn a(&self) -> impl Foo { self.b(|| 0) //~^ ERROR no method named `b` found for reference `&Self` in the current scope } } fn main() {} </ins>

<ins> error[E0599]: no method named `b` found for reference `&Self` in the current scope --> $DIR/issue-117794.rs:5:14 | LL |         self.b(|| 0) |              ^ help: there is a method with a similar name: `a` error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0599`. </ins>
Change:
<!-- [31mICE[0m: Rustc '' 'error: internal compiler error: no type for local variable HirId(DefId(0:3 ~ E798F6428C27040F6BCB788CE3C70B28DC596BC8C3AD45A9CC67EC872D6B13EF[a927]::main).70) (local )', 'error: internal compiler error: no type for local variable HirId(DefId(0:3 ~ E798F6428C27040F6BCB788CE3C70B28DC596BC8C3AD45A9CC67EC872D6B13EF[a927]::main).70) (local )' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information Command: &lt;!-- Include a backtrace in the code block by setting in your environment. E.g. . --&lt;details&lt;summary&lt;strongProgram output&lt;/strong&lt;/summary&lt;p&lt;/p&lt;/details&lt;!-- TRIAGEBOTSTART --&lt;!-- TRIAGEBOTASSIGNSTART --&lt;!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --&lt;!-- TRIAGEBOTASSIGNEND --&lt;!-- TRIAGEBOTEND --
Regression in nightly-2023-10-31 Regression in = ping
reduced a bit further:
claim

Discussion:
} }; <del> let coerce_to = match opt_coerce_to { Some(c) => c, None => { // If the loop context is not a `loop { }`, then break with // a value is illegal, and `opt_coerce_to` will be `None`. // Return error in that case (#114529). return Ty::new_misc_error(tcx); } }; </del> <ins> // If the loop context is not a `loop { }`, then break with // a value is illegal, and `opt_coerce_to` will be `None`. // Set expectation to error in that case and set tainted // by error (#114529) let coerce_to = opt_coerce_to.unwrap_or_else(|| { let guar = tcx.sess.delay_span_bug( expr.span, "illegal break with value found but no error reported", ); self.set_tainted_by_errors(guar); Ty::new_error(tcx, guar) }); </ins> // Recurse without `enclosing_breakables` borrowed. e_ty = self.check_expr_with_hint(e, coerce_to);

}; 51 }]; <ins> while true { break (|| { //~ ERROR `break` with value from a `while` loop let local = 9; }); } </ins> }

LL |             break; |             ~~~~~ <del> error: aborting due to 2 previous errors </del> <ins> error[E0571]: `break` with value from a `while` loop --> $DIR/issue-114529-illegal-break-with-value.rs:22:9 | LL |       while true { |       ---------- you can't `break` with a value in a `while` loop LL | /         break (|| { LL | |             let local = 9; LL | |         }); | |__________^ can only break with a value inside `loop` or breakable block | help: use `break` on its own without a value inside this `while` loop | LL |         break; |         ~~~~~ error: aborting due to 3 previous errors </ins> For more information about this error, try `rustc --explain E0571`.
Change:
this is my attempt to bootstrap rust-1.75.0 beta, which fails with this beauty: this is my command: I can workaround this by reverting can you please have a look at this error and the backtrace? I don't get why this error comes up. Thanks
this is my
The fixme here seems to be the issue: As workaround you can try to run before the build. cc
I'm compiling offline, from the beta src tarball.
I'm aware. It seems that there is a bug when using vendored sources in combination with remap-debuginfo. Creating the directory should help even if it is kept empty.
WG-prioritization assigning priority (). label -I-prioritize +P-medium
Well, the cargo eclass is already exporting CARGOHOME env var, and a CARGOREGISTRY_DIR as well, and I'm doubtfull about the package manager allowing x.py to escape it's sandbox. Neverthelss, I'll try your suggestion when I'm back home on the machine.
If you have set the directory you need to create is .
for your information only

Discussion:
} if self.config.rust_remap_debuginfo { <del> // FIXME: handle vendored sources let registry_src = t!(home::cargo_home()).join("registry").join("src"); </del> let mut env_var = OsString::new(); <del> for entry in t!(std::fs::read_dir(registry_src)) { if !env_var.is_empty() { env_var.push("t"); } env_var.push(t!(entry).path()); </del> <ins> if self.config.vendor { let vendor = self.build.src.join("vendor"); env_var.push(vendor); </ins> env_var.push("=/rust/deps"); <ins> } else { let registry_src = t!(home::cargo_home()).join("registry").join("src"); for entry in t!(std::fs::read_dir(registry_src)) { if !env_var.is_empty() { env_var.push("t"); } env_var.push(t!(entry).path()); env_var.push("=/rust/deps"); } </ins> } cargo.env("RUSTC_CARGO_REGISTRY_SRC_TO_REMAP", env_var); }
Change:
<!-- [31mICE[0m: Rustc '' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details
Regression in nightly-2023-11-08 / ping
I think is fixing an issue that may have the same root cause.

Discussion:
let mir_opaque_ty = tcx.mir_borrowck(owner_def_id).concrete_opaque_types.get(&def_id).copied(); if let Some(mir_opaque_ty) = mir_opaque_ty { <ins> if mir_opaque_ty.references_error() { return mir_opaque_ty.ty; } </ins> let scope = tcx.local_def_id_to_hir_id(owner_def_id); debug!(?scope); let mut locator = RpitConstraintChecker { def_id, tcx, found: mir_opaque_ty };

<ins> trait Foo {} trait T { fn a(&self) -> impl Foo { self.b(|| 0) //~^ ERROR no method named `b` found for reference `&Self` in the current scope } } fn main() {} </ins>

<ins> error[E0599]: no method named `b` found for reference `&Self` in the current scope --> $DIR/issue-117794.rs:5:14 | LL |         self.b(|| 0) |              ^ help: there is a method with a similar name: `a` error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0599`. </ins>
Change:
<!-- [31mICE[0m: Rustc '--crate-type=lib --edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'internal error: entered unreachable code'', 'thread 'rustc' panicked at 'internal error: entered unreachable code'' File: --code: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details
Regression in nightly-2023-02-12 found 8 bors merge commits in the specified range commit[0] 2023-02-10: Auto merge of - flip1995:clippyup, r=Manishearth commit[1] 2023-02-10: Auto merge of - JulianKnodt:arrayconstval, r=cjgillot commit[2] 2023-02-11: Auto merge of - BoxyUwU:deferredprojectionequality, r=lcnr commit[3] 2023-02-11: Auto merge of - Dylan-DPC:rollup-fkl9swa, r=Dylan-DPC commit[4] 2023-02-11: Auto merge of - petrochenkov:doclink2, r=oli-obk commit[5] 2023-02-11: Auto merge of - the8472:rawvec-simpler-layout, r=thomcc commit[6] 2023-02-11: Auto merge of - matthiaskrgr:rollup-qnn380r, r=matthiaskrgr commit[7] 2023-02-11: Auto merge of - cjgillot:sroa-const, r=oli-obk ERROR: no CI builds available between and within last 167 days maybe ? ping

Discussion:
self.per_ns(|this, ns| { let key = BindingKey::new(target, ns); let _ = this.try_define(import.parent_scope.module, key, dummy_binding, false); <ins> this.update_resolution(import.parent_scope.module, key, false, |_, resolution| { resolution.single_imports.remove(&import); }) </ins> }); self.record_use(target, dummy_binding, false); } else if import.imported_module.get().is_none() {

<ins> #![crate_type = "lib"] use super::A; //~ ERROR failed to resolve mod b { pub trait A {} pub trait B {} } /// [`A`] pub use b::*; </ins>

<ins> error[E0433]: failed to resolve: there are too many leading `super` keywords --> $DIR/issue-117920.rs:3:5 | LL | use super::A; |     ^^^^^ there are too many leading `super` keywords error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0433`. </ins>