Make codegen_fulfill_obligation a canonical query and rename it to

`resolve_vtable`.

Author: skinnyBat

src/librustc/arena.rs

@@ -65,6 +65,12 @@ macro_rules! arena_types {
                         Vec<rustc::traits::query::outlives_bounds::OutlivesBound<'tcx>>
                     >
                 >,
+            [] resolve_vtables:
+                rustc::infer::canonical::Canonical<'tcx,
+                    rustc::infer::canonical::QueryResponse<'tcx,
+                        rustc::traits::Vtable<'tcx, ()>
+                    >
+                >,
             [] type_op_subtype:
                 rustc::infer::canonical::Canonical<'tcx,
                     rustc::infer::canonical::QueryResponse<'tcx, ()>

src/librustc/dep_graph/dep_node.rs

@@ -55,7 +55,7 @@ use crate::mir;
 use crate::mir::interpret::ConstEvalInput;
 use crate::traits;
 use crate::traits::query::{
-    CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
+    CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTraitGoal, CanonicalTyGoal,
     CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpNormalizeGoal,
     CanonicalTypeOpProvePredicateGoal, CanonicalTypeOpSubtypeGoal,
 };

src/librustc/query/mod.rs

@@ -3,7 +3,7 @@ use crate::mir;
 use crate::mir::interpret::ConstEvalInput;
 use crate::traits;
 use crate::traits::query::{
-    CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
+    CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTraitGoal, CanonicalTyGoal,
     CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpNormalizeGoal,
     CanonicalTypeOpProvePredicateGoal, CanonicalTypeOpSubtypeGoal,
 };
@@ -592,17 +592,15 @@ rustc_queries! {
             no_force
             desc { |tcx| "finding all methods for trait {}", tcx.def_path_str(key.def_id()) }
         }
-    }
 
-    Codegen {
-        query codegen_fulfill_obligation(
-            key: (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>)
-        ) -> Vtable<'tcx, ()> {
+        /// Do not call this query directly: invoke `infcx.resolve_vtable()` instead.
+        query resolve_vtable(
+            goal: CanonicalTraitGoal<'tcx>
+        ) -> Result<&'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, Vtable<'tcx, ()>>>, NoSolution> {
             no_force
-            cache_on_disk_if { true }
             desc { |tcx|
-                "checking if `{}` fulfills its obligations",
-                tcx.def_path_str(key.1.def_id())
+                "resolving vtable for `{}`",
+                tcx.def_path_str(goal.value.value.def_id())
             }
         }
     }

src/librustc/traits/codegen/mod.rs

@@ -3,79 +3,10 @@
 // seems likely that they should eventually be merged into more
 // general routines.
 
-use crate::infer::InferCtxt;
-use crate::traits::{
-    FulfillmentContext, Obligation, ObligationCause, SelectionContext, TraitEngine, Vtable,
-};
 use crate::ty::fold::TypeFoldable;
 use crate::ty::subst::{Subst, SubstsRef};
 use crate::ty::{self, TyCtxt};
 
