Turn const eval queries in canonical queries, and add

inference context into mir execution context.

Author: skinnyBat

src/librustc/dep_graph/dep_node.rs

@@ -52,7 +52,7 @@
 use crate::hir::map::DefPathHash;
 use crate::ich::{Fingerprint, StableHashingContext};
 use crate::mir;
-use crate::mir::interpret::GlobalId;
+use crate::mir::interpret::ConstEvalInput;
 use crate::traits;
 use crate::traits::query::{
     CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,

src/librustc/infer/canonical/canonicalizer.rs

@@ -13,12 +13,12 @@ use crate::infer::InferCtxt;
 use crate::ty::flags::FlagComputation;
 use crate::ty::fold::{TypeFoldable, TypeFolder};
 use crate::ty::subst::GenericArg;
-use crate::ty::{self, BoundVar, InferConst, List, Ty, TyCtxt, TypeFlags};
-use std::sync::atomic::Ordering;
+use crate::ty::{self, BoundVar, InferConst, Ty, TyCtxt, TypeFlags};
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_index::vec::Idx;
 use smallvec::SmallVec;
+use std::sync::atomic::Ordering;
 
 impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// Canonicalizes a query value `V`. When we canonicalize a query,
@@ -496,12 +496,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
 
         // Fast path: nothing that needs to be canonicalized.
         if !value.has_type_flags(needs_canonical_flags) {
-            let canon_value = Canonical {
-                max_universe: ty::UniverseIndex::ROOT,
-                variables: List::empty(),
-                value: value.clone(),
-            };
-            return canon_value;
+            return Canonical::empty(value.clone());
         }
 
         let mut canonicalizer = Canonicalizer {

src/librustc/infer/canonical/mod.rs

@@ -266,6 +266,17 @@ impl<'tcx, R> Canonical<'tcx, QueryResponse<'tcx, R>> {
     }
 }
 
+impl<'tcx, V: TypeFoldable<'tcx>> Canonical<'tcx, V> {
+    pub fn empty(value: V) -> Canonical<'tcx, V> {
+        assert!(!value.has_local_value() && !value.has_placeholders());
+        Canonical {
+            max_universe: ty::UniverseIndex::ROOT,
+            variables: List::empty(),
+            value: value.clone(),
+        }
+    }
+}
+
 impl<'tcx, V> Canonical<'tcx, V> {
     /// Allows you to map the `value` of a canonical while keeping the
     /// same set of bound variables.

src/librustc/mir/interpret/mod.rs

@@ -115,6 +115,7 @@ pub use self::allocation::{Allocation, AllocationExtra, Relocations, UndefMask};
 
 pub use self::pointer::{CheckInAllocMsg, Pointer, PointerArithmetic};
 
+use crate::infer::canonical::Canonical;
 use crate::mir;
 use crate::ty::codec::TyDecoder;
 use crate::ty::layout::{self, Size};
@@ -147,6 +148,8 @@ pub struct GlobalId<'tcx> {
     pub promoted: Option<mir::Promoted>,
 }
 
+pub type ConstEvalInput<'tcx> = Canonical<'tcx, ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>>;
+
 #[derive(Copy, Clone, Eq, Hash, Ord, PartialEq, PartialOrd, Debug)]
 pub struct AllocId(pub u64);
 

src/librustc/mir/interpret/queries.rs

@@ -1,5 +1,7 @@
 use super::{ConstEvalResult, ErrorHandled, GlobalId};
 
+use crate::infer::canonical::{Canonical, OriginalQueryValues};
+use crate::infer::InferCtxt;
 use crate::mir;
 use crate::ty::subst::{InternalSubsts, SubstsRef};
 use crate::ty::{self, TyCtxt};
@@ -19,7 +21,7 @@ impl<'tcx> TyCtxt<'tcx> {
         let instance = ty::Instance::new(def_id, substs);
         let cid = GlobalId { instance, promoted: None };
         let param_env = self.param_env(def_id).with_reveal_all();
-        self.const_eval_validated(param_env.and(cid))
+        self.const_eval_validated(Canonical::empty(param_env.and(cid)))
     }
 
     /// Resolves and evaluates a constant.
@@ -38,12 +40,8 @@ impl<'tcx> TyCtxt<'tcx> {
         substs: SubstsRef<'tcx>,
         span: Option<Span>,
     ) -> ConstEvalResult<'tcx> {
