diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index 04e57883c7753..5e67065d1c13f 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -510,6 +510,7 @@ impl_stable_hash_for!(struct ::middle::const_val::ConstEvalErr<'tcx> { impl_stable_hash_for!(struct ::middle::const_val::FrameInfo { span, + lint_root, location }); @@ -523,21 +524,11 @@ for ::middle::const_val::ErrKind<'gcx> { mem::discriminant(self).hash_stable(hcx, hasher); match *self { - NonConstPath | TypeckError | + CouldNotResolve | CheckMatchError => { // nothing to do } - UnimplementedConstVal(s) => { - s.hash_stable(hcx, hasher); - } - IndexOutOfBounds { len, index } => { - len.hash_stable(hcx, hasher); - index.hash_stable(hcx, hasher); - } - LayoutError(ref layout_error) => { - layout_error.hash_stable(hcx, hasher); - } Miri(ref err, ref trace) => { err.hash_stable(hcx, hasher); trace.hash_stable(hcx, hasher); @@ -608,8 +599,8 @@ for ::mir::interpret::EvalErrorKind<'gcx, O> { RemainderByZero | DivisionByZero | GeneratorResumedAfterReturn | - GeneratorResumedAfterPanic | - ReferencedConstant => {} + GeneratorResumedAfterPanic => {} + ReferencedConstant(ref err) => err.hash_stable(hcx, hasher), MachineError(ref err) => err.hash_stable(hcx, hasher), FunctionPointerTyMismatch(a, b) => { a.hash_stable(hcx, hasher); diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 381bb161e4205..824930a7eb000 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -655,6 +655,9 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> { f(self); self.param_env = old_param_env; } + pub fn current_lint_root(&self) -> ast::NodeId { + self.last_ast_node_with_lint_attrs + } } impl<'a, 'tcx> LayoutOf for &'a LateContext<'a, 'tcx> { diff --git a/src/librustc/middle/const_val.rs b/src/librustc/middle/const_val.rs index d7f116705113e..88275b3c18cc1 100644 --- a/src/librustc/middle/const_val.rs +++ b/src/librustc/middle/const_val.rs @@ -9,13 +9,15 @@ // except according to those terms. use hir::def_id::DefId; -use ty::{self, TyCtxt, layout}; +use ty; use ty::subst::Substs; +use ty::maps::TyCtxtAt; use mir::interpret::ConstValue; use errors::DiagnosticBuilder; use graphviz::IntoCow; use syntax_pos::Span; +use syntax::ast; use std::borrow::Cow; use rustc_data_structures::sync::Lrc; @@ -28,30 +30,26 @@ pub enum ConstVal<'tcx> { Value(ConstValue<'tcx>), } -#[derive(Clone, Debug)] +#[derive(Clone, Debug, RustcEncodable, RustcDecodable)] pub struct ConstEvalErr<'tcx> { pub span: Span, pub kind: Lrc>, } -#[derive(Clone, Debug)] +#[derive(Clone, Debug, RustcEncodable, RustcDecodable)] pub enum ErrKind<'tcx> { - NonConstPath, - UnimplementedConstVal(&'static str), - IndexOutOfBounds { len: u64, index: u64 }, - - LayoutError(layout::LayoutError<'tcx>), - + CouldNotResolve, TypeckError, CheckMatchError, Miri(::mir::interpret::EvalError<'tcx>, Vec), } -#[derive(Clone, Debug)] +#[derive(Clone, Debug, RustcEncodable, RustcDecodable)] pub struct FrameInfo { pub span: Span, pub location: String, + pub lint_root: Option, } #[derive(Clone, Debug)] @@ -83,16 +81,7 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> { } match *self.kind { - NonConstPath => simple!("non-constant path in constant expression"), - UnimplementedConstVal(what) => - simple!("unimplemented constant expression: {}", what), - IndexOutOfBounds { len, index } => { - simple!("index out of bounds: the len is {} but the index is {}", - len, index) - } - - LayoutError(ref err) => Simple(err.to_string().into_cow()), - + CouldNotResolve => simple!("could not resolve"), TypeckError => simple!("type-checking failed"), CheckMatchError => simple!("match-checking failed"), Miri(ref err, ref trace) => Backtrace(err, trace), @@ -100,64 +89,90 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> { } pub fn struct_error(&self, - tcx: TyCtxt<'a, 'gcx, 'tcx>, - primary_span: Span, - primary_kind: &str) - -> DiagnosticBuilder<'gcx> + tcx: TyCtxtAt<'a, 'gcx, 'tcx>, + message: &str) + -> Option> { - let mut diag = struct_error(tcx, self.span, "constant evaluation error"); - self.note(tcx, primary_span, primary_kind, &mut diag); - diag + self.struct_generic(tcx, message, None, true) } - pub fn note(&self, - _tcx: TyCtxt<'a, 'gcx, 'tcx>, - primary_span: Span, - primary_kind: &str, - diag: &mut DiagnosticBuilder) - { - match self.description() { - ConstEvalErrDescription::Simple(message) => { - diag.span_label(self.span, message); - } - ConstEvalErrDescription::Backtrace(miri, frames) => { - diag.span_label(self.span, format!("{}", miri)); - for frame in frames { - diag.span_label(frame.span, format!("inside call to `{}`", frame.location)); - } - } + pub fn report_as_error(&self, + tcx: TyCtxtAt<'a, 'gcx, 'tcx>, + message: &str + ) { + let err = self.struct_generic(tcx, message, None, true); + if let Some(mut err) = err { + err.emit(); } + } - if !primary_span.contains(self.span) { - diag.span_note(primary_span, - &format!("for {} here", primary_kind)); + pub fn report_as_lint(&self, + tcx: TyCtxtAt<'a, 'gcx, 'tcx>, + message: &str, + lint_root: ast::NodeId, + ) { + let lint = self.struct_generic( + tcx, + message, + Some(lint_root), + false, + ); + if let Some(mut lint) = lint { + lint.emit(); } } - pub fn report(&self, - tcx: TyCtxt<'a, 'gcx, 'tcx>, - primary_span: Span, - primary_kind: &str) - { - match *self.kind { - ErrKind::TypeckError | ErrKind::CheckMatchError => return, - ErrKind::Miri(ref miri, _) => { + fn struct_generic( + &self, + tcx: TyCtxtAt<'a, 'gcx, 'tcx>, + message: &str, + lint_root: Option, + as_err: bool, + ) -> Option> { + let (msg, frames): (_, &[_]) = match *self.kind { + ErrKind::TypeckError | ErrKind::CheckMatchError => return None, + ErrKind::Miri(ref miri, ref frames) => { match miri.kind { ::mir::interpret::EvalErrorKind::TypeckError | - ::mir::interpret::EvalErrorKind::Layout(_) => return, - _ => {}, + ::mir::interpret::EvalErrorKind::Layout(_) => return None, + ::mir::interpret::EvalErrorKind::ReferencedConstant(ref inner) => { + inner.struct_generic(tcx, "referenced constant", lint_root, as_err)?.emit(); + (miri.to_string(), frames) + }, + _ => (miri.to_string(), frames), } } - _ => {} + _ => (self.description().into_oneline().to_string(), &[]), + }; + trace!("reporting const eval failure at {:?}", self.span); + let mut err = if as_err { + struct_error(tcx, message) + } else { + let node_id = frames + .iter() + .rev() + .filter_map(|frame| frame.lint_root) + .next() + .or(lint_root) + .expect("some part of a failing const eval must be local"); + tcx.struct_span_lint_node( + ::rustc::lint::builtin::CONST_ERR, + node_id, + tcx.span, + message, + ) + }; + err.span_label(self.span, msg); + for FrameInfo { span, location, .. } in frames { + err.span_label(*span, format!("inside call to `{}`", location)); } - self.struct_error(tcx, primary_span, primary_kind).emit(); + Some(err) } } pub fn struct_error<'a, 'gcx, 'tcx>( - tcx: TyCtxt<'a, 'gcx, 'tcx>, - span: Span, + tcx: TyCtxtAt<'a, 'gcx, 'tcx>, msg: &str, -) -> DiagnosticBuilder<'gcx> { - struct_span_err!(tcx.sess, span, E0080, "{}", msg) +) -> DiagnosticBuilder<'tcx> { + struct_span_err!(tcx.sess, tcx.span, E0080, "{}", msg) } diff --git a/src/librustc/mir/interpret/error.rs b/src/librustc/mir/interpret/error.rs index 45819afca3f5c..bf5bae6b20c42 100644 --- a/src/librustc/mir/interpret/error.rs +++ b/src/librustc/mir/interpret/error.rs @@ -1,6 +1,7 @@ use std::{fmt, env}; use mir; +use middle::const_val::ConstEvalErr; use ty::{FnSig, Ty, layout}; use ty::layout::{Size, Align}; @@ -10,21 +11,50 @@ use super::{ use backtrace::Backtrace; -#[derive(Debug, Clone)] +#[derive(Debug, Clone, RustcEncodable, RustcDecodable)] pub struct EvalError<'tcx> { pub kind: EvalErrorKind<'tcx, u64>, - pub backtrace: Option, } impl<'tcx> From> for EvalError<'tcx> { fn from(kind: EvalErrorKind<'tcx, u64>) -> Self { - let backtrace = match env::var("MIRI_BACKTRACE") { - Ok(ref val) if !val.is_empty() => Some(Backtrace::new_unresolved()), - _ => None - }; + match env::var("MIRI_BACKTRACE") { + Ok(ref val) if !val.is_empty() => { + let backtrace = Backtrace::new(); + + use std::fmt::Write; + let mut trace_text = "\n\nAn error occurred in miri:\n".to_string(); + write!(trace_text, "backtrace frames: {}\n", backtrace.frames().len()).unwrap(); + 'frames: for (i, frame) in backtrace.frames().iter().enumerate() { + if frame.symbols().is_empty() { + write!(trace_text, "{}: no symbols\n", i).unwrap(); + } + for symbol in frame.symbols() { + write!(trace_text, "{}: ", i).unwrap(); + if let Some(name) = symbol.name() { + write!(trace_text, "{}\n", name).unwrap(); + } else { + write!(trace_text, "\n").unwrap(); + } + write!(trace_text, "\tat ").unwrap(); + if let Some(file_path) = symbol.filename() { + write!(trace_text, "{}", file_path.display()).unwrap(); + } else { + write!(trace_text, "").unwrap(); + } + if let Some(line) = symbol.lineno() { + write!(trace_text, ":{}\n", line).unwrap(); + } else { + write!(trace_text, "\n").unwrap(); + } + } + } + error!("{}", trace_text); + }, + _ => {}, + } EvalError { kind, - backtrace, } } } @@ -122,7 +152,7 @@ pub enum EvalErrorKind<'tcx, O> { TypeckError, /// Cannot compute this constant because it depends on another one /// which already produced an error - ReferencedConstant, + ReferencedConstant(ConstEvalErr<'tcx>), GeneratorResumedAfterReturn, GeneratorResumedAfterPanic, } @@ -238,7 +268,7 @@ impl<'tcx, O> EvalErrorKind<'tcx, O> { "there were unresolved type arguments during trait selection", TypeckError => "encountered constants with type errors, stopping evaluation", - ReferencedConstant => + ReferencedConstant(_) => "referenced constant has errors", Overflow(mir::BinOp::Add) => "attempt to add with overflow", Overflow(mir::BinOp::Sub) => "attempt to subtract with overflow", diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index dc4233436c660..f76b312ee530d 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -827,10 +827,13 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { } ConstEvalFailure(ref err) => { - if let ::middle::const_val::ErrKind::TypeckError = *err.kind { - return; + match err.struct_error( + self.tcx.at(span), + "could not evaluate constant expression", + ) { + Some(err) => err, + None => return, } - err.struct_error(self.tcx, span, "constant expression") } Overflow => { diff --git a/src/librustc/traits/fulfill.rs b/src/librustc/traits/fulfill.rs index 4447a2b6ed140..dff89f3c888a7 100644 --- a/src/librustc/traits/fulfill.rs +++ b/src/librustc/traits/fulfill.rs @@ -534,8 +534,7 @@ fn process_predicate<'a, 'gcx, 'tcx>( } else { Err(CodeSelectionError(ConstEvalFailure(ConstEvalErr { span: obligation.cause.span, - kind: ErrKind::UnimplementedConstVal("could not resolve") - .into(), + kind: ErrKind::CouldNotResolve.into(), }))) } }, diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 0bb0208e2a1b4..f947ed4568624 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -2075,15 +2075,17 @@ impl<'a, 'gcx, 'tcx> AdtDef { } else { info!("invalid enum discriminant: {:#?}", val); ::middle::const_val::struct_error( - tcx, - tcx.def_span(expr_did), + tcx.at(tcx.def_span(expr_did)), "constant evaluation of enum discriminant resulted in non-integer", ).emit(); None } } Err(err) => { - err.report(tcx, tcx.def_span(expr_did), "enum discriminant"); + err.report_as_error( + tcx.at(tcx.def_span(expr_did)), + "could not evaluate enum discriminant", + ); if !expr_did.is_local() { span_bug!(tcx.def_span(expr_did), "variant discriminant evaluation succeeded \ diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs index e77ede72143b1..79a6311185076 100644 --- a/src/librustc/ty/structural_impls.rs +++ b/src/librustc/ty/structural_impls.rs @@ -476,7 +476,6 @@ impl<'a, 'tcx> Lift<'tcx> for interpret::EvalError<'a> { fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option { Some(interpret::EvalError { kind: tcx.lift(&self.kind)?, - backtrace: self.backtrace.clone(), }) } } @@ -578,7 +577,7 @@ impl<'a, 'tcx, O: Lift<'tcx>> Lift<'tcx> for interpret::EvalErrorKind<'a, O> { PathNotFound(ref v) => PathNotFound(v.clone()), UnimplementedTraitSelection => UnimplementedTraitSelection, TypeckError => TypeckError, - ReferencedConstant => ReferencedConstant, + ReferencedConstant(ref err) => ReferencedConstant(tcx.lift(err)?), OverflowNeg => OverflowNeg, Overflow(op) => Overflow(op), DivisionByZero => DivisionByZero, @@ -595,14 +594,7 @@ impl<'a, 'tcx> Lift<'tcx> for const_val::ErrKind<'a> { use middle::const_val::ErrKind::*; Some(match *self { - NonConstPath => NonConstPath, - UnimplementedConstVal(s) => UnimplementedConstVal(s), - IndexOutOfBounds { len, index } => IndexOutOfBounds { len, index }, - - LayoutError(ref e) => { - return tcx.lift(e).map(LayoutError) - } - + CouldNotResolve => CouldNotResolve, TypeckError => TypeckError, CheckMatchError => CheckMatchError, Miri(ref e, ref frames) => return tcx.lift(e).map(|e| Miri(e, frames.clone())), diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index 18026a14259de..8493190796435 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -147,7 +147,7 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &'a BorrowckCtxt<'a, 'tcx>, } Categorization::Interior(ref b, mc::InteriorElement(ik)) => { bccx.cannot_move_out_of_interior_noncopy( - move_from.span, b.ty, ik == Kind::Index, Origin::Ast) + move_from.span, b.ty, Some(ik == Kind::Index), Origin::Ast) } Categorization::Downcast(ref b, _) | diff --git a/src/librustc_codegen_llvm/mir/constant.rs b/src/librustc_codegen_llvm/mir/constant.rs index ef0bc3ed3306a..7c1035e2fcb88 100644 --- a/src/librustc_codegen_llvm/mir/constant.rs +++ b/src/librustc_codegen_llvm/mir/constant.rs @@ -217,7 +217,10 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> { Ok((llval, constant.ty)) }) .unwrap_or_else(|e| { - e.report(bx.tcx(), constant.span, "shuffle_indices"); + e.report_as_error( + bx.tcx().at(constant.span), + "could not evaluate shuffle_indices at compile time", + ); // We've errored, so we don't have to produce working code. let ty = self.monomorphize(&constant.ty); let llty = bx.cx.layout_of(ty).llvm_type(bx.cx); diff --git a/src/librustc_codegen_llvm/mir/operand.rs b/src/librustc_codegen_llvm/mir/operand.rs index 98383e882c4e8..9f32b41cb13e7 100644 --- a/src/librustc_codegen_llvm/mir/operand.rs +++ b/src/librustc_codegen_llvm/mir/operand.rs @@ -416,7 +416,10 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> { // FIXME: generate a panic here }, mir::Literal::Value { .. } => { - err.report(bx.tcx(), constant.span, "const operand"); + err.report_as_error( + bx.tcx().at(constant.span), + "could not evaluate constant operand", + ); }, } // We've errored, so we don't have to produce working code. diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 79c7a79114761..d788e312d155a 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -1501,24 +1501,11 @@ fn check_const(cx: &LateContext, body_id: hir::BodyId, what: &str) { }; if let Err(err) = cx.tcx.const_eval(param_env.and(cid)) { let span = cx.tcx.def_span(def_id); - let mut diag = cx.struct_span_lint( - CONST_ERR, - span, + err.report_as_lint( + cx.tcx.at(span), &format!("this {} cannot be used", what), + cx.current_lint_root(), ); - use rustc::middle::const_val::ConstEvalErrDescription; - match err.description() { - ConstEvalErrDescription::Simple(message) => { - diag.span_label(span, message); - } - ConstEvalErrDescription::Backtrace(miri, frames) => { - diag.span_label(span, format!("{}", miri)); - for frame in frames { - diag.span_label(frame.span, format!("inside call to `{}`", frame.location)); - } - } - } - diag.emit() } } diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs index 5efbdeafd1bbf..ba0557d062f24 100644 --- a/src/librustc_mir/borrow_check/mod.rs +++ b/src/librustc_mir/borrow_check/mod.rs @@ -132,14 +132,21 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>( IllegalMoveOriginKind::Static => { tcx.cannot_move_out_of(span, "static item", origin) } - IllegalMoveOriginKind::BorrowedContent => { - tcx.cannot_move_out_of(span, "borrowed content", origin) + IllegalMoveOriginKind::BorrowedContent { target_ty: ty } => { + // Inspect the type of the content behind the + // borrow to provide feedback about why this + // was a move rather than a copy. + match ty.sty { + ty::TyArray(..) | ty::TySlice(..) => + tcx.cannot_move_out_of_interior_noncopy(span, ty, None, origin), + _ => tcx.cannot_move_out_of(span, "borrowed content", origin) + } } IllegalMoveOriginKind::InteriorOfTypeWithDestructor { container_ty: ty } => { tcx.cannot_move_out_of_interior_of_drop(span, ty, origin) } IllegalMoveOriginKind::InteriorOfSliceOrArray { ty, is_index } => { - tcx.cannot_move_out_of_interior_noncopy(span, ty, is_index, origin) + tcx.cannot_move_out_of_interior_noncopy(span, ty, Some(is_index), origin) } }; err.emit(); diff --git a/src/librustc_mir/dataflow/move_paths/builder.rs b/src/librustc_mir/dataflow/move_paths/builder.rs index 2ff22842141d9..590f9917015dc 100644 --- a/src/librustc_mir/dataflow/move_paths/builder.rs +++ b/src/librustc_mir/dataflow/move_paths/builder.rs @@ -119,8 +119,8 @@ impl<'b, 'a, 'gcx, 'tcx> Gatherer<'b, 'a, 'gcx, 'tcx> { } fn create_move_path(&mut self, place: &Place<'tcx>) { - // This is an assignment, not a move, so this not being a valid - // move path is OK. + // This is an non-moving access (such as an overwrite or + // drop), so this not being a valid move path is OK. let _ = self.move_path_for(place); } @@ -135,8 +135,9 @@ impl<'b, 'a, 'gcx, 'tcx> Gatherer<'b, 'a, 'gcx, 'tcx> { let place_ty = proj.base.ty(mir, tcx).to_ty(tcx); match place_ty.sty { ty::TyRef(..) | ty::TyRawPtr(..) => - return Err(MoveError::cannot_move_out_of(mir.source_info(self.loc).span, - BorrowedContent)), + return Err(MoveError::cannot_move_out_of( + mir.source_info(self.loc).span, + BorrowedContent { target_ty: place.ty(mir, tcx).to_ty(tcx) })), ty::TyAdt(adt, _) if adt.has_dtor(tcx) && !adt.is_box() => return Err(MoveError::cannot_move_out_of(mir.source_info(self.loc).span, InteriorOfTypeWithDestructor { diff --git a/src/librustc_mir/dataflow/move_paths/mod.rs b/src/librustc_mir/dataflow/move_paths/mod.rs index 610963af9e13c..a73e47bc16ab2 100644 --- a/src/librustc_mir/dataflow/move_paths/mod.rs +++ b/src/librustc_mir/dataflow/move_paths/mod.rs @@ -277,9 +277,23 @@ pub struct IllegalMoveOrigin<'tcx> { #[derive(Debug)] pub(crate) enum IllegalMoveOriginKind<'tcx> { + /// Illegal move due to attempt to move from `static` variable. Static, - BorrowedContent, + + /// Illegal move due to attempt to move from behind a reference. + BorrowedContent { + /// The content's type: if erroneous code was trying to move + /// from `*x` where `x: &T`, then this will be `T`. + target_ty: ty::Ty<'tcx>, + }, + + /// Illegal move due to attempt to move from field of an ADT that + /// implements `Drop`. Rust maintains invariant that all `Drop` + /// ADT's remain fully-initialized so that user-defined destructor + /// can safely read from all of the ADT's fields. InteriorOfTypeWithDestructor { container_ty: ty::Ty<'tcx> }, + + /// Illegal move due to attempt to move out of a slice or array. InteriorOfSliceOrArray { ty: ty::Ty<'tcx>, is_index: bool, }, } diff --git a/src/librustc_mir/hair/cx/expr.rs b/src/librustc_mir/hair/cx/expr.rs index f6f98f0732e3a..f23e10ae5d2d8 100644 --- a/src/librustc_mir/hair/cx/expr.rs +++ b/src/librustc_mir/hair/cx/expr.rs @@ -523,7 +523,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>, let count = match cx.tcx.at(span).const_eval(cx.param_env.and(global_id)) { Ok(cv) => cv.unwrap_usize(cx.tcx), Err(e) => { - e.report(cx.tcx, cx.tcx.def_span(def_id), "array length"); + e.report_as_error(cx.tcx.at(span), "could not evaluate array length"); 0 }, }; diff --git a/src/librustc_mir/hair/pattern/check_match.rs b/src/librustc_mir/hair/pattern/check_match.rs index 0a1139700984d..7cef8a75aa6ba 100644 --- a/src/librustc_mir/hair/pattern/check_match.rs +++ b/src/librustc_mir/hair/pattern/check_match.rs @@ -141,13 +141,13 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> { PatternError::FloatBug => { // FIXME(#31407) this is only necessary because float parsing is buggy ::rustc::middle::const_val::struct_error( - self.tcx, pat_span, + self.tcx.at(pat_span), "could not evaluate float literal (see issue #31407)", ).emit(); } PatternError::NonConstPath(span) => { ::rustc::middle::const_val::struct_error( - self.tcx, span, + self.tcx.at(span), "runtime values cannot be referenced in patterns", ).emit(); } diff --git a/src/librustc_mir/hair/pattern/mod.rs b/src/librustc_mir/hair/pattern/mod.rs index 4cfe74413dfa5..7dae79530c488 100644 --- a/src/librustc_mir/hair/pattern/mod.rs +++ b/src/librustc_mir/hair/pattern/mod.rs @@ -695,7 +695,10 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> { return self.const_to_pat(instance, value, id, span) }, Err(err) => { - err.report(self.tcx, span, "pattern"); + err.report_as_error( + self.tcx.at(span), + "could not evaluate constant pattern", + ); PatternKind::Wild }, } diff --git a/src/librustc_mir/interpret/const_eval.rs b/src/librustc_mir/interpret/const_eval.rs index 44832df824064..3fcf1b5c8ed59 100644 --- a/src/librustc_mir/interpret/const_eval.rs +++ b/src/librustc_mir/interpret/const_eval.rs @@ -65,34 +65,12 @@ pub fn eval_promoted<'a, 'mir, 'tcx>( cid: GlobalId<'tcx>, mir: &'mir mir::Mir<'tcx>, param_env: ty::ParamEnv<'tcx>, -) -> Option<(Value, Scalar, Ty<'tcx>)> { +) -> EvalResult<'tcx, (Value, Scalar, Ty<'tcx>)> { ecx.with_fresh_body(|ecx| { - let res = eval_body_using_ecx(ecx, cid, Some(mir), param_env); - match res { - Ok(val) => Some(val), - Err(mut err) => { - ecx.report(&mut err, false, None); - None - } - } + eval_body_using_ecx(ecx, cid, Some(mir), param_env) }) } -pub fn eval_body<'a, 'tcx>( - tcx: TyCtxt<'a, 'tcx, 'tcx>, - cid: GlobalId<'tcx>, - param_env: ty::ParamEnv<'tcx>, -) -> Option<(Value, Scalar, Ty<'tcx>)> { - let (res, ecx) = eval_body_and_ecx(tcx, cid, None, param_env); - match res { - Ok(val) => Some(val), - Err(mut err) => { - ecx.report(&mut err, true, None); - None - } - } -} - pub fn value_to_const_value<'tcx>( ecx: &EvalContext<'_, '_, 'tcx, CompileTimeEvaluator>, val: Value, @@ -124,9 +102,17 @@ pub fn value_to_const_value<'tcx>( })(); match val { Ok(val) => ty::Const::from_const_value(ecx.tcx.tcx, val, ty), - Err(mut err) => { - ecx.report(&mut err, true, None); - bug!("miri error occured when converting Value to ConstValue") + Err(err) => { + let (frames, span) = ecx.generate_stacktrace(None); + let err = ConstEvalErr { + span, + kind: ErrKind::Miri(err, frames).into(), + }; + err.report_as_error( + ecx.tcx, + "failed to convert Value to ConstValue, this is a bug", + ); + span_bug!(span, "miri error occured when converting Value to ConstValue") } } } @@ -578,16 +564,17 @@ pub fn const_eval_provider<'a, 'tcx>( val = ecx.try_read_by_ref(val, miri_ty)?; } Ok(value_to_const_value(&ecx, val, miri_ty)) - }).map_err(|mut err| { - if tcx.is_static(def_id).is_some() { - ecx.report(&mut err, true, None); - } + }).map_err(|err| { let (trace, span) = ecx.generate_stacktrace(None); let err = ErrKind::Miri(err, trace); - ConstEvalErr { + let err = ConstEvalErr { kind: err.into(), span, + }; + if tcx.is_static(def_id).is_some() { + err.report_as_error(ecx.tcx, "could not evaluate static initializer"); } + err }) } diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs index 632f7abfdb499..3e91fa72cae58 100644 --- a/src/librustc_mir/interpret/eval_context.rs +++ b/src/librustc_mir/interpret/eval_context.rs @@ -3,7 +3,7 @@ use std::fmt::Write; use rustc::hir::def_id::DefId; use rustc::hir::def::Def; use rustc::hir::map::definitions::DefPathData; -use rustc::middle::const_val::{ConstVal, ErrKind}; +use rustc::middle::const_val::ConstVal; use rustc::mir; use rustc::ty::layout::{self, Size, Align, HasDataLayout, IntegerExt, LayoutOf, TyLayout}; use rustc::ty::subst::{Subst, Substs}; @@ -15,7 +15,7 @@ use syntax::codemap::{self, Span}; use syntax::ast::Mutability; use rustc::mir::interpret::{ GlobalId, Value, Scalar, - EvalError, EvalResult, EvalErrorKind, Pointer, ConstValue, + EvalResult, EvalErrorKind, Pointer, ConstValue, }; use std::mem; @@ -1056,15 +1056,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M } else { self.param_env }; - self.tcx.const_eval(param_env.and(gid)).map_err(|err| match *err.kind { - ErrKind::Miri(ref err, _) => match err.kind { - EvalErrorKind::TypeckError | - EvalErrorKind::Layout(_) => EvalErrorKind::TypeckError.into(), - _ => EvalErrorKind::ReferencedConstant.into(), - }, - ErrKind::TypeckError => EvalErrorKind::TypeckError.into(), - ref other => bug!("const eval returned {:?}", other), - }) + self.tcx.const_eval(param_env.and(gid)).map_err(|err| EvalErrorKind::ReferencedConstant(err).into()) } pub fn force_allocation(&mut self, place: Place) -> EvalResult<'tcx, Place> { @@ -1626,7 +1618,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M let mut last_span = None; let mut frames = Vec::new(); // skip 1 because the last frame is just the environment of the constant - for &Frame { instance, span, .. } in self.stack().iter().skip(1).rev() { + for &Frame { instance, span, mir, block, stmt, .. } in self.stack().iter().skip(1).rev() { // make sure we don't emit frames that are duplicates of the previous if explicit_span == Some(span) { last_span = Some(span); @@ -1644,82 +1636,20 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M } else { instance.to_string() }; - frames.push(FrameInfo { span, location }); - } - trace!("generate stacktrace: {:#?}, {:?}", frames, explicit_span); - (frames, self.tcx.span) - } - - pub fn report(&self, e: &mut EvalError, as_err: bool, explicit_span: Option) { - match e.kind { - EvalErrorKind::Layout(_) | - EvalErrorKind::TypeckError => return, - _ => {}, - } - if let Some(ref mut backtrace) = e.backtrace { - let mut trace_text = "\n\nAn error occurred in miri:\n".to_string(); - backtrace.resolve(); - write!(trace_text, "backtrace frames: {}\n", backtrace.frames().len()).unwrap(); - 'frames: for (i, frame) in backtrace.frames().iter().enumerate() { - if frame.symbols().is_empty() { - write!(trace_text, "{}: no symbols\n", i).unwrap(); - } - for symbol in frame.symbols() { - write!(trace_text, "{}: ", i).unwrap(); - if let Some(name) = symbol.name() { - write!(trace_text, "{}\n", name).unwrap(); - } else { - write!(trace_text, "\n").unwrap(); - } - write!(trace_text, "\tat ").unwrap(); - if let Some(file_path) = symbol.filename() { - write!(trace_text, "{}", file_path.display()).unwrap(); - } else { - write!(trace_text, "").unwrap(); - } - if let Some(line) = symbol.lineno() { - write!(trace_text, ":{}\n", line).unwrap(); - } else { - write!(trace_text, "\n").unwrap(); - } - } - } - error!("{}", trace_text); - } - if let Some(frame) = self.stack().last() { - let block = &frame.mir.basic_blocks()[frame.block]; - let span = explicit_span.unwrap_or_else(|| if frame.stmt < block.statements.len() { - block.statements[frame.stmt].source_info.span - } else { - block.terminator().source_info.span - }); - trace!("reporting const eval failure at {:?}", span); - let mut err = if as_err { - ::rustc::middle::const_val::struct_error(*self.tcx, span, "constant evaluation error") + let block = &mir.basic_blocks()[block]; + let source_info = if stmt < block.statements.len() { + block.statements[stmt].source_info } else { - let node_id = self - .stack() - .iter() - .rev() - .filter_map(|frame| self.tcx.hir.as_local_node_id(frame.instance.def_id())) - .next() - .expect("some part of a failing const eval must be local"); - self.tcx.struct_span_lint_node( - ::rustc::lint::builtin::CONST_ERR, - node_id, - span, - "constant evaluation error", - ) + block.terminator().source_info }; - let (frames, span) = self.generate_stacktrace(explicit_span); - err.span_label(span, e.to_string()); - for FrameInfo { span, location } in frames { - err.span_note(span, &format!("inside call to `{}`", location)); - } - err.emit(); - } else { - self.tcx.sess.err(&e.to_string()); + let lint_root = match mir.source_scope_local_data { + mir::ClearCrossCrate::Set(ref ivs) => Some(ivs[source_info.scope].lint_root), + mir::ClearCrossCrate::Clear => None, + }; + frames.push(FrameInfo { span, location, lint_root }); } + trace!("generate stacktrace: {:#?}, {:?}", frames, explicit_span); + (frames, self.tcx.span) } pub fn sign_extend(&self, value: u128, ty: Ty<'tcx>) -> EvalResult<'tcx, u128> { diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs index dc56de47fbf63..ec308c2193d56 100644 --- a/src/librustc_mir/interpret/memory.rs +++ b/src/librustc_mir/interpret/memory.rs @@ -7,7 +7,7 @@ use rustc::ty::ParamEnv; use rustc::ty::maps::TyCtxtAt; use rustc::ty::layout::{self, Align, TargetDataLayout, Size}; use syntax::ast::Mutability; -use rustc::middle::const_val::{ConstVal, ErrKind}; +use rustc::middle::const_val::ConstVal; use rustc_data_structures::fx::{FxHashSet, FxHashMap}; use rustc::mir::interpret::{Pointer, AllocId, Allocation, AccessKind, Value, @@ -285,16 +285,10 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> { instance, promoted: None, }; - self.tcx.const_eval(ParamEnv::reveal_all().and(gid)).map_err(|err| { - match *err.kind { - ErrKind::Miri(ref err, _) => match err.kind { - EvalErrorKind::TypeckError | - EvalErrorKind::Layout(_) => EvalErrorKind::TypeckError.into(), - _ => EvalErrorKind::ReferencedConstant.into(), - }, - ErrKind::TypeckError => EvalErrorKind::TypeckError.into(), - ref other => bug!("const eval returned {:?}", other), - } + self.tcx.const_eval(ParamEnv::reveal_all().and(gid)).map_err(|_| { + // no need to report anything, the const_eval call takes care of that for statics + assert!(self.tcx.is_static(def_id).is_some()); + EvalErrorKind::TypeckError.into() }).map(|val| { let const_val = match val.val { ConstVal::Value(val) => val, diff --git a/src/librustc_mir/interpret/mod.rs b/src/librustc_mir/interpret/mod.rs index b5b4ac6df6b5e..3afcd6f2d9bb5 100644 --- a/src/librustc_mir/interpret/mod.rs +++ b/src/librustc_mir/interpret/mod.rs @@ -21,7 +21,6 @@ pub use self::memory::{Memory, MemoryKind, HasMemory}; pub use self::const_eval::{ eval_promoted, mk_borrowck_eval_cx, - eval_body, CompileTimeEvaluator, const_value_to_allocation_provider, const_eval_provider, diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index a8a50e14c6822..a8a50c50f592e 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -388,7 +388,10 @@ fn collect_items_rec<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, Ok(val) => collect_const(tcx, val, instance.substs, &mut neighbors), Err(err) => { let span = tcx.def_span(def_id); - err.report(tcx, span, "static"); + err.report_as_error( + tcx.at(span), + "could not evaluate static initializer", + ); } } } @@ -1187,13 +1190,25 @@ fn collect_neighbours<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let param_env = ty::ParamEnv::reveal_all(); for i in 0..mir.promoted.len() { use rustc_data_structures::indexed_vec::Idx; + let i = Promoted::new(i); let cid = GlobalId { instance, - promoted: Some(Promoted::new(i)), + promoted: Some(i), }; match tcx.const_eval(param_env.and(cid)) { Ok(val) => collect_const(tcx, val, instance.substs, output), - Err(_) => {}, + Err(err) => { + use rustc::middle::const_val::ErrKind; + use rustc::mir::interpret::EvalErrorKind; + if let ErrKind::Miri(ref miri, ..) = *err.kind { + if let EvalErrorKind::ReferencedConstant(_) = miri.kind { + err.report_as_error( + tcx.at(mir.promoted[i].span), + "erroneous constant used", + ); + } + } + }, } } } @@ -1236,7 +1251,10 @@ fn collect_const<'a, 'tcx>( Ok(val) => val.val, Err(err) => { let span = tcx.def_span(def_id); - err.report(tcx, span, "constant"); + err.report_as_error( + tcx.at(span), + "constant evaluation error", + ); return; } } diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs index d39042ceba99f..2438281508461 100644 --- a/src/librustc_mir/transform/const_prop.rs +++ b/src/librustc_mir/transform/const_prop.rs @@ -17,7 +17,7 @@ use rustc::mir::{Constant, Literal, Location, Place, Mir, Operand, Rvalue, Local use rustc::mir::{NullOp, StatementKind, Statement, BasicBlock, LocalKind}; use rustc::mir::{TerminatorKind, ClearCrossCrate, SourceInfo, BinOp, ProjectionElem}; use rustc::mir::visit::{Visitor, PlaceContext}; -use rustc::middle::const_val::ConstVal; +use rustc::middle::const_val::{ConstVal, ConstEvalErr, ErrKind}; use rustc::ty::{TyCtxt, self, Instance}; use rustc::mir::interpret::{Value, Scalar, GlobalId, EvalResult}; use interpret::EvalContext; @@ -121,17 +121,37 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { fn use_ecx( &mut self, - span: Span, + source_info: SourceInfo, f: F ) -> Option where F: FnOnce(&mut Self) -> EvalResult<'tcx, T>, { - self.ecx.tcx.span = span; + self.ecx.tcx.span = source_info.span; + let lint_root = match self.mir.source_scope_local_data { + ClearCrossCrate::Set(ref ivs) => { + use rustc_data_structures::indexed_vec::Idx; + //FIXME(#51314): remove this check + if source_info.scope.index() >= ivs.len() { + return None; + } + ivs[source_info.scope].lint_root + }, + ClearCrossCrate::Clear => return None, + }; let r = match f(self) { Ok(val) => Some(val), - Err(mut err) => { - self.ecx.report(&mut err, false, Some(span)); + Err(err) => { + let (frames, span) = self.ecx.generate_stacktrace(None); + let err = ConstEvalErr { + span, + kind: ErrKind::Miri(err, frames).into(), + }; + err.report_as_lint( + self.ecx.tcx, + "this expression will panic at runtime", + lint_root, + ); None }, }; @@ -139,30 +159,37 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { r } - fn const_eval(&mut self, cid: GlobalId<'tcx>, span: Span) -> Option> { + fn const_eval(&mut self, cid: GlobalId<'tcx>, source_info: SourceInfo) -> Option> { let value = match self.tcx.const_eval(self.param_env.and(cid)) { Ok(val) => val, Err(err) => { - err.report(self.tcx, err.span, "constant propagated"); + err.report_as_error( + self.tcx.at(err.span), + "constant evaluation error", + ); return None; }, }; let val = match value.val { ConstVal::Value(v) => { - self.use_ecx(span, |this| this.ecx.const_value_to_value(v, value.ty))? + self.use_ecx(source_info, |this| this.ecx.const_value_to_value(v, value.ty))? }, _ => bug!("eval produced: {:?}", value), }; - let val = (val, value.ty, span); + let val = (val, value.ty, source_info.span); trace!("evaluated {:?} to {:?}", cid, val); Some(val) } - fn eval_constant(&mut self, c: &Constant<'tcx>) -> Option> { + fn eval_constant( + &mut self, + c: &Constant<'tcx>, + source_info: SourceInfo, + ) -> Option> { match c.literal { Literal::Value { value } => match value.val { ConstVal::Value(v) => { - let v = self.use_ecx(c.span, |this| { + let v = self.use_ecx(source_info, |this| { this.ecx.const_value_to_value(v, value.ty) })?; Some((v, value.ty, c.span)) @@ -178,7 +205,7 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { instance, promoted: None, }; - self.const_eval(cid, c.span) + self.const_eval(cid, source_info) }, }, // evaluate the promoted and replace the constant with the evaluated result @@ -196,10 +223,9 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { }; // cannot use `const_eval` here, because that would require having the MIR // for the current function available, but we're producing said MIR right now - let span = self.mir.span; - let (value, _, ty) = self.use_ecx(span, |this| { - Ok(eval_promoted(&mut this.ecx, cid, this.mir, this.param_env)) - })??; + let (value, _, ty) = self.use_ecx(source_info, |this| { + eval_promoted(&mut this.ecx, cid, this.mir, this.param_env) + })?; let val = (value, ty, c.span); trace!("evaluated {:?} to {:?}", c, val); Some(val) @@ -207,14 +233,14 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { } } - fn eval_place(&mut self, place: &Place<'tcx>) -> Option> { + fn eval_place(&mut self, place: &Place<'tcx>, source_info: SourceInfo) -> Option> { match *place { Place::Local(loc) => self.places[loc].clone(), Place::Projection(ref proj) => match proj.elem { ProjectionElem::Field(field, _) => { trace!("field proj on {:?}", proj.base); - let (base, ty, span) = self.eval_place(&proj.base)?; - let valty = self.use_ecx(span, |this| { + let (base, ty, span) = self.eval_place(&proj.base, source_info)?; + let valty = self.use_ecx(source_info, |this| { this.ecx.read_field(base, None, field, ty) })?; Some((valty.value, valty.ty, span)) @@ -225,10 +251,11 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { } } - fn eval_operand(&mut self, op: &Operand<'tcx>) -> Option> { + fn eval_operand(&mut self, op: &Operand<'tcx>, source_info: SourceInfo) -> Option> { match *op { - Operand::Constant(ref c) => self.eval_constant(c), - Operand::Move(ref place) | Operand::Copy(ref place) => self.eval_place(place), + Operand::Constant(ref c) => self.eval_constant(c, source_info), + | Operand::Move(ref place) + | Operand::Copy(ref place) => self.eval_place(place, source_info), } } @@ -243,10 +270,10 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { // This branch exists for the sanity type check Rvalue::Use(Operand::Constant(ref c)) => { assert_eq!(c.ty, place_ty); - self.eval_constant(c) + self.eval_constant(c, source_info) }, Rvalue::Use(ref op) => { - self.eval_operand(op) + self.eval_operand(op, source_info) }, Rvalue::Repeat(..) | Rvalue::Ref(..) | @@ -279,17 +306,17 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { return None; } - let val = self.eval_operand(arg)?; - let prim = self.use_ecx(span, |this| { + let val = self.eval_operand(arg, source_info)?; + let prim = self.use_ecx(source_info, |this| { this.ecx.value_to_scalar(ValTy { value: val.0, ty: val.1 }) })?; - let val = self.use_ecx(span, |this| this.ecx.unary_op(op, prim, val.1))?; + let val = self.use_ecx(source_info, |this| this.ecx.unary_op(op, prim, val.1))?; Some((Value::Scalar(val), place_ty, span)) } Rvalue::CheckedBinaryOp(op, ref left, ref right) | Rvalue::BinaryOp(op, ref left, ref right) => { trace!("rvalue binop {:?} for {:?} and {:?}", op, left, right); - let right = self.eval_operand(right)?; + let right = self.eval_operand(right, source_info)?; let def_id = if self.tcx.is_closure(self.source.def_id) { self.tcx.closure_base_def_id(self.source.def_id) } else { @@ -301,7 +328,7 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { return None; } - let r = self.use_ecx(span, |this| { + let r = self.use_ecx(source_info, |this| { this.ecx.value_to_scalar(ValTy { value: right.0, ty: right.1 }) })?; if op == BinOp::Shr || op == BinOp::Shl { @@ -332,12 +359,12 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { return None; } } - let left = self.eval_operand(left)?; - let l = self.use_ecx(span, |this| { + let left = self.eval_operand(left, source_info)?; + let l = self.use_ecx(source_info, |this| { this.ecx.value_to_scalar(ValTy { value: left.0, ty: left.1 }) })?; trace!("const evaluating {:?} for {:?} and {:?}", op, left, right); - let (val, overflow) = self.use_ecx(span, |this| { + let (val, overflow) = self.use_ecx(source_info, |this| { this.ecx.binary_op(op, l, left.1, r, right.1) })?; let val = if let Rvalue::CheckedBinaryOp(..) = *rvalue { @@ -348,11 +375,8 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { } else { if overflow { use rustc::mir::interpret::EvalErrorKind; - let mut err = EvalErrorKind::Overflow(op).into(); - self.use_ecx(span, |this| { - this.ecx.report(&mut err, false, Some(span)); - Ok(()) - }); + let err = EvalErrorKind::Overflow(op).into(); + let _: Option<()> = self.use_ecx(source_info, |_| Err(err)); return None; } Value::Scalar(val) @@ -431,7 +455,8 @@ impl<'b, 'a, 'tcx> Visitor<'tcx> for ConstPropagator<'b, 'a, 'tcx> { ) { trace!("visit_constant: {:?}", constant); self.super_constant(constant, location); - self.eval_constant(constant); + let source_info = *self.mir.source_info(location); + self.eval_constant(constant, source_info); } fn visit_statement( @@ -466,8 +491,9 @@ impl<'b, 'a, 'tcx> Visitor<'tcx> for ConstPropagator<'b, 'a, 'tcx> { location: Location, ) { self.super_terminator_kind(block, kind, location); + let source_info = *self.mir.source_info(location); if let TerminatorKind::Assert { expected, msg, cond, .. } = kind { - if let Some(value) = self.eval_operand(cond) { + if let Some(value) = self.eval_operand(cond, source_info) { trace!("assertion on {:?} should be {:?}", value, expected); if Value::Scalar(Scalar::from_bool(*expected)) != value.0 { // poison all places this operand references so that further code @@ -502,13 +528,15 @@ impl<'b, 'a, 'tcx> Visitor<'tcx> for ConstPropagator<'b, 'a, 'tcx> { DivisionByZero | RemainderByZero => msg.description().to_owned(), BoundsCheck { ref len, ref index } => { - let len = self.eval_operand(len).expect("len must be const"); + let len = self + .eval_operand(len, source_info) + .expect("len must be const"); let len = match len.0 { Value::Scalar(Scalar::Bits { bits, ..}) => bits, _ => bug!("const len not primitive: {:?}", len), }; let index = self - .eval_operand(index) + .eval_operand(index, source_info) .expect("index must be const"); let index = match index.0 { Value::Scalar(Scalar::Bits { bits, .. }) => bits, diff --git a/src/librustc_mir/util/borrowck_errors.rs b/src/librustc_mir/util/borrowck_errors.rs index d6b3e674f8f80..d01b90ad2628e 100644 --- a/src/librustc_mir/util/borrowck_errors.rs +++ b/src/librustc_mir/util/borrowck_errors.rs @@ -312,15 +312,19 @@ pub trait BorrowckErrors<'cx>: Sized + Copy { self.cancel_if_wrong_origin(err, o) } + /// Signal an error due to an attempt to move out of the interior + /// of an array or slice. `is_index` is None when error origin + /// didn't capture whether there was an indexing operation or not. fn cannot_move_out_of_interior_noncopy(self, move_from_span: Span, ty: ty::Ty, - is_index: bool, + is_index: Option, o: Origin) -> DiagnosticBuilder<'cx> { let type_name = match (&ty.sty, is_index) { - (&ty::TyArray(_, _), true) => "array", + (&ty::TyArray(_, _), Some(true)) | + (&ty::TyArray(_, _), None) => "array", (&ty::TySlice(_), _) => "slice", _ => span_bug!(move_from_span, "this path should not cause illegal move"), }; diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index c2c71d90f0674..83a654aaae9ca 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -4040,7 +4040,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { let count = tcx.const_eval(param_env.and(global_id)); if let Err(ref err) = count { - err.report(tcx, tcx.def_span(count_def_id), "constant expression"); + err.report_as_error( + tcx.at(tcx.def_span(count_def_id)), + "could not evaluate repeat length", + ); } let uty = match expected { diff --git a/src/libstd/build.rs b/src/libstd/build.rs index c34877d369c93..c001e4e8cebf9 100644 --- a/src/libstd/build.rs +++ b/src/libstd/build.rs @@ -74,7 +74,6 @@ fn main() { } println!("cargo:rustc-link-lib=zircon"); println!("cargo:rustc-link-lib=fdio"); - println!("cargo:rustc-link-lib=launchpad"); // for std::process } else if target.contains("cloudabi") { if cfg!(feature = "backtrace") { println!("cargo:rustc-link-lib=unwind"); diff --git a/src/libstd/sys/unix/process/process_fuchsia.rs b/src/libstd/sys/unix/process/process_fuchsia.rs index 06c0540fec0d7..0fbeb8603a99b 100644 --- a/src/libstd/sys/unix/process/process_fuchsia.rs +++ b/src/libstd/sys/unix/process/process_fuchsia.rs @@ -56,68 +56,49 @@ impl Command { -> io::Result { use sys::process::zircon::*; - let job_handle = zx_job_default(); let envp = match maybe_envp { Some(envp) => envp.as_ptr(), None => ptr::null(), }; - // To make sure launchpad_destroy gets called on the launchpad if this function fails - struct LaunchpadDestructor(*mut launchpad_t); - impl Drop for LaunchpadDestructor { - fn drop(&mut self) { unsafe { launchpad_destroy(self.0); } } - } - - // Duplicate the job handle - let mut job_copy: zx_handle_t = ZX_HANDLE_INVALID; - zx_cvt(zx_handle_duplicate(job_handle, ZX_RIGHT_SAME_RIGHTS, &mut job_copy))?; - // Create a launchpad - let mut launchpad: *mut launchpad_t = ptr::null_mut(); - zx_cvt(launchpad_create(job_copy, self.get_argv()[0], &mut launchpad))?; - let launchpad_destructor = LaunchpadDestructor(launchpad); - - // Set the process argv - zx_cvt(launchpad_set_args(launchpad, self.get_argv().len() as i32 - 1, - self.get_argv().as_ptr()))?; - // Setup the environment vars - zx_cvt(launchpad_set_environ(launchpad, envp))?; - zx_cvt(launchpad_add_vdso_vmo(launchpad))?; - // Load the executable - zx_cvt(launchpad_elf_load(launchpad, launchpad_vmo_from_file(self.get_argv()[0])))?; - zx_cvt(launchpad_load_vdso(launchpad, ZX_HANDLE_INVALID))?; - zx_cvt(launchpad_clone(launchpad, LP_CLONE_FDIO_NAMESPACE | LP_CLONE_FDIO_CWD))?; + let transfer_or_clone = |opt_fd, target_fd| if let Some(local_fd) = opt_fd { + fdio_spawn_action_t { + action: FDIO_SPAWN_ACTION_TRANSFER_FD, + local_fd, + target_fd, + ..Default::default() + } + } else { + fdio_spawn_action_t { + action: FDIO_SPAWN_ACTION_CLONE_FD, + local_fd: target_fd, + target_fd, + ..Default::default() + } + }; // Clone stdin, stdout, and stderr - if let Some(fd) = stdio.stdin.fd() { - zx_cvt(launchpad_transfer_fd(launchpad, fd, 0))?; - } else { - zx_cvt(launchpad_clone_fd(launchpad, 0, 0))?; - } - if let Some(fd) = stdio.stdout.fd() { - zx_cvt(launchpad_transfer_fd(launchpad, fd, 1))?; - } else { - zx_cvt(launchpad_clone_fd(launchpad, 1, 1))?; - } - if let Some(fd) = stdio.stderr.fd() { - zx_cvt(launchpad_transfer_fd(launchpad, fd, 2))?; - } else { - zx_cvt(launchpad_clone_fd(launchpad, 2, 2))?; - } + let action1 = transfer_or_clone(stdio.stdin.fd(), 0); + let action2 = transfer_or_clone(stdio.stdout.fd(), 1); + let action3 = transfer_or_clone(stdio.stderr.fd(), 2); + let actions = [action1, action2, action3]; - // We don't want FileDesc::drop to be called on any stdio. It would close their fds. The - // fds will be closed once the child process finishes. + // We don't want FileDesc::drop to be called on any stdio. fdio_spawn_etc + // always consumes transferred file descriptors. mem::forget(stdio); for callback in self.get_closures().iter_mut() { callback()?; } - // `launchpad_go` destroys the launchpad, so we must not - mem::forget(launchpad_destructor); - let mut process_handle: zx_handle_t = 0; - let mut err_msg: *const libc::c_char = ptr::null(); - zx_cvt(launchpad_go(launchpad, &mut process_handle, &mut err_msg))?; + zx_cvt(fdio_spawn_etc( + 0, + FDIO_SPAWN_SHARE_JOB | FDIO_SPAWN_CLONE_LDSVC | FDIO_SPAWN_CLONE_NAMESPACE, + self.get_argv()[0], self.get_argv().as_ptr(), envp, 3, actions.as_ptr(), + &mut process_handle, + ptr::null_mut(), + ))?; // FIXME: See if we want to do something with that err_msg Ok(process_handle) diff --git a/src/libstd/sys/unix/process/zircon.rs b/src/libstd/sys/unix/process/zircon.rs index 90864e6ef3ff2..a06c73ee263c2 100644 --- a/src/libstd/sys/unix/process/zircon.rs +++ b/src/libstd/sys/unix/process/zircon.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(non_camel_case_types)] +#![allow(non_camel_case_types, unused)] use convert::TryInto; use io; @@ -117,75 +117,36 @@ extern { avail: *mut size_t) -> zx_status_t; } -// From `enum special_handles` in system/ulib/launchpad/launchpad.c -// HND_LOADER_SVC = 0 -// HND_EXEC_VMO = 1 -// HND_SEGMENTS_VMAR = 2 -const HND_SPECIAL_COUNT: c_int = 3; - +#[derive(Default)] #[repr(C)] -pub struct launchpad_t { - argc: u32, - envc: u32, - args: *const c_char, - args_len: size_t, - env: *const c_char, - env_len: size_t, - - handles: *mut zx_handle_t, - handles_info: *mut u32, - handle_count: size_t, - handle_alloc: size_t, - - entry: zx_vaddr_t, - base: zx_vaddr_t, - vdso_base: zx_vaddr_t, - - stack_size: size_t, - - special_handles: [zx_handle_t; HND_SPECIAL_COUNT as usize], - loader_message: bool, +pub struct fdio_spawn_action_t { + pub action: u32, + pub reserved0: u32, + pub local_fd: i32, + pub target_fd: i32, + pub reserved1: u64, } extern { - pub fn launchpad_create(job: zx_handle_t, name: *const c_char, - lp: *mut *mut launchpad_t) -> zx_status_t; - - pub fn launchpad_go(lp: *mut launchpad_t, - proc_handle: *mut zx_handle_t, - err_msg: *mut *const c_char) -> zx_status_t; - - pub fn launchpad_destroy(lp: *mut launchpad_t); - - pub fn launchpad_set_args(lp: *mut launchpad_t, argc: c_int, - argv: *const *const c_char) -> zx_status_t; - - pub fn launchpad_set_environ(lp: *mut launchpad_t, envp: *const *const c_char) -> zx_status_t; - - pub fn launchpad_clone(lp: *mut launchpad_t, what: u32) -> zx_status_t; - - pub fn launchpad_clone_fd(lp: *mut launchpad_t, fd: c_int, target_fd: c_int) -> zx_status_t; - - pub fn launchpad_transfer_fd(lp: *mut launchpad_t, fd: c_int, target_fd: c_int) -> zx_status_t; - - pub fn launchpad_elf_load(lp: *mut launchpad_t, vmo: zx_handle_t) -> zx_status_t; - - pub fn launchpad_add_vdso_vmo(lp: *mut launchpad_t) -> zx_status_t; + pub fn fdio_spawn_etc(job: zx_handle_t, flags: u32, path: *const c_char, + argv: *const *const c_char, envp: *const *const c_char, + action_count: u64, actions: *const fdio_spawn_action_t, + process: *mut zx_handle_t, err_msg: *mut c_char) -> zx_status_t; +} - pub fn launchpad_load_vdso(lp: *mut launchpad_t, vmo: zx_handle_t) -> zx_status_t; +// fdio_spawn_etc flags - pub fn launchpad_vmo_from_file(filename: *const c_char) -> zx_handle_t; -} +pub const FDIO_SPAWN_CLONE_JOB: u32 = 0x0001; +pub const FDIO_SPAWN_CLONE_LDSVC: u32 = 0x0002; +pub const FDIO_SPAWN_CLONE_NAMESPACE: u32 = 0x0004; +pub const FDIO_SPAWN_CLONE_STDIO: u32 = 0x0008; +pub const FDIO_SPAWN_CLONE_ENVIRON: u32 = 0x0010; +pub const FDIO_SPAWN_CLONE_ALL: u32 = 0xFFFF; -// Launchpad clone constants +// fdio_spawn_etc actions -pub const LP_CLONE_FDIO_NAMESPACE: u32 = 0x0001; -pub const LP_CLONE_FDIO_CWD: u32 = 0x0002; -// LP_CLONE_FDIO_STDIO = 0x0004 -// LP_CLONE_FDIO_ALL = 0x00FF -// LP_CLONE_ENVIRON = 0x0100 -// LP_CLONE_DEFAULT_JOB = 0x0200 -// LP_CLONE_ALL = 0xFFFF +pub const FDIO_SPAWN_ACTION_CLONE_FD: u32 = 0x0001; +pub const FDIO_SPAWN_ACTION_TRANSFER_FD: u32 = 0x0002; // Errors diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 95d519eae5851..e94f994a77650 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -767,6 +767,9 @@ impl<'a> Parser<'a> { err.span_label(self.span, format!("expected identifier, found {}", token_descr)); } else { err.span_label(self.span, "expected identifier"); + if self.token == token::Comma && self.look_ahead(1, |t| t.is_ident()) { + err.span_suggestion(self.span, "remove this comma", "".into()); + } } err } @@ -2527,8 +2530,14 @@ impl<'a> Parser<'a> { Err(mut e) => { e.span_label(struct_sp, "while parsing this struct"); e.emit(); - self.recover_stmt(); - break; + + // If the next token is a comma, then try to parse + // what comes next as additional fields, rather than + // bailing out until next `}`. + if self.token != token::Comma { + self.recover_stmt(); + break; + } } } @@ -3710,26 +3719,89 @@ impl<'a> Parser<'a> { Ok((before, slice, after)) } + fn parse_pat_field( + &mut self, + lo: Span, + attrs: Vec + ) -> PResult<'a, codemap::Spanned> { + // Check if a colon exists one ahead. This means we're parsing a fieldname. + let hi; + let (subpat, fieldname, is_shorthand) = if self.look_ahead(1, |t| t == &token::Colon) { + // Parsing a pattern of the form "fieldname: pat" + let fieldname = self.parse_field_name()?; + self.bump(); + let pat = self.parse_pat()?; + hi = pat.span; + (pat, fieldname, false) + } else { + // Parsing a pattern of the form "(box) (ref) (mut) fieldname" + let is_box = self.eat_keyword(keywords::Box); + let boxed_span = self.span; + let is_ref = self.eat_keyword(keywords::Ref); + let is_mut = self.eat_keyword(keywords::Mut); + let fieldname = self.parse_ident()?; + hi = self.prev_span; + + let bind_type = match (is_ref, is_mut) { + (true, true) => BindingMode::ByRef(Mutability::Mutable), + (true, false) => BindingMode::ByRef(Mutability::Immutable), + (false, true) => BindingMode::ByValue(Mutability::Mutable), + (false, false) => BindingMode::ByValue(Mutability::Immutable), + }; + let fieldpat = P(Pat { + id: ast::DUMMY_NODE_ID, + node: PatKind::Ident(bind_type, fieldname, None), + span: boxed_span.to(hi), + }); + + let subpat = if is_box { + P(Pat { + id: ast::DUMMY_NODE_ID, + node: PatKind::Box(fieldpat), + span: lo.to(hi), + }) + } else { + fieldpat + }; + (subpat, fieldname, true) + }; + + Ok(codemap::Spanned { + span: lo.to(hi), + node: ast::FieldPat { + ident: fieldname, + pat: subpat, + is_shorthand, + attrs: attrs.into(), + } + }) + } + /// Parse the fields of a struct-like pattern fn parse_pat_fields(&mut self) -> PResult<'a, (Vec>, bool)> { let mut fields = Vec::new(); let mut etc = false; - let mut first = true; - while self.token != token::CloseDelim(token::Brace) { - if first { - first = false; - } else { - self.expect(&token::Comma)?; - // accept trailing commas - if self.check(&token::CloseDelim(token::Brace)) { break } - } + let mut ate_comma = true; + let mut delayed_err: Option> = None; + let mut etc_span = None; + while self.token != token::CloseDelim(token::Brace) { let attrs = self.parse_outer_attributes()?; let lo = self.span; - let hi; + + // check that a comma comes after every field + if !ate_comma { + let err = self.struct_span_err(self.prev_span, "expected `,`"); + return Err(err); + } + ate_comma = false; if self.check(&token::DotDot) || self.token == token::DotDotDot { + etc = true; + let mut etc_sp = self.span; + if self.token == token::DotDotDot { // Issue #46718 + // Accept `...` as if it were `..` to avoid further errors let mut err = self.struct_span_err(self.span, "expected field pattern, found `...`"); err.span_suggestion_with_applicability( @@ -3740,73 +3812,76 @@ impl<'a> Parser<'a> { ); err.emit(); } + self.bump(); // `..` || `...`:w - self.bump(); - if self.token != token::CloseDelim(token::Brace) { - let token_str = self.this_token_to_string(); - let mut err = self.fatal(&format!("expected `{}`, found `{}`", "}", token_str)); - if self.token == token::Comma { // Issue #49257 - err.span_label(self.span, - "`..` must be in the last position, \ - and cannot have a trailing comma"); + if self.token == token::CloseDelim(token::Brace) { + etc_span = Some(etc_sp); + break; + } + let token_str = self.this_token_to_string(); + let mut err = self.fatal(&format!("expected `}}`, found `{}`", token_str)); + + err.span_label(self.span, "expected `}`"); + let mut comma_sp = None; + if self.token == token::Comma { // Issue #49257 + etc_sp = etc_sp.to(self.sess.codemap().span_until_non_whitespace(self.span)); + err.span_label(etc_sp, + "`..` must be at the end and cannot have a trailing comma"); + comma_sp = Some(self.span); + self.bump(); + ate_comma = true; + } + + etc_span = Some(etc_sp); + if self.token == token::CloseDelim(token::Brace) { + // If the struct looks otherwise well formed, recover and continue. + if let Some(sp) = comma_sp { + err.span_suggestion_short(sp, "remove this comma", "".into()); + } + err.emit(); + break; + } else if self.token.is_ident() && ate_comma { + // Accept fields coming after `..,`. + // This way we avoid "pattern missing fields" errors afterwards. + // We delay this error until the end in order to have a span for a + // suggested fix. + if let Some(mut delayed_err) = delayed_err { + delayed_err.emit(); + return Err(err); } else { - err.span_label(self.span, "expected `}`"); + delayed_err = Some(err); + } + } else { + if let Some(mut err) = delayed_err { + err.emit(); } return Err(err); } - etc = true; - break; } - // Check if a colon exists one ahead. This means we're parsing a fieldname. - let (subpat, fieldname, is_shorthand) = if self.look_ahead(1, |t| t == &token::Colon) { - // Parsing a pattern of the form "fieldname: pat" - let fieldname = self.parse_field_name()?; - self.bump(); - let pat = self.parse_pat()?; - hi = pat.span; - (pat, fieldname, false) - } else { - // Parsing a pattern of the form "(box) (ref) (mut) fieldname" - let is_box = self.eat_keyword(keywords::Box); - let boxed_span = self.span; - let is_ref = self.eat_keyword(keywords::Ref); - let is_mut = self.eat_keyword(keywords::Mut); - let fieldname = self.parse_ident()?; - hi = self.prev_span; - - let bind_type = match (is_ref, is_mut) { - (true, true) => BindingMode::ByRef(Mutability::Mutable), - (true, false) => BindingMode::ByRef(Mutability::Immutable), - (false, true) => BindingMode::ByValue(Mutability::Mutable), - (false, false) => BindingMode::ByValue(Mutability::Immutable), - }; - let fieldpat = P(Pat { - id: ast::DUMMY_NODE_ID, - node: PatKind::Ident(bind_type, fieldname, None), - span: boxed_span.to(hi), - }); - - let subpat = if is_box { - P(Pat { - id: ast::DUMMY_NODE_ID, - node: PatKind::Box(fieldpat), - span: lo.to(hi), - }) - } else { - fieldpat - }; - (subpat, fieldname, true) - }; - - fields.push(codemap::Spanned { span: lo.to(hi), - node: ast::FieldPat { - ident: fieldname, - pat: subpat, - is_shorthand, - attrs: attrs.into(), - } + fields.push(match self.parse_pat_field(lo, attrs) { + Ok(field) => field, + Err(err) => { + if let Some(mut delayed_err) = delayed_err { + delayed_err.emit(); + } + return Err(err); + } }); + ate_comma = self.eat(&token::Comma); + } + + if let Some(mut err) = delayed_err { + if let Some(etc_span) = etc_span { + err.multipart_suggestion( + "move the `..` to the end of the field list", + vec![ + (etc_span, "".into()), + (self.span, format!("{}.. }}", if ate_comma { "" } else { ", " })), + ], + ); + } + err.emit(); } return Ok((fields, etc)); } diff --git a/src/test/compile-fail/const-array-oob.rs b/src/test/compile-fail/const-array-oob.rs index 108b7948dfcc2..22a3c5ceeb714 100644 --- a/src/test/compile-fail/const-array-oob.rs +++ b/src/test/compile-fail/const-array-oob.rs @@ -16,7 +16,7 @@ const FOO: [usize; 3] = [1, 2, 3]; const BAR: usize = FOO[5]; // no error, because the error below occurs before regular const eval const BLUB: [u32; FOO[4]] = [5, 6]; -//~^ ERROR constant evaluation error [E0080] +//~^ ERROR could not evaluate constant expression [E0080] //~| index out of bounds: the len is 3 but the index is 4 fn main() { diff --git a/src/test/compile-fail/const-err-early.rs b/src/test/compile-fail/const-err-early.rs index f8b20f6ee7933..92c6b1fd0b582 100644 --- a/src/test/compile-fail/const-err-early.rs +++ b/src/test/compile-fail/const-err-early.rs @@ -12,7 +12,7 @@ pub const A: i8 = -std::i8::MIN; //~ ERROR const_err //~^ ERROR this constant cannot be used -//~| ERROR constant evaluation error +//~| ERROR this expression will panic at runtime pub const B: u8 = 200u8 + 200u8; //~ ERROR const_err //~^ ERROR this constant cannot be used pub const C: u8 = 200u8 * 4; //~ ERROR const_err diff --git a/src/test/compile-fail/const-err-multi.rs b/src/test/compile-fail/const-err-multi.rs index 6f0281b8bd0ca..4a5e78b381ed0 100644 --- a/src/test/compile-fail/const-err-multi.rs +++ b/src/test/compile-fail/const-err-multi.rs @@ -13,14 +13,17 @@ pub const A: i8 = -std::i8::MIN; //~^ ERROR E0080 //~| ERROR attempt to negate with overflow -//~| ERROR constant evaluation error +//~| ERROR this expression will panic at runtime //~| ERROR this constant cannot be used pub const B: i8 = A; //~^ ERROR const_err +//~| ERROR const_err pub const C: u8 = A as u8; //~^ ERROR const_err +//~| ERROR const_err pub const D: i8 = 50 - A; //~^ ERROR const_err +//~| ERROR const_err fn main() { let _ = (A, B, C, D); diff --git a/src/test/compile-fail/const-err.rs b/src/test/compile-fail/const-err.rs index f6a64bcba21c3..f77603b3ebafc 100644 --- a/src/test/compile-fail/const-err.rs +++ b/src/test/compile-fail/const-err.rs @@ -23,6 +23,7 @@ fn black_box(_: T) { // Make sure that the two uses get two errors. const FOO: u8 = [5u8][1]; //~^ ERROR constant evaluation error +//~| ERROR constant evaluation error //~| index out of bounds: the len is 1 but the index is 1 fn main() { diff --git a/src/test/compile-fail/const-integer-bool-ops.rs b/src/test/compile-fail/const-integer-bool-ops.rs index 3065122af6a94..29bc665a22e7b 100644 --- a/src/test/compile-fail/const-integer-bool-ops.rs +++ b/src/test/compile-fail/const-integer-bool-ops.rs @@ -16,7 +16,6 @@ const X: usize = 42 && 39; //~| ERROR mismatched types //~| expected usize, found bool const ARR: [i32; X] = [99; 34]; -//~^ ERROR constant evaluation error const X1: usize = 42 || 39; //~^ ERROR mismatched types @@ -26,7 +25,6 @@ const X1: usize = 42 || 39; //~| ERROR mismatched types //~| expected usize, found bool const ARR1: [i32; X1] = [99; 47]; -//~^ ERROR constant evaluation error const X2: usize = -42 || -39; //~^ ERROR mismatched types @@ -36,7 +34,6 @@ const X2: usize = -42 || -39; //~| ERROR mismatched types //~| expected usize, found bool const ARR2: [i32; X2] = [99; 18446744073709551607]; -//~^ ERROR constant evaluation error const X3: usize = -42 && -39; //~^ ERROR mismatched types @@ -46,43 +43,36 @@ const X3: usize = -42 && -39; //~| ERROR mismatched types //~| expected usize, found bool const ARR3: [i32; X3] = [99; 6]; -//~^ ERROR constant evaluation error const Y: usize = 42.0 == 42.0; //~^ ERROR mismatched types //~| expected usize, found bool const ARRR: [i32; Y] = [99; 1]; -//~^ ERROR constant evaluation error const Y1: usize = 42.0 >= 42.0; //~^ ERROR mismatched types //~| expected usize, found bool const ARRR1: [i32; Y1] = [99; 1]; -//~^ ERROR constant evaluation error const Y2: usize = 42.0 <= 42.0; //~^ ERROR mismatched types //~| expected usize, found bool const ARRR2: [i32; Y2] = [99; 1]; -//~^ ERROR constant evaluation error const Y3: usize = 42.0 > 42.0; //~^ ERROR mismatched types //~| expected usize, found bool const ARRR3: [i32; Y3] = [99; 0]; -//~^ ERROR constant evaluation error const Y4: usize = 42.0 < 42.0; //~^ ERROR mismatched types //~| expected usize, found bool const ARRR4: [i32; Y4] = [99; 0]; -//~^ ERROR constant evaluation error const Y5: usize = 42.0 != 42.0; //~^ ERROR mismatched types //~| expected usize, found bool const ARRR5: [i32; Y5] = [99; 0]; -//~^ ERROR constant evaluation error fn main() { let _ = ARR; diff --git a/src/test/compile-fail/const-len-underflow-subspans.rs b/src/test/compile-fail/const-len-underflow-subspans.rs index 85cc893aa133c..054c272a3d321 100644 --- a/src/test/compile-fail/const-len-underflow-subspans.rs +++ b/src/test/compile-fail/const-len-underflow-subspans.rs @@ -16,6 +16,6 @@ const TWO: usize = 2; fn main() { let a: [i8; ONE - TWO] = unimplemented!(); - //~^ ERROR constant evaluation error + //~^ ERROR could not evaluate constant expression //~| attempt to subtract with overflow } diff --git a/src/test/compile-fail/const-match-check.rs b/src/test/compile-fail/const-match-check.rs index 36a6600b62d98..304eef7847c91 100644 --- a/src/test/compile-fail/const-match-check.rs +++ b/src/test/compile-fail/const-match-check.rs @@ -40,5 +40,4 @@ fn main() { #[cfg(eval2)] let x: [i32; { let 0 = 0; 0 }] = []; //[eval2]~^ ERROR refutable pattern in local binding - //[eval2]~| ERROR constant evaluation error } diff --git a/src/test/compile-fail/const-tup-index-span.rs b/src/test/compile-fail/const-tup-index-span.rs index 7596881ef9b9a..b42c440f87d74 100644 --- a/src/test/compile-fail/const-tup-index-span.rs +++ b/src/test/compile-fail/const-tup-index-span.rs @@ -14,7 +14,6 @@ const TUP: (usize,) = 5usize << 64; //~^ ERROR mismatched types //~| expected tuple, found usize const ARR: [i32; TUP.0] = []; -//~^ ERROR constant evaluation error fn main() { } diff --git a/src/test/compile-fail/eval-enum.rs b/src/test/compile-fail/eval-enum.rs index 7315616860293..ada038114d8d0 100644 --- a/src/test/compile-fail/eval-enum.rs +++ b/src/test/compile-fail/eval-enum.rs @@ -11,12 +11,12 @@ enum Test { DivZero = 1/0, //~^ attempt to divide by zero - //~| ERROR constant evaluation error - //~| ERROR constant evaluation error + //~| ERROR could not evaluate enum discriminant + //~| ERROR this expression will panic at runtime RemZero = 1%0, //~^ attempt to calculate the remainder with a divisor of zero - //~| ERROR constant evaluation error - //~| ERROR constant evaluation error + //~| ERROR could not evaluate enum discriminant + //~| ERROR this expression will panic at runtime } fn main() {} diff --git a/src/test/compile-fail/issue-43105.rs b/src/test/compile-fail/issue-43105.rs index 6fa65a541b39b..8a0471135afc4 100644 --- a/src/test/compile-fail/issue-43105.rs +++ b/src/test/compile-fail/issue-43105.rs @@ -12,11 +12,11 @@ fn xyz() -> u8 { 42 } const NUM: u8 = xyz(); //~^ ERROR calls in constants are limited to constant functions, tuple structs and tuple variants -//~| ERROR constant evaluation error fn main() { match 1 { NUM => unimplemented!(), + //~^ ERROR could not evaluate constant pattern _ => unimplemented!(), } } diff --git a/src/test/compile-fail/issue-8460-const.rs b/src/test/compile-fail/issue-8460-const.rs index 1d59e75a0f0f0..b0d6cb5df875a 100644 --- a/src/test/compile-fail/issue-8460-const.rs +++ b/src/test/compile-fail/issue-8460-const.rs @@ -16,62 +16,62 @@ use std::thread; fn main() { assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err()); //~^ ERROR attempt to divide with overflow - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err()); //~^ ERROR attempt to divide with overflow - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err()); //~^ ERROR attempt to divide with overflow - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err()); //~^ ERROR attempt to divide with overflow - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err()); //~^ ERROR attempt to divide with overflow - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err()); //~^ ERROR attempt to divide by zero - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err()); //~^ ERROR attempt to divide by zero - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err()); //~^ ERROR attempt to divide by zero - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err()); //~^ ERROR attempt to divide by zero - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err()); //~^ ERROR attempt to divide by zero - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err()); //~^ ERROR attempt to calculate the remainder with overflow - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err()); //~^ ERROR attempt to calculate the remainder with overflow - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err()); //~^ ERROR attempt to calculate the remainder with overflow - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err()); //~^ ERROR attempt to calculate the remainder with overflow - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err()); //~^ ERROR attempt to calculate the remainder with overflow - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err()); //~^ ERROR attempt to calculate the remainder with a divisor of zero - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err()); //~^ ERROR attempt to calculate the remainder with a divisor of zero - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err()); //~^ ERROR attempt to calculate the remainder with a divisor of zero - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err()); //~^ ERROR attempt to calculate the remainder with a divisor of zero - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err()); //~^ ERROR attempt to calculate the remainder with a divisor of zero - //~| ERROR constant evaluation error + //~| ERROR this expression will panic at runtime } diff --git a/src/test/parse-fail/bind-struct-early-modifiers.rs b/src/test/parse-fail/bind-struct-early-modifiers.rs index 25348a3bfd18f..e9e76af11a530 100644 --- a/src/test/parse-fail/bind-struct-early-modifiers.rs +++ b/src/test/parse-fail/bind-struct-early-modifiers.rs @@ -13,7 +13,7 @@ fn main() { struct Foo { x: isize } match (Foo { x: 10 }) { - Foo { ref x: ref x } => {}, //~ ERROR expected `,`, found `:` + Foo { ref x: ref x } => {}, //~ ERROR expected `,` _ => {} } } diff --git a/src/test/ui/borrowck/borrowck-move-out-of-vec-tail.nll.stderr b/src/test/ui/borrowck/borrowck-move-out-of-vec-tail.nll.stderr index a430c97158a48..96b376ea7ae40 100644 --- a/src/test/ui/borrowck/borrowck-move-out-of-vec-tail.nll.stderr +++ b/src/test/ui/borrowck/borrowck-move-out-of-vec-tail.nll.stderr @@ -1,15 +1,15 @@ -error[E0507]: cannot move out of borrowed content +error[E0508]: cannot move out of type `[Foo]`, a non-copy slice --> $DIR/borrowck-move-out-of-vec-tail.rs:30:33 | LL | &[Foo { string: a }, - | ^ cannot move out of borrowed content + | ^ cannot move out of here -error[E0507]: cannot move out of borrowed content +error[E0508]: cannot move out of type `[Foo]`, a non-copy slice --> $DIR/borrowck-move-out-of-vec-tail.rs:34:33 | LL | Foo { string: b }] => { - | ^ cannot move out of borrowed content + | ^ cannot move out of here error: aborting due to 2 previous errors -For more information about this error, try `rustc --explain E0507`. +For more information about this error, try `rustc --explain E0508`. diff --git a/src/test/ui/borrowck/borrowck-vec-pattern-nesting.nll.stderr b/src/test/ui/borrowck/borrowck-vec-pattern-nesting.nll.stderr index d5a66a6c70635..6d28a37463b92 100644 --- a/src/test/ui/borrowck/borrowck-vec-pattern-nesting.nll.stderr +++ b/src/test/ui/borrowck/borrowck-vec-pattern-nesting.nll.stderr @@ -1,51 +1,76 @@ -error[E0507]: cannot move out of borrowed content - --> $DIR/borrowck-vec-pattern-nesting.rs:42:15 +error[E0506]: cannot assign to `vec[..]` because it is borrowed + --> $DIR/borrowck-vec-pattern-nesting.rs:20:13 + | +LL | [box ref _a, _, _] => { + | ------ borrow of `vec[..]` occurs here +LL | //~^ borrow of `vec[..]` occurs here +LL | vec[0] = box 4; //~ ERROR cannot assign + | ^^^^^^ assignment to borrowed `vec[..]` occurs here +LL | //~^ assignment to borrowed `vec[..]` occurs here +LL | _a.use_ref(); + | -- borrow later used here + +error[E0506]: cannot assign to `vec[..]` because it is borrowed + --> $DIR/borrowck-vec-pattern-nesting.rs:33:13 + | +LL | &mut [ref _b..] => { + | ------ borrow of `vec[..]` occurs here +LL | //~^ borrow of `vec[..]` occurs here +LL | vec[0] = box 4; //~ ERROR cannot assign + | ^^^^^^ assignment to borrowed `vec[..]` occurs here +LL | //~^ assignment to borrowed `vec[..]` occurs here +LL | _b.use_ref(); + | -- borrow later used here + +error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice + --> $DIR/borrowck-vec-pattern-nesting.rs:44:15 | LL | &mut [_a, //~ ERROR cannot move out - | ^^ cannot move out of borrowed content + | ^^ cannot move out of here -error[E0507]: cannot move out of borrowed content - --> $DIR/borrowck-vec-pattern-nesting.rs:55:13 +error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice + --> $DIR/borrowck-vec-pattern-nesting.rs:57:13 | LL | let a = vec[0]; //~ ERROR cannot move out - | ^^^^^^ cannot move out of borrowed content + | ^^^^^^ cannot move out of here -error[E0507]: cannot move out of borrowed content - --> $DIR/borrowck-vec-pattern-nesting.rs:65:10 +error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice + --> $DIR/borrowck-vec-pattern-nesting.rs:67:10 | LL | _b] => {} - | ^^ cannot move out of borrowed content + | ^^ cannot move out of here -error[E0507]: cannot move out of borrowed content - --> $DIR/borrowck-vec-pattern-nesting.rs:68:13 +error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice + --> $DIR/borrowck-vec-pattern-nesting.rs:70:13 | LL | let a = vec[0]; //~ ERROR cannot move out - | ^^^^^^ cannot move out of borrowed content + | ^^^^^^ cannot move out of here -error[E0507]: cannot move out of borrowed content - --> $DIR/borrowck-vec-pattern-nesting.rs:76:15 +error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice + --> $DIR/borrowck-vec-pattern-nesting.rs:78:15 | LL | &mut [_a, _b, _c] => {} //~ ERROR cannot move out - | ^^ cannot move out of borrowed content + | ^^ cannot move out of here -error[E0507]: cannot move out of borrowed content - --> $DIR/borrowck-vec-pattern-nesting.rs:76:19 +error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice + --> $DIR/borrowck-vec-pattern-nesting.rs:78:19 | LL | &mut [_a, _b, _c] => {} //~ ERROR cannot move out - | ^^ cannot move out of borrowed content + | ^^ cannot move out of here -error[E0507]: cannot move out of borrowed content - --> $DIR/borrowck-vec-pattern-nesting.rs:76:23 +error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice + --> $DIR/borrowck-vec-pattern-nesting.rs:78:23 | LL | &mut [_a, _b, _c] => {} //~ ERROR cannot move out - | ^^ cannot move out of borrowed content + | ^^ cannot move out of here -error[E0507]: cannot move out of borrowed content - --> $DIR/borrowck-vec-pattern-nesting.rs:80:13 +error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice + --> $DIR/borrowck-vec-pattern-nesting.rs:82:13 | LL | let a = vec[0]; //~ ERROR cannot move out - | ^^^^^^ cannot move out of borrowed content + | ^^^^^^ cannot move out of here -error: aborting due to 8 previous errors +error: aborting due to 10 previous errors -For more information about this error, try `rustc --explain E0507`. +Some errors occurred: E0506, E0508. +For more information about an error, try `rustc --explain E0506`. diff --git a/src/test/ui/borrowck/borrowck-vec-pattern-nesting.rs b/src/test/ui/borrowck/borrowck-vec-pattern-nesting.rs index 111968e9c9313..63dac0a83004a 100644 --- a/src/test/ui/borrowck/borrowck-vec-pattern-nesting.rs +++ b/src/test/ui/borrowck/borrowck-vec-pattern-nesting.rs @@ -19,6 +19,7 @@ fn a() { //~^ borrow of `vec[..]` occurs here vec[0] = box 4; //~ ERROR cannot assign //~^ assignment to borrowed `vec[..]` occurs here + _a.use_ref(); } } } @@ -31,6 +32,7 @@ fn b() { //~^ borrow of `vec[..]` occurs here vec[0] = box 4; //~ ERROR cannot assign //~^ assignment to borrowed `vec[..]` occurs here + _b.use_ref(); } } } @@ -82,3 +84,6 @@ fn e() { } fn main() {} + +trait Fake { fn use_mut(&mut self) { } fn use_ref(&self) { } } +impl Fake for T { } diff --git a/src/test/ui/borrowck/borrowck-vec-pattern-nesting.stderr b/src/test/ui/borrowck/borrowck-vec-pattern-nesting.stderr index 6673549e23903..a03e1eab7ad06 100644 --- a/src/test/ui/borrowck/borrowck-vec-pattern-nesting.stderr +++ b/src/test/ui/borrowck/borrowck-vec-pattern-nesting.stderr @@ -8,7 +8,7 @@ LL | vec[0] = box 4; //~ ERROR cannot assign | ^^^^^^^^^^^^^^ assignment to borrowed `vec[..]` occurs here error[E0506]: cannot assign to `vec[..]` because it is borrowed - --> $DIR/borrowck-vec-pattern-nesting.rs:32:13 + --> $DIR/borrowck-vec-pattern-nesting.rs:33:13 | LL | &mut [ref _b..] => { | ------ borrow of `vec[..]` occurs here @@ -17,7 +17,7 @@ LL | vec[0] = box 4; //~ ERROR cannot assign | ^^^^^^^^^^^^^^ assignment to borrowed `vec[..]` occurs here error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice - --> $DIR/borrowck-vec-pattern-nesting.rs:42:14 + --> $DIR/borrowck-vec-pattern-nesting.rs:44:14 | LL | &mut [_a, //~ ERROR cannot move out | ^-- hint: to prevent move, use `ref _a` or `ref mut _a` @@ -30,7 +30,7 @@ LL | | ] => { | |_________^ cannot move out of here error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice - --> $DIR/borrowck-vec-pattern-nesting.rs:55:13 + --> $DIR/borrowck-vec-pattern-nesting.rs:57:13 | LL | let a = vec[0]; //~ ERROR cannot move out | ^^^^^^ @@ -39,7 +39,7 @@ LL | let a = vec[0]; //~ ERROR cannot move out | help: consider using a reference instead: `&vec[0]` error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice - --> $DIR/borrowck-vec-pattern-nesting.rs:63:14 + --> $DIR/borrowck-vec-pattern-nesting.rs:65:14 | LL | &mut [ //~ ERROR cannot move out | ______________^ @@ -50,7 +50,7 @@ LL | | _b] => {} | hint: to prevent move, use `ref _b` or `ref mut _b` error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice - --> $DIR/borrowck-vec-pattern-nesting.rs:68:13 + --> $DIR/borrowck-vec-pattern-nesting.rs:70:13 | LL | let a = vec[0]; //~ ERROR cannot move out | ^^^^^^ @@ -59,7 +59,7 @@ LL | let a = vec[0]; //~ ERROR cannot move out | help: consider using a reference instead: `&vec[0]` error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice - --> $DIR/borrowck-vec-pattern-nesting.rs:76:14 + --> $DIR/borrowck-vec-pattern-nesting.rs:78:14 | LL | &mut [_a, _b, _c] => {} //~ ERROR cannot move out | ^--^^--^^--^ @@ -70,7 +70,7 @@ LL | &mut [_a, _b, _c] => {} //~ ERROR cannot move out | cannot move out of here error[E0508]: cannot move out of type `[std::boxed::Box]`, a non-copy slice - --> $DIR/borrowck-vec-pattern-nesting.rs:80:13 + --> $DIR/borrowck-vec-pattern-nesting.rs:82:13 | LL | let a = vec[0]; //~ ERROR cannot move out | ^^^^^^ diff --git a/src/test/ui/const-eval-overflow-2.rs b/src/test/ui/const-eval-overflow-2.rs index 63f33cafaf827..ce3d54ee46d93 100644 --- a/src/test/ui/const-eval-overflow-2.rs +++ b/src/test/ui/const-eval-overflow-2.rs @@ -19,11 +19,11 @@ use std::{u8, u16, u32, u64, usize}; const NEG_128: i8 = -128; const NEG_NEG_128: i8 = -NEG_128; -//~^ ERROR E0080 fn main() { match -128i8 { NEG_NEG_128 => println!("A"), + //~^ ERROR could not evaluate constant pattern _ => println!("B"), } } diff --git a/src/test/ui/const-eval-overflow-2.stderr b/src/test/ui/const-eval-overflow-2.stderr index 9cee718c286b6..e99d409880e07 100644 --- a/src/test/ui/const-eval-overflow-2.stderr +++ b/src/test/ui/const-eval-overflow-2.stderr @@ -1,12 +1,9 @@ -error[E0080]: constant evaluation error - --> $DIR/const-eval-overflow-2.rs:21:25 +error[E0080]: could not evaluate constant pattern + --> $DIR/const-eval-overflow-2.rs:25:9 | LL | const NEG_NEG_128: i8 = -NEG_128; - | ^^^^^^^^ attempt to negate with overflow - | -note: for pattern here - --> $DIR/const-eval-overflow-2.rs:26:9 - | + | -------- attempt to negate with overflow +... LL | NEG_NEG_128 => println!("A"), | ^^^^^^^^^^^ diff --git a/src/test/ui/const-eval-overflow-4.rs b/src/test/ui/const-eval-overflow-4.rs index ed14036b0b4cb..9fc31b7c72781 100644 --- a/src/test/ui/const-eval-overflow-4.rs +++ b/src/test/ui/const-eval-overflow-4.rs @@ -20,9 +20,9 @@ use std::{i8, i16, i32, i64, isize}; use std::{u8, u16, u32, u64, usize}; const A_I8_T + //~^ ERROR could not evaluate constant expression : [u32; (i8::MAX as i8 + 1i8) as usize] - //~^ ERROR E0080 - //~| ERROR attempt to add with overflow + //~^ ERROR attempt to add with overflow = [0; (i8::MAX as usize) + 1]; fn main() { diff --git a/src/test/ui/const-eval-overflow-4.stderr b/src/test/ui/const-eval-overflow-4.stderr index fc4762f0554f7..058c8730d7c9e 100644 --- a/src/test/ui/const-eval-overflow-4.stderr +++ b/src/test/ui/const-eval-overflow-4.stderr @@ -1,16 +1,21 @@ error: attempt to add with overflow - --> $DIR/const-eval-overflow-4.rs:23:13 + --> $DIR/const-eval-overflow-4.rs:24:13 | LL | : [u32; (i8::MAX as i8 + 1i8) as usize] | ^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(const_err)] on by default -error[E0080]: constant evaluation error - --> $DIR/const-eval-overflow-4.rs:23:13 +error[E0080]: could not evaluate constant expression + --> $DIR/const-eval-overflow-4.rs:22:1 | -LL | : [u32; (i8::MAX as i8 + 1i8) as usize] - | ^^^^^^^^^^^^^^^^^^^^^ attempt to add with overflow +LL | / const A_I8_T +LL | | //~^ ERROR could not evaluate constant expression +LL | | : [u32; (i8::MAX as i8 + 1i8) as usize] + | | --------------------- attempt to add with overflow +LL | | //~^ ERROR attempt to add with overflow +LL | | = [0; (i8::MAX as usize) + 1]; + | |__________________________________^ error: aborting due to 2 previous errors diff --git a/src/test/ui/const-eval/conditional_array_execution.nll.stderr b/src/test/ui/const-eval/conditional_array_execution.nll.stderr new file mode 100644 index 0000000000000..3580950854dc7 --- /dev/null +++ b/src/test/ui/const-eval/conditional_array_execution.nll.stderr @@ -0,0 +1,74 @@ +warning: attempt to subtract with overflow + --> $DIR/conditional_array_execution.rs:15:19 + | +LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; + | ^^^^^ + | +note: lint level defined here + --> $DIR/conditional_array_execution.rs:11:9 + | +LL | #![warn(const_err)] + | ^^^^^^^^^ + +warning: this constant cannot be used + --> $DIR/conditional_array_execution.rs:15:1 + | +LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; + | ^^^^^^^^^^^^^^^^^^-----^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | attempt to subtract with overflow + +warning: referenced constant + --> $DIR/conditional_array_execution.rs:20:20 + | +LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; + | ----- attempt to subtract with overflow +... +LL | println!("{}", FOO); + | ^^^ + +warning: this expression will panic at runtime + --> $DIR/conditional_array_execution.rs:20:20 + | +LL | println!("{}", FOO); + | ^^^ referenced constant has errors + +error[E0080]: referenced constant + --> $DIR/conditional_array_execution.rs:20:5 + | +LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; + | ----- attempt to subtract with overflow +... +LL | println!("{}", FOO); + | ^^^^^^^^^^^^^^^^^^^^ + | + = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) + +error[E0080]: erroneous constant used + --> $DIR/conditional_array_execution.rs:20:5 + | +LL | println!("{}", FOO); + | ^^^^^^^^^^^^^^^---^^ + | | + | referenced constant has errors + | + = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) + +error[E0080]: referenced constant + --> $DIR/conditional_array_execution.rs:20:20 + | +LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; + | ----- attempt to subtract with overflow +... +LL | println!("{}", FOO); + | ^^^ + +error[E0080]: erroneous constant used + --> $DIR/conditional_array_execution.rs:20:20 + | +LL | println!("{}", FOO); + | ^^^ referenced constant has errors + +error: aborting due to 4 previous errors + +For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/const-eval/conditional_array_execution.rs b/src/test/ui/const-eval/conditional_array_execution.rs index 8952a8386d7b8..ac555b25afdcd 100644 --- a/src/test/ui/const-eval/conditional_array_execution.rs +++ b/src/test/ui/const-eval/conditional_array_execution.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// compile-pass #![warn(const_err)] const X: u32 = 5; @@ -19,5 +18,8 @@ const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; fn main() { println!("{}", FOO); - //~^ WARN constant evaluation error + //~^ WARN this expression will panic at runtime + //~| WARN referenced constant + //~| ERROR erroneous constant used + //~| E0080 } diff --git a/src/test/ui/const-eval/conditional_array_execution.stderr b/src/test/ui/const-eval/conditional_array_execution.stderr index 5cf73b9fad66d..64010c946a7f1 100644 --- a/src/test/ui/const-eval/conditional_array_execution.stderr +++ b/src/test/ui/const-eval/conditional_array_execution.stderr @@ -1,24 +1,53 @@ warning: attempt to subtract with overflow - --> $DIR/conditional_array_execution.rs:16:19 + --> $DIR/conditional_array_execution.rs:15:19 | LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; | ^^^^^ | note: lint level defined here - --> $DIR/conditional_array_execution.rs:12:9 + --> $DIR/conditional_array_execution.rs:11:9 | LL | #![warn(const_err)] | ^^^^^^^^^ warning: this constant cannot be used - --> $DIR/conditional_array_execution.rs:16:1 + --> $DIR/conditional_array_execution.rs:15:1 | LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow + | ^^^^^^^^^^^^^^^^^^-----^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | attempt to subtract with overflow -warning: constant evaluation error - --> $DIR/conditional_array_execution.rs:21:20 +warning: referenced constant + --> $DIR/conditional_array_execution.rs:20:20 + | +LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; + | ----- attempt to subtract with overflow +... +LL | println!("{}", FOO); + | ^^^ + +warning: this expression will panic at runtime + --> $DIR/conditional_array_execution.rs:20:20 | LL | println!("{}", FOO); | ^^^ referenced constant has errors +error[E0080]: referenced constant + --> $DIR/conditional_array_execution.rs:20:20 + | +LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; + | ----- attempt to subtract with overflow +... +LL | println!("{}", FOO); + | ^^^ + +error[E0080]: erroneous constant used + --> $DIR/conditional_array_execution.rs:20:20 + | +LL | println!("{}", FOO); + | ^^^ referenced constant has errors + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/const-eval/index_out_of_bounds.rs b/src/test/ui/const-eval/index_out_of_bounds.rs index f3578bcef6e41..55c64d2b04e45 100644 --- a/src/test/ui/const-eval/index_out_of_bounds.rs +++ b/src/test/ui/const-eval/index_out_of_bounds.rs @@ -10,6 +10,7 @@ static FOO: i32 = [][0]; //~^ ERROR E0080 +//~| ERROR E0080 fn main() { let array = [std::env::args().len()]; diff --git a/src/test/ui/const-eval/index_out_of_bounds.stderr b/src/test/ui/const-eval/index_out_of_bounds.stderr index 96e592dc209a8..828fba55a3afe 100644 --- a/src/test/ui/const-eval/index_out_of_bounds.stderr +++ b/src/test/ui/const-eval/index_out_of_bounds.stderr @@ -1,17 +1,25 @@ -error[E0080]: constant evaluation error +error[E0080]: could not evaluate static initializer --> $DIR/index_out_of_bounds.rs:11:19 | LL | static FOO: i32 = [][0]; | ^^^^^ index out of bounds: the len is 0 but the index is 0 +error[E0080]: could not evaluate static initializer + --> $DIR/index_out_of_bounds.rs:11:1 + | +LL | static FOO: i32 = [][0]; + | ^^^^^^^^^^^^^^^^^^-----^ + | | + | index out of bounds: the len is 0 but the index is 0 + error: index out of bounds: the len is 1 but the index is 1 - --> $DIR/index_out_of_bounds.rs:16:5 + --> $DIR/index_out_of_bounds.rs:17:5 | LL | array[1]; //~ ERROR index out of bounds | ^^^^^^^^ | = note: #[deny(const_err)] on by default -error: aborting due to 2 previous errors +error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/const-eval/issue-43197.nll.stderr b/src/test/ui/const-eval/issue-43197.nll.stderr new file mode 100644 index 0000000000000..3bde12ade90c3 --- /dev/null +++ b/src/test/ui/const-eval/issue-43197.nll.stderr @@ -0,0 +1,118 @@ +warning: attempt to subtract with overflow + --> $DIR/issue-43197.rs:20:20 + | +LL | const X: u32 = 0-1; + | ^^^ + | +note: lint level defined here + --> $DIR/issue-43197.rs:11:9 + | +LL | #![warn(const_err)] + | ^^^^^^^^^ + +warning: this constant cannot be used + --> $DIR/issue-43197.rs:20:5 + | +LL | const X: u32 = 0-1; + | ^^^^^^^^^^^^^^^---^ + | | + | attempt to subtract with overflow + +warning: attempt to subtract with overflow + --> $DIR/issue-43197.rs:23:24 + | +LL | const Y: u32 = foo(0-1); + | ^^^ + +warning: this constant cannot be used + --> $DIR/issue-43197.rs:23:5 + | +LL | const Y: u32 = foo(0-1); + | ^^^^^^^^^^^^^^^^^^^---^^ + | | + | attempt to subtract with overflow + +warning: referenced constant + --> $DIR/issue-43197.rs:26:23 + | +LL | const X: u32 = 0-1; + | --- attempt to subtract with overflow +... +LL | println!("{} {}", X, Y); + | ^ + +warning: this expression will panic at runtime + --> $DIR/issue-43197.rs:26:23 + | +LL | println!("{} {}", X, Y); + | ^ referenced constant has errors + +warning: referenced constant + --> $DIR/issue-43197.rs:26:26 + | +LL | const Y: u32 = foo(0-1); + | --- attempt to subtract with overflow +... +LL | println!("{} {}", X, Y); + | ^ + +warning: this expression will panic at runtime + --> $DIR/issue-43197.rs:26:26 + | +LL | println!("{} {}", X, Y); + | ^ referenced constant has errors + +error[E0080]: referenced constant + --> $DIR/issue-43197.rs:26:5 + | +LL | const X: u32 = 0-1; + | --- attempt to subtract with overflow +... +LL | println!("{} {}", X, Y); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) + +error[E0080]: erroneous constant used + --> $DIR/issue-43197.rs:26:5 + | +LL | println!("{} {}", X, Y); + | ^^^^^^^^^^^^^^^^^^-^^^^^ + | | + | referenced constant has errors + | + = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) + +error[E0080]: referenced constant + --> $DIR/issue-43197.rs:26:26 + | +LL | const Y: u32 = foo(0-1); + | --- attempt to subtract with overflow +... +LL | println!("{} {}", X, Y); + | ^ + +error[E0080]: erroneous constant used + --> $DIR/issue-43197.rs:26:26 + | +LL | println!("{} {}", X, Y); + | ^ referenced constant has errors + +error[E0080]: referenced constant + --> $DIR/issue-43197.rs:26:23 + | +LL | const X: u32 = 0-1; + | --- attempt to subtract with overflow +... +LL | println!("{} {}", X, Y); + | ^ + +error[E0080]: erroneous constant used + --> $DIR/issue-43197.rs:26:23 + | +LL | println!("{} {}", X, Y); + | ^ referenced constant has errors + +error: aborting due to 6 previous errors + +For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/const-eval/issue-43197.rs b/src/test/ui/const-eval/issue-43197.rs index 7ec100e411b36..03aa65eb27467 100644 --- a/src/test/ui/const-eval/issue-43197.rs +++ b/src/test/ui/const-eval/issue-43197.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// compile-pass #![warn(const_err)] #![feature(const_fn)] @@ -25,6 +24,12 @@ fn main() { //~^ WARN attempt to subtract with overflow //~| WARN this constant cannot be used println!("{} {}", X, Y); - //~^ WARN constant evaluation error - //~| WARN constant evaluation error + //~^ WARN this expression will panic at runtime + //~| WARN this expression will panic at runtime + //~| ERROR erroneous constant used + //~| ERROR erroneous constant used + //~| ERROR E0080 + //~| ERROR E0080 + //~| WARN referenced constant + //~| WARN referenced constant } diff --git a/src/test/ui/const-eval/issue-43197.stderr b/src/test/ui/const-eval/issue-43197.stderr index d0e13d5657e75..071d878730744 100644 --- a/src/test/ui/const-eval/issue-43197.stderr +++ b/src/test/ui/const-eval/issue-43197.stderr @@ -1,42 +1,97 @@ warning: attempt to subtract with overflow - --> $DIR/issue-43197.rs:21:20 + --> $DIR/issue-43197.rs:20:20 | LL | const X: u32 = 0-1; | ^^^ | note: lint level defined here - --> $DIR/issue-43197.rs:12:9 + --> $DIR/issue-43197.rs:11:9 | LL | #![warn(const_err)] | ^^^^^^^^^ warning: this constant cannot be used - --> $DIR/issue-43197.rs:21:5 + --> $DIR/issue-43197.rs:20:5 | LL | const X: u32 = 0-1; - | ^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow + | ^^^^^^^^^^^^^^^---^ + | | + | attempt to subtract with overflow warning: attempt to subtract with overflow - --> $DIR/issue-43197.rs:24:24 + --> $DIR/issue-43197.rs:23:24 | LL | const Y: u32 = foo(0-1); | ^^^ warning: this constant cannot be used - --> $DIR/issue-43197.rs:24:5 + --> $DIR/issue-43197.rs:23:5 | LL | const Y: u32 = foo(0-1); - | ^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow + | ^^^^^^^^^^^^^^^^^^^---^^ + | | + | attempt to subtract with overflow -warning: constant evaluation error - --> $DIR/issue-43197.rs:27:23 +warning: referenced constant + --> $DIR/issue-43197.rs:26:23 + | +LL | const X: u32 = 0-1; + | --- attempt to subtract with overflow +... +LL | println!("{} {}", X, Y); + | ^ + +warning: this expression will panic at runtime + --> $DIR/issue-43197.rs:26:23 | LL | println!("{} {}", X, Y); | ^ referenced constant has errors -warning: constant evaluation error - --> $DIR/issue-43197.rs:27:26 +warning: referenced constant + --> $DIR/issue-43197.rs:26:26 + | +LL | const Y: u32 = foo(0-1); + | --- attempt to subtract with overflow +... +LL | println!("{} {}", X, Y); + | ^ + +warning: this expression will panic at runtime + --> $DIR/issue-43197.rs:26:26 | LL | println!("{} {}", X, Y); | ^ referenced constant has errors +error[E0080]: referenced constant + --> $DIR/issue-43197.rs:26:26 + | +LL | const Y: u32 = foo(0-1); + | --- attempt to subtract with overflow +... +LL | println!("{} {}", X, Y); + | ^ + +error[E0080]: erroneous constant used + --> $DIR/issue-43197.rs:26:26 + | +LL | println!("{} {}", X, Y); + | ^ referenced constant has errors + +error[E0080]: referenced constant + --> $DIR/issue-43197.rs:26:23 + | +LL | const X: u32 = 0-1; + | --- attempt to subtract with overflow +... +LL | println!("{} {}", X, Y); + | ^ + +error[E0080]: erroneous constant used + --> $DIR/issue-43197.rs:26:23 + | +LL | println!("{} {}", X, Y); + | ^ referenced constant has errors + +error: aborting due to 4 previous errors + +For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/const-eval/issue-44578.nll.stderr b/src/test/ui/const-eval/issue-44578.nll.stderr new file mode 100644 index 0000000000000..ad4f08966c012 --- /dev/null +++ b/src/test/ui/const-eval/issue-44578.nll.stderr @@ -0,0 +1,39 @@ +error[E0080]: referenced constant + --> $DIR/issue-44578.rs:35:5 + | +LL | const AMT: usize = [A::AMT][(A::AMT > B::AMT) as usize]; + | ------------------------------------ index out of bounds: the len is 1 but the index is 1 +... +LL | println!("{}", as Foo>::AMT); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) + +error[E0080]: erroneous constant used + --> $DIR/issue-44578.rs:35:5 + | +LL | println!("{}", as Foo>::AMT); + | ^^^^^^^^^^^^^^^--------------------------^^ + | | + | referenced constant has errors + | + = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) + +error[E0080]: referenced constant + --> $DIR/issue-44578.rs:35:20 + | +LL | const AMT: usize = [A::AMT][(A::AMT > B::AMT) as usize]; + | ------------------------------------ index out of bounds: the len is 1 but the index is 1 +... +LL | println!("{}", as Foo>::AMT); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0080]: erroneous constant used + --> $DIR/issue-44578.rs:35:20 + | +LL | println!("{}", as Foo>::AMT); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors + +error: aborting due to 4 previous errors + +For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/const-eval/issue-44578.rs b/src/test/ui/const-eval/issue-44578.rs index 4133a8864f619..59ac4ab311c6c 100644 --- a/src/test/ui/const-eval/issue-44578.rs +++ b/src/test/ui/const-eval/issue-44578.rs @@ -8,8 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// compile-pass -#![warn(const_err)] +#![allow(const_err)] trait Foo { const AMT: usize; @@ -33,6 +32,7 @@ impl Foo for u16 { } fn main() { - println!("{}", as Foo>::AMT); //~ WARN const_err - //~^ WARN const_err + println!("{}", as Foo>::AMT); + //~^ ERROR erroneous constant used + //~| ERROR E0080 } diff --git a/src/test/ui/const-eval/issue-44578.stderr b/src/test/ui/const-eval/issue-44578.stderr index ce6ff86610aa5..28a723a069edf 100644 --- a/src/test/ui/const-eval/issue-44578.stderr +++ b/src/test/ui/const-eval/issue-44578.stderr @@ -1,18 +1,18 @@ -warning: constant evaluation error - --> $DIR/issue-44578.rs:36:20 +error[E0080]: referenced constant + --> $DIR/issue-44578.rs:35:20 | -LL | println!("{}", as Foo>::AMT); //~ WARN const_err - | ^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors - | -note: lint level defined here - --> $DIR/issue-44578.rs:12:9 - | -LL | #![warn(const_err)] - | ^^^^^^^^^ +LL | const AMT: usize = [A::AMT][(A::AMT > B::AMT) as usize]; + | ------------------------------------ index out of bounds: the len is 1 but the index is 1 +... +LL | println!("{}", as Foo>::AMT); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ -warning: constant evaluation error - --> $DIR/issue-44578.rs:36:20 +error[E0080]: erroneous constant used + --> $DIR/issue-44578.rs:35:20 | -LL | println!("{}", as Foo>::AMT); //~ WARN const_err +LL | println!("{}", as Foo>::AMT); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/const-eval/issue-50814-2.rs b/src/test/ui/const-eval/issue-50814-2.rs new file mode 100644 index 0000000000000..af627ee5fbe70 --- /dev/null +++ b/src/test/ui/const-eval/issue-50814-2.rs @@ -0,0 +1,43 @@ +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +trait C { + const BOO: usize; +} + +trait Foo { + const BAR: usize; +} + +struct A(T); + +impl Foo for A { + const BAR: usize = [5, 6, 7][T::BOO]; +} + +fn foo() -> &'static usize { + & as Foo>::BAR //~ ERROR erroneous constant used +//~| ERROR E0080 +} + +impl C for () { + const BOO: usize = 42; +} + +impl C for u32 { + const BOO: usize = 1; +} + +fn main() { + println!("{:x}", foo::<()>() as *const usize as usize); + println!("{:x}", foo::() as *const usize as usize); + println!("{:x}", foo::<()>()); + println!("{:x}", foo::()); +} diff --git a/src/test/ui/const-eval/issue-50814-2.stderr b/src/test/ui/const-eval/issue-50814-2.stderr new file mode 100644 index 0000000000000..3c59cb0e2bc72 --- /dev/null +++ b/src/test/ui/const-eval/issue-50814-2.stderr @@ -0,0 +1,20 @@ +error[E0080]: referenced constant + --> $DIR/issue-50814-2.rs:26:5 + | +LL | const BAR: usize = [5, 6, 7][T::BOO]; + | ----------------- index out of bounds: the len is 3 but the index is 42 +... +LL | & as Foo>::BAR //~ ERROR erroneous constant used + | ^^^^^^^^^^^^^^^^^^^^^^ + +error[E0080]: erroneous constant used + --> $DIR/issue-50814-2.rs:26:5 + | +LL | & as Foo>::BAR //~ ERROR erroneous constant used + | ^--------------------- + | | + | referenced constant has errors + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/const-eval/issue-50814.rs b/src/test/ui/const-eval/issue-50814.rs new file mode 100644 index 0000000000000..8f2752453b52e --- /dev/null +++ b/src/test/ui/const-eval/issue-50814.rs @@ -0,0 +1,33 @@ +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +trait Unsigned { + const MAX: u8; +} + +struct U8(u8); +impl Unsigned for U8 { + const MAX: u8 = 0xff; +} + +struct Sum(A,B); + +impl Unsigned for Sum { + const MAX: u8 = A::MAX + B::MAX; +} + +fn foo(_: T) -> &'static u8 { + &Sum::::MAX //~ ERROR erroneous constant used +//~| ERROR E0080 +} + +fn main() { + foo(0); +} diff --git a/src/test/ui/const-eval/issue-50814.stderr b/src/test/ui/const-eval/issue-50814.stderr new file mode 100644 index 0000000000000..145279ccc033d --- /dev/null +++ b/src/test/ui/const-eval/issue-50814.stderr @@ -0,0 +1,20 @@ +error[E0080]: referenced constant + --> $DIR/issue-50814.rs:27:5 + | +LL | const MAX: u8 = A::MAX + B::MAX; + | --------------- attempt to add with overflow +... +LL | &Sum::::MAX //~ ERROR erroneous constant used + | ^^^^^^^^^^^^^^^^^^ + +error[E0080]: erroneous constant used + --> $DIR/issue-50814.rs:27:5 + | +LL | &Sum::::MAX //~ ERROR erroneous constant used + | ^----------------- + | | + | referenced constant has errors + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/const-eval/promoted_const_fn_fail.rs b/src/test/ui/const-eval/promoted_const_fn_fail.rs index 5ced2c9dd8f59..4888ed6e8dc7b 100644 --- a/src/test/ui/const-eval/promoted_const_fn_fail.rs +++ b/src/test/ui/const-eval/promoted_const_fn_fail.rs @@ -23,8 +23,8 @@ const fn bar() -> u8 { // is run on a system whose pointers need more // than 8 bits Bar { a: &42 }.b as u8 - //~^ constant evaluation error - //~| constant evaluation error + //~^ ERROR this expression will panic at runtime + //~| ERROR this expression will panic at runtime } } diff --git a/src/test/ui/const-eval/promoted_const_fn_fail.stderr b/src/test/ui/const-eval/promoted_const_fn_fail.stderr index f910705bb7b3c..d805e1a27c993 100644 --- a/src/test/ui/const-eval/promoted_const_fn_fail.stderr +++ b/src/test/ui/const-eval/promoted_const_fn_fail.stderr @@ -1,4 +1,4 @@ -error: constant evaluation error +error: this expression will panic at runtime --> $DIR/promoted_const_fn_fail.rs:25:9 | LL | Bar { a: &42 }.b as u8 @@ -9,23 +9,12 @@ note: lint level defined here | LL | #![deny(const_err)] | ^^^^^^^^^ -note: inside call to `bar` - --> $DIR/promoted_const_fn_fail.rs:35:28 - | -LL | let x: &'static u8 = &(bar() + 1); - | ^^^^^ -error: constant evaluation error +error: this expression will panic at runtime --> $DIR/promoted_const_fn_fail.rs:25:9 | LL | Bar { a: &42 }.b as u8 | ^^^^^^^^^^^^^^^^^^^^^^ a raw memory access tried to access part of a pointer value as raw bytes - | -note: inside call to `bar` - --> $DIR/promoted_const_fn_fail.rs:35:28 - | -LL | let x: &'static u8 = &(bar() + 1); - | ^^^^^ error: aborting due to 2 previous errors diff --git a/src/test/ui/const-eval/promoted_errors.stderr b/src/test/ui/const-eval/promoted_errors.stderr index 683ee5375fbf6..a4c1c48a03dfe 100644 --- a/src/test/ui/const-eval/promoted_errors.stderr +++ b/src/test/ui/const-eval/promoted_errors.stderr @@ -1,4 +1,4 @@ -warning: constant evaluation error +warning: this expression will panic at runtime --> $DIR/promoted_errors.rs:17:14 | LL | let _x = 0u32 - 1; @@ -16,7 +16,7 @@ warning: attempt to divide by zero LL | println!("{}", 1/(1-1)); | ^^^^^^^ -warning: constant evaluation error +warning: this expression will panic at runtime --> $DIR/promoted_errors.rs:19:20 | LL | println!("{}", 1/(1-1)); @@ -28,13 +28,13 @@ warning: attempt to divide by zero LL | let _x = 1/(1-1); | ^^^^^^^ -warning: constant evaluation error +warning: this expression will panic at runtime --> $DIR/promoted_errors.rs:22:14 | LL | let _x = 1/(1-1); | ^^^^^^^ attempt to divide by zero -warning: constant evaluation error +warning: this expression will panic at runtime --> $DIR/promoted_errors.rs:25:20 | LL | println!("{}", 1/(false as u32)); diff --git a/src/test/ui/const-eval/pub_const_err.stderr b/src/test/ui/const-eval/pub_const_err.stderr index 068825f1cd310..352289417547e 100644 --- a/src/test/ui/const-eval/pub_const_err.stderr +++ b/src/test/ui/const-eval/pub_const_err.stderr @@ -14,7 +14,9 @@ warning: this constant cannot be used --> $DIR/pub_const_err.rs:16:1 | LL | pub const Z: u32 = 0 - 1; - | ^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow + | ^^^^^^^^^^^^^^^^^^^-----^ + | | + | attempt to subtract with overflow warning: attempt to subtract with overflow --> $DIR/pub_const_err.rs:20:22 diff --git a/src/test/ui/const-eval/pub_const_err_bin.stderr b/src/test/ui/const-eval/pub_const_err_bin.stderr index dcb8125fc55bc..a6db2176011d5 100644 --- a/src/test/ui/const-eval/pub_const_err_bin.stderr +++ b/src/test/ui/const-eval/pub_const_err_bin.stderr @@ -14,7 +14,9 @@ warning: this constant cannot be used --> $DIR/pub_const_err_bin.rs:14:1 | LL | pub const Z: u32 = 0 - 1; - | ^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow + | ^^^^^^^^^^^^^^^^^^^-----^ + | | + | attempt to subtract with overflow warning: attempt to subtract with overflow --> $DIR/pub_const_err_bin.rs:18:22 diff --git a/src/test/ui/const-fn-error.rs b/src/test/ui/const-fn-error.rs index 17dc9f94fe19c..6eda41730b307 100644 --- a/src/test/ui/const-fn-error.rs +++ b/src/test/ui/const-fn-error.rs @@ -19,7 +19,6 @@ const fn f(x: usize) -> usize { for i in 0..x { //~^ ERROR E0015 //~| ERROR E0019 - //~| ERROR E0080 sum += i; } sum @@ -27,5 +26,5 @@ const fn f(x: usize) -> usize { #[allow(unused_variables)] fn main() { - let a : [i32; f(X)]; + let a : [i32; f(X)]; //~ ERROR E0080 } diff --git a/src/test/ui/const-fn-error.stderr b/src/test/ui/const-fn-error.stderr index 29edc2756afff..cdbf86f42ecc0 100644 --- a/src/test/ui/const-fn-error.stderr +++ b/src/test/ui/const-fn-error.stderr @@ -26,20 +26,16 @@ error[E0019]: constant function contains unimplemented expression type LL | for i in 0..x { | ^^^^ -error[E0080]: constant evaluation error - --> $DIR/const-fn-error.rs:19:14 +error[E0080]: could not evaluate constant expression + --> $DIR/const-fn-error.rs:29:13 | LL | for i in 0..x { - | ^^^^ calling non-const fn `>::into_iter` + | ---- calling non-const fn `>::into_iter` ... -LL | let a : [i32; f(X)]; - | ---- inside call to `f` - | -note: for constant expression here - --> $DIR/const-fn-error.rs:30:13 - | -LL | let a : [i32; f(X)]; - | ^^^^^^^^^^^ +LL | let a : [i32; f(X)]; //~ ERROR E0080 + | ^^^^^^----^ + | | + | inside call to `f` error: aborting due to 5 previous errors diff --git a/src/test/ui/const-len-underflow-separate-spans.rs b/src/test/ui/const-len-underflow-separate-spans.rs index 453e332a903c7..20b8865767459 100644 --- a/src/test/ui/const-len-underflow-separate-spans.rs +++ b/src/test/ui/const-len-underflow-separate-spans.rs @@ -21,4 +21,5 @@ const LEN: usize = ONE - TWO; fn main() { let a: [i8; LEN] = unimplemented!(); //~^ ERROR E0080 +//~| ERROR E0080 } diff --git a/src/test/ui/const-len-underflow-separate-spans.stderr b/src/test/ui/const-len-underflow-separate-spans.stderr index 48ff7a81c24ee..630828ef8f517 100644 --- a/src/test/ui/const-len-underflow-separate-spans.stderr +++ b/src/test/ui/const-len-underflow-separate-spans.stderr @@ -12,12 +12,23 @@ error[E0080]: constant evaluation error LL | const LEN: usize = ONE - TWO; | ^^^^^^^^^ attempt to subtract with overflow -error[E0080]: constant evaluation error - --> $DIR/const-len-underflow-separate-spans.rs:22:17 +error[E0080]: referenced constant + --> $DIR/const-len-underflow-separate-spans.rs:22:12 + | +LL | const LEN: usize = ONE - TWO; + | --------- attempt to subtract with overflow +... +LL | let a: [i8; LEN] = unimplemented!(); + | ^^^^^^^^^ + +error[E0080]: could not evaluate constant expression + --> $DIR/const-len-underflow-separate-spans.rs:22:12 | LL | let a: [i8; LEN] = unimplemented!(); - | ^^^ referenced constant has errors + | ^^^^^---^ + | | + | referenced constant has errors -error: aborting due to 3 previous errors +error: aborting due to 4 previous errors For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/error-codes/E0080.stderr b/src/test/ui/error-codes/E0080.stderr index 25ec5c458312d..a213c2b1b208e 100644 --- a/src/test/ui/error-codes/E0080.stderr +++ b/src/test/ui/error-codes/E0080.stderr @@ -6,7 +6,7 @@ LL | X = (1 << 500), //~ ERROR E0080 | = note: #[deny(exceeding_bitshifts)] on by default -error[E0080]: constant evaluation error +error[E0080]: could not evaluate enum discriminant --> $DIR/E0080.rs:12:9 | LL | X = (1 << 500), //~ ERROR E0080 @@ -20,13 +20,13 @@ LL | Y = (1 / 0) //~ ERROR E0080 | = note: #[deny(const_err)] on by default -error: constant evaluation error +error: this expression will panic at runtime --> $DIR/E0080.rs:14:9 | LL | Y = (1 / 0) //~ ERROR E0080 | ^^^^^^^ attempt to divide by zero -error[E0080]: constant evaluation error +error[E0080]: could not evaluate enum discriminant --> $DIR/E0080.rs:14:9 | LL | Y = (1 / 0) //~ ERROR E0080 diff --git a/src/test/ui/infinite-recursion-const-fn.rs b/src/test/ui/infinite-recursion-const-fn.rs index f98074bc554bb..4f1f67214509e 100644 --- a/src/test/ui/infinite-recursion-const-fn.rs +++ b/src/test/ui/infinite-recursion-const-fn.rs @@ -11,8 +11,8 @@ //https://github.com/rust-lang/rust/issues/31364 #![feature(const_fn)] -const fn a() -> usize { b() } //~ ERROR constant evaluation error +const fn a() -> usize { b() } const fn b() -> usize { a() } -const ARR: [i32; a()] = [5; 6]; +const ARR: [i32; a()] = [5; 6]; //~ ERROR could not evaluate constant expression fn main(){} diff --git a/src/test/ui/infinite-recursion-const-fn.stderr b/src/test/ui/infinite-recursion-const-fn.stderr index 81717fe1f0929..fb7c1be75413e 100644 --- a/src/test/ui/infinite-recursion-const-fn.stderr +++ b/src/test/ui/infinite-recursion-const-fn.stderr @@ -1,8 +1,8 @@ -error[E0080]: constant evaluation error - --> $DIR/infinite-recursion-const-fn.rs:14:25 +error[E0080]: could not evaluate constant expression + --> $DIR/infinite-recursion-const-fn.rs:16:1 | -LL | const fn a() -> usize { b() } //~ ERROR constant evaluation error - | ^^^ +LL | const fn a() -> usize { b() } + | --- | | | reached the configured maximum number of stack frames | inside call to `b` @@ -58,14 +58,10 @@ LL | const fn b() -> usize { a() } | inside call to `a` | inside call to `a` | inside call to `a` -LL | const ARR: [i32; a()] = [5; 6]; - | --- inside call to `a` - | -note: for constant expression here - --> $DIR/infinite-recursion-const-fn.rs:16:1 - | -LL | const ARR: [i32; a()] = [5; 6]; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | const ARR: [i32; a()] = [5; 6]; //~ ERROR could not evaluate constant expression + | ^^^^^^^^^^^^^^^^^---^^^^^^^^^^^ + | | + | inside call to `a` error: aborting due to previous error diff --git a/src/test/ui/issue-49257.rs b/src/test/ui/issue-49257.rs index a319849223740..f288a2b217428 100644 --- a/src/test/ui/issue-49257.rs +++ b/src/test/ui/issue-49257.rs @@ -17,6 +17,8 @@ struct Point { x: u8, y: u8 } fn main() { let p = Point { x: 0, y: 0 }; + let Point { .., y, } = p; //~ ERROR expected `}`, found `,` let Point { .., y } = p; //~ ERROR expected `}`, found `,` - //~| ERROR pattern does not mention fields `x`, `y` + let Point { .., } = p; //~ ERROR expected `}`, found `,` + let Point { .. } = p; } diff --git a/src/test/ui/issue-49257.stderr b/src/test/ui/issue-49257.stderr index fec990764bb14..40179832b49b2 100644 --- a/src/test/ui/issue-49257.stderr +++ b/src/test/ui/issue-49257.stderr @@ -1,15 +1,38 @@ error: expected `}`, found `,` --> $DIR/issue-49257.rs:20:19 | -LL | let Point { .., y } = p; //~ ERROR expected `}`, found `,` - | ^ `..` must be in the last position, and cannot have a trailing comma +LL | let Point { .., y, } = p; //~ ERROR expected `}`, found `,` + | --^ + | | | + | | expected `}` + | `..` must be at the end and cannot have a trailing comma +help: move the `..` to the end of the field list + | +LL | let Point { y, .. } = p; //~ ERROR expected `}`, found `,` + | -- ^^^^ -error[E0027]: pattern does not mention fields `x`, `y` - --> $DIR/issue-49257.rs:20:9 +error: expected `}`, found `,` + --> $DIR/issue-49257.rs:21:19 | LL | let Point { .., y } = p; //~ ERROR expected `}`, found `,` - | ^^^^^^^^^^^^^^^ missing fields `x`, `y` + | --^ + | | | + | | expected `}` + | `..` must be at the end and cannot have a trailing comma +help: move the `..` to the end of the field list + | +LL | let Point { y , .. } = p; //~ ERROR expected `}`, found `,` + | -- ^^^^^^ + +error: expected `}`, found `,` + --> $DIR/issue-49257.rs:22:19 + | +LL | let Point { .., } = p; //~ ERROR expected `}`, found `,` + | --^ + | | | + | | expected `}` + | | help: remove this comma + | `..` must be at the end and cannot have a trailing comma -error: aborting due to 2 previous errors +error: aborting due to 3 previous errors -For more information about this error, try `rustc --explain E0027`. diff --git a/src/test/ui/struct-duplicate-comma.rs b/src/test/ui/struct-duplicate-comma.rs new file mode 100644 index 0000000000000..d7ee2f220d470 --- /dev/null +++ b/src/test/ui/struct-duplicate-comma.rs @@ -0,0 +1,27 @@ +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// compile-flags: -Z parse-only + +// Issue #50974 + +struct Foo { + a: u8, + b: u8 +} + +fn main() { + let bar = Foo { + a: 0,, + //~^ ERROR expected identifier + b: 42 + }; +} + diff --git a/src/test/ui/struct-duplicate-comma.stderr b/src/test/ui/struct-duplicate-comma.stderr new file mode 100644 index 0000000000000..06e3b95c24830 --- /dev/null +++ b/src/test/ui/struct-duplicate-comma.stderr @@ -0,0 +1,13 @@ +error: expected identifier, found `,` + --> $DIR/struct-duplicate-comma.rs:22:14 + | +LL | let bar = Foo { + | --- while parsing this struct +LL | a: 0,, + | ^ + | | + | expected identifier + | help: remove this comma + +error: aborting due to previous error + diff --git a/src/test/ui/type-dependent-def-issue-49241.rs b/src/test/ui/type-dependent-def-issue-49241.rs index 64264999fd2f1..db27ae89e69fd 100644 --- a/src/test/ui/type-dependent-def-issue-49241.rs +++ b/src/test/ui/type-dependent-def-issue-49241.rs @@ -11,5 +11,5 @@ fn main() { let v = vec![0]; const l: usize = v.count(); //~ ERROR can't capture dynamic environment in a fn item - let s: [u32; l] = v.into_iter().collect(); //~ ERROR constant evaluation error + let s: [u32; l] = v.into_iter().collect(); } diff --git a/src/test/ui/type-dependent-def-issue-49241.stderr b/src/test/ui/type-dependent-def-issue-49241.stderr index f00edccae5d50..361d28f274fa3 100644 --- a/src/test/ui/type-dependent-def-issue-49241.stderr +++ b/src/test/ui/type-dependent-def-issue-49241.stderr @@ -6,13 +6,6 @@ LL | const l: usize = v.count(); //~ ERROR can't capture dynamic environment | = help: use the `|| { ... }` closure form instead -error[E0080]: constant evaluation error - --> $DIR/type-dependent-def-issue-49241.rs:14:18 - | -LL | let s: [u32; l] = v.into_iter().collect(); //~ ERROR constant evaluation error - | ^ encountered constants with type errors, stopping evaluation - -error: aborting due to 2 previous errors +error: aborting due to previous error -Some errors occurred: E0080, E0434. -For more information about an error, try `rustc --explain E0080`. +For more information about this error, try `rustc --explain E0434`.