From 6005b0ad2fc1398d7d4f757cc96eb783ee8fc1ac Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Mon, 25 Jun 2018 17:41:20 +0200 Subject: [PATCH] Move the Lrc outside the error type and name the fields --- src/librustc/ich/impls_ty.rs | 3 ++- src/librustc/middle/const_val.rs | 13 ++++++------ src/librustc/mir/interpret/error.rs | 3 ++- src/librustc/traits/fulfill.rs | 6 +++--- src/librustc/traits/mod.rs | 2 +- src/librustc/traits/structural_impls.rs | 4 +++- src/librustc/ty/structural_impls.rs | 8 ++++---- src/librustc_codegen_llvm/mir/constant.rs | 9 +++++---- src/librustc_codegen_llvm/mir/operand.rs | 3 ++- src/librustc_mir/interpret/const_eval.rs | 23 +++++++++++++--------- src/librustc_mir/monomorphize/collector.rs | 2 +- src/librustc_mir/transform/const_prop.rs | 3 ++- 12 files changed, 46 insertions(+), 33 deletions(-) diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index 8779d3d3f07..a8e1c04207d 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -505,7 +505,8 @@ impl_stable_hash_for!(struct ty::Const<'tcx> { impl_stable_hash_for!(struct ::middle::const_val::ConstEvalErr<'tcx> { span, - data + stacktrace, + error }); impl_stable_hash_for!(struct ::middle::const_val::FrameInfo { diff --git a/src/librustc/middle/const_val.rs b/src/librustc/middle/const_val.rs index c39422d21c0..9177b70d1a4 100644 --- a/src/librustc/middle/const_val.rs +++ b/src/librustc/middle/const_val.rs @@ -20,7 +20,7 @@ use syntax::ast; use rustc_data_structures::sync::Lrc; -pub type EvalResult<'tcx> = Result<&'tcx ty::Const<'tcx>, ConstEvalErr<'tcx>>; +pub type EvalResult<'tcx> = Result<&'tcx ty::Const<'tcx>, Lrc>>; #[derive(Copy, Clone, Debug, Hash, RustcEncodable, RustcDecodable, Eq, PartialEq, Ord, PartialOrd)] pub enum ConstVal<'tcx> { @@ -31,7 +31,8 @@ pub enum ConstVal<'tcx> { #[derive(Clone, Debug, RustcEncodable, RustcDecodable)] pub struct ConstEvalErr<'tcx> { pub span: Span, - pub data: Lrc<(::mir::interpret::EvalError<'tcx>, Vec)>, + pub error: ::mir::interpret::EvalError<'tcx>, + pub stacktrace: Vec, } #[derive(Clone, Debug, RustcEncodable, RustcDecodable)] @@ -81,7 +82,7 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> { message: &str, lint_root: Option, ) -> Option> { - match self.data.0.kind { + match self.error.kind { ::mir::interpret::EvalErrorKind::TypeckError | ::mir::interpret::EvalErrorKind::TooGeneric | ::mir::interpret::EvalErrorKind::CheckMatchError | @@ -93,7 +94,7 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> { } trace!("reporting const eval failure at {:?}", self.span); let mut err = if let Some(lint_root) = lint_root { - let node_id = self.data.1 + let node_id = self.stacktrace .iter() .rev() .filter_map(|frame| frame.lint_root) @@ -108,8 +109,8 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> { } else { struct_error(tcx, message) }; - err.span_label(self.span, self.data.0.to_string()); - for FrameInfo { span, location, .. } in &self.data.1 { + err.span_label(self.span, self.error.to_string()); + for FrameInfo { span, location, .. } in &self.stacktrace { err.span_label(*span, format!("inside call to `{}`", location)); } Some(err) diff --git a/src/librustc/mir/interpret/error.rs b/src/librustc/mir/interpret/error.rs index 827ac7ef7fc..b018b2c0391 100644 --- a/src/librustc/mir/interpret/error.rs +++ b/src/librustc/mir/interpret/error.rs @@ -4,6 +4,7 @@ use mir; use middle::const_val::ConstEvalErr; use ty::{FnSig, Ty, layout}; use ty::layout::{Size, Align}; +use rustc_data_structures::sync::Lrc; use super::{ Pointer, Lock, AccessKind @@ -155,7 +156,7 @@ pub enum EvalErrorKind<'tcx, O> { CheckMatchError, /// Cannot compute this constant because it depends on another one /// which already produced an error - ReferencedConstant(ConstEvalErr<'tcx>), + ReferencedConstant(Lrc>), GeneratorResumedAfterReturn, GeneratorResumedAfterPanic, } diff --git a/src/librustc/traits/fulfill.rs b/src/librustc/traits/fulfill.rs index c9021bcd410..398c99ffaf9 100644 --- a/src/librustc/traits/fulfill.rs +++ b/src/librustc/traits/fulfill.rs @@ -499,12 +499,12 @@ impl<'a, 'b, 'gcx, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'gcx, CodeSelectionError(ConstEvalFailure(err))) } } else { - let err = EvalErrorKind::TooGeneric.into(); ProcessResult::Error( CodeSelectionError(ConstEvalFailure(ConstEvalErr { span: obligation.cause.span, - data: (err, vec![]).into(), - })) + error: EvalErrorKind::TooGeneric.into(), + stacktrace: vec![], + }.into())) ) } }, diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs index c7e55fa574f..88236aa8b67 100644 --- a/src/librustc/traits/mod.rs +++ b/src/librustc/traits/mod.rs @@ -381,7 +381,7 @@ pub enum SelectionError<'tcx> { ty::PolyTraitRef<'tcx>, ty::error::TypeError<'tcx>), TraitNotObjectSafe(DefId), - ConstEvalFailure(ConstEvalErr<'tcx>), + ConstEvalFailure(Lrc>), Overflow, } diff --git a/src/librustc/traits/structural_impls.rs b/src/librustc/traits/structural_impls.rs index d24c84b2556..39e358803cb 100644 --- a/src/librustc/traits/structural_impls.rs +++ b/src/librustc/traits/structural_impls.rs @@ -172,7 +172,9 @@ impl<'a, 'tcx> Lift<'tcx> for traits::SelectionError<'a> { }) } super::TraitNotObjectSafe(def_id) => Some(super::TraitNotObjectSafe(def_id)), - super::ConstEvalFailure(ref err) => tcx.lift(err).map(super::ConstEvalFailure), + super::ConstEvalFailure(ref err) => tcx.lift(&**err).map(|err| super::ConstEvalFailure( + err.into(), + )), super::Overflow => bug!(), // FIXME: ape ConstEvalFailure? } } diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs index 3ff714d89c4..f00ec8be195 100644 --- a/src/librustc/ty/structural_impls.rs +++ b/src/librustc/ty/structural_impls.rs @@ -18,7 +18,6 @@ use ty::{self, Lift, Ty, TyCtxt}; use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; use rustc_data_structures::accumulate_vec::AccumulateVec; use rustc_data_structures::indexed_vec::{IndexVec, Idx}; -use rustc_data_structures::sync::Lrc; use mir::interpret; use std::rc::Rc; @@ -462,10 +461,11 @@ impl<'a, 'tcx> Lift<'tcx> for ty::error::TypeError<'a> { impl<'a, 'tcx> Lift<'tcx> for ConstEvalErr<'a> { type Lifted = ConstEvalErr<'tcx>; fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option { - tcx.lift(&self.data.0).map(|data| { + tcx.lift(&self.error).map(|error| { ConstEvalErr { span: self.span, - data: Lrc::new((data, self.data.1.clone())), + stacktrace: self.stacktrace.clone(), + error, } }) } @@ -579,7 +579,7 @@ impl<'a, 'tcx, O: Lift<'tcx>> Lift<'tcx> for interpret::EvalErrorKind<'a, O> { TypeckError => TypeckError, TooGeneric => TooGeneric, CheckMatchError => CheckMatchError, - ReferencedConstant(ref err) => ReferencedConstant(tcx.lift(err)?), + ReferencedConstant(ref err) => ReferencedConstant(tcx.lift(&**err)?.into()), OverflowNeg => OverflowNeg, Overflow(op) => Overflow(op), DivisionByZero => DivisionByZero, diff --git a/src/librustc_codegen_llvm/mir/constant.rs b/src/librustc_codegen_llvm/mir/constant.rs index 7c1035e2fcb..fc219df9b04 100644 --- a/src/librustc_codegen_llvm/mir/constant.rs +++ b/src/librustc_codegen_llvm/mir/constant.rs @@ -14,6 +14,7 @@ use rustc_mir::interpret::{read_target_uint, const_val_field}; use rustc::hir::def_id::DefId; use rustc::mir; use rustc_data_structures::indexed_vec::Idx; +use rustc_data_structures::sync::Lrc; use rustc::mir::interpret::{GlobalId, Pointer, Scalar, Allocation, ConstValue, AllocType}; use rustc::ty::{self, Ty}; use rustc::ty::layout::{self, HasDataLayout, LayoutOf, Size}; @@ -117,7 +118,7 @@ pub fn const_alloc_to_llvm(cx: &CodegenCx, alloc: &Allocation) -> ValueRef { pub fn codegen_static_initializer<'a, 'tcx>( cx: &CodegenCx<'a, 'tcx>, def_id: DefId) - -> Result> + -> Result>> { let instance = ty::Instance::mono(cx.tcx, def_id); let cid = GlobalId { @@ -139,7 +140,7 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> { &mut self, bx: &Builder<'a, 'tcx>, constant: &'tcx ty::Const<'tcx>, - ) -> Result, ConstEvalErr<'tcx>> { + ) -> Result, Lrc>> { match constant.val { ConstVal::Unevaluated(def_id, ref substs) => { let tcx = bx.tcx(); @@ -160,7 +161,7 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> { &mut self, bx: &Builder<'a, 'tcx>, constant: &mir::Constant<'tcx>, - ) -> Result, ConstEvalErr<'tcx>> { + ) -> Result, Lrc>> { match constant.literal { mir::Literal::Promoted { index } => { let param_env = ty::ParamEnv::reveal_all(); @@ -189,7 +190,7 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> { ty::TyArray(_, n) => n.unwrap_usize(bx.tcx()), ref other => bug!("invalid simd shuffle type: {}", other), }; - let values: Result, _> = (0..fields).map(|field| { + let values: Result, Lrc<_>> = (0..fields).map(|field| { let field = const_val_field( bx.tcx(), ty::ParamEnv::reveal_all(), diff --git a/src/librustc_codegen_llvm/mir/operand.rs b/src/librustc_codegen_llvm/mir/operand.rs index 9f32b41cb13..0381a5e2987 100644 --- a/src/librustc_codegen_llvm/mir/operand.rs +++ b/src/librustc_codegen_llvm/mir/operand.rs @@ -15,6 +15,7 @@ use rustc::mir::interpret::ConstValue; use rustc::ty; use rustc::ty::layout::{self, Align, LayoutOf, TyLayout}; use rustc_data_structures::indexed_vec::Idx; +use rustc_data_structures::sync::Lrc; use base; use common::{self, CodegenCx, C_null, C_undef, C_usize}; @@ -97,7 +98,7 @@ impl<'a, 'tcx> OperandRef<'tcx> { pub fn from_const(bx: &Builder<'a, 'tcx>, val: ConstValue<'tcx>, ty: ty::Ty<'tcx>) - -> Result, ConstEvalErr<'tcx>> { + -> Result, Lrc>> { let layout = bx.cx.layout_of(ty); if layout.is_zst() { diff --git a/src/librustc_mir/interpret/const_eval.rs b/src/librustc_mir/interpret/const_eval.rs index 831b3bfd8d1..52edd22f027 100644 --- a/src/librustc_mir/interpret/const_eval.rs +++ b/src/librustc_mir/interpret/const_eval.rs @@ -104,7 +104,8 @@ pub fn value_to_const_value<'tcx>( let (frames, span) = ecx.generate_stacktrace(None); let err = ConstEvalErr { span, - data: (err, frames).into(), + error: err, + stacktrace: frames, }; err.report_as_error( ecx.tcx, @@ -466,9 +467,10 @@ pub fn const_val_field<'a, 'tcx>( result.map_err(|err| { let (trace, span) = ecx.generate_stacktrace(None); ConstEvalErr { - data: (err, trace).into(), + error: err, + stacktrace: trace, span, - } + }.into() }) } @@ -537,9 +539,10 @@ pub fn const_eval_provider<'a, 'tcx>( // Do match-check before building MIR if tcx.check_match(def_id).is_err() { return Err(ConstEvalErr { - data: (EvalErrorKind::CheckMatchError.into(), Vec::new()).into(), + error: EvalErrorKind::CheckMatchError.into(), + stacktrace: vec![], span, - }); + }.into()); } if let hir::BodyOwnerKind::Const = tcx.hir.body_owner_kind(id) { @@ -549,9 +552,10 @@ pub fn const_eval_provider<'a, 'tcx>( // Do not continue into miri if typeck errors occurred; it will fail horribly if tables.tainted_by_errors { return Err(ConstEvalErr { - data: (EvalErrorKind::TypeckError.into(), Vec::new()).into(), + error: EvalErrorKind::CheckMatchError.into(), + stacktrace: vec![], span, - }); + }.into()); } }; @@ -564,13 +568,14 @@ pub fn const_eval_provider<'a, 'tcx>( }).map_err(|err| { let (trace, span) = ecx.generate_stacktrace(None); let err = ConstEvalErr { - data: (err, trace).into(), + error: err, + stacktrace: trace, span, }; if tcx.is_static(def_id).is_some() { err.report_as_error(ecx.tcx, "could not evaluate static initializer"); } - err + err.into() }) } diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index 8e13ac3d415..2d364f24b6b 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -1210,7 +1210,7 @@ fn collect_neighbours<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, Ok(val) => collect_const(tcx, val, instance.substs, output), Err(err) => { use rustc::mir::interpret::EvalErrorKind; - if let EvalErrorKind::ReferencedConstant(_) = err.data.0.kind { + if let EvalErrorKind::ReferencedConstant(_) = err.error.kind { err.report_as_error( tcx.at(mir.promoted[i].span), "erroneous constant used", diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs index ee53cfb7b6b..2233c5c7980 100644 --- a/src/librustc_mir/transform/const_prop.rs +++ b/src/librustc_mir/transform/const_prop.rs @@ -145,7 +145,8 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> { let (frames, span) = self.ecx.generate_stacktrace(None); let err = ConstEvalErr { span, - data: (err, frames).into(), + error: err, + stacktrace: frames, }; err.report_as_lint( self.ecx.tcx,