-        let instance = ty::Instance::resolve(self, param_env, def_id, substs);
-        if let Some(instance) = instance {
-            self.const_eval_instance(param_env, instance, span)
-        } else {
-            Err(ErrorHandled::TooGeneric)
-        }
+        self.infer_ctxt()
+            .enter(|ref infcx| infcx.const_eval_resolve(param_env, def_id, substs, span))
     }
 
     pub fn const_eval_instance(
@@ -53,10 +51,11 @@ impl<'tcx> TyCtxt<'tcx> {
         span: Option<Span>,
     ) -> ConstEvalResult<'tcx> {
         let cid = GlobalId { instance, promoted: None };
+        let canonical = Canonical::empty(param_env.and(cid));
         if let Some(span) = span {
-            self.at(span).const_eval_validated(param_env.and(cid))
+            self.at(span).const_eval_validated(canonical)
         } else {
-            self.const_eval_validated(param_env.and(cid))
+            self.const_eval_validated(canonical)
         }
     }
 
@@ -68,6 +67,39 @@ impl<'tcx> TyCtxt<'tcx> {
     ) -> ConstEvalResult<'tcx> {
         let cid = GlobalId { instance, promoted: Some(promoted) };
         let param_env = ty::ParamEnv::reveal_all();
-        self.const_eval_validated(param_env.and(cid))
+        self.const_eval_validated(Canonical::empty(param_env.and(cid)))
+    }
+}
+
+impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
+    pub fn const_eval_instance(
+        &self,
+        param_env: ty::ParamEnv<'tcx>,
+        instance: ty::Instance<'tcx>,
+        span: Option<Span>,
+    ) -> ConstEvalResult<'tcx> {
+        let cid = GlobalId { instance, promoted: None };
+        let mut orig_values = OriginalQueryValues::default();
+        let canonical = self.canonicalize_query(&param_env.and(cid), &mut orig_values);
+        if let Some(span) = span {
+            self.tcx.at(span).const_eval_validated(canonical)
+        } else {
+            self.tcx.const_eval_validated(canonical)
+        }
+    }
+
+    pub fn const_eval_resolve(
+        &self,
+        param_env: ty::ParamEnv<'tcx>,
+        def_id: DefId,
+        substs: SubstsRef<'tcx>,
+        span: Option<Span>,
+    ) -> ConstEvalResult<'tcx> {
+        let instance = ty::Instance::resolve(self, param_env, def_id, substs);
+        if let Some(instance) = instance {
+            self.const_eval_instance(param_env, instance, span)
+        } else {
+            Err(ErrorHandled::TooGeneric)
+        }
     }
 }

src/librustc/query/mod.rs

@@ -1,6 +1,6 @@
 use crate::dep_graph::{DepKind, DepNode, RecoverKey, SerializedDepNodeIndex};
 use crate::mir;