-/// Attempts to resolve an obligation to a vtable. The result is
-/// a shallow vtable resolution, meaning that we do not
-/// (necessarily) resolve all nested obligations on the impl. Note
-/// that type check should guarantee to us that all nested
-/// obligations *could be* resolved if we wanted to.
-/// Assumes that this is run after the entire crate has been successfully type-checked.
-pub fn codegen_fulfill_obligation<'tcx>(
-    ty: TyCtxt<'tcx>,
-    (param_env, trait_ref): (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>),
-) -> Vtable<'tcx, ()> {
-    // Remove any references to regions; this helps improve caching.
-    let trait_ref = ty.erase_regions(&trait_ref);
-
-    debug!(
-        "codegen_fulfill_obligation(trait_ref={:?}, def_id={:?})",
-        (param_env, trait_ref),
-        trait_ref.def_id()
-    );
-
-    // Do the initial selection for the obligation. This yields the
-    // shallow result we are looking for -- that is, what specific impl.
-    ty.infer_ctxt().enter(|infcx| {
-        let mut selcx = SelectionContext::new(&infcx);
-
-        let obligation_cause = ObligationCause::dummy();
-        let obligation =
-            Obligation::new(obligation_cause, param_env, trait_ref.to_poly_trait_predicate());
-
-        let selection = match selcx.select(&obligation) {
-            Ok(Some(selection)) => selection,
-            Ok(None) => {
-                // Ambiguity can happen when monomorphizing during trans
-                // expands to some humongo type that never occurred
-                // statically -- this humongo type can then overflow,
-                // leading to an ambiguous result. So report this as an
-                // overflow bug, since I believe this is the only case
-                // where ambiguity can result.
-                bug!(
-                    "Encountered ambiguity selecting `{:?}` during codegen, \
-                      presuming due to overflow",
-                    trait_ref
-                )
-            }
-            Err(e) => {
-                bug!("Encountered error `{:?}` selecting `{:?}` during codegen", e, trait_ref)
-            }
-        };
-
-        debug!("fulfill_obligation: selection={:?}", selection);
-
-        // Currently, we use a fulfillment context to completely resolve
-        // all nested obligations. This is because they can inform the
-        // inference of the impl's type parameters.
-        let mut fulfill_cx = FulfillmentContext::new();
-        let vtable = selection.map(|predicate| {
-            debug!("fulfill_obligation: register_predicate_obligation {:?}", predicate);
-            fulfill_cx.register_predicate_obligation(&infcx, predicate);
-        });
-        let vtable = infcx.drain_fulfillment_cx_or_panic(&mut fulfill_cx, &vtable);
-
-        info!("Cache miss: {:?} => {:?}", trait_ref, vtable);
-        vtable
-    })
-}
-
 impl<'tcx> TyCtxt<'tcx> {
     /// Monomorphizes a type from the AST by first applying the
     /// in-scope substitutions and then normalizing any associated
@@ -100,37 +31,3 @@ impl<'tcx> TyCtxt<'tcx> {
         self.normalize_erasing_regions(param_env, substituted)
     }
 }
-
-// # Global Cache
-
-impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
-    /// Finishes processes any obligations that remain in the
-    /// fulfillment context, and then returns the result with all type
-    /// variables removed and regions erased. Because this is intended
-    /// for use after type-check has completed, if any errors occur,
-    /// it will panic. It is used during normalization and other cases
-    /// where processing the obligations in `fulfill_cx` may cause
-    /// type inference variables that appear in `result` to be
-    /// unified, and hence we need to process those obligations to get
-    /// the complete picture of the type.
-    fn drain_fulfillment_cx_or_panic<T>(
-        &self,
-        fulfill_cx: &mut FulfillmentContext<'tcx>,
-        result: &T,
-    ) -> T
-    where
-        T: TypeFoldable<'tcx>,
-    {
-        debug!("drain_fulfillment_cx_or_panic()");
-
-        // In principle, we only need to do this so long as `result`
-        // contains unbound type parameters. It could be a slight
-        // optimization to stop iterating early.
-        if let Err(errors) = fulfill_cx.select_all_or_error(self) {
-            bug!("Encountered errors `{:?}` resolving bounds after type-checking", errors);
-        }
-
-        let result = self.resolve_vars_if_possible(result);
-        self.tcx.erase_regions(&result)
-    }
-}

src/librustc/traits/mod.rs

