From 1b6afd1e42ba2a809c2b7255ed61784d9901555e Mon Sep 17 00:00:00 2001 From: Jonathan Turner Date: Thu, 12 May 2016 16:39:09 -0700 Subject: [PATCH] Update errors to use new error format --- src/librustc/infer/error_reporting.rs | 4 +- src/librustc_borrowck/borrowck/check_loans.rs | 141 +++++++++--------- .../borrowck/gather_loans/move_error.rs | 31 ++-- src/librustc_borrowck/borrowck/mod.rs | 23 +-- src/librustc_resolve/lib.rs | 43 +++--- src/libsyntax/errors/mod.rs | 8 +- .../compile-fail/augmented-assignments.rs | 2 + .../compile-fail/blind-item-block-middle.rs | 2 +- .../compile-fail/blind-item-item-shadow.rs | 4 +- .../borrowck/borrowck-box-insensitivity.rs | 16 +- .../borrowck-let-suggestion-suffixes.rs | 3 + .../borrowck/borrowck-let-suggestion.rs | 10 +- .../borrowck/borrowck-move-error-with-note.rs | 3 + .../borrowck/borrowck-move-out-of-vec-tail.rs | 8 +- .../borrowck/borrowck-vec-pattern-nesting.rs | 18 ++- .../compile-fail/const-pattern-irrefutable.rs | 18 +-- src/test/compile-fail/enum-in-scope.rs | 2 +- src/test/compile-fail/issue-19498.rs | 4 +- src/test/compile-fail/issue-23716.rs | 3 +- src/test/compile-fail/issue-24081.rs | 5 + src/test/compile-fail/issue-27033.rs | 4 +- src/test/compile-fail/issue-3907.rs | 4 +- src/test/compile-fail/issue-5035.rs | 5 +- .../moves-based-on-type-block-bad.rs | 1 + src/test/compile-fail/mut-suggestion.rs | 14 +- src/test/compile-fail/name-clash-nullary.rs | 2 +- .../pat-shadow-in-nested-binding.rs | 2 +- .../resolve-conflict-item-vs-import.rs | 2 +- 28 files changed, 219 insertions(+), 163 deletions(-) diff --git a/src/librustc/infer/error_reporting.rs b/src/librustc/infer/error_reporting.rs index 3900fab2d930a..48a2d5755d714 100644 --- a/src/librustc/infer/error_reporting.rs +++ b/src/librustc/infer/error_reporting.rs @@ -482,10 +482,10 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { trace.origin); if !is_simple_error { - err = err.note_expected_found(&"type", &expected, &found); + err.note_expected_found(&"type", &expected, &found); } - err = err.span_label(trace.origin.span(), &terr); + err.span_label(trace.origin.span(), &terr); self.check_and_note_conflicting_crates(&mut err, terr, trace.origin.span()); diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index c0c3d5ecd0abf..997a254cf39db 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -475,99 +475,104 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { let mut err = match (new_loan.kind, old_loan.kind) { (ty::MutBorrow, ty::MutBorrow) => { - struct_span_err!(self.bccx, new_loan.span, E0499, - "cannot borrow `{}`{} as mutable \ - more than once at a time", - nl, new_loan_msg) - .span_label( + let mut err =struct_span_err!(self.bccx, new_loan.span, E0499, + "cannot borrow `{}`{} as mutable \ + more than once at a time", + nl, new_loan_msg); + err.span_label( old_loan.span, - &format!("first mutable borrow occurs here{}", old_loan_msg)) - .span_label( + &format!("first mutable borrow occurs here{}", old_loan_msg)); + err.span_label( new_loan.span, - &format!("second mutable borrow occurs here{}", new_loan_msg)) - .span_label( + &format!("second mutable borrow occurs here{}", new_loan_msg)); + err.span_label( previous_end_span, - &format!("first borrow ends here")) + &format!("first borrow ends here")); + err } (ty::UniqueImmBorrow, ty::UniqueImmBorrow) => { - struct_span_err!(self.bccx, new_loan.span, E0524, + let mut err = struct_span_err!(self.bccx, new_loan.span, E0524, "two closures require unique access to `{}` \ at the same time", - nl) - .span_label( + nl); + err.span_label( old_loan.span, - &format!("first closure is constructed here")) - .span_label( + &format!("first closure is constructed here")); + err.span_label( new_loan.span, - &format!("second closure is constructed here")) - .span_label( + &format!("second closure is constructed here")); + err.span_label( previous_end_span, - &format!("borrow from first closure ends here")) + &format!("borrow from first closure ends here")); + err } (ty::UniqueImmBorrow, _) => { - struct_span_err!(self.bccx, new_loan.span, E0500, - "closure requires unique access to `{}` \ - but {} is already borrowed{}", - nl, ol_pronoun, old_loan_msg) - .span_label( + let mut err = struct_span_err!(self.bccx, new_loan.span, E0500, + "closure requires unique access to `{}` \ + but {} is already borrowed{}", + nl, ol_pronoun, old_loan_msg); + err.span_label( new_loan.span, - &format!("closure construction occurs here{}", new_loan_msg)) - .span_label( + &format!("closure construction occurs here{}", new_loan_msg)); + err.span_label( old_loan.span, - &format!("borrow occurs here{}", old_loan_msg)) - .span_label( + &format!("borrow occurs here{}", old_loan_msg)); + err.span_label( previous_end_span, - &format!("borrow ends here")) + &format!("borrow ends here")); + err } (_, ty::UniqueImmBorrow) => { - struct_span_err!(self.bccx, new_loan.span, E0501, - "cannot borrow `{}`{} as {} because \ - previous closure requires unique access", - nl, new_loan_msg, new_loan.kind.to_user_str()) - .span_label( + let mut err = struct_span_err!(self.bccx, new_loan.span, E0501, + "cannot borrow `{}`{} as {} because \ + previous closure requires unique access", + nl, new_loan_msg, new_loan.kind.to_user_str()); + err.span_label( new_loan.span, - &format!("borrow occurs here{}", new_loan_msg)) - .span_label( + &format!("borrow occurs here{}", new_loan_msg)); + err.span_label( old_loan.span, - &format!("closure construction occurs here{}", old_loan_msg)) - .span_label( + &format!("closure construction occurs here{}", old_loan_msg)); + err.span_label( previous_end_span, - &format!("borrow from closure ends here")) + &format!("borrow from closure ends here")); + err } (_, _) => { - struct_span_err!(self.bccx, new_loan.span, E0502, - "cannot borrow `{}`{} as {} because \ - {} is also borrowed as {}{}", - nl, - new_loan_msg, - new_loan.kind.to_user_str(), - ol_pronoun, - old_loan.kind.to_user_str(), - old_loan_msg) - .span_label( + let mut err = struct_span_err!(self.bccx, new_loan.span, E0502, + "cannot borrow `{}`{} as {} because \ + {} is also borrowed as {}{}", + nl, + new_loan_msg, + new_loan.kind.to_user_str(), + ol_pronoun, + old_loan.kind.to_user_str(), + old_loan_msg); + err.span_label( new_loan.span, &format!("{} borrow occurs here{}", new_loan.kind.to_user_str(), - new_loan_msg)) - .span_label( + new_loan_msg)); + err.span_label( old_loan.span, &format!("{} borrow occurs here{}", old_loan.kind.to_user_str(), - old_loan_msg)) - .span_label( + old_loan_msg)); + err.span_label( previous_end_span, &format!("{} borrow ends here", - old_loan.kind.to_user_str())) + old_loan.kind.to_user_str())); + err } }; match new_loan.cause { euv::ClosureCapture(span) => { - err = err.span_label( + err.span_label( span, &format!("borrow occurs due to use of `{}` in closure", nl)); } @@ -576,7 +581,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { match old_loan.cause { euv::ClosureCapture(span) => { - err = err.span_label( + err.span_label( span, &format!("previous borrow occurs due to use of `{}` in closure", ol)); @@ -664,35 +669,37 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { UseWhileBorrowed(loan_path, loan_span) => { let mut err = match move_kind { move_data::Captured => { - struct_span_err!(self.bccx, span, E0504, + let mut err = struct_span_err!(self.bccx, span, E0504, "cannot move `{}` into closure because it is borrowed", - &self.bccx.loan_path_to_string(move_path)) - .span_label( + &self.bccx.loan_path_to_string(move_path)); + err.span_label( loan_span, &format!("borrow of `{}` occurs here", &self.bccx.loan_path_to_string(&loan_path)) - ) - .span_label( + ); + err.span_label( span, &format!("move into closure occurs here") - ) + ); + err } move_data::Declared | move_data::MoveExpr | move_data::MovePat => { - struct_span_err!(self.bccx, span, E0505, + let mut err = struct_span_err!(self.bccx, span, E0505, "cannot move out of `{}` because it is borrowed", - &self.bccx.loan_path_to_string(move_path)) - .span_label( + &self.bccx.loan_path_to_string(move_path)); + err.span_label( loan_span, &format!("borrow of `{}` occurs here", &self.bccx.loan_path_to_string(&loan_path)) - ) - .span_label( + ); + err.span_label( span, &format!("move out of `{}` occurs here", &self.bccx.loan_path_to_string(move_path)) - ) + ); + err } }; diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index 0f2381f1ff916..cdc68edbf300b 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -121,22 +121,25 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, Categorization::Deref(_, _, mc::Implicit(..)) | Categorization::Deref(_, _, mc::UnsafePtr(..)) | Categorization::StaticItem => { - struct_span_err!(bccx, move_from.span, E0507, + let mut err = struct_span_err!(bccx, move_from.span, E0507, "cannot move out of {}", - move_from.descriptive_string(bccx.tcx)) - .span_label( + move_from.descriptive_string(bccx.tcx)); + err.span_label( move_from.span, &format!("move occurs here") - ) + ); + err } Categorization::Interior(ref b, mc::InteriorElement(Kind::Index, _)) => { let expr = bccx.tcx.map.expect_expr(move_from.id); if let hir::ExprIndex(..) = expr.node { - struct_span_err!(bccx, move_from.span, E0508, - "cannot move out of type `{}`, \ - a non-copy fixed-size array", - b.ty) + let mut err = struct_span_err!(bccx, move_from.span, E0508, + "cannot move out of type `{}`, \ + a non-copy fixed-size array", + b.ty); + err.span_label(move_from.span, &format!("can not move out of here")); + err } else { span_bug!(move_from.span, "this path should not cause illegal move"); } @@ -147,10 +150,12 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, match b.ty.sty { ty::TyStruct(def, _) | ty::TyEnum(def, _) if def.has_dtor() => { - struct_span_err!(bccx, move_from.span, E0509, - "cannot move out of type `{}`, \ - which defines the `Drop` trait", - b.ty) + let mut err = struct_span_err!(bccx, move_from.span, E0509, + "cannot move out of type `{}`, \ + which defines the `Drop` trait", + b.ty); + err.span_label(move_from.span, &format!("can not move out of here")); + err }, _ => { span_bug!(move_from.span, "this path should not cause illegal move"); @@ -168,7 +173,7 @@ fn note_move_destination(mut err: DiagnosticBuilder, pat_name: ast::Name, is_first_note: bool) -> DiagnosticBuilder { if is_first_note { - err = err.span_label( + err.span_label( move_to_span, &format!("attempting to move value to here")); err.help( diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index e5fb08b36bf7e..36222e172b8d6 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -624,9 +624,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { let mut db = self.struct_span_err( err.span, &self.bckerr_to_string(&err)); - self.note_and_explain_bckerr(&mut db, err); - db.span_label(span, &format!("cannot borrow")) - .emit(); + self.note_and_explain_bckerr(&mut db, err, span); + db.emit(); } pub fn report_use_of_moved_value(&self, @@ -721,10 +720,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { err.span_label( use_span, &format!("value moved{} here in previous iteration of loop", - move_note)) + move_note)); + err } else { err.span_label(use_span, &format!("value {} here after move", verb_participle)) - .span_label(move_span, &format!("value moved{} here", move_note)) + .span_label(move_span, &format!("value moved{} here", move_note)); + err }; err.note(&format!("move occurs because `{}` has type `{}`, \ @@ -951,7 +952,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { .emit(); } - pub fn note_and_explain_bckerr(&self, db: &mut DiagnosticBuilder, err: BckError<'tcx>) { + pub fn note_and_explain_bckerr(&self, db: &mut DiagnosticBuilder, err: BckError<'tcx>, + error_span: Span) { let code = err.code; match code { err_mutbl => { @@ -976,13 +978,11 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { let span = self.tcx.map.span(local_id); if let Ok(snippet) = self.tcx.sess.codemap().span_to_snippet(span) { if snippet != "self" { - db.span_suggestion( - span, - &format!("to make the {} mutable, use `mut` as shown:", - self.cmt_to_string(&err.cmt)), - format!("mut {}", snippet)); + db.span_label(span, + &format!("use `mut {}` here to make mutable", snippet)); } } + db.span_label(error_span, &format!("cannot borrow mutably")); } } } @@ -1000,6 +1000,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { super_scope, ""); if let Some(span) = statement_scope_span(self.tcx, super_scope) { + db.span_label(error_span, &format!("does not live long enough")); db.span_help(span, "consider using a `let` binding to increase its lifetime"); } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 947c1e689e81a..02cb16b2314b7 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -123,7 +123,7 @@ enum ResolutionError<'a> { SelfUsedOutsideImplOrTrait, /// error E0412: use of undeclared UseOfUndeclared(&'a str, &'a str, SuggestedCandidates), - /// error E0413: declaration shadows an enum variant or unit-like struct in scope + /// error E0413: cannot be named the same as an enum variant or unit-like struct in scope DeclarationShadowsEnumVariantOrUnitLikeStruct(Name), /// error E0414: only irrefutable patterns allowed here ConstantForIrrefutableBinding(Name), @@ -205,7 +205,7 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, E0401, "can't use type parameters from outer function; \ try using a local type parameter instead"); - err = err.span_label(span, &format!("use of type variable from outer function")); + err.span_label(span, &format!("use of type variable from outer function")); err } ResolutionError::OuterTypeParameterContext => { @@ -232,7 +232,7 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, "trait `{}` is not in scope", name); show_candidates(&mut err, &candidates); - err = err.span_label(span, &format!("`{}` is not in scope", name)); + err.span_label(span, &format!("`{}` is not in scope", name)); err } ResolutionError::UndeclaredAssociatedType => { @@ -285,7 +285,7 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, span, E0411, "use of `Self` outside of an impl or trait"); - err = err.span_label(span, &format!("Used outside of impl or trait")); + err.span_label(span, &format!("Used outside of impl or trait")); err } ResolutionError::UseOfUndeclared(kind, name, candidates) => { @@ -296,7 +296,7 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, kind, name); show_candidates(&mut err, &candidates); - err = err.span_label(span, &format!("undefined or not in scope")); + err.span_label(span, &format!("undefined or not in scope")); err } ResolutionError::DeclarationShadowsEnumVariantOrUnitLikeStruct(name) => { @@ -306,7 +306,7 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, "`{}` cannot be named the same as an enum variant \ or unit-like struct in scope", name); - err = err.span_label(span, + err.span_label(span, &format!("has same name as enum variant or unit-like struct")); err } @@ -315,13 +315,13 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, span, E0414, "let variables cannot be named the same as const variables"); - err = err.span_label(span, - &format!("cannot be named the same as a const variable")); + err.span_label(span, + &format!("cannot be named the same as a const variable")); if let Some(binding) = resolver.current_module .resolve_name_in_lexical_scope(name, ValueNS) { let participle = if binding.is_import() { "imported" } else { "defined" }; - err = err.span_label(binding.span, &format!("a constant `{}` is {} here", - name, participle)); + err.span_label(binding.span, &format!("a constant `{}` is {} here", + name, participle)); } err } @@ -331,7 +331,7 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, E0415, "identifier `{}` is bound more than once in this parameter list", identifier); - err = err.span_label(span, &format!("used as parameter more than once")); + err.span_label(span, &format!("used as parameter more than once")); err } ResolutionError::IdentifierBoundMoreThanOnceInSamePattern(identifier) => { @@ -340,7 +340,7 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, E0416, "identifier `{}` is bound more than once in the same pattern", identifier); - err = err.span_label(span, &format!("used in a pattern more than once")); + err.span_label(span, &format!("used in a pattern more than once")); err } ResolutionError::StaticVariableReference(binding) => { @@ -349,10 +349,10 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, E0417, "static variables cannot be referenced in a \ pattern, use a `const` instead"); - err = err.span_label(span, &format!("static variable used in pattern")); + err.span_label(span, &format!("static variable used in pattern")); if binding.span != codemap::DUMMY_SP { let participle = if binding.is_import() { "imported" } else { "defined" }; - err = err.span_label(binding.span, &format!("static variable {} here", participle)); + err.span_label(binding.span, &format!("static variable {} here", participle)); } err } @@ -1819,8 +1819,8 @@ impl<'a> Resolver<'a> { // If it's a typedef, give a note if let Def::TyAlias(..) = path_res.base_def { let trait_name = trait_path.segments.last().unwrap().identifier.name; - err = err.span_label(trait_path.span, - &format!("`{}` is not a trait", trait_name)); + err.span_label(trait_path.span, + &format!("`{}` is not a trait", trait_name)); let definition_site = { let segments = &trait_path.segments; @@ -1832,8 +1832,8 @@ impl<'a> Resolver<'a> { }; if definition_site != codemap::DUMMY_SP { - err = err.span_label(definition_site, - &format!("note: type aliases cannot be used for traits")); + err.span_label(definition_site, + &format!("type aliases cannot be used for traits")); } } err.emit(); @@ -3480,14 +3480,15 @@ impl<'a> Resolver<'a> { (false, false) => struct_span_err!(self.session, span, E0428, "{}", msg), (true, true) => struct_span_err!(self.session, span, E0252, "{}", msg), _ => { - let e = struct_span_err!(self.session, span, E0255, "{}", msg); - e.span_label(span, &format!("`{}` was already imported", name)) + let mut e = struct_span_err!(self.session, span, E0255, "{}", msg); + e.span_label(span, &format!("`{}` was already imported", name)); + e } }, }; if old_binding.span != codemap::DUMMY_SP { - err = err.span_label(old_binding.span, &format!("previous {} of `{}` here", noun, name)); + err.span_label(old_binding.span, &format!("previous {} of `{}` here", noun, name)); } err.emit(); } diff --git a/src/libsyntax/errors/mod.rs b/src/libsyntax/errors/mod.rs index 04f540c81ae0a..7592214c0ab92 100644 --- a/src/libsyntax/errors/mod.rs +++ b/src/libsyntax/errors/mod.rs @@ -235,17 +235,17 @@ impl<'a> DiagnosticBuilder<'a> { /// all, and you just supplied a `Span` to create the diagnostic, /// then the snippet will just include that `Span`, which is /// called the primary span. - pub fn span_label(mut self, span: Span, label: &fmt::Display) - -> DiagnosticBuilder<'a> { + pub fn span_label(&mut self, span: Span, label: &fmt::Display) + -> &mut DiagnosticBuilder<'a> { self.span.push_span_label(span, format!("{}", label)); self } - pub fn note_expected_found(mut self, + pub fn note_expected_found(&mut self, label: &fmt::Display, expected: &fmt::Display, found: &fmt::Display) - -> DiagnosticBuilder<'a> + -> &mut DiagnosticBuilder<'a> { // For now, just attach these as notes self.note(&format!("expected {} `{}`", label, expected)); diff --git a/src/test/compile-fail/augmented-assignments.rs b/src/test/compile-fail/augmented-assignments.rs index 8ac6b419295ee..92a8b10669cee 100644 --- a/src/test/compile-fail/augmented-assignments.rs +++ b/src/test/compile-fail/augmented-assignments.rs @@ -27,7 +27,9 @@ fn main() { x; //~ value moved here let y = Int(2); + //~^use `mut y` here to make mutable y //~ error: cannot borrow immutable local variable `y` as mutable + //~| cannot borrow += Int(1); } diff --git a/src/test/compile-fail/blind-item-block-middle.rs b/src/test/compile-fail/blind-item-block-middle.rs index 930f769771d58..287eab7a56338 100644 --- a/src/test/compile-fail/blind-item-block-middle.rs +++ b/src/test/compile-fail/blind-item-block-middle.rs @@ -12,6 +12,6 @@ mod foo { pub struct bar; } fn main() { let bar = 5; - //~^ ERROR declaration of `bar` shadows an enum variant or unit-like struct in scope + //~^ ERROR cannot be named the same use foo::bar; } diff --git a/src/test/compile-fail/blind-item-item-shadow.rs b/src/test/compile-fail/blind-item-item-shadow.rs index b08c78e9060de..853282ff01436 100644 --- a/src/test/compile-fail/blind-item-item-shadow.rs +++ b/src/test/compile-fail/blind-item-item-shadow.rs @@ -10,6 +10,8 @@ mod foo { pub mod foo { } } //~ NOTE previous definition of `foo` here -use foo::foo; //~ ERROR a module named `foo` has already been defined in this module +use foo::foo; +//~^ ERROR a module named `foo` has already been defined in this module +//~| was already imported fn main() {} diff --git a/src/test/compile-fail/borrowck/borrowck-box-insensitivity.rs b/src/test/compile-fail/borrowck/borrowck-box-insensitivity.rs index bde3212c5bc63..3fd71f715647d 100644 --- a/src/test/compile-fail/borrowck/borrowck-box-insensitivity.rs +++ b/src/test/compile-fail/borrowck/borrowck-box-insensitivity.rs @@ -61,7 +61,9 @@ fn move_after_borrow() { let a: Box<_> = box B { x: box 0, y: box 1 }; let _x = &a.x; //~^ NOTE borrow of `a.x` occurs here - let _y = a.y; //~ ERROR cannot move + let _y = a.y; + //~^ ERROR cannot move + //~| move out of } fn copy_after_mut_borrow() { @@ -75,7 +77,9 @@ fn move_after_mut_borrow() { let mut a: Box<_> = box B { x: box 0, y: box 1 }; let _x = &mut a.x; //~^ NOTE borrow of `a.x` occurs here - let _y = a.y; //~ ERROR cannot move + let _y = a.y; + //~^ ERROR cannot move + //~| move out of } fn borrow_after_mut_borrow() { @@ -127,7 +131,9 @@ fn move_after_borrow_nested() { let a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 }; let _x = &a.x.x; //~^ borrow of `a.x.x` occurs here - let _y = a.y; //~ ERROR cannot move + let _y = a.y; + //~^ ERROR cannot move + //~| move out of } fn copy_after_mut_borrow_nested() { @@ -141,7 +147,9 @@ fn move_after_mut_borrow_nested() { let mut a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 }; let _x = &mut a.x.x; //~^ NOTE borrow of `a.x.x` occurs here - let _y = a.y; //~ ERROR cannot move + let _y = a.y; + //~^ ERROR cannot move + //~| move out of } fn borrow_after_mut_borrow_nested() { diff --git a/src/test/compile-fail/borrowck/borrowck-let-suggestion-suffixes.rs b/src/test/compile-fail/borrowck/borrowck-let-suggestion-suffixes.rs index f551a2aa81155..02aa771c78789 100644 --- a/src/test/compile-fail/borrowck/borrowck-let-suggestion-suffixes.rs +++ b/src/test/compile-fail/borrowck/borrowck-let-suggestion-suffixes.rs @@ -26,6 +26,7 @@ fn f() { v3.push(&'x'); // statement 6 //~^ ERROR borrowed value does not live long enough + //~| does not live long enough //~| NOTE ...but borrowed value is only valid for the statement //~| HELP consider using a `let` binding to increase its lifetime @@ -36,6 +37,7 @@ fn f() { v4.push(&'y'); //~^ ERROR borrowed value does not live long enough + //~| does not live long enough //~| NOTE ...but borrowed value is only valid for the statement //~| HELP consider using a `let` binding to increase its lifetime @@ -46,6 +48,7 @@ fn f() { v5.push(&'z'); //~^ ERROR borrowed value does not live long enough + //~| does not live long enough //~| NOTE ...but borrowed value is only valid for the statement //~| HELP consider using a `let` binding to increase its lifetime diff --git a/src/test/compile-fail/borrowck/borrowck-let-suggestion.rs b/src/test/compile-fail/borrowck/borrowck-let-suggestion.rs index 7e9d448275dc7..866e72f1a5258 100644 --- a/src/test/compile-fail/borrowck/borrowck-let-suggestion.rs +++ b/src/test/compile-fail/borrowck/borrowck-let-suggestion.rs @@ -9,10 +9,12 @@ // except according to those terms. fn f() { - let x = [1].iter(); //~ ERROR borrowed value does not live long enough - //~^ NOTE reference must be valid for the block suffix following statement - //~^^ HELP consider using a `let` binding to increase its lifetime - //~^^^ NOTE ...but borrowed value is only valid for the statement at 12:4 + let x = [1].iter(); + //~^ ERROR borrowed value does not live long enough + //~|does not live long enough + //~| NOTE reference must be valid for the block suffix following statement + //~| HELP consider using a `let` binding to increase its lifetime + //~| NOTE ...but borrowed value is only valid for the statement at 12:4 } fn main() { diff --git a/src/test/compile-fail/borrowck/borrowck-move-error-with-note.rs b/src/test/compile-fail/borrowck/borrowck-move-error-with-note.rs index e4b9fb2671124..ffa7d1925569e 100644 --- a/src/test/compile-fail/borrowck/borrowck-move-error-with-note.rs +++ b/src/test/compile-fail/borrowck/borrowck-move-error-with-note.rs @@ -19,6 +19,7 @@ enum Foo { fn blah() { let f = &Foo::Foo1(box 1, box 2); match *f { //~ ERROR cannot move out of + //~| move occurs here Foo::Foo1(num1, //~ NOTE attempting to move value to here num2) => (), //~ NOTE and here Foo::Foo2(num) => (), //~ NOTE and here @@ -37,6 +38,7 @@ impl Drop for S { fn move_in_match() { match (S {f: "foo".to_string(), g: "bar".to_string()}) { S { //~ ERROR cannot move out of type `S`, which defines the `Drop` trait + //~| can not move out of here f: _s, //~ NOTE attempting to move value to here g: _t //~ NOTE and here } => {} @@ -53,6 +55,7 @@ fn free(_: T) {} fn blah2() { let a = &A { a: box 1 }; match a.a { //~ ERROR cannot move out of + //~| move occurs here n => { //~ NOTE attempting to move value to here free(n) } diff --git a/src/test/compile-fail/borrowck/borrowck-move-out-of-vec-tail.rs b/src/test/compile-fail/borrowck/borrowck-move-out-of-vec-tail.rs index d9a2f89a9e21e..2f1c69d0d7dad 100644 --- a/src/test/compile-fail/borrowck/borrowck-move-out-of-vec-tail.rs +++ b/src/test/compile-fail/borrowck/borrowck-move-out-of-vec-tail.rs @@ -27,10 +27,12 @@ pub fn main() { match x { [_, tail..] => { match tail { - [Foo { string: a }, //~ ERROR cannot move out of borrowed content + [Foo { string: a }, + //~^ ERROR cannot move out of borrowed content + //~| move occurs here + //~| attempting to move value to here Foo { string: b }] => { - //~^^ NOTE attempting to move value to here - //~^^ NOTE and here + //~^ NOTE and here } _ => { unreachable!(); diff --git a/src/test/compile-fail/borrowck/borrowck-vec-pattern-nesting.rs b/src/test/compile-fail/borrowck/borrowck-vec-pattern-nesting.rs index 1a21b03a457a8..1c63b458e62e1 100644 --- a/src/test/compile-fail/borrowck/borrowck-vec-pattern-nesting.rs +++ b/src/test/compile-fail/borrowck/borrowck-vec-pattern-nesting.rs @@ -19,6 +19,7 @@ fn a() { [box ref _a, _, _] => { //~^ borrow of `vec[..]` occurs here vec[0] = box 4; //~ ERROR cannot assign + //~^ assignment to `vec[..]` occurs here } } } @@ -30,6 +31,7 @@ fn b() { [_b..] => { //~^ borrow of `vec[..]` occurs here vec[0] = box 4; //~ ERROR cannot assign + //~^ assignment to `vec[..]` occurs here } } } @@ -39,8 +41,9 @@ fn c() { let vec: &mut [Box] = &mut vec; match vec { [_a, //~ ERROR cannot move out - _b..] => { //~^ NOTE attempting to move value to here - + //~| move occurs here + //~| attempting to move value to here + _b..] => { // Note: `_a` is *moved* here, but `b` is borrowing, // hence illegal. // @@ -51,6 +54,7 @@ fn c() { } let a = vec[0]; //~ ERROR cannot move out //~^ NOTE attempting to move value to here + //~| can not move out of here } fn d() { @@ -58,11 +62,13 @@ fn d() { let vec: &mut [Box] = &mut vec; match vec { [_a.., //~ ERROR cannot move out + //~^ move occurs here _b] => {} //~ NOTE attempting to move value to here _ => {} } let a = vec[0]; //~ ERROR cannot move out //~^ NOTE attempting to move value to here + //~| can not move out of here } fn e() { @@ -70,13 +76,15 @@ fn e() { let vec: &mut [Box] = &mut vec; match vec { [_a, _b, _c] => {} //~ ERROR cannot move out - //~^ NOTE attempting to move value to here - //~^^ NOTE and here - //~^^^ NOTE and here + //~| move occurs here + //~| NOTE attempting to move value to here + //~| NOTE and here + //~| NOTE and here _ => {} } let a = vec[0]; //~ ERROR cannot move out //~^ NOTE attempting to move value to here + //~| can not move out of here } fn main() {} diff --git a/src/test/compile-fail/const-pattern-irrefutable.rs b/src/test/compile-fail/const-pattern-irrefutable.rs index 0be1e974e7d7d..392f391fb5120 100644 --- a/src/test/compile-fail/const-pattern-irrefutable.rs +++ b/src/test/compile-fail/const-pattern-irrefutable.rs @@ -13,16 +13,16 @@ mod foo { pub const d: u8 = 2; } -use foo::b as c; //~ NOTE constant imported here -use foo::d; //~ NOTE constant imported here +use foo::b as c; //~ NOTE is imported here +use foo::d; //~ NOTE is imported here -const a: u8 = 2; //~ NOTE constant defined here +const a: u8 = 2; //~ NOTE is defined here fn main() { - let a = 4; //~ ERROR variable bindings cannot - //~^ NOTE there already is a constant in scope - let c = 4; //~ ERROR variable bindings cannot - //~^ NOTE there already is a constant in scope - let d = 4; //~ ERROR variable bindings cannot - //~^ NOTE there already is a constant in scope + let a = 4; //~ ERROR let variables cannot + //~^ NOTE cannot be named the same as a const variable + let c = 4; //~ ERROR let variables cannot + //~^ NOTE cannot be named the same as a const variable + let d = 4; //~ ERROR let variables cannot + //~^ NOTE cannot be named the same as a const variable } diff --git a/src/test/compile-fail/enum-in-scope.rs b/src/test/compile-fail/enum-in-scope.rs index 7be06ec7de812..6dffd1999d79b 100644 --- a/src/test/compile-fail/enum-in-scope.rs +++ b/src/test/compile-fail/enum-in-scope.rs @@ -11,5 +11,5 @@ struct hello(isize); fn main() { - let hello = 0; //~ERROR declaration of `hello` shadows + let hello = 0; //~ERROR cannot be named the same } diff --git a/src/test/compile-fail/issue-19498.rs b/src/test/compile-fail/issue-19498.rs index 87b79b5cd67eb..2e2115b71103a 100644 --- a/src/test/compile-fail/issue-19498.rs +++ b/src/test/compile-fail/issue-19498.rs @@ -11,11 +11,13 @@ use self::A; //~ NOTE previous import of `A` here use self::B; //~ NOTE previous import of `B` here mod A {} //~ ERROR a module named `A` has already been imported in this module +//~| `A` was already imported pub mod B {} //~ ERROR a module named `B` has already been imported in this module - +//~| `B` was already imported mod C { use C::D; //~ NOTE previous import of `D` here mod D {} //~ ERROR a module named `D` has already been imported in this module + //~| `D` was already imported } fn main() {} diff --git a/src/test/compile-fail/issue-23716.rs b/src/test/compile-fail/issue-23716.rs index 31604e2fdd3a7..b0d36610b7a51 100644 --- a/src/test/compile-fail/issue-23716.rs +++ b/src/test/compile-fail/issue-23716.rs @@ -13,6 +13,7 @@ static foo: i32 = 0; fn bar(foo: i32) {} //~^ ERROR static variables cannot be referenced in a pattern, use a `const` instead +//~| static variable used in pattern mod submod { pub static answer: i32 = 42; @@ -23,6 +24,6 @@ use self::submod::answer; fn question(answer: i32) {} //~^ ERROR static variables cannot be referenced in a pattern, use a `const` instead - +//~| static variable used in pattern fn main() { } diff --git a/src/test/compile-fail/issue-24081.rs b/src/test/compile-fail/issue-24081.rs index 94fb30082892e..188716c5e93f5 100644 --- a/src/test/compile-fail/issue-24081.rs +++ b/src/test/compile-fail/issue-24081.rs @@ -15,9 +15,14 @@ use std::ops::Div; //~ NOTE previous import use std::ops::Rem; //~ NOTE previous import type Add = bool; //~ ERROR a trait named `Add` has already been imported in this module +//~| was already imported struct Sub { x: f32 } //~ ERROR a trait named `Sub` has already been imported in this module +//~| was already imported enum Mul { A, B } //~ ERROR a trait named `Mul` has already been imported in this module +//~| was already imported mod Div { } //~ ERROR a trait named `Div` has already been imported in this module +//~| was already imported trait Rem { } //~ ERROR a trait named `Rem` has already been imported in this module +//~| was already imported fn main() {} diff --git a/src/test/compile-fail/issue-27033.rs b/src/test/compile-fail/issue-27033.rs index a729cf95a7bf3..b0904dfeaa7a3 100644 --- a/src/test/compile-fail/issue-27033.rs +++ b/src/test/compile-fail/issue-27033.rs @@ -10,11 +10,11 @@ fn main() { match Some(1) { - None @ _ => {} //~ ERROR declaration of `None` shadows an enum variant + None @ _ => {} //~ ERROR cannot be named the same }; const C: u8 = 1; match 1 { - C @ 2 => { //~ ERROR variable bindings cannot shadow constants + C @ 2 => { //~ ERROR cannot be named the same println!("{}", C); } _ => {} diff --git a/src/test/compile-fail/issue-3907.rs b/src/test/compile-fail/issue-3907.rs index 1dbf211b26941..c99ff1813e0d1 100644 --- a/src/test/compile-fail/issue-3907.rs +++ b/src/test/compile-fail/issue-3907.rs @@ -11,14 +11,14 @@ // aux-build:issue_3907.rs extern crate issue_3907; -type Foo = issue_3907::Foo; //~ NOTE: type defined here +type Foo = issue_3907::Foo; //~ NOTE: type aliases cannot be used for traits struct S { name: isize } impl Foo for S { //~ ERROR: `Foo` is not a trait - //~^ NOTE: `type` aliases cannot be used for traits + //~| `Foo` is not a trait fn bar() { } } diff --git a/src/test/compile-fail/issue-5035.rs b/src/test/compile-fail/issue-5035.rs index dabeb503841c5..a186a399a112c 100644 --- a/src/test/compile-fail/issue-5035.rs +++ b/src/test/compile-fail/issue-5035.rs @@ -9,7 +9,8 @@ // except according to those terms. trait I {} -type K = I; //~ NOTE: type defined here +type K = I; +//~^ NOTE: aliases cannot be used for traits impl K for isize {} //~ ERROR: `K` is not a trait -//~^ NOTE: `type` aliases cannot be used for traits +//~| is not a trait fn main() {} diff --git a/src/test/compile-fail/moves-based-on-type-block-bad.rs b/src/test/compile-fail/moves-based-on-type-block-bad.rs index a1e876594c25d..1fd69e2dbfe74 100644 --- a/src/test/compile-fail/moves-based-on-type-block-bad.rs +++ b/src/test/compile-fail/moves-based-on-type-block-bad.rs @@ -32,6 +32,7 @@ fn main() { loop { f(&s, |hellothere| { match hellothere.x { //~ ERROR cannot move out + //~| move occurs here box E::Foo(_) => {} box E::Bar(x) => println!("{}", x.to_string()), //~ NOTE attempting to move value to here box E::Baz => {} diff --git a/src/test/compile-fail/mut-suggestion.rs b/src/test/compile-fail/mut-suggestion.rs index efd796e11958b..242ad7aee8d12 100644 --- a/src/test/compile-fail/mut-suggestion.rs +++ b/src/test/compile-fail/mut-suggestion.rs @@ -17,14 +17,16 @@ impl S { } fn func(arg: S) { - //~^ HELP use `mut` as shown - //~| SUGGESTION fn func(mut arg: S) { - arg.mutate(); //~ ERROR cannot borrow immutable argument + //~^ here to make mutable + arg.mutate(); + //~^ ERROR cannot borrow immutable argument + //~| cannot borrow mutably } fn main() { let local = S; - //~^ HELP use `mut` as shown - //~| SUGGESTION let mut local = S; - local.mutate(); //~ ERROR cannot borrow immutable local variable + //~^ here to make mutable + local.mutate(); + //~^ ERROR cannot borrow immutable local variable + //~| cannot borrow mutably } diff --git a/src/test/compile-fail/name-clash-nullary.rs b/src/test/compile-fail/name-clash-nullary.rs index 1250318a7291d..662bb7bfe57f0 100644 --- a/src/test/compile-fail/name-clash-nullary.rs +++ b/src/test/compile-fail/name-clash-nullary.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// error-pattern:declaration of `None` shadows +// error-pattern:cannot be named the same use std::option::*; fn main() { diff --git a/src/test/compile-fail/pat-shadow-in-nested-binding.rs b/src/test/compile-fail/pat-shadow-in-nested-binding.rs index 526e4c1618721..4a8513e10d755 100644 --- a/src/test/compile-fail/pat-shadow-in-nested-binding.rs +++ b/src/test/compile-fail/pat-shadow-in-nested-binding.rs @@ -11,5 +11,5 @@ struct foo(usize); fn main() { - let (foo, _) = (2, 3); //~ ERROR declaration of `foo` shadows + let (foo, _) = (2, 3); //~ ERROR `foo` cannot be named the same as } diff --git a/src/test/compile-fail/resolve-conflict-item-vs-import.rs b/src/test/compile-fail/resolve-conflict-item-vs-import.rs index dbd1ecf44fd73..5a068ce42142f 100644 --- a/src/test/compile-fail/resolve-conflict-item-vs-import.rs +++ b/src/test/compile-fail/resolve-conflict-item-vs-import.rs @@ -13,6 +13,6 @@ use std::mem::transmute; fn transmute() {} //~^ ERROR a value named `transmute` has already been imported in this module - +//~| was already imported fn main() { }