-use crate::mir::interpret::GlobalId;
+use crate::mir::interpret::ConstEvalInput;
 use crate::traits;
 use crate::traits::query::{
     CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
@@ -467,12 +467,12 @@ rustc_queries! {
         /// during validation. Please add a comment to every use site explaining why using
         /// `const_eval_validated` isn't sufficient. The returned constant also isn't in a suitable
         /// form to be used outside of const eval.
-        query const_eval_raw(key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>)
+        query const_eval_raw(key: ConstEvalInput<'tcx>)
             -> ConstEvalRawResult<'tcx> {
             no_force
             desc { |tcx|
                 "const-evaluating `{}`",
-                tcx.def_path_str(key.value.instance.def.def_id())
+                tcx.def_path_str(key.value.value.instance.def.def_id())
             }
         }
 
@@ -484,12 +484,12 @@ rustc_queries! {
         ///
         /// **Do not use this** directly, use one of the following wrappers: `tcx.const_eval_poly`,
         /// `tcx.const_eval_resolve`, `tcx.const_eval_instance`, or `tcx.const_eval_promoted`.
-        query const_eval_validated(key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>)
+        query const_eval_validated(key: ConstEvalInput<'tcx>)
             -> ConstEvalResult<'tcx> {
             no_force
             desc { |tcx|
                 "const-evaluating + checking `{}`",
-                tcx.def_path_str(key.value.instance.def.def_id())
+                tcx.def_path_str(key.value.value.instance.def.def_id())
             }
             cache_on_disk_if(_, opt_result) {
                 // Only store results without errors

src/librustc/traits/fulfill.rs

@@ -15,6 +15,7 @@ use super::CodeSelectionError;
 use super::{ConstEvalFailure, Unimplemented};
 use super::{FulfillmentError, FulfillmentErrorCode};
 use super::{ObligationCause, PredicateObligation};
+use crate::mir::interpret::ErrorHandled;
 
 impl<'tcx> ForestObligation for PendingPredicateObligation<'tcx> {
     type Predicate = ty::Predicate<'tcx>;
@@ -506,26 +507,19 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
             }
 
             ty::Predicate::ConstEvaluatable(def_id, substs) => {
-                if obligation.param_env.has_local_value() {
-                    ProcessResult::Unchanged
-                } else {
-                    if !substs.has_local_value() {
-                        match self.selcx.tcx().const_eval_resolve(
-                            obligation.param_env,
-                            def_id,
-                            substs,
-                            Some(obligation.cause.span),
-                        ) {
-                            Ok(_) => ProcessResult::Changed(vec![]),
-                            Err(err) => {
-                                ProcessResult::Error(CodeSelectionError(ConstEvalFailure(err)))
-                            }
-                        }
-                    } else {
+                match self.selcx.infcx().const_eval_resolve(
+                    obligation.param_env,
+                    def_id,
+                    substs,
+                    Some(obligation.cause.span),
+                ) {
+                    Ok(_) => ProcessResult::Changed(vec![]),
+                    Err(ErrorHandled::TooGeneric) => {
                         pending_obligation.stalled_on =
                             substs.types().map(|ty| infer_ty(ty)).collect();
                         ProcessResult::Unchanged
                     }
+                    Err(err) => ProcessResult::Error(CodeSelectionError(ConstEvalFailure(err))),
                 }
             }
         }

src/librustc/traits/select.rs

@@ -32,6 +32,7 @@ use super::{
 use crate::dep_graph::{DepKind, DepNodeIndex};
 use crate::infer::{CombinedSnapshot, InferCtxt, InferOk, PlaceholderMap, TypeFreshener};
 use crate::middle::lang_items;
+use crate::mir::interpret::ErrorHandled;
 use crate::ty::fast_reject;
 use crate::ty::relate::TypeRelation;
 use crate::ty::subst::{Subst, SubstsRef};
@@ -799,15 +800,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
 
             ty::Predicate::ConstEvaluatable(def_id, substs) => {
-                if !(obligation.param_env, substs).has_local_value() {
-                    match self.tcx().const_eval_resolve(obligation.param_env, def_id, substs, None)
-                    {
-                        Ok(_) => Ok(EvaluatedToOk),
-                        Err(_) => Ok(EvaluatedToErr),
-                    }
-                } else {
-                    // Inference variables still left in param_env or substs.
-                    Ok(EvaluatedToAmbig)
+                match self.infcx.const_eval_resolve(
+                    obligation.param_env,
+                    def_id,
+                    substs,
+                    Some(obligation.cause.span),
+                ) {
+                    Ok(_) => Ok(EvaluatedToOk),
+                    Err(ErrorHandled::TooGeneric) => Ok(EvaluatedToAmbig),
+                    Err(_) => Ok(EvaluatedToErr),
                 }
             }
         }

src/librustc/ty/query/keys.rs

@@ -199,15 +199,25 @@ impl Key for Symbol {
 /// Canonical query goals correspond to abstract trait operations that
 /// are not tied to any crate in particular.
 impl<'tcx, T> Key for Canonical<'tcx, T> {
-    fn query_crate(&self) -> CrateNum {
+    default fn query_crate(&self) -> CrateNum {
         LOCAL_CRATE
     }
 
-    fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
+    default fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
         DUMMY_SP
     }
 }
 
+impl<'tcx, T: Key> Key for Canonical<'tcx, T> {
+    fn query_crate(&self) -> CrateNum {
+        self.value.query_crate()
+    }
+
+    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
+        self.value.default_span(tcx)
+    }
+}
+
 impl Key for (Symbol, u32, u32) {
     fn query_crate(&self) -> CrateNum {
         LOCAL_CRATE

src/librustc/ty/query/mod.rs

@@ -13,8 +13,7 @@ use crate::middle::region;
 use crate::middle::resolve_lifetime::{ObjectLifetimeDefault, Region, ResolveLifetimes};
 use crate::middle::stability::{self, DeprecationEntry};
 use crate::mir;
-use crate::mir::interpret::GlobalId;
-use crate::mir::interpret::{ConstEvalRawResult, ConstEvalResult};
+use crate::mir::interpret::{ConstEvalInput, ConstEvalRawResult, ConstEvalResult};
 use crate::mir::mono::CodegenUnit;
 use crate::session::config::{EntryFnType, OptLevel, OutputFilenames, SymbolManglingVersion};
 use crate::session::CrateDisambiguator;