@@ -1235,7 +1235,6 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) {
         is_object_safe: object_safety::is_object_safe_provider,
         specialization_graph_of: specialize::specialization_graph_provider,
         specializes: specialize::specializes,
-        codegen_fulfill_obligation: codegen::codegen_fulfill_obligation,
         vtable_methods,
         substitute_normalize_and_test_predicates,
         ..*providers

src/librustc/traits/query/mod.rs

@@ -15,6 +15,7 @@ pub mod method_autoderef;
 pub mod normalize;
 pub mod normalize_erasing_regions;
 pub mod outlives_bounds;
+pub mod resolve_vtable;
 pub mod type_op;
 
 pub type CanonicalProjectionGoal<'tcx> =
@@ -24,6 +25,8 @@ pub type CanonicalTyGoal<'tcx> = Canonical<'tcx, ty::ParamEnvAnd<'tcx, Ty<'tcx>>
 
 pub type CanonicalPredicateGoal<'tcx> = Canonical<'tcx, ty::ParamEnvAnd<'tcx, ty::Predicate<'tcx>>>;
 
+pub type CanonicalTraitGoal<'tcx> = Canonical<'tcx, ty::ParamEnvAnd<'tcx, ty::PolyTraitRef<'tcx>>>;
+
 pub type CanonicalTypeOpAscribeUserTypeGoal<'tcx> =
     Canonical<'tcx, ty::ParamEnvAnd<'tcx, type_op::ascribe_user_type::AscribeUserType<'tcx>>>;
 

src/librustc/traits/query/resolve_vtable.rs

@@ -0,0 +1,31 @@
+use crate::infer::canonical::OriginalQueryValues;
+use crate::infer::InferCtxt;
+use crate::traits::{ObligationCause, Vtable};
+use crate::ty;
+
+impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
+    pub fn resolve_vtable(
+        &self,
+        param_env: ty::ParamEnv<'tcx>,
+        trait_ref: ty::TraitRef<'tcx>,
+    ) -> Option<Vtable<'tcx, ()>> {
+        // Remove any references to regions; this helps improve caching.
+        let trait_ref = self.tcx.erase_regions(&trait_ref);
+
+        let mut orig_values = OriginalQueryValues::default();
+        let canonical =
+            self.canonicalize_query(&param_env.and(ty::Binder::bind(trait_ref)), &mut orig_values);
+        if let Ok(query_response) = self.tcx.resolve_vtable(canonical) {
+            if query_response.is_proven() {
+                let result = self.instantiate_query_response_and_region_obligations(
+                    &ObligationCause::dummy(),
+                    param_env,
+                    &orig_values,
+                    query_response,
+                );
+                return Some(result.unwrap().value);
+            }
+        };
+        None
+    }
+}

src/librustc/ty/instance.rs

@@ -397,7 +397,8 @@ fn resolve_associated_item<'infcx, 'tcx>(
     );
 
     let trait_ref = ty::TraitRef::from_method(tcx, trait_id, rcvr_substs);
-    let vtbl = tcx.codegen_fulfill_obligation((param_env, ty::Binder::bind(trait_ref)));
+
+    let vtbl = infcx.resolve_vtable(param_env, trait_ref)?;
 
     // Now that we know which impl is being used, we can dispatch to
     // the actual function:

src/librustc/ty/query/mod.rs

@@ -22,7 +22,7 @@ use crate::traits::query::method_autoderef::MethodAutoderefStepsResult;
 use crate::traits::query::normalize::NormalizationResult;
 use crate::traits::query::outlives_bounds::OutlivesBound;
 use crate::traits::query::{
-    CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
+    CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTraitGoal, CanonicalTyGoal,
     CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpNormalizeGoal,
     CanonicalTypeOpProvePredicateGoal, CanonicalTypeOpSubtypeGoal, NoSolution,
 };

src/librustc_mir/monomorphize/mod.rs

