From bca294da1f27cdbf66584b84f62c3090053b65ed Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Mon, 24 Sep 2018 15:27:47 -0400 Subject: [PATCH] rename `QueryResult` to `QueryResponse` `Result` really sounds like the rustc result type --- src/librustc/ich/impls_ty.rs | 2 +- src/librustc/infer/canonical/mod.rs | 20 ++-- .../{query_result.rs => query_response.rs} | 104 +++++++++--------- src/librustc/traits/query/dropck_outlives.rs | 2 +- src/librustc/traits/query/normalize.rs | 2 +- src/librustc/traits/query/outlives_bounds.rs | 2 +- src/librustc/traits/query/type_op/custom.rs | 4 +- src/librustc/traits/query/type_op/eq.rs | 12 +- .../query/type_op/implied_outlives_bounds.rs | 12 +- src/librustc/traits/query/type_op/mod.rs | 28 ++--- .../traits/query/type_op/normalize.rs | 40 +++---- src/librustc/traits/query/type_op/outlives.rs | 12 +- .../traits/query/type_op/prove_predicate.rs | 12 +- src/librustc/traits/query/type_op/subtype.rs | 10 +- src/librustc/ty/query/mod.rs | 20 ++-- src/librustc_traits/chalk_context.rs | 6 +- src/librustc_traits/dropck_outlives.rs | 6 +- .../implied_outlives_bounds.rs | 2 +- .../normalize_projection_ty.rs | 4 +- src/librustc_traits/type_op.rs | 16 +-- 20 files changed, 158 insertions(+), 158 deletions(-) rename src/librustc/infer/canonical/{query_result.rs => query_response.rs} (86%) diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index f51a3e71d07..dd2c41dda64 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -1297,7 +1297,7 @@ impl<'tcx> for struct infer::canonical::CanonicalVarValues<'tcx> { }); impl_stable_hash_for!( - impl<'tcx, R> for struct infer::canonical::QueryResult<'tcx, R> { + impl<'tcx, R> for struct infer::canonical::QueryResponse<'tcx, R> { var_values, region_constraints, certainty, value } ); diff --git a/src/librustc/infer/canonical/mod.rs b/src/librustc/infer/canonical/mod.rs index 6e9d87c089b..c937f80ea09 100644 --- a/src/librustc/infer/canonical/mod.rs +++ b/src/librustc/infer/canonical/mod.rs @@ -44,7 +44,7 @@ mod canonicalizer; -pub mod query_result; +pub mod query_response; mod substitute; @@ -118,10 +118,10 @@ pub enum CanonicalTyVarKind { } /// After we execute a query with a canonicalized key, we get back a -/// `Canonical>`. You can use +/// `Canonical>`. You can use /// `instantiate_query_result` to access the data in this result. #[derive(Clone, Debug)] -pub struct QueryResult<'tcx, R> { +pub struct QueryResponse<'tcx, R> { pub var_values: CanonicalVarValues<'tcx>, pub region_constraints: Vec>, pub certainty: Certainty, @@ -130,8 +130,8 @@ pub struct QueryResult<'tcx, R> { pub type Canonicalized<'gcx, V> = Canonical<'gcx, >::Lifted>; -pub type CanonicalizedQueryResult<'gcx, T> = - Lrc>::Lifted>>>; +pub type CanonicalizedQueryResponse<'gcx, T> = + Lrc>::Lifted>>>; /// Indicates whether or not we were able to prove the query to be /// true. @@ -168,7 +168,7 @@ pub fn is_ambiguous(&self) -> bool { } } -impl<'tcx, R> QueryResult<'tcx, R> { +impl<'tcx, R> QueryResponse<'tcx, R> { pub fn is_proven(&self) -> bool { self.certainty.is_proven() } @@ -178,7 +178,7 @@ pub fn is_ambiguous(&self) -> bool { } } -impl<'tcx, R> Canonical<'tcx, QueryResult<'tcx, R>> { +impl<'tcx, R> Canonical<'tcx, QueryResponse<'tcx, R>> { pub fn is_proven(&self) -> bool { self.value.is_proven() } @@ -351,14 +351,14 @@ impl<'tcx> TypeFoldable<'tcx> for CanonicalVarValues<'tcx> { } BraceStructTypeFoldableImpl! { - impl<'tcx, R> TypeFoldable<'tcx> for QueryResult<'tcx, R> { + impl<'tcx, R> TypeFoldable<'tcx> for QueryResponse<'tcx, R> { var_values, region_constraints, certainty, value } where R: TypeFoldable<'tcx>, } BraceStructLiftImpl! { - impl<'a, 'tcx, R> Lift<'tcx> for QueryResult<'a, R> { - type Lifted = QueryResult<'tcx, R::Lifted>; + impl<'a, 'tcx, R> Lift<'tcx> for QueryResponse<'a, R> { + type Lifted = QueryResponse<'tcx, R::Lifted>; var_values, region_constraints, certainty, value } where R: Lift<'tcx> } diff --git a/src/librustc/infer/canonical/query_result.rs b/src/librustc/infer/canonical/query_response.rs similarity index 86% rename from src/librustc/infer/canonical/query_result.rs rename to src/librustc/infer/canonical/query_response.rs index d75d39201c4..07421f0bd45 100644 --- a/src/librustc/infer/canonical/query_result.rs +++ b/src/librustc/infer/canonical/query_response.rs @@ -19,8 +19,8 @@ use infer::canonical::substitute::substitute_value; use infer::canonical::{ - Canonical, CanonicalVarKind, CanonicalVarValues, CanonicalizedQueryResult, Certainty, - QueryRegionConstraint, QueryResult, SmallCanonicalVarValues, + Canonical, CanonicalVarKind, CanonicalVarValues, CanonicalizedQueryResponse, Certainty, + QueryRegionConstraint, QueryResponse, SmallCanonicalVarValues, }; use infer::region_constraints::{Constraint, RegionConstraintData}; use infer::InferCtxtBuilder; @@ -59,7 +59,7 @@ pub fn enter_canonical_trait_query( canonical_key: &Canonical<'tcx, K>, operation: impl FnOnce(&InferCtxt<'_, 'gcx, 'tcx>, &mut FulfillmentContext<'tcx>, K) -> Fallible, - ) -> Fallible> + ) -> Fallible> where K: TypeFoldable<'tcx>, R: Debug + Lift<'gcx> + TypeFoldable<'tcx>, @@ -67,7 +67,7 @@ pub fn enter_canonical_trait_query( self.enter_with_canonical(DUMMY_SP, canonical_key, |ref infcx, key, canonical_inference_vars| { let fulfill_cx = &mut FulfillmentContext::new(); let value = operation(infcx, fulfill_cx, key)?; - infcx.make_canonicalized_query_result(canonical_inference_vars, value, fulfill_cx) + infcx.make_canonicalized_query_response(canonical_inference_vars, value, fulfill_cx) }) } } @@ -92,41 +92,41 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> { /// the same thing happens, but the resulting query is marked as ambiguous. /// - Finally, if any of the obligations result in a hard error, /// then `Err(NoSolution)` is returned. - pub fn make_canonicalized_query_result( + pub fn make_canonicalized_query_response( &self, inference_vars: CanonicalVarValues<'tcx>, answer: T, fulfill_cx: &mut FulfillmentContext<'tcx>, - ) -> Fallible> + ) -> Fallible> where T: Debug + Lift<'gcx> + TypeFoldable<'tcx>, { - let query_result = self.make_query_result(inference_vars, answer, fulfill_cx)?; - let canonical_result = self.canonicalize_response(&query_result); + let query_response = self.make_query_response(inference_vars, answer, fulfill_cx)?; + let canonical_result = self.canonicalize_response(&query_response); debug!( - "make_canonicalized_query_result: canonical_result = {:#?}", + "make_canonicalized_query_response: canonical_result = {:#?}", canonical_result ); Ok(Lrc::new(canonical_result)) } - /// Helper for `make_canonicalized_query_result` that does + /// Helper for `make_canonicalized_query_response` that does /// everything up until the final canonicalization. - fn make_query_result( + fn make_query_response( &self, inference_vars: CanonicalVarValues<'tcx>, answer: T, fulfill_cx: &mut FulfillmentContext<'tcx>, - ) -> Result, NoSolution> + ) -> Result, NoSolution> where T: Debug + TypeFoldable<'tcx> + Lift<'gcx>, { let tcx = self.tcx; debug!( - "make_query_result(\ + "make_query_response(\ inference_vars={:?}, \ answer={:?})", inference_vars, answer, @@ -138,7 +138,7 @@ fn make_query_result( if !true_errors.is_empty() { // FIXME -- we don't indicate *why* we failed to solve - debug!("make_query_result: true_errors={:#?}", true_errors); + debug!("make_query_response: true_errors={:#?}", true_errors); return Err(NoSolution); } @@ -162,7 +162,7 @@ fn make_query_result( Certainty::Ambiguous }; - Ok(QueryResult { + Ok(QueryResponse { var_values: inference_vars, region_constraints, certainty, @@ -180,12 +180,12 @@ fn make_query_result( /// out the [chapter in the rustc guide][c]. /// /// [c]: https://rust-lang-nursery.github.io/rustc-guide/traits/canonicalization.html#processing-the-canonicalized-query-result - pub fn instantiate_query_result_and_region_obligations( + pub fn instantiate_query_response_and_region_obligations( &self, cause: &ObligationCause<'tcx>, param_env: ty::ParamEnv<'tcx>, original_values: &SmallCanonicalVarValues<'tcx>, - query_result: &Canonical<'tcx, QueryResult<'tcx, R>>, + query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>, ) -> InferResult<'tcx, R> where R: Debug + TypeFoldable<'tcx>, @@ -193,17 +193,17 @@ pub fn instantiate_query_result_and_region_obligations( let InferOk { value: result_subst, mut obligations, - } = self.query_result_substitution(cause, param_env, original_values, query_result)?; + } = self.query_response_substitution(cause, param_env, original_values, query_response)?; obligations.extend(self.query_region_constraints_into_obligations( cause, param_env, - &query_result.value.region_constraints, + &query_response.value.region_constraints, &result_subst, )); let user_result: R = - query_result.substitute_projected(self.tcx, &result_subst, |q_r| &q_r.value); + query_response.substitute_projected(self.tcx, &result_subst, |q_r| &q_r.value); Ok(InferOk { value: user_result, @@ -212,7 +212,7 @@ pub fn instantiate_query_result_and_region_obligations( } /// An alternative to - /// `instantiate_query_result_and_region_obligations` that is more + /// `instantiate_query_response_and_region_obligations` that is more /// efficient for NLL. NLL is a bit more advanced in the /// "transition to chalk" than the rest of the compiler. During /// the NLL type check, all of the "processing" of types and @@ -227,8 +227,8 @@ pub fn instantiate_query_result_and_region_obligations( /// into the older infcx-style constraints (e.g., calls to /// `sub_regions` or `register_region_obligation`). /// - /// Therefore, `instantiate_nll_query_result_and_region_obligations` performs the same - /// basic operations as `instantiate_query_result_and_region_obligations` but + /// Therefore, `instantiate_nll_query_response_and_region_obligations` performs the same + /// basic operations as `instantiate_query_response_and_region_obligations` but /// it returns its result differently: /// /// - It creates a substitution `S` that maps from the original @@ -246,12 +246,12 @@ pub fn instantiate_query_result_and_region_obligations( /// are propagated back in the return value. /// - Finally, the query result (of type `R`) is propagated back, /// after applying the substitution `S`. - pub fn instantiate_nll_query_result_and_region_obligations( + pub fn instantiate_nll_query_response_and_region_obligations( &self, cause: &ObligationCause<'tcx>, param_env: ty::ParamEnv<'tcx>, original_values: &SmallCanonicalVarValues<'tcx>, - query_result: &Canonical<'tcx, QueryResult<'tcx, R>>, + query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>, output_query_region_constraints: &mut Vec>, ) -> InferResult<'tcx, R> where @@ -259,13 +259,13 @@ pub fn instantiate_nll_query_result_and_region_obligations( { // In an NLL query, there should be no type variables in the // query, only region variables. - debug_assert!(query_result.variables.iter().all(|v| match v.kind { + debug_assert!(query_response.variables.iter().all(|v| match v.kind { CanonicalVarKind::Ty(_) => false, CanonicalVarKind::Region => true, })); let result_subst = - self.query_result_substitution_guess(cause, original_values, query_result); + self.query_response_substitution_guess(cause, original_values, query_response); // Compute `QueryRegionConstraint` values that unify each of // the original values `v_o` that was canonicalized into a @@ -274,7 +274,7 @@ pub fn instantiate_nll_query_result_and_region_obligations( for (index, original_value) in original_values.iter().enumerate() { // ...with the value `v_r` of that variable from the query. - let result_value = query_result.substitute_projected(self.tcx, &result_subst, |v| { + let result_value = query_response.substitute_projected(self.tcx, &result_subst, |v| { &v.var_values[CanonicalVar::new(index)] }); match (original_value.unpack(), result_value.unpack()) { @@ -309,7 +309,7 @@ pub fn instantiate_nll_query_result_and_region_obligations( // ...also include the other query region constraints from the query. output_query_region_constraints.extend( - query_result.value.region_constraints.iter().filter_map(|r_c| { + query_response.value.region_constraints.iter().filter_map(|r_c| { let &ty::OutlivesPredicate(k1, r2) = r_c.skip_binder(); // reconstructed below let k1 = substitute_value(self.tcx, &result_subst, &k1); let r2 = substitute_value(self.tcx, &result_subst, &r2); @@ -322,7 +322,7 @@ pub fn instantiate_nll_query_result_and_region_obligations( ); let user_result: R = - query_result.substitute_projected(self.tcx, &result_subst, |q_r| &q_r.value); + query_response.substitute_projected(self.tcx, &result_subst, |q_r| &q_r.value); Ok(InferOk { value: user_result, @@ -340,30 +340,30 @@ pub fn instantiate_nll_query_result_and_region_obligations( /// example) we are doing lazy normalization and the value /// assigned to a type variable is unified with an unnormalized /// projection. - fn query_result_substitution( + fn query_response_substitution( &self, cause: &ObligationCause<'tcx>, param_env: ty::ParamEnv<'tcx>, original_values: &SmallCanonicalVarValues<'tcx>, - query_result: &Canonical<'tcx, QueryResult<'tcx, R>>, + query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>, ) -> InferResult<'tcx, CanonicalVarValues<'tcx>> where R: Debug + TypeFoldable<'tcx>, { debug!( - "query_result_substitution(original_values={:#?}, query_result={:#?})", - original_values, query_result, + "query_response_substitution(original_values={:#?}, query_response={:#?})", + original_values, query_response, ); let result_subst = - self.query_result_substitution_guess(cause, original_values, query_result); + self.query_response_substitution_guess(cause, original_values, query_response); - let obligations = self.unify_query_result_substitution_guess( + let obligations = self.unify_query_response_substitution_guess( cause, param_env, original_values, &result_subst, - query_result, + query_response, )? .into_obligations(); @@ -382,25 +382,25 @@ fn query_result_substitution( /// will instantiate fresh inference variables for each canonical /// variable instead. Therefore, the result of this method must be /// properly unified - fn query_result_substitution_guess( + fn query_response_substitution_guess( &self, cause: &ObligationCause<'tcx>, original_values: &SmallCanonicalVarValues<'tcx>, - query_result: &Canonical<'tcx, QueryResult<'tcx, R>>, + query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>, ) -> CanonicalVarValues<'tcx> where R: Debug + TypeFoldable<'tcx>, { debug!( - "query_result_substitution_guess(original_values={:#?}, query_result={:#?})", - original_values, query_result, + "query_response_substitution_guess(original_values={:#?}, query_response={:#?})", + original_values, query_response, ); // Every canonical query result includes values for each of // the inputs to the query. Therefore, we begin by unifying // these values with the original inputs that were // canonicalized. - let result_values = &query_result.value.var_values; + let result_values = &query_response.value.var_values; assert_eq!(original_values.len(), result_values.len()); // Quickly try to find initial values for the canonical @@ -411,7 +411,7 @@ fn query_result_substitution_guess( // result, then we can type the corresponding value from the // input. See the example above. let mut opt_values: IndexVec>> = - IndexVec::from_elem_n(None, query_result.variables.len()); + IndexVec::from_elem_n(None, query_response.variables.len()); // In terms of our example above, we are iterating over pairs like: // [(?A, Vec), ('static, '?1), (?B, ?0)] @@ -438,7 +438,7 @@ fn query_result_substitution_guess( // given variable in the loop above, use that. Otherwise, use // a fresh inference variable. let result_subst = CanonicalVarValues { - var_values: query_result + var_values: query_response .variables .iter() .enumerate() @@ -456,29 +456,29 @@ fn query_result_substitution_guess( /// query result. Often, but not always, this is a no-op, because /// we already found the mapping in the "guessing" step. /// - /// See also: `query_result_substitution_guess` - fn unify_query_result_substitution_guess( + /// See also: `query_response_substitution_guess` + fn unify_query_response_substitution_guess( &self, cause: &ObligationCause<'tcx>, param_env: ty::ParamEnv<'tcx>, original_values: &SmallCanonicalVarValues<'tcx>, result_subst: &CanonicalVarValues<'tcx>, - query_result: &Canonical<'tcx, QueryResult<'tcx, R>>, + query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>, ) -> InferResult<'tcx, ()> where R: Debug + TypeFoldable<'tcx>, { // A closure that yields the result value for the given // canonical variable; this is taken from - // `query_result.var_values` after applying the substitution + // `query_response.var_values` after applying the substitution // `result_subst`. - let substituted_query_result = |index: CanonicalVar| -> Kind<'tcx> { - query_result.substitute_projected(self.tcx, &result_subst, |v| &v.var_values[index]) + let substituted_query_response = |index: CanonicalVar| -> Kind<'tcx> { + query_response.substitute_projected(self.tcx, &result_subst, |v| &v.var_values[index]) }; // Unify the original value for each variable with the value - // taken from `query_result` (after applying `result_subst`). - Ok(self.unify_canonical_vars(cause, param_env, original_values, substituted_query_result)?) + // taken from `query_response` (after applying `result_subst`). + Ok(self.unify_canonical_vars(cause, param_env, original_values, substituted_query_response)?) } /// Converts the region constraints resulting from a query into an diff --git a/src/librustc/traits/query/dropck_outlives.rs b/src/librustc/traits/query/dropck_outlives.rs index aaf03f8e7fb..c2091c182d6 100644 --- a/src/librustc/traits/query/dropck_outlives.rs +++ b/src/librustc/traits/query/dropck_outlives.rs @@ -58,7 +58,7 @@ pub fn dropck_outlives(&self, ty: Ty<'tcx>) -> InferOk<'tcx, Vec>> { match &gcx.dropck_outlives(c_ty) { Ok(result) if result.is_proven() => { if let Ok(InferOk { value, obligations }) = - self.infcx.instantiate_query_result_and_region_obligations( + self.infcx.instantiate_query_response_and_region_obligations( self.cause, self.param_env, &orig_values, diff --git a/src/librustc/traits/query/normalize.rs b/src/librustc/traits/query/normalize.rs index 9b9643aab97..833c650680e 100644 --- a/src/librustc/traits/query/normalize.rs +++ b/src/librustc/traits/query/normalize.rs @@ -167,7 +167,7 @@ fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> { return ty; } - match self.infcx.instantiate_query_result_and_region_obligations( + match self.infcx.instantiate_query_response_and_region_obligations( self.cause, self.param_env, &orig_values, diff --git a/src/librustc/traits/query/outlives_bounds.rs b/src/librustc/traits/query/outlives_bounds.rs index 47c8ee357fb..5415efe1514 100644 --- a/src/librustc/traits/query/outlives_bounds.rs +++ b/src/librustc/traits/query/outlives_bounds.rs @@ -119,7 +119,7 @@ pub fn implied_outlives_bounds( }; assert!(result.value.is_proven()); - let result = self.instantiate_query_result_and_region_obligations( + let result = self.instantiate_query_response_and_region_obligations( &ObligationCause::misc(span, body_id), param_env, &orig_values, &result); debug!("implied_outlives_bounds for {:?}: {:#?}", ty, result); let result = match result { diff --git a/src/librustc/traits/query/type_op/custom.rs b/src/librustc/traits/query/type_op/custom.rs index 6708112697b..54860dd0434 100644 --- a/src/librustc/traits/query/type_op/custom.rs +++ b/src/librustc/traits/query/type_op/custom.rs @@ -12,7 +12,7 @@ use std::fmt; use traits::query::Fallible; -use infer::canonical::query_result; +use infer::canonical::query_response; use infer::canonical::QueryRegionConstraint; use std::rc::Rc; use syntax::source_map::DUMMY_SP; @@ -102,7 +102,7 @@ fn scrape_region_constraints<'gcx, 'tcx, R>( let region_constraint_data = infcx.take_and_reset_region_constraints(); - let outlives = query_result::make_query_outlives( + let outlives = query_response::make_query_outlives( infcx.tcx, region_obligations .iter() diff --git a/src/librustc/traits/query/type_op/eq.rs b/src/librustc/traits/query/type_op/eq.rs index 52a087cbc80..43dea442df6 100644 --- a/src/librustc/traits/query/type_op/eq.rs +++ b/src/librustc/traits/query/type_op/eq.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResult, QueryResult}; +use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; use traits::query::Fallible; use ty::{ParamEnvAnd, Ty, TyCtxt}; @@ -25,12 +25,12 @@ pub fn new(a: Ty<'tcx>, b: Ty<'tcx>) -> Self { } impl<'gcx: 'tcx, 'tcx> super::QueryTypeOp<'gcx, 'tcx> for Eq<'tcx> { - type QueryResult = (); + type QueryResponse = (); fn try_fast_path( _tcx: TyCtxt<'_, 'gcx, 'tcx>, key: &ParamEnvAnd<'tcx, Eq<'tcx>>, - ) -> Option { + ) -> Option { if key.value.a == key.value.b { Some(()) } else { @@ -41,13 +41,13 @@ fn try_fast_path( fn perform_query( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Self>>, - ) -> Fallible> { + ) -> Fallible> { tcx.type_op_eq(canonicalized) } fn shrink_to_tcx_lifetime( - v: &'a CanonicalizedQueryResult<'gcx, ()>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, ()>> { + v: &'a CanonicalizedQueryResponse<'gcx, ()>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, ()>> { v } } diff --git a/src/librustc/traits/query/type_op/implied_outlives_bounds.rs b/src/librustc/traits/query/type_op/implied_outlives_bounds.rs index 27534bc8c3c..b113a322d37 100644 --- a/src/librustc/traits/query/type_op/implied_outlives_bounds.rs +++ b/src/librustc/traits/query/type_op/implied_outlives_bounds.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResult, QueryResult}; +use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; use traits::query::outlives_bounds::OutlivesBound; use traits::query::Fallible; use ty::{ParamEnvAnd, Ty, TyCtxt}; @@ -25,19 +25,19 @@ pub fn new(ty: Ty<'tcx>) -> Self { } impl<'gcx: 'tcx, 'tcx> super::QueryTypeOp<'gcx, 'tcx> for ImpliedOutlivesBounds<'tcx> { - type QueryResult = Vec>; + type QueryResponse = Vec>; fn try_fast_path( _tcx: TyCtxt<'_, 'gcx, 'tcx>, _key: &ParamEnvAnd<'tcx, Self>, - ) -> Option { + ) -> Option { None } fn perform_query( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Self>>, - ) -> Fallible> { + ) -> Fallible> { // FIXME the query should take a `ImpliedOutlivesBounds` let Canonical { variables, @@ -56,8 +56,8 @@ fn perform_query( } fn shrink_to_tcx_lifetime( - v: &'a CanonicalizedQueryResult<'gcx, Self::QueryResult>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, Self::QueryResult>> { + v: &'a CanonicalizedQueryResponse<'gcx, Self::QueryResponse>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self::QueryResponse>> { v } } diff --git a/src/librustc/traits/query/type_op/mod.rs b/src/librustc/traits/query/type_op/mod.rs index 8e4236d1754..0d86b009996 100644 --- a/src/librustc/traits/query/type_op/mod.rs +++ b/src/librustc/traits/query/type_op/mod.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResult, QueryRegionConstraint, - QueryResult}; +use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryRegionConstraint, + QueryResponse}; use infer::{InferCtxt, InferOk}; use smallvec::SmallVec; use std::fmt; @@ -55,7 +55,7 @@ fn fully_perform( pub trait QueryTypeOp<'gcx: 'tcx, 'tcx>: fmt::Debug + Sized + TypeFoldable<'tcx> + Lift<'gcx> { - type QueryResult: TypeFoldable<'tcx> + Lift<'gcx>; + type QueryResponse: TypeFoldable<'tcx> + Lift<'gcx>; /// Give query the option for a simple fast path that never /// actually hits the tcx cache lookup etc. Return `Some(r)` with @@ -63,7 +63,7 @@ pub trait QueryTypeOp<'gcx: 'tcx, 'tcx>: fn try_fast_path( tcx: TyCtxt<'_, 'gcx, 'tcx>, key: &ParamEnvAnd<'tcx, Self>, - ) -> Option; + ) -> Option; /// Performs the actual query with the canonicalized key -- the /// real work happens here. This method is not given an `infcx` @@ -74,29 +74,29 @@ fn try_fast_path( fn perform_query( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Self>>, - ) -> Fallible>; + ) -> Fallible>; /// Casts a lifted query result (which is in the gcx lifetime) /// into the tcx lifetime. This is always just an identity cast, /// but the generic code doesn't realize it -- put another way, in - /// the generic code, we have a `Lifted<'gcx, Self::QueryResult>` - /// and we want to convert that to a `Self::QueryResult`. This is + /// the generic code, we have a `Lifted<'gcx, Self::QueryResponse>` + /// and we want to convert that to a `Self::QueryResponse`. This is /// not a priori valid, so we can't do it -- but in practice, it /// is always a no-op (e.g., the lifted form of a type, /// `Ty<'gcx>`, is a subtype of `Ty<'tcx>`). So we have to push /// the operation into the impls that know more specifically what - /// `QueryResult` is. This operation would (maybe) be nicer with + /// `QueryResponse` is. This operation would (maybe) be nicer with /// something like HKTs or GATs, since then we could make - /// `QueryResult` parametric and `'gcx` and `'tcx` etc. + /// `QueryResponse` parametric and `'gcx` and `'tcx` etc. fn shrink_to_tcx_lifetime( - lifted_query_result: &'a CanonicalizedQueryResult<'gcx, Self::QueryResult>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, Self::QueryResult>>; + lifted_query_result: &'a CanonicalizedQueryResponse<'gcx, Self::QueryResponse>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self::QueryResponse>>; fn fully_perform_into( query_key: ParamEnvAnd<'tcx, Self>, infcx: &InferCtxt<'_, 'gcx, 'tcx>, output_query_region_constraints: &mut Vec>, - ) -> Fallible { + ) -> Fallible { if let Some(result) = QueryTypeOp::try_fast_path(infcx.tcx, &query_key) { return Ok(result); } @@ -114,7 +114,7 @@ fn fully_perform_into( let param_env = query_key.param_env; let InferOk { value, obligations } = infcx - .instantiate_nll_query_result_and_region_obligations( + .instantiate_nll_query_response_and_region_obligations( &ObligationCause::dummy(), param_env, &canonical_var_values, @@ -145,7 +145,7 @@ impl<'gcx: 'tcx, 'tcx, Q> TypeOp<'gcx, 'tcx> for ParamEnvAnd<'tcx, Q> where Q: QueryTypeOp<'gcx, 'tcx>, { - type Output = Q::QueryResult; + type Output = Q::QueryResponse; fn fully_perform( self, diff --git a/src/librustc/traits/query/type_op/normalize.rs b/src/librustc/traits/query/type_op/normalize.rs index 0c393fa4ca8..c45e8b2554b 100644 --- a/src/librustc/traits/query/type_op/normalize.rs +++ b/src/librustc/traits/query/type_op/normalize.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResult, QueryResult}; +use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; use std::fmt; use traits::query::Fallible; use ty::fold::TypeFoldable; @@ -32,7 +32,7 @@ impl<'gcx: 'tcx, 'tcx, T> super::QueryTypeOp<'gcx, 'tcx> for Normalize where T: Normalizable<'gcx, 'tcx>, { - type QueryResult = T; + type QueryResponse = T; fn try_fast_path(_tcx: TyCtxt<'_, 'gcx, 'tcx>, key: &ParamEnvAnd<'tcx, Self>) -> Option { if !key.value.value.has_projections() { @@ -45,13 +45,13 @@ fn try_fast_path(_tcx: TyCtxt<'_, 'gcx, 'tcx>, key: &ParamEnvAnd<'tcx, Self>) -> fn perform_query( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Self>>, - ) -> Fallible> { + ) -> Fallible> { T::type_op_method(tcx, canonicalized) } fn shrink_to_tcx_lifetime( - v: &'a CanonicalizedQueryResult<'gcx, T>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, T>> { + v: &'a CanonicalizedQueryResponse<'gcx, T>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, T>> { T::shrink_to_tcx_lifetime(v) } } @@ -60,13 +60,13 @@ pub trait Normalizable<'gcx, 'tcx>: fmt::Debug + TypeFoldable<'tcx> + Lift<'gcx> fn type_op_method( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Normalize>>, - ) -> Fallible>; + ) -> Fallible>; /// Convert from the `'gcx` (lifted) form of `Self` into the `tcx` /// form of `Self`. fn shrink_to_tcx_lifetime( - v: &'a CanonicalizedQueryResult<'gcx, Self>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, Self>>; + v: &'a CanonicalizedQueryResponse<'gcx, Self>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self>>; } impl Normalizable<'gcx, 'tcx> for Ty<'tcx> @@ -76,13 +76,13 @@ impl Normalizable<'gcx, 'tcx> for Ty<'tcx> fn type_op_method( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Normalize>>, - ) -> Fallible> { + ) -> Fallible> { tcx.type_op_normalize_ty(canonicalized) } fn shrink_to_tcx_lifetime( - v: &'a CanonicalizedQueryResult<'gcx, Self>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, Self>> { + v: &'a CanonicalizedQueryResponse<'gcx, Self>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self>> { v } } @@ -94,13 +94,13 @@ impl Normalizable<'gcx, 'tcx> for ty::Predicate<'tcx> fn type_op_method( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Normalize>>, - ) -> Fallible> { + ) -> Fallible> { tcx.type_op_normalize_predicate(canonicalized) } fn shrink_to_tcx_lifetime( - v: &'a CanonicalizedQueryResult<'gcx, Self>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, Self>> { + v: &'a CanonicalizedQueryResponse<'gcx, Self>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self>> { v } } @@ -112,13 +112,13 @@ impl Normalizable<'gcx, 'tcx> for ty::PolyFnSig<'tcx> fn type_op_method( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Normalize>>, - ) -> Fallible> { + ) -> Fallible> { tcx.type_op_normalize_poly_fn_sig(canonicalized) } fn shrink_to_tcx_lifetime( - v: &'a CanonicalizedQueryResult<'gcx, Self>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, Self>> { + v: &'a CanonicalizedQueryResponse<'gcx, Self>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self>> { v } } @@ -130,13 +130,13 @@ impl Normalizable<'gcx, 'tcx> for ty::FnSig<'tcx> fn type_op_method( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Normalize>>, - ) -> Fallible> { + ) -> Fallible> { tcx.type_op_normalize_fn_sig(canonicalized) } fn shrink_to_tcx_lifetime( - v: &'a CanonicalizedQueryResult<'gcx, Self>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, Self>> { + v: &'a CanonicalizedQueryResponse<'gcx, Self>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self>> { v } } diff --git a/src/librustc/traits/query/type_op/outlives.rs b/src/librustc/traits/query/type_op/outlives.rs index e41ae7a72f9..a36c5accd2a 100644 --- a/src/librustc/traits/query/type_op/outlives.rs +++ b/src/librustc/traits/query/type_op/outlives.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResult, QueryResult}; +use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; use traits::query::dropck_outlives::trivial_dropck_outlives; use traits::query::dropck_outlives::DropckOutlivesResult; use traits::query::Fallible; @@ -29,12 +29,12 @@ impl super::QueryTypeOp<'gcx, 'tcx> for DropckOutlives<'tcx> where 'gcx: 'tcx, { - type QueryResult = DropckOutlivesResult<'tcx>; + type QueryResponse = DropckOutlivesResult<'tcx>; fn try_fast_path( tcx: TyCtxt<'_, 'gcx, 'tcx>, key: &ParamEnvAnd<'tcx, Self>, - ) -> Option { + ) -> Option { if trivial_dropck_outlives(tcx, key.value.dropped_ty) { Some(DropckOutlivesResult::default()) } else { @@ -45,7 +45,7 @@ fn try_fast_path( fn perform_query( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Self>>, - ) -> Fallible> { + ) -> Fallible> { // Subtle: note that we are not invoking // `infcx.at(...).dropck_outlives(...)` here, but rather the // underlying `dropck_outlives` query. This same underlying @@ -76,8 +76,8 @@ fn perform_query( } fn shrink_to_tcx_lifetime( - lifted_query_result: &'a CanonicalizedQueryResult<'gcx, Self::QueryResult>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, Self::QueryResult>> { + lifted_query_result: &'a CanonicalizedQueryResponse<'gcx, Self::QueryResponse>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self::QueryResponse>> { lifted_query_result } } diff --git a/src/librustc/traits/query/type_op/prove_predicate.rs b/src/librustc/traits/query/type_op/prove_predicate.rs index e1b3b3c436d..460ddb2a138 100644 --- a/src/librustc/traits/query/type_op/prove_predicate.rs +++ b/src/librustc/traits/query/type_op/prove_predicate.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResult, QueryResult}; +use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; use traits::query::Fallible; use ty::{ParamEnvAnd, Predicate, TyCtxt}; @@ -24,12 +24,12 @@ pub fn new(predicate: Predicate<'tcx>) -> Self { } impl<'gcx: 'tcx, 'tcx> super::QueryTypeOp<'gcx, 'tcx> for ProvePredicate<'tcx> { - type QueryResult = (); + type QueryResponse = (); fn try_fast_path( tcx: TyCtxt<'_, 'gcx, 'tcx>, key: &ParamEnvAnd<'tcx, Self>, - ) -> Option { + ) -> Option { // Proving Sized, very often on "obviously sized" types like // `&T`, accounts for about 60% percentage of the predicates // we have to prove. No need to canonicalize and all that for @@ -50,13 +50,13 @@ fn try_fast_path( fn perform_query( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Self>>, - ) -> Fallible> { + ) -> Fallible> { tcx.type_op_prove_predicate(canonicalized) } fn shrink_to_tcx_lifetime( - v: &'a CanonicalizedQueryResult<'gcx, ()>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, ()>> { + v: &'a CanonicalizedQueryResponse<'gcx, ()>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, ()>> { v } } diff --git a/src/librustc/traits/query/type_op/subtype.rs b/src/librustc/traits/query/type_op/subtype.rs index dc41bb1d6ab..2b2939c644a 100644 --- a/src/librustc/traits/query/type_op/subtype.rs +++ b/src/librustc/traits/query/type_op/subtype.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResult, QueryResult}; +use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; use traits::query::Fallible; use ty::{ParamEnvAnd, Ty, TyCtxt}; @@ -28,7 +28,7 @@ pub fn new(sub: Ty<'tcx>, sup: Ty<'tcx>) -> Self { } impl<'gcx: 'tcx, 'tcx> super::QueryTypeOp<'gcx, 'tcx> for Subtype<'tcx> { - type QueryResult = (); + type QueryResponse = (); fn try_fast_path(_tcx: TyCtxt<'_, 'gcx, 'tcx>, key: &ParamEnvAnd<'tcx, Self>) -> Option<()> { if key.value.sub == key.value.sup { @@ -41,13 +41,13 @@ fn try_fast_path(_tcx: TyCtxt<'_, 'gcx, 'tcx>, key: &ParamEnvAnd<'tcx, Self>) -> fn perform_query( tcx: TyCtxt<'_, 'gcx, 'tcx>, canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Self>>, - ) -> Fallible> { + ) -> Fallible> { tcx.type_op_subtype(canonicalized) } fn shrink_to_tcx_lifetime( - v: &'a CanonicalizedQueryResult<'gcx, ()>, - ) -> &'a Canonical<'tcx, QueryResult<'tcx, ()>> { + v: &'a CanonicalizedQueryResponse<'gcx, ()>, + ) -> &'a Canonical<'tcx, QueryResponse<'tcx, ()>> { v } } diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs index 7f5bc35f91f..c4f39ffcd20 100644 --- a/src/librustc/ty/query/mod.rs +++ b/src/librustc/ty/query/mod.rs @@ -559,7 +559,7 @@ [] fn normalize_projection_ty: NormalizeProjectionTy( CanonicalProjectionGoal<'tcx> ) -> Result< - Lrc>>>, + Lrc>>>, NoSolution, >, @@ -571,7 +571,7 @@ [] fn implied_outlives_bounds: ImpliedOutlivesBounds( CanonicalTyGoal<'tcx> ) -> Result< - Lrc>>>>, + Lrc>>>>, NoSolution, >, @@ -579,7 +579,7 @@ [] fn dropck_outlives: DropckOutlives( CanonicalTyGoal<'tcx> ) -> Result< - Lrc>>>, + Lrc>>>, NoSolution, >, @@ -593,7 +593,7 @@ [] fn type_op_eq: TypeOpEq( CanonicalTypeOpEqGoal<'tcx> ) -> Result< - Lrc>>, + Lrc>>, NoSolution, >, @@ -601,7 +601,7 @@ [] fn type_op_subtype: TypeOpSubtype( CanonicalTypeOpSubtypeGoal<'tcx> ) -> Result< - Lrc>>, + Lrc>>, NoSolution, >, @@ -609,7 +609,7 @@ [] fn type_op_prove_predicate: TypeOpProvePredicate( CanonicalTypeOpProvePredicateGoal<'tcx> ) -> Result< - Lrc>>, + Lrc>>, NoSolution, >, @@ -617,7 +617,7 @@ [] fn type_op_normalize_ty: TypeOpNormalizeTy( CanonicalTypeOpNormalizeGoal<'tcx, Ty<'tcx>> ) -> Result< - Lrc>>>, + Lrc>>>, NoSolution, >, @@ -625,7 +625,7 @@ [] fn type_op_normalize_predicate: TypeOpNormalizePredicate( CanonicalTypeOpNormalizeGoal<'tcx, ty::Predicate<'tcx>> ) -> Result< - Lrc>>>, + Lrc>>>, NoSolution, >, @@ -633,7 +633,7 @@ [] fn type_op_normalize_poly_fn_sig: TypeOpNormalizePolyFnSig( CanonicalTypeOpNormalizeGoal<'tcx, ty::PolyFnSig<'tcx>> ) -> Result< - Lrc>>>, + Lrc>>>, NoSolution, >, @@ -641,7 +641,7 @@ [] fn type_op_normalize_fn_sig: TypeOpNormalizeFnSig( CanonicalTypeOpNormalizeGoal<'tcx, ty::FnSig<'tcx>> ) -> Result< - Lrc>>>, + Lrc>>>, NoSolution, >, diff --git a/src/librustc_traits/chalk_context.rs b/src/librustc_traits/chalk_context.rs index dea3aa4372a..5a0ab842200 100644 --- a/src/librustc_traits/chalk_context.rs +++ b/src/librustc_traits/chalk_context.rs @@ -10,7 +10,7 @@ use chalk_engine::fallible::Fallible as ChalkEngineFallible; use chalk_engine::{context, hh::HhGoal, DelayedLiteral, ExClause}; -use rustc::infer::canonical::{Canonical, CanonicalVarValues, QueryRegionConstraint, QueryResult}; +use rustc::infer::canonical::{Canonical, CanonicalVarValues, QueryRegionConstraint, QueryResponse}; use rustc::infer::{InferCtxt, InferOk, LateBoundRegionConversionTime}; use rustc::traits::{ WellFormed, @@ -77,7 +77,7 @@ impl context::Context for ChalkArenas<'tcx> { // u-canonicalization not yet implemented type UniverseMap = UniverseMap; - type Solution = Canonical<'tcx, QueryResult<'tcx, ()>>; + type Solution = Canonical<'tcx, QueryResponse<'tcx, ()>>; type InferenceNormalizedSubst = CanonicalVarValues<'tcx>; @@ -116,7 +116,7 @@ fn make_solution( &self, _root_goal: &Canonical<'gcx, ty::ParamEnvAnd<'gcx, Goal<'gcx>>>, _simplified_answers: impl context::AnswerStream>, - ) -> Option>> { + ) -> Option>> { unimplemented!() } } diff --git a/src/librustc_traits/dropck_outlives.rs b/src/librustc_traits/dropck_outlives.rs index 1745679bc27..37e61e74e64 100644 --- a/src/librustc_traits/dropck_outlives.rs +++ b/src/librustc_traits/dropck_outlives.rs @@ -9,7 +9,7 @@ // except according to those terms. use rustc::hir::def_id::DefId; -use rustc::infer::canonical::{Canonical, QueryResult}; +use rustc::infer::canonical::{Canonical, QueryResponse}; use rustc::traits::query::dropck_outlives::{DropckOutlivesResult, DtorckConstraint}; use rustc::traits::query::{CanonicalTyGoal, NoSolution}; use rustc::traits::{FulfillmentContext, Normalized, ObligationCause, TraitEngineExt}; @@ -31,7 +31,7 @@ fn dropck_outlives<'tcx>( tcx: TyCtxt<'_, 'tcx, 'tcx>, canonical_goal: CanonicalTyGoal<'tcx>, -) -> Result>>>, NoSolution> { +) -> Result>>>, NoSolution> { debug!("dropck_outlives(goal={:#?})", canonical_goal); tcx.infer_ctxt().enter_with_canonical(DUMMY_SP, &canonical_goal, |ref infcx, goal, canonical_inference_vars| { @@ -143,7 +143,7 @@ fn dropck_outlives<'tcx>( debug!("dropck_outlives: result = {:#?}", result); - infcx.make_canonicalized_query_result(canonical_inference_vars, result, fulfill_cx) + infcx.make_canonicalized_query_response(canonical_inference_vars, result, fulfill_cx) }) } diff --git a/src/librustc_traits/implied_outlives_bounds.rs b/src/librustc_traits/implied_outlives_bounds.rs index 7b31518c07b..ad0a54e392f 100644 --- a/src/librustc_traits/implied_outlives_bounds.rs +++ b/src/librustc_traits/implied_outlives_bounds.rs @@ -37,7 +37,7 @@ fn implied_outlives_bounds<'tcx>( tcx: TyCtxt<'_, 'tcx, 'tcx>, goal: CanonicalTyGoal<'tcx>, ) -> Result< - Lrc>>>>, + Lrc>>>>, NoSolution, > { tcx.infer_ctxt() diff --git a/src/librustc_traits/normalize_projection_ty.rs b/src/librustc_traits/normalize_projection_ty.rs index 1c0f677fbf3..637a50728f3 100644 --- a/src/librustc_traits/normalize_projection_ty.rs +++ b/src/librustc_traits/normalize_projection_ty.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use rustc::infer::canonical::{Canonical, QueryResult}; +use rustc::infer::canonical::{Canonical, QueryResponse}; use rustc::traits::query::{normalize::NormalizationResult, CanonicalProjectionGoal, NoSolution}; use rustc::traits::{self, ObligationCause, SelectionContext, TraitEngineExt}; use rustc::ty::query::Providers; @@ -28,7 +28,7 @@ fn normalize_projection_ty<'tcx>( tcx: TyCtxt<'_, 'tcx, 'tcx>, goal: CanonicalProjectionGoal<'tcx>, -) -> Result>>>, NoSolution> { +) -> Result>>>, NoSolution> { debug!("normalize_provider(goal={:#?})", goal); tcx.sess diff --git a/src/librustc_traits/type_op.rs b/src/librustc_traits/type_op.rs index 8fe4290528e..a857cdbda45 100644 --- a/src/librustc_traits/type_op.rs +++ b/src/librustc_traits/type_op.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use rustc::infer::canonical::{Canonical, QueryResult}; +use rustc::infer::canonical::{Canonical, QueryResponse}; use rustc::infer::InferCtxt; use rustc::traits::query::type_op::eq::Eq; use rustc::traits::query::type_op::normalize::Normalize; @@ -38,7 +38,7 @@ fn type_op_eq<'tcx>( tcx: TyCtxt<'_, 'tcx, 'tcx>, canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Eq<'tcx>>>, -) -> Result>>, NoSolution> { +) -> Result>>, NoSolution> { tcx.infer_ctxt() .enter_canonical_trait_query(&canonicalized, |infcx, fulfill_cx, key| { let (param_env, Eq { a, b }) = key.into_parts(); @@ -68,7 +68,7 @@ fn type_op_normalize( fn type_op_normalize_ty( tcx: TyCtxt<'_, 'tcx, 'tcx>, canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Normalize>>>, -) -> Result>>>, NoSolution> { +) -> Result>>>, NoSolution> { tcx.infer_ctxt() .enter_canonical_trait_query(&canonicalized, type_op_normalize) } @@ -76,7 +76,7 @@ fn type_op_normalize_ty( fn type_op_normalize_predicate( tcx: TyCtxt<'_, 'tcx, 'tcx>, canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Normalize>>>, -) -> Result>>>, NoSolution> { +) -> Result>>>, NoSolution> { tcx.infer_ctxt() .enter_canonical_trait_query(&canonicalized, type_op_normalize) } @@ -84,7 +84,7 @@ fn type_op_normalize_predicate( fn type_op_normalize_fn_sig( tcx: TyCtxt<'_, 'tcx, 'tcx>, canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Normalize>>>, -) -> Result>>>, NoSolution> { +) -> Result>>>, NoSolution> { tcx.infer_ctxt() .enter_canonical_trait_query(&canonicalized, type_op_normalize) } @@ -92,7 +92,7 @@ fn type_op_normalize_fn_sig( fn type_op_normalize_poly_fn_sig( tcx: TyCtxt<'_, 'tcx, 'tcx>, canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Normalize>>>, -) -> Result>>>, NoSolution> { +) -> Result>>>, NoSolution> { tcx.infer_ctxt() .enter_canonical_trait_query(&canonicalized, type_op_normalize) } @@ -100,7 +100,7 @@ fn type_op_normalize_poly_fn_sig( fn type_op_subtype<'tcx>( tcx: TyCtxt<'_, 'tcx, 'tcx>, canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Subtype<'tcx>>>, -) -> Result>>, NoSolution> { +) -> Result>>, NoSolution> { tcx.infer_ctxt() .enter_canonical_trait_query(&canonicalized, |infcx, fulfill_cx, key| { let (param_env, Subtype { sub, sup }) = key.into_parts(); @@ -114,7 +114,7 @@ fn type_op_subtype<'tcx>( fn type_op_prove_predicate<'tcx>( tcx: TyCtxt<'_, 'tcx, 'tcx>, canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, ProvePredicate<'tcx>>>, -) -> Result>>, NoSolution> { +) -> Result>>, NoSolution> { tcx.infer_ctxt() .enter_canonical_trait_query(&canonicalized, |infcx, fulfill_cx, key| { let (param_env, ProvePredicate { predicate }) = key.into_parts(); -- GitLab