update queries for deduplication

Author: b-naber

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -1,4 +1,4 @@
-use super::{CompileTimeEvalContext, CompileTimeInterpreter, ConstEvalErr, MemoryExtra};
+use super::{CompileTimeEvalContext, CompileTimeInterpreter, ConstEvalError, MemoryExtra};
 use crate::interpret::eval_nullary_intrinsic;
 use crate::interpret::{
     intern_const_alloc_recursive, Allocation, ConstAlloc, ConstValue, CtfeValidationMode, GlobalId,
@@ -10,15 +10,16 @@ use rustc_errors::ErrorReported;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_middle::mir;
-use rustc_middle::mir::interpret::ErrorHandled;
+use rustc_middle::mir::interpret::{
+    ConstDedupError, ConstDedupResult, ConstErrorEmitted, ConstEvalErr, ConstOrigin, ErrorHandled,
+};
 use rustc_middle::mir::pretty::display_allocation;
 use rustc_middle::traits::Reveal;
-use rustc_middle::ty::layout::LayoutOf;
+use rustc_middle::ty::layout::{LayoutError, LayoutOf};
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, subst::Subst, TyCtxt};
 use rustc_span::source_map::Span;
 use rustc_target::abi::Abi;
-use std::borrow::Cow;
 use std::convert::TryInto;
 
 pub fn note_on_undefined_behavior_error() -> &'static str {
@@ -28,6 +29,7 @@ pub fn note_on_undefined_behavior_error() -> &'static str {
 }
 
 // Returns a pointer to where the result lives
+#[instrument(skip(ecx, body), level = "debug")]
 fn eval_body_using_ecx<'mir, 'tcx>(
     ecx: &mut CompileTimeEvalContext<'mir, 'tcx>,
     cid: GlobalId<'tcx>,
@@ -66,6 +68,8 @@ fn eval_body_using_ecx<'mir, 'tcx>(
         StackPopCleanup::None { cleanup: false },
     )?;
 
+    debug!("returned from push_stack_frame");
+
     // The main interpreter loop.
     ecx.run()?;
 
@@ -160,6 +164,7 @@ pub(super) fn op_to_const<'tcx>(
             ConstValue::Scalar(Scalar::ZST)
         }
     };
+
     match immediate {
         Ok(ref mplace) => to_const_value(mplace),
         // see comment on `let try_as_immediate` above
@@ -212,92 +217,119 @@ fn turn_into_const_value<'tcx>(
     op_to_const(&ecx, &mplace.into())
 }
 
+#[instrument(skip(tcx), level = "debug")]
 pub fn eval_to_const_value_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToConstValueResult<'tcx> {
     assert!(key.param_env.constness() == hir::Constness::Const);
-    // see comment in eval_to_allocation_raw_provider for what we're doing here
-    if key.param_env.reveal() == Reveal::All {
-        let mut key = key;
-        key.param_env = key.param_env.with_user_facing();
-        match tcx.eval_to_const_value_raw(key) {
-            // try again with reveal all as requested
-            Err(ErrorHandled::TooGeneric) => {}
-            // deduplicate calls
-            other => return other,
-        }
-    }
+    let (param_env, id) = key.into_parts();
+    let reveal = param_env.reveal();
 
     // We call `const_eval` for zero arg intrinsics, too, in order to cache their value.
     // Catch such calls and evaluate them instead of trying to load a constant's MIR.
     if let ty::InstanceDef::Intrinsic(def_id) = key.value.instance.def {
-        let ty = key.value.instance.ty(tcx, key.param_env);
+        let ty = key.value.instance.ty(tcx, param_env);
         let substs = match ty.kind() {
             ty::FnDef(_, substs) => substs,
             _ => bug!("intrinsic with type {:?}", ty),
         };
-        return eval_nullary_intrinsic(tcx, key.param_env, def_id, substs).map_err(|error| {
-            let span = tcx.def_span(def_id);
-            let error = ConstEvalErr { error: error.into_kind(), stacktrace: vec![], span };
-            error.report_as_error(tcx.at(span), "could not evaluate nullary intrinsic")
-        });
+        match eval_nullary_intrinsic(tcx, param_env, def_id, substs) {
+            Ok(val) => {
+                // store result for deduplication
+                let res = ConstDedupResult::new(reveal, Ok(val), None);
+                tcx.save_const_value_for_dedup(id, res);
+
+                return Ok(val);
+            }
+            Err(e) => {
+                let span = tcx.def_span(def_id);
+                let error = ConstEvalErr { error: e.into_kind(), stacktrace: vec![], span };
+
+                let error_handled = tcx.handle_err_for_dedup(
+                    id,
+                    ConstOrigin::ConstValue,
+                    error,
+                    reveal,
+                    span,
+                    |e| {
+                        tcx.report_and_add_error(
+                            id,
+                            e,
+                            span,
+                            "could not evaluate nullary intrinsic",
+                        )
+                    },
+                );
+
+                return Err(error_handled);
+            }
+        }
     }
 