@@ -12,17 +12,17 @@ pub fn custom_coerce_unsize_info<'tcx>(
 ) -> CustomCoerceUnsized {
     let def_id = tcx.lang_items().coerce_unsized_trait().unwrap();
 
-    let trait_ref = ty::Binder::bind(ty::TraitRef {
-        def_id: def_id,
-        substs: tcx.mk_substs_trait(source_ty, &[target_ty.into()]),
-    });
+    let trait_ref =
+        ty::TraitRef { def_id, substs: tcx.mk_substs_trait(source_ty, &[target_ty.into()]) };
 
-    match tcx.codegen_fulfill_obligation((ty::ParamEnv::reveal_all(), trait_ref)) {
-        traits::VtableImpl(traits::VtableImplData { impl_def_id, .. }) => {
-            tcx.coerce_unsized_info(impl_def_id).custom_kind.unwrap()
-        }
-        vtable => {
-            bug!("invalid `CoerceUnsized` vtable: {:?}", vtable);
+    let impl_def_id = tcx.infer_ctxt().enter(|ref infcx| {
+        match infcx.resolve_vtable(ty::ParamEnv::reveal_all(), trait_ref).unwrap() {
+            traits::VtableImpl(traits::VtableImplData { impl_def_id, .. }) => impl_def_id,
+            vtable => {
+                bug!("invalid `CoerceUnsized` vtable: {:?}", vtable);
+            }
         }
-    }
+    });
+
+    tcx.coerce_unsized_info(impl_def_id).custom_kind.unwrap()
 }

src/librustc_traits/lib.rs

@@ -19,6 +19,7 @@ mod implied_outlives_bounds;
 pub mod lowering;
 mod normalize_erasing_regions;
 mod normalize_projection_ty;
+mod resolve_vtable;
 mod type_op;
 
 use rustc::ty::query::Providers;
@@ -31,5 +32,6 @@ pub fn provide(p: &mut Providers<'_>) {
     chalk_context::provide(p);
     normalize_projection_ty::provide(p);
     normalize_erasing_regions::provide(p);
+    resolve_vtable::provide(p);
     type_op::provide(p);
 }

src/librustc_traits/resolve_vtable.rs

@@ -0,0 +1,63 @@
+use rustc::infer::canonical::{Canonical, QueryResponse};
+use rustc::traits::query::{CanonicalTraitGoal, NoSolution};
+use rustc::traits::{Obligation, ObligationCause, SelectionContext, TraitQueryMode, Vtable};
+use rustc::ty::query::Providers;
+use rustc::ty::{ParamEnvAnd, TyCtxt};
+
+crate fn provide(p: &mut Providers<'_>) {
+    *p = Providers { resolve_vtable, ..*p };
+}
+
+/// Attempts to resolve a vtable.
+pub fn resolve_vtable<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    canonical_goal: CanonicalTraitGoal<'tcx>,
+) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Vtable<'tcx, ()>>>, NoSolution> {
+    // Do the initial selection for the obligation. This yields the
+    // shallow result we are looking for -- that is, what specific impl.
+    tcx.infer_ctxt().enter_canonical_trait_query(
+        &canonical_goal,
+        |infcx, fulfill_cx, ParamEnvAnd { param_env, value: trait_ref }| {
+            debug!(
+                "resolve_vtable(param_env={:?}, trait_ref={:?}, def_id={:?})",
+                param_env,
+                trait_ref,
+                trait_ref.def_id()
+            );
+
+            let mut selcx = SelectionContext::with_query_mode(&infcx, TraitQueryMode::Canonical);
+
+            let obligation_cause = ObligationCause::dummy();
+            let obligation =
+                Obligation::new(obligation_cause, param_env, trait_ref.to_poly_trait_predicate());
+
+            let selection = match selcx.select(&obligation) {
+                Ok(Some(selection)) => selection,
+                Ok(None) => return Err(NoSolution),
+                Err(e) => {
+                    debug!(
+                        "Encountered error `{:?}` when resolving vtable for `{:?}`",
+                        e, trait_ref
+                    );
+                    return Err(NoSolution);
+                }
+            };
+
+            debug!("resolve_vtable: selection={:?}", selection);
+
+            // Currently, we use a fulfillment context to completely resolve
+            // all nested obligations. This is because they can inform the
+            // inference of the impl's type parameters.
+            let mut vtable = selection.map(|predicate| {
+                debug!("resolve_vtable: register_predicate_obligation {:?}", predicate);
+                fulfill_cx.register_predicate_obligation(&infcx, predicate);
+            });
+
+            vtable = infcx.resolve_vars_if_possible(&vtable);
+            vtable = tcx.erase_regions(&vtable);
+
+            info!("Cache miss: {:?} => {:?}", trait_ref, vtable);
+            Ok(vtable)
+        },
+    )
+}