jiebi/CodeConvo huggingface dataset:
Change:
Tested on nightly and stable. The second diagnostic is strange. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --
label +A-diagnostics S-has-mvce
claim
any idea why rustbot ignored me?
Just guessing, the missing + for S-has-mcve maybe?
Oops, this should'nt've been closed.

Discussion:
let attrs = self.parse_inner_attributes()?; let post_attr_lo = self.token.span; <del> let mut items = ThinVec::new(); while let Some(item) = self.parse_item(ForceCollect::No)? { self.maybe_consume_incorrect_semicolon(Some(&item)); </del> <ins> let mut items: ThinVec<P<_>> = ThinVec::new(); // There shouldn't be any stray semicolons before or after items. // `parse_item` consumes the appropriate semicolons so any leftover is an error. loop { while self.maybe_consume_incorrect_semicolon(items.last().map(|x| &**x)) {} // Eat all bad semicolons let Some(item) = self.parse_item(ForceCollect::No)? else { break; }; </ins> items.push(item); }

<ins> // Regression test for issue #124935 // Tests that we do not erroneously emit an error about // missing main function when the mod starts with a `;` ; //~ ERROR expected item, found `;` fn main() { } </ins>

<ins> error: expected item, found `;` --> $DIR/fn-no-semicolon-issue-124935-semi-after-item.rs:5:1 | LL | ; | ^ help: remove this semicolon error: aborting due to 1 previous error </ins>

#![allow(unused_variables)]; //~ ERROR expected item, found `;` <del> //~^ ERROR `main` function </del> fn foo() {} <ins> //~^ ERROR `main` function </ins>

|                            ^ help: remove this semicolon error[E0601]: `main` function not found in crate `issue_49040` <del> --> $DIR/issue-49040.rs:1:29 </del> <ins> --> $DIR/issue-49040.rs:2:12 </ins> | <del> LL | #![allow(unused_variables)]; |                             ^ consider adding a `main` function to `$DIR/issue-49040.rs` </del> <ins> LL | fn foo() {} |            ^ consider adding a `main` function to `$DIR/issue-49040.rs` </ins> error: aborting due to 2 previous errors

<ins> // Regression test for issue #124935 // Tests that we still emit an error after an item. fn main() { } ; //~ ERROR expected item, found `;` </ins>

<ins> error: expected item, found `;` --> $DIR/missing-main-issue-124935-semi-after-item.rs:5:1 | LL | ; | ^ help: remove this semicolon | = help: function declarations are not followed by a semicolon error: aborting due to 1 previous error </ins>
Change:
I get a segfault when I try to run on the following code: I see the same behavior with the latest nightly . I see no error with 1.77.0 or earlier. It also works fine on Linux, and on an older Intel Macbook. I also updated to the latest XCode to make sure all parts of my toolchain were up to date. Doing so did not make the segfault go away.
The problem disappears if I turn off incremental compilation by adding this to the :
I believe this bisects to LLVM 18 from cc
We are hitting an LLVM assertion:
Could someone please run and then repeat the rustc command with and share the bitcode files?
I can reproduce it, and I will try to reduce it.
Upstream issue: Reduced:
It has already been backported to LLVM 18: label +llvm-fixed-upstream

Discussion:
[submodule "src/llvm-project"] path = src/llvm-project url = https://github.com/rust-lang/llvm-project.git <del> branch = rustc/18.0-2024-02-13 </del> <ins> branch = rustc/18.1-2024-05-19 </ins> shallow = true [submodule "src/doc/embedded-book"] path = src/doc/embedded-book

<del> Subproject commit 5399a24c66cb6164cf32280e7d300488c90d5765 </del> <ins> Subproject commit b31c30a9bb4dbbd13c359d0e2bea7f65d20adf3f </ins>
Change:
<!-- [31mICE[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' 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<!-- query stack: [typeck] type-checking [analysis] running analysis passes on this crate --
cc

Discussion:
// If a string was expected and the found expression is a character literal, // perhaps the user meant to write `"s"` to specify a string literal. (ty::Ref(_, r, _), ty::Char) if r.is_str() => { <del> suggestions.push(TypeErrorAdditionalDiags::MeantStrLiteral { start: span.with_hi(span.lo() + BytePos(1)), end: span.with_lo(span.hi() - BytePos(1)), }) </del> <ins> if let Ok(code) = self.tcx.sess().source_map().span_to_snippet(span) && code.starts_with("'") && code.ends_with("'") { suggestions.push(TypeErrorAdditionalDiags::MeantStrLiteral { start: span.with_hi(span.lo() + BytePos(1)), end: span.with_lo(span.hi() - BytePos(1)), }); } </ins> } // For code `if Some(..) = expr `, the type mismatch may be expected `bool` but found `()`, // we try to suggest to add the missing `let` for `if let Some(..) = expr`

<del> //@ known-bug: rust-lang/rust#125081 use std::cell::Cell; fn main() { let _: Cell<&str, "a"> = Cell::new('β); } </del>

<ins> // issue: rust-lang/rust#125081 fn main() { let _: &str = 'β; //~^ ERROR expected `while`, `for`, `loop` or `{` after a label //~| ERROR mismatched types } </ins>

<ins> error: expected `while`, `for`, `loop` or `{` after a label --> $DIR/str-as-char-butchered.rs:4:21 | LL |     let _: &str = 'β; |                     ^ expected `while`, `for`, `loop` or `{` after a label | help: add `'` to close the char literal | LL |     let _: &str = 'β'; |                     + error[E0308]: mismatched types --> $DIR/str-as-char-butchered.rs:4:19 | LL |     let _: &str = 'β; |            ----   ^^ expected `&str`, found `char` |            | |            expected due to this error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </ins>

<ins> // Don't suggest double quotes when encountering an expr of type `char` where a `&str` // is expected if the expr is not a char literal. // issue: rust-lang/rust#125595 fn main() { let _: &str = ('a'); //~ ERROR mismatched types let token = || 'a'; let _: &str = token(); //~ ERROR mismatched types } </ins>

<ins> error[E0308]: mismatched types --> $DIR/str-as-char-non-lit.rs:6:19 | LL |     let _: &str = ('a'); |            ----   ^^^^^ expected `&str`, found `char` |            | |            expected due to this error[E0308]: mismatched types --> $DIR/str-as-char-non-lit.rs:8:19 | LL |     let _: &str = token(); |            ----   ^^^^^^^ expected `&str`, found `char` |            | |            expected due to this error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </ins>
Change:
From ICEs at no symbol mangling. is required for the repro. The symbol mangling ICE was fixed in which is nominated for beta backport, but this seems to hint that something isn't marked that should be. I suspect that adding the above would probably break cggcc and cg_clif. From Miguel, this uses the most recent beta
label +F-f16andf128 +T-libs -needs-triage
The fallback impls for and are lacking an hint .
I did see that, just didn’t get a chance to test a fix for it yet. Care to put a patch up? (If not, I'll get to it at some point)
PR at .

Discussion:
($ty:ident) => { #[stable(feature = "rust1", since = "1.0.0")] impl Debug for $ty { <ins> #[inline] </ins> fn fmt(&self, _fmt: &mut Formatter<'_>) -> Result { panic!("floating point support is turned off"); }
Change:
With extra verbose flag (), one would see a lots of warnings about check-cfg when building -Zbuild-std. But it doesn't need to be that way. Can we doodfooding check-cfg flag to and to resolve them? Step to reproduce: I expected to see this happen: No warnings about " unexpected " Some are: label +F-check-cfg +-Zbuild-std cc

Discussion:
panic_immediate_abort = ["core/panic_immediate_abort"] # Choose algorithms that are optimized for binary size instead of runtime performance optimize_for_size = ["core/optimize_for_size"] <ins> [lints.rust.unexpected_cfgs] level = "warn" # x.py uses beta cargo, so `check-cfg` entries do not yet take effect # for rust-lang/rust. But for users of `-Zbuild-std` it does. # The unused warning is waiting for rust-lang/cargo#13925 to reach beta. check-cfg = [ 'cfg(bootstrap)', 'cfg(no_global_oom_handling)', 'cfg(no_rc)', 'cfg(no_sync)', ] </ins>

# Make `RefCell` store additional debugging information, which is printed out when # a borrow error occurs debug_refcell = [] <ins> [lints.rust.unexpected_cfgs] level = "warn" # x.py uses beta cargo, so `check-cfg` entries do not yet take effect # for rust-lang/rust. But for users of `-Zbuild-std` it does. # The unused warning is waiting for rust-lang/cargo#13925 to reach beta. check-cfg = [ 'cfg(bootstrap)', 'cfg(no_fp_fmt_parse)', 'cfg(stdarch_intel_sde)', # This matches `EXTRA_CHECK_CFGS` in `src/bootstrap/src/lib.rs`. 'cfg(feature, values(any()))', ] </ins>

name = "stdbenches" path = "benches/lib.rs" test = true <ins> [lints.rust.unexpected_cfgs] level = "warn" check-cfg = [ 'cfg(bootstrap)', 'cfg(backtrace_in_libstd)', 'cfg(netbsd10)', 'cfg(target_arch, values("xtensa"))', 'cfg(feature, values("std", "as_crate"))', ] </ins>

(Some(Mode::ToolRustc), "rust_analyzer", None), (Some(Mode::ToolStd), "rust_analyzer", None), (Some(Mode::Codegen), "parallel_compiler", None), <ins> // NOTE: consider updating `check-cfg` entries in `std/Cargo.toml` too. // cfg(bootstrap) remove these once the bootstrap compiler supports // `lints.rust.unexpected_cfgs.check-cfg` </ins> (Some(Mode::Std), "stdarch_intel_sde", None), (Some(Mode::Std), "no_fp_fmt_parse", None), (Some(Mode::Std), "no_global_oom_handling", None),
Change:
Trying to bless mir-opt tests used to work fine on my Linux box, but some recent-ish change broke that:
seems to be some macOS/Apple SDK tool. does build std for a bunch of foreign targets, but that used to work, so something must have changed, and now is required. I'm not even sure where that error comes from, does not occur as a string in the Rust repository... Cc
Maybe is related? appears in the there, and here looks like it may be the one printing the error. Cc But this can't be a build script, right? bootstrap must be calling directly but then printing its errors without giving any context. Cc
In general, the mir-opt test setup is designed to dodge any use of the crate, because the whole strategy of the mir-opt tests is oriented around not needing a C toolchain.
I've posted a fix in It seems to work locally.

Discussion:
customize(spec_map); std::fs::write(&path, serde_json::to_vec_pretty(&spec).unwrap()).unwrap(); <del> let target = TargetSelection::create_synthetic(&name, path.to_str().unwrap()); crate::utils::cc_detect::find_target(builder, target); target </del> <ins> TargetSelection::create_synthetic(&name, path.to_str().unwrap()) </ins> }
Change:
<!-- [31mICE[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)', 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)' 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<!-- query stack: [typeck] type-checking [checkwellformed] checking that is well-formed --
fyi

Discussion:
// If this is due to a block, then maybe we forgot a `return`/`break`. if due_to_block && let Some(expr) = expression <del> && let Some((parent_fn_decl, parent_id)) = fcx .tcx .hir() .parent_iter(block_or_return_id) .find_map(|(_, node)| Some((node.fn_decl()?, node.associated_body()?.0))) </del> <ins> && let Some(parent_fn_decl) = fcx.tcx.hir().fn_decl_by_hir_id(fcx.tcx.local_def_id_to_hir_id(fcx.body_id)) </ins> { fcx.suggest_missing_break_or_return_expr( &mut err,

expected, found, block_or_return_id, <del> parent_id, </del> <ins> fcx.body_id, </ins> ); }

<ins> const fn f() -> usize { //~^ ERROR mismatched types const FIELD: usize = loop { 0 //~^ ERROR mismatched types }; } fn main() {} </ins>

<ins> error[E0308]: mismatched types --> $DIR/dont-suggest-through-inner-const.rs:4:9 | LL |         0 |         ^ expected `()`, found integer error[E0308]: mismatched types --> $DIR/dont-suggest-through-inner-const.rs:1:17 | LL | const fn f() -> usize { |          -      ^^^^^ expected `usize`, found `()` |          | |          implicitly returns `()` as its body has no tail or `return` expression error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </ins>
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. --This appears to be an issue in the lint, possibly it assuming can be normalized, when due to the bound and the lack of implementation , the type is effectively <!-- 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. --: locally <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details
Still crashes with , although the Ice is a bit different.
I would appreciate if you opened a new issue for that, and shared the backtrace, etc there instead.

Discussion:
return; } } <del> let param_env = ty::ParamEnv::empty(); if ty.is_copy_modulo_regions(cx.tcx, param_env) { </del> <ins> if ty.is_copy_modulo_regions(cx.tcx, cx.param_env) { </ins> return; } <del> if type_implements_negative_copy_modulo_regions(cx.tcx, ty, param_env) { </del> <ins> if type_implements_negative_copy_modulo_regions(cx.tcx, ty, cx.param_env) { </ins> return; } if def.is_variant_list_non_exhaustive()

.tcx .infer_ctxt() .build() <del> .type_implements_trait(iter_trait, [ty], param_env) </del> <ins> .type_implements_trait(iter_trait, [ty], cx.param_env) </ins> .must_apply_modulo_regions() { return;

if type_allowed_to_implement_copy( cx.tcx, <del> param_env, </del> <ins> cx.param_env, </ins> ty, traits::ObligationCause::misc(item.span, item.owner_id.def_id), )

<ins> //@ check-pass #![feature(trivial_bounds)] #![allow(trivial_bounds)] // Make sure that we still use the where-clauses from the struct when checking // if it may implement `Copy` unconditionally. // Fix for <https://github.com/rust-lang/rust/issues/125394>. pub trait Foo { type Assoc; } pub struct Bar; // This needs to be public pub struct Baz2(<Bar as Foo>::Assoc) where Bar: Foo; fn main() {} </ins>
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. --<!-- 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. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details
Maybe but probably easier to debug from scratch.

Discussion:
// ambiguous. if let Some(bad_ty) = &steps.opt_bad_ty { if is_suggestion.0 { <del> // Ambiguity was encountered during a suggestion. Just keep going. debug!("ProbeContext: encountered ambiguity in suggestion"); </del> <ins> // Ambiguity was encountered during a suggestion. There's really // not much use in suggesting methods in this case. return Err(MethodError::NoMatch(NoMatchData { static_candidates: Vec::new(), unsatisfied_predicates: Vec::new(), out_of_scope_traits: Vec::new(), similar_candidate: None, mode, })); </ins> } else if bad_ty.reached_raw_pointer && !self.tcx.features().arbitrary_self_types && !self.tcx.sess.at_least_rust_2018()

<ins> // Fix for <https://github.com/rust-lang/rust/issues/125432>. fn separate_arms() { let mut x = None; match x { None => { x = Some(0); } Some(right) => { consume(right); //~^ ERROR cannot find function `consume` in this scope } } } fn main() {} </ins>

<ins> error[E0425]: cannot find function `consume` in this scope --> $DIR/suggest-method-on-call-for-ambig-receiver.rs:10:13 | LL |             consume(right); |             ^^^^^^^ not found in this scope error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0425`. </ins>
Change:
<!-- [31mICE[0m: Rustc '-Zmir-opt-level=5 -Zvalidate-mir -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'broken MIR in Item(DefId(0:8 ~ [c6e7]::main)) (after pass ScalarReplacementOfAggregates) at bb3[12]:'', 'thread 'rustc' panicked at 'broken MIR in Item(DefId(0:8 ~ [c6e7]::main)) (after pass ScalarReplacementOfAggregates) at bb3[12]:'' 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<!-- query stack: [optimizedmir] optimizing MIR for [collectandpartitionmonoitems] collectandpartitionmonoitems -- label +F-ptrmetadata
cc
Thanks! I have a fix for this in -- I didn't know it was possible without that change. I'll pull it out to a separate PR.

Discussion:
// Exclude #[repr(simd)] types so that they are not de-optimized into an array return true; } <ins> if Some(def.did()) == tcx.lang_items().dyn_metadata() { // codegen wants to see the `DynMetadata<T>`, // not the inner reference-to-opaque-type. return true; } </ins> // We already excluded unions and enums, so this ADT must have one variant let variant = def.variant(FIRST_VARIANT); if variant.fields.len() > 1 {

<ins> //@ run-pass //@ compile-flags: -Zmir-opt-level=5 -Zvalidate-mir #![feature(ptr_metadata)] // Regression for <https://github.com/rust-lang/rust/issues/125506>, // which failed because of SRoA would project into `DynMetadata`. trait Foo {} struct Bar; impl Foo for Bar {} fn main() { let a: *mut dyn Foo = &mut Bar; let _d = a.to_raw_parts().0 as usize; } </ins>
Change:
<!-- [31mICE[0m: Rustc '-Clink-dead-code=true --crate-type=lib -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: Failed to normalize Alias(Projection, AliasTy { args: [Bar], defid: DefId(0:4 ~ tribo[552e]::Foo::Assoc) }), maybe try to call instead', 'error: internal compiler error: Failed to normalize Alias(Projection, AliasTy { args: [Bar], defid: DefId(0:4 ~ tribo[552e]::Foo::Assoc) }), maybe try to call instead' 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<!-- query stack: [mirshims] generating MIR shim for [collectandpartitionmonoitems] collectandpartitionmonoitems -- label +F-trivialbounds
cc this is the one that still crashes from

Discussion:
{ debug!("RootCollector: ADT drop-glue for `{id:?}`",); <ins> // This type is impossible to instantiate, so we should not try to // generate a `drop_in_place` instance for it. if self.tcx.instantiate_and_check_impossible_predicates(( id.owner_id.to_def_id(), ty::List::empty(), )) { return; } </ins> let ty = self.tcx.type_of(id.owner_id.to_def_id()).no_bound_vars().unwrap(); visit_drop_use(self.tcx, ty, true, DUMMY_SP, self.output); }

<ins> //@ compile-flags: -Clink-dead-code=on --crate-type=lib //@ build-pass #![feature(trivial_bounds)] #![allow(trivial_bounds)] // Make sure we don't monomorphize the drop impl for `Baz`, since it has predicates // that don't hold under a reveal-all param env. trait Foo { type Assoc; } struct Bar; struct Baz(<Bar as Foo>::Assoc) where Bar: Foo; </ins>
Change:
I tried running this code in miri: I expected to see this happen: compile error Instead, this happened: compiled successfully and miri reported a data race this is because the automatic is incorrect: 'a,+T%3E ReentrantLock's tracking issue:
label I-unsound
label requires-nightly

Discussion:
impl<T: ?Sized> !Send for ReentrantLockGuard<'_, T> {} #[unstable(feature = "reentrant_lock", issue = "121440")] <ins> unsafe impl<T: ?Sized + Sync> Sync for ReentrantLockGuard<'_, T> {} #[unstable(feature = "reentrant_lock", issue = "121440")] </ins> impl<T> ReentrantLock<T> { /// Creates a new re-entrant lock in an unlocked state ready for use. ///

<ins> #![feature(reentrant_lock)] use std::sync::ReentrantLock; use std::cell::Cell; // ReentrantLockGuard<Cell<i32>> must not be Sync, that would be unsound. fn test_sync<T: Sync>(_t: T) {} fn main() { let m = ReentrantLock::new(Cell::new(0i32)); let guard = m.lock(); test_sync(guard); //~^ ERROR `Cell<i32>` cannot be shared between threads safely [E0277] } </ins>

<ins> error[E0277]: `Cell<i32>` cannot be shared between threads safely --> $DIR/reentrantlockguard-sync.rs:13:15 | LL |     test_sync(guard); |     --------- ^^^^^ `Cell<i32>` cannot be shared between threads safely |     | |     required by a bound introduced by this call | = help: the trait `Sync` is not implemented for `Cell<i32>`, which is required by `ReentrantLockGuard<'_, Cell<i32>>: Sync` = note: if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI32` instead = note: required for `ReentrantLockGuard<'_, Cell<i32>>` to implement `Sync` note: required by a bound in `test_sync` --> $DIR/reentrantlockguard-sync.rs:7:17 | LL | fn test_sync<T: Sync>(_t: T) {} |                 ^^^^ required by this bound in `test_sync` error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0277`. </ins>
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<!-- query stack: [mirbuilt] building MIR for [checkunsafety] unsafety-checking -- label +F-genericconstexprs
Huhu, the master artifacts -v is super confusing since the nightly date is incorrect I don't think cargo-bisect-rustc would work on that. Anyway it's ofc, nothing much else has landed since the nightly was cut. label -F-genericconstexprs +F-inline_const
ah, I would just look at the commit hash given by rustc :sweat_smile:

Discussion:
self.visit_expr(elem); self.resolve_anon_const(ct, AnonConstKind::ConstArg(IsRepeatExpr::Yes)); } <ins> ExprKind::ConstBlock(ref expr) => { self.resolve_anon_const_manual(false, AnonConstKind::InlineConst, |this| { this.visit_expr(expr) }); } </ins> ExprKind::Index(ref elem, ref idx, _) => { self.resolve_expr(elem, Some(expr)); self.visit_expr(idx);

<ins> const fn test_me<T>(a: usize) -> usize { const { a } //~^ ERROR:  attempt to use a non-constant value in a constant } fn main() {} </ins>

<ins> error[E0435]: attempt to use a non-constant value in a constant --> $DIR/referencing_local_variables.rs:2:13 | LL | const fn test_me<T>(a: usize) -> usize { |                     - this would need to be a `const` LL |     const { a } |             ^ error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0435`. </ins>