Report const eval error inside the query

Author: oli-obk

src/librustc/dep_graph/dep_node.rs

@@ -530,6 +530,7 @@ define_dep_nodes!( <'tcx>
     [] UsedTraitImports(DefId),
     [] HasTypeckTables(DefId),
     [] ConstEval { param_env: ParamEnvAnd<'tcx, GlobalId<'tcx>> },
+    [] ConstEvalRaw { param_env: ParamEnvAnd<'tcx, GlobalId<'tcx>> },
     [] CheckMatch(DefId),
     [] SymbolName(DefId),
     [] InstanceSymbolName { instance: Instance<'tcx> },

src/librustc/hir/def.rs

@@ -74,6 +74,7 @@ pub enum Def {
     SelfCtor(DefId /* impl */),  // DefId refers to the impl
     Method(DefId),
     AssociatedConst(DefId),
+    Closure(hir::BodyId),
 
     Local(ast::NodeId),
     Upvar(ast::NodeId,  // node id of closed over local
@@ -281,6 +282,7 @@ impl Def {
                 id
             }
 
+            Def::Closure(_) |
             Def::Local(..) |
             Def::Upvar(..) |
             Def::Label(..)  |
@@ -319,6 +321,7 @@ impl Def {
             Def::Trait(..) => "trait",
             Def::ForeignTy(..) => "foreign type",
             Def::Method(..) => "method",
+            Def::Closure(_) => "closure",
             Def::Const(..) => "constant",
             Def::AssociatedConst(..) => "associated constant",
             Def::TyParam(..) => "type parameter",

src/librustc/hir/map/mod.rs

@@ -340,9 +340,14 @@ impl<'hir> Map<'hir> {
                 let def_id = self.local_def_id(variant.node.data.id());
                 Some(Def::Variant(def_id))
             }
+            Node::Expr(expr) => {
+                match expr.node {
+                    ExprKind::Closure(_, _, body_id, _, _) => Some(Def::Closure(body_id)),
+                    _ => None,
+                }
+            }
             Node::Field(_) |
             Node::AnonConst(_) |
-            Node::Expr(_) |
             Node::Stmt(_) |
             Node::Ty(_) |
             Node::TraitRef(_) |

src/librustc/ich/impls_hir.rs

@@ -1044,6 +1044,7 @@ impl_stable_hash_for!(enum hir::def::Def {
     SelfCtor(impl_def_id),
     VariantCtor(def_id, ctor_kind),
     Method(def_id),
+    Closure(body_id),
     AssociatedConst(def_id),
     Local(def_id),
     Upvar(def_id, index, expr_id),

src/librustc/ich/impls_ty.rs

@@ -483,10 +483,9 @@ impl_stable_hash_for!(struct ty::Const<'tcx> {
     val
 });
 
-impl_stable_hash_for!(struct ::mir::interpret::ConstEvalErr<'tcx> {
-    span,
-    stacktrace,
-    error
+impl_stable_hash_for!(enum mir::interpret::ErrorHandled {
+    Reported,
+    TooGeneric
 });
 
 impl_stable_hash_for!(struct ::mir::interpret::FrameInfo {
@@ -503,8 +502,6 @@ impl_stable_hash_for!(struct ty::GenericPredicates<'tcx> {
     predicates
 });
 
-impl_stable_hash_for!(struct ::mir::interpret::EvalError<'tcx> { kind });
-
 impl<'a, 'gcx, O: HashStable<StableHashingContext<'a>>> HashStable<StableHashingContext<'a>>
 for ::mir::interpret::EvalErrorKind<'gcx, O> {
     fn hash_stable<W: StableHasherResult>(&self,
@@ -543,14 +540,14 @@ for ::mir::interpret::EvalErrorKind<'gcx, O> {
             UnimplementedTraitSelection |
             TypeckError |
             TooGeneric |
-            CheckMatchError |
             DerefFunctionPointer |
             ExecuteMemory |
             OverflowNeg |
             RemainderByZero |
             DivisionByZero |
             GeneratorResumedAfterReturn |
             GeneratorResumedAfterPanic |
+            ReferencedConstant |
             InfiniteLoop => {}
             ReadUndefBytes(offset) => offset.hash_stable(hcx, hasher),
             InvalidDiscriminant(val) => val.hash_stable(hcx, hasher),
@@ -560,7 +557,6 @@ for ::mir::interpret::EvalErrorKind<'gcx, O> {
                 line.hash_stable(hcx, hasher);
                 col.hash_stable(hcx, hasher);
             },
-            ReferencedConstant(ref err) => err.hash_stable(hcx, hasher),
             MachineError(ref err) => err.hash_stable(hcx, hasher),
             FunctionAbiMismatch(a, b) => {
                 a.hash_stable(hcx, hasher);

src/librustc/mir/interpret/error.rs

@@ -13,7 +13,6 @@ use std::{fmt, env};
 use mir;
 use ty::{Ty, layout};
 use ty::layout::{Size, Align};
-use rustc_data_structures::sync::Lrc;
 use rustc_target::spec::abi::Abi;
 
 use super::{
@@ -30,7 +29,26 @@ use syntax_pos::Span;
 use syntax::ast;
 use syntax::symbol::Symbol;
 
-pub type ConstEvalResult<'tcx> = Result<&'tcx ty::Const<'tcx>, Lrc<ConstEvalErr<'tcx>>>;
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ErrorHandled {
+    /// Already reported a lint or an error for this evaluation
+    Reported,
+    /// Don't emit an error, the evaluation failed because the MIR was generic
+    /// and the substs didn't fully monomorphize it.
+    TooGeneric,
+}
+
+impl ErrorHandled {
+    pub fn assert_reported(self) {
+        match self {
+            ErrorHandled::Reported => {},
+            ErrorHandled::TooGeneric => bug!("MIR interpretation failed without reporting an error \
+                                              even though it was fully monomorphized"),
+        }
+    }
+}
+
+pub type ConstEvalResult<'tcx> = Result<&'tcx ty::Const<'tcx>, ErrorHandled>;
 
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
 pub struct ConstEvalErr<'tcx> {
@@ -50,33 +68,41 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> {
     pub fn struct_error(&self,
         tcx: TyCtxtAt<'a, 'gcx, 'tcx>,
         message: &str)
-        -> Option<DiagnosticBuilder<'tcx>>
+        -> Result<DiagnosticBuilder<'tcx>, ErrorHandled>
     {
         self.struct_generic(tcx, message, None)
     }
 
     pub fn report_as_error(&self,
         tcx: TyCtxtAt<'a, 'gcx, 'tcx>,
         message: &str
-    ) {
+    ) -> ErrorHandled {
         let err = self.struct_error(tcx, message);
-        if let Some(mut err) = err {
-            err.emit();
+        match err {
+            Ok(mut err) => {
+                err.emit();
+                ErrorHandled::Reported
+            },
+            Err(err) => err,
         }
     }
 
     pub fn report_as_lint(&self,
         tcx: TyCtxtAt<'a, 'gcx, 'tcx>,
         message: &str,
         lint_root: ast::NodeId,
-    ) {
+    ) -> ErrorHandled {
         let lint = self.struct_generic(
             tcx,
             message,
             Some(lint_root),
         );
-        if let Some(mut lint) = lint {
-            lint.emit();
+        match lint {
+            Ok(mut lint) => {
+                lint.emit();
+                ErrorHandled::Reported
+            },
+            Err(err) => err,
         }
     }
 
@@ -85,15 +111,11 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> {
         tcx: TyCtxtAt<'a, 'gcx, 'tcx>,
         message: &str,
         lint_root: Option<ast::NodeId>,
-    ) -> Option<DiagnosticBuilder<'tcx>> {
+    ) -> Result<DiagnosticBuilder<'tcx>, ErrorHandled> {
         match self.error.kind {
-            ::mir::interpret::EvalErrorKind::TypeckError |
-            ::mir::interpret::EvalErrorKind::TooGeneric |
-            ::mir::interpret::EvalErrorKind::CheckMatchError |
-            ::mir::interpret::EvalErrorKind::Layout(_) => return None,
-            ::mir::interpret::EvalErrorKind::ReferencedConstant(ref inner) => {
-                inner.struct_generic(tcx, "referenced constant has errors", lint_root)?.emit();
-            },
+            EvalErrorKind::TooGeneric => return Err(ErrorHandled::TooGeneric),
+            EvalErrorKind::TypeckError |
+            EvalErrorKind::Layout(_) => return Err(ErrorHandled::Reported),
             _ => {},
         }
         trace!("reporting const eval failure at {:?}", self.span);
@@ -117,7 +139,7 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> {
         for FrameInfo { span, location, .. } in &self.stacktrace {
             err.span_label(*span, format!("inside call to `{}`", location));
         }
-        Some(err)
+        Ok(err)
     }
 }
 
@@ -279,10 +301,9 @@ pub enum EvalErrorKind<'tcx, O> {
     TypeckError,
     /// Resolution can fail if we are in a too generic context
     TooGeneric,
-    CheckMatchError,
     /// Cannot compute this constant because it depends on another one
     /// which already produced an error
-    ReferencedConstant(Lrc<ConstEvalErr<'tcx>>),
+    ReferencedConstant,
     GeneratorResumedAfterReturn,
     GeneratorResumedAfterPanic,
     InfiniteLoop,
@@ -407,9 +428,7 @@ impl<'tcx, O> EvalErrorKind<'tcx, O> {
                 "encountered constants with type errors, stopping evaluation",
             TooGeneric =>
                 "encountered overly generic constant",
-            CheckMatchError =>
-                "match checking failed",
-            ReferencedConstant(_) =>
+            ReferencedConstant =>
                 "referenced constant has errors",
             Overflow(mir::BinOp::Add) => "attempt to add with overflow",
             Overflow(mir::BinOp::Sub) => "attempt to subtract with overflow",

src/librustc/mir/interpret/mod.rs

@@ -20,7 +20,7 @@ mod value;
 
 pub use self::error::{
     EvalError, EvalResult, EvalErrorKind, AssertMessage, ConstEvalErr, struct_error,
-    FrameInfo, ConstEvalResult,
+    FrameInfo, ConstEvalResult, ErrorHandled,
 };
 
 pub use self::value::{Scalar, ConstValue};

src/librustc/traits/error_reporting.rs

@@ -880,18 +880,10 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 self.tcx.report_object_safety_error(span, did, violations)
             }
 
-            ConstEvalFailure(ref err) => {
-                match err.struct_error(
-                    self.tcx.at(span),
-                    "could not evaluate constant expression",
-                ) {
-                    Some(err) => err,
-                    None => {
-                        self.tcx.sess.delay_span_bug(span,
-                            &format!("constant in type had an ignored error: {:?}", err));
-                        return;
-                    }
-                }
+            // already reported in the query
+            ConstEvalFailure => {
+                self.tcx.sess.delay_span_bug(span, "constant in type had an ignored error");
+                return;
             }
 
             Overflow => {

src/librustc/traits/fulfill.rs

@@ -16,8 +16,6 @@ use rustc_data_structures::obligation_forest::{Error, ForestObligation, Obligati
 use rustc_data_structures::obligation_forest::{ObligationProcessor, ProcessResult};
 use std::marker::PhantomData;
 use hir::def_id::DefId;
-use mir::interpret::ConstEvalErr;
-use mir::interpret::EvalErrorKind;
 
 use super::CodeAmbiguity;
 use super::CodeProjectionError;
@@ -491,17 +489,11 @@ impl<'a, 'b, 'gcx, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'gcx,
                                     match self.selcx.tcx().at(obligation.cause.span)
                                                           .const_eval(param_env.and(cid)) {
                                         Ok(_) => ProcessResult::Changed(vec![]),
-                                        Err(err) => ProcessResult::Error(
-                                            CodeSelectionError(ConstEvalFailure(err)))
+                                        Err(_) => ProcessResult::Error(
+                                            CodeSelectionError(ConstEvalFailure))
                                     }
                                 } else {
-                                    ProcessResult::Error(
-                                        CodeSelectionError(ConstEvalFailure(ConstEvalErr {
-                                            span: obligation.cause.span,
-                                            error: EvalErrorKind::TooGeneric.into(),
-                                            stacktrace: vec![],
-                                        }.into()))
-                                    )
+                                    ProcessResult::Error(CodeSelectionError(ConstEvalFailure))
                                 }
                             },
                             None => {

src/librustc/traits/mod.rs

@@ -23,7 +23,6 @@ use hir::def_id::DefId;
 use infer::SuppressRegionErrors;
 use infer::outlives::env::OutlivesEnvironment;
 use middle::region;
-use mir::interpret::ConstEvalErr;
 use ty::subst::Substs;
 use ty::{self, AdtKind, List, Ty, TyCtxt, GenericParamDefKind, ToPredicate};
 use ty::error::{ExpectedFound, TypeError};
@@ -438,7 +437,7 @@ pub enum SelectionError<'tcx> {
                                 ty::PolyTraitRef<'tcx>,
                                 ty::error::TypeError<'tcx>),
     TraitNotObjectSafe(DefId),
-    ConstEvalFailure(Lrc<ConstEvalErr<'tcx>>),
+    ConstEvalFailure,
     Overflow,
 }