-    tcx.eval_to_allocation_raw(key).map(|val| turn_into_const_value(tcx, val, key))
+    let result =
+        tcx.dedup_eval_alloc_raw(key, None).map(|val| turn_into_const_value(tcx, val, key));
+
+    // store result for deduplication
+    let val = ConstDedupResult::new(
+        reveal,
+        result.map_err(|e| ConstDedupError::new_handled(e, reveal)),
+        None,
+    );
+    tcx.save_const_value_for_dedup(id, val);
+
+    result
 }
 
+#[instrument(skip(tcx), level = "debug")]
 pub fn eval_to_allocation_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToAllocationRawResult<'tcx> {
     assert!(key.param_env.constness() == hir::Constness::Const);
-    // Because the constant is computed twice (once per value of `Reveal`), we are at risk of
-    // reporting the same error twice here. To resolve this, we check whether we can evaluate the
-    // constant in the more restrictive `Reveal::UserFacing`, which most likely already was
-    // computed. For a large percentage of constants that will already have succeeded. Only
-    // associated constants of generic functions will fail due to not enough monomorphization
-    // information being available.
-
-    // In case we fail in the `UserFacing` variant, we just do the real computation.
-    if key.param_env.reveal() == Reveal::All {
-        let mut key = key;
-        key.param_env = key.param_env.with_user_facing();
-        match tcx.eval_to_allocation_raw(key) {
-            // try again with reveal all as requested
-            Err(ErrorHandled::TooGeneric) => {}
-            // deduplicate calls
-            other => return other,
-        }
-    }
+    let (param_env, cid) = key.into_parts();
+    let reveal = param_env.reveal();
+
     if cfg!(debug_assertions) {
         // Make sure we format the instance even if we do not print it.
         // This serves as a regression test against an ICE on printing.
         // The next two lines concatenated contain some discussion:
         // https://rust-lang.zulipchat.com/#narrow/stream/146212-t-compiler.2Fconst-eval/
         // subject/anon_const_instance_printing/near/135980032
-        let instance = with_no_trimmed_paths(|| key.value.instance.to_string());
+        let instance = with_no_trimmed_paths(|| cid.instance.to_string());
         trace!("const eval: {:?} ({})", key, instance);
     }
 
-    let cid = key.value;
     let def = cid.instance.def.with_opt_param();
 
     if let Some(def) = def.as_local() {
         if tcx.has_typeck_results(def.did) {
             if let Some(error_reported) = tcx.typeck_opt_const_arg(def).tainted_by_errors {
-                return Err(ErrorHandled::Reported(error_reported));
+                let err = ConstErrorEmitted::Emitted(ErrorHandled::Reported(error_reported));
+                let err_handled =
+                    tcx.handle_reported_error_for_dedup(cid, ConstOrigin::Alloc, err, reveal);
+
+                return Err(err_handled);
             }
         }
         if !tcx.is_mir_available(def.did) {
             tcx.sess.delay_span_bug(
                 tcx.def_span(def.did),
                 &format!("no MIR body is available for {:?}", def.did),
             );
-            return Err(ErrorHandled::Reported(ErrorReported {}));
+
+            let err = ConstErrorEmitted::Emitted(ErrorHandled::Reported(ErrorReported {}));
+            let err_handled =
+                tcx.handle_reported_error_for_dedup(cid, ConstOrigin::Alloc, err, reveal);
+
+            return Err(err_handled);
         }
         if let Some(error_reported) = tcx.mir_const_qualif_opt_const_arg(def).error_occured {
-            return Err(ErrorHandled::Reported(error_reported));
+            let err = ConstErrorEmitted::Emitted(ErrorHandled::Reported(error_reported));
+            let err_handled =
+                tcx.handle_reported_error_for_dedup(cid, ConstOrigin::Alloc, err, reveal);
+
+            return Err(err_handled);
         }
     }
 
@@ -316,46 +348,41 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
     let res = ecx.load_mir(cid.instance.def, cid.promoted);
     match res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, &body)) {
         Err(error) => {
-            let err = ConstEvalErr::new(&ecx, error, None);
-            // Some CTFE errors raise just a lint, not a hard error; see
-            // <https://github.com/rust-lang/rust/issues/71800>.
-            let is_hard_err = if let Some(def) = def.as_local() {
-                // (Associated) consts only emit a lint, since they might be unused.
-                !matches!(tcx.def_kind(def.did.to_def_id()), DefKind::Const | DefKind::AssocConst)
-                    // check if the inner InterpError is hard
-                    || err.error.is_hard_err()
-            } else {
-                // use of broken constant from other crate: always an error
-                true
-            };
-
-            if is_hard_err {
-                let msg = if is_static {
-                    Cow::from("could not evaluate static initializer")
-                } else {
-                    // If the current item has generics, we'd like to enrich the message with the
-                    // instance and its substs: to show the actual compile-time values, in addition to
-                    // the expression, leading to the const eval error.
-                    let instance = &key.value.instance;
-                    if !instance.substs.is_empty() {
-                        let instance = with_no_trimmed_paths(|| instance.to_string());
-                        let msg = format!("evaluation of `{}` failed", instance);
-                        Cow::from(msg)
-                    } else {
-                        Cow::from("evaluation of constant value failed")
+            debug!("error from eval_body_using_ecx: {:?}", error);
+            if reveal == Reveal::Selection {
+                match error.kind() {
+                    err_inval!(Layout(LayoutError::Unknown(_)))
+                    | err_inval!(TooGeneric)
+                    | err_inval!(AlreadyReported(_)) => {
+                        // We do want to report these errors
                     }
-                };
+                    _ => {
+                        let err = ConstEvalError::new(&ecx, error, None);
+                        let error_handled = tcx.handle_err_for_dedup(
+                            cid,
+                            ConstOrigin::Alloc,
+                            err.into_inner(),
+                            reveal,
+                            ecx.cur_span(),
+                            |_e| ErrorHandled::Silent(cid),
+                        );
 
-                Err(err.report_as_error(ecx.tcx.at(ecx.cur_span()), &msg))
-            } else {
-                let hir_id = tcx.hir().local_def_id_to_hir_id(def.as_local().unwrap().did);
-                Err(err.report_as_lint(
-                    tcx.at(tcx.def_span(def.did)),
-                    "any use of this value will cause an error",
-                    hir_id,
-                    Some(err.span),
-                ))
+                        return Err(error_handled);
+                    }
+                }
             }
+
+            let err = ConstEvalError::new(&ecx, error, None);
+            let err_handled = tcx.handle_err_for_dedup(
+                cid,
+                ConstOrigin::Alloc,
+                err.into_inner(),
+                reveal,
+                ecx.cur_span(),
+                |e| tcx.report_alloc_error(cid, param_env, e, is_static, def, ecx.cur_span()),
+            );
+
+            Err(err_handled)
         }
         Ok(mplace) => {
             // Since evaluation had no errors, validate the resulting constant.
@@ -377,27 +404,49 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
                 }
             };
             let alloc_id = mplace.ptr.provenance.unwrap();
+
             if let Err(error) = validation {
                 // Validation failed, report an error. This is always a hard error.
-                let err = ConstEvalErr::new(&ecx, error, None);
-                Err(err.struct_error(
-                    ecx.tcx,
-                    "it is undefined behavior to use this value",
-                    |mut diag| {
-                        diag.note(note_on_undefined_behavior_error());
-                        diag.note(&format!(
-                            "the raw bytes of the constant ({}",
-                            display_allocation(
-                                *ecx.tcx,
-                                ecx.tcx.global_alloc(alloc_id).unwrap_memory()
-                            )
-                        ));
-                        diag.emit();
+                let err = ConstEvalError::new(&ecx, error, None).into_inner();
+
+                // FIXME: Do we also want to keep these silent with Reveal::Selection?
+                let error_handled = tcx.handle_err_for_dedup(
+                    cid,
+                    ConstOrigin::Alloc,
+                    err,
+                    reveal,
+                    ecx.cur_span(),
+                    |e| {
+                        e.struct_error(
+                            ecx.tcx,
+                            "it is undefined behavior to use this value",
+                            |mut diag| {
+                                diag.note(note_on_undefined_behavior_error());
+                                diag.note(&format!(
+                                    "the raw bytes of the constant ({}",
+                                    display_allocation(
+                                        *ecx.tcx,
+                                        ecx.tcx.global_alloc(alloc_id).unwrap_memory()
+                                    )
+                                ));
+                                diag.emit();
+                            },
+                        )
+                        .get_error()
                     },
-                ))
+                );
+
+                Err(error_handled)
             } else {
                 // Convert to raw constant
-                Ok(ConstAlloc { alloc_id, ty: mplace.layout.ty })
+                let const_alloc = ConstAlloc { alloc_id, ty: mplace.layout.ty };
+                let result = Ok(const_alloc);
+                let val = ConstDedupResult::new(reveal, result, None);
+
+                // store result in order to deduplicate later
+                tcx.save_alloc_for_dedup(cid, val);
+
+                Ok(const_alloc)
             }
         }
     }