From 007aabae930d753742f6916d91d3fc8838db08a1 Mon Sep 17 00:00:00 2001 From: =?utf8?q?John=20K=C3=A5re=20Alsaker?= Date: Fri, 14 Jun 2019 18:09:57 +0200 Subject: [PATCH] Remove unnecessary lift calls --- src/librustc/infer/canonical/canonicalizer.rs | 30 +++++-------------- src/librustc/infer/canonical/mod.rs | 4 +-- .../infer/canonical/query_response.rs | 16 +++++----- src/librustc/infer/opaque_types/mod.rs | 5 ---- src/librustc/middle/mem_categorization.rs | 5 +--- src/librustc/traits/codegen/mod.rs | 10 ++----- src/librustc/traits/project.rs | 1 - src/librustc/traits/query/normalize.rs | 1 - src/librustc/traits/query/type_op/mod.rs | 6 ++-- .../traits/query/type_op/normalize.rs | 2 +- src/librustc/traits/specialize/mod.rs | 7 +---- src/librustc/ty/error.rs | 9 ++++-- src/librustc/ty/sty.rs | 13 ++++---- src/librustc_mir/borrow_check/mod.rs | 2 +- .../borrow_check/nll/region_infer/mod.rs | 4 +-- .../borrow_check/nll/type_check/mod.rs | 4 +-- src/librustc_mir/build/expr/as_rvalue.rs | 4 +-- .../dataflow/drop_flag_effects.rs | 2 +- src/librustc_mir/hair/constant.rs | 2 +- src/librustc_mir/hair/cx/mod.rs | 7 +---- src/librustc_mir/hair/pattern/_match.rs | 2 +- .../normalize_erasing_regions.rs | 3 +- 22 files changed, 50 insertions(+), 89 deletions(-) diff --git a/src/librustc/infer/canonical/canonicalizer.rs b/src/librustc/infer/canonical/canonicalizer.rs index b4779eec65f..a156075b812 100644 --- a/src/librustc/infer/canonical/canonicalizer.rs +++ b/src/librustc/infer/canonical/canonicalizer.rs @@ -14,7 +14,7 @@ use std::sync::atomic::Ordering; use crate::ty::fold::{TypeFoldable, TypeFolder}; use crate::ty::subst::Kind; -use crate::ty::{self, BoundVar, InferConst, Lift, List, Ty, TyCtxt, TypeFlags}; +use crate::ty::{self, BoundVar, InferConst, List, Ty, TyCtxt, TypeFlags}; use crate::ty::flags::FlagComputation; use rustc_data_structures::fx::FxHashMap; @@ -43,7 +43,7 @@ pub fn canonicalize_query( query_state: &mut OriginalQueryValues<'tcx>, ) -> Canonicalized<'tcx, V> where - V: TypeFoldable<'tcx> + Lift<'tcx>, + V: TypeFoldable<'tcx>, { self.tcx .sess @@ -87,7 +87,7 @@ pub fn canonicalize_query( /// [c]: https://rust-lang.github.io/rustc-guide/traits/canonicalization.html#canonicalizing-the-query-result pub fn canonicalize_response(&self, value: &V) -> Canonicalized<'tcx, V> where - V: TypeFoldable<'tcx> + Lift<'tcx>, + V: TypeFoldable<'tcx>, { let mut query_state = OriginalQueryValues::default(); Canonicalizer::canonicalize( @@ -101,7 +101,7 @@ pub fn canonicalize_response(&self, value: &V) -> Canonicalized<'tcx, V> pub fn canonicalize_user_type_annotation(&self, value: &V) -> Canonicalized<'tcx, V> where - V: TypeFoldable<'tcx> + Lift<'tcx>, + V: TypeFoldable<'tcx>, { let mut query_state = OriginalQueryValues::default(); Canonicalizer::canonicalize( @@ -132,7 +132,7 @@ pub fn canonicalize_hr_query_hack( query_state: &mut OriginalQueryValues<'tcx>, ) -> Canonicalized<'tcx, V> where - V: TypeFoldable<'tcx> + Lift<'tcx>, + V: TypeFoldable<'tcx>, { self.tcx .sess @@ -506,7 +506,7 @@ fn canonicalize( query_state: &mut OriginalQueryValues<'tcx>, ) -> Canonicalized<'tcx, V> where - V: TypeFoldable<'tcx> + Lift<'tcx>, + V: TypeFoldable<'tcx>, { let needs_canonical_flags = if canonicalize_region_mode.any() { TypeFlags::KEEP_IN_LOCAL_TCX | @@ -520,20 +520,12 @@ fn canonicalize( TypeFlags::HAS_CT_PLACEHOLDER }; - let gcx = tcx.global_tcx(); - // Fast path: nothing that needs to be canonicalized. if !value.has_type_flags(needs_canonical_flags) { - let out_value = gcx.lift(value).unwrap_or_else(|| { - bug!( - "failed to lift `{:?}` (nothing to canonicalize)", - value - ) - }); let canon_value = Canonical { max_universe: ty::UniverseIndex::ROOT, variables: List::empty(), - value: out_value, + value: value.clone(), }; return canon_value; } @@ -553,13 +545,7 @@ fn canonicalize( // Once we have canonicalized `out_value`, it should not // contain anything that ties it to this inference context // anymore, so it should live in the global arena. - let out_value = gcx.lift(&out_value).unwrap_or_else(|| { - bug!( - "failed to lift `{:?}`, canonicalized from `{:?}`", - out_value, - value - ) - }); + debug_assert!(!out_value.has_type_flags(TypeFlags::KEEP_IN_LOCAL_TCX)); let canonical_variables = tcx.intern_canonical_var_infos(&canonicalizer.variables); diff --git a/src/librustc/infer/canonical/mod.rs b/src/librustc/infer/canonical/mod.rs index 8b1c34a487f..b2c7bd73b68 100644 --- a/src/librustc/infer/canonical/mod.rs +++ b/src/librustc/infer/canonical/mod.rs @@ -194,10 +194,10 @@ pub struct QueryResponse<'tcx, R> { pub value: R, } -pub type Canonicalized<'tcx, V> = Canonical<'tcx, >::Lifted>; +pub type Canonicalized<'tcx, V> = Canonical<'tcx, V>; pub type CanonicalizedQueryResponse<'tcx, T> = - &'tcx Canonical<'tcx, QueryResponse<'tcx, >::Lifted>>; + &'tcx Canonical<'tcx, QueryResponse<'tcx, T>>; /// Indicates whether or not we were able to prove the query to be /// true. diff --git a/src/librustc/infer/canonical/query_response.rs b/src/librustc/infer/canonical/query_response.rs index 8b11ebf9b92..3e92fed005c 100644 --- a/src/librustc/infer/canonical/query_response.rs +++ b/src/librustc/infer/canonical/query_response.rs @@ -26,7 +26,7 @@ use crate::traits::{Obligation, ObligationCause, PredicateObligation}; use crate::ty::fold::TypeFoldable; use crate::ty::subst::{Kind, UnpackedKind}; -use crate::ty::{self, BoundVar, InferConst, Lift, Ty, TyCtxt}; +use crate::ty::{self, BoundVar, InferConst, Ty, TyCtxt}; use crate::util::captures::Captures; impl<'tcx> InferCtxtBuilder<'tcx> { @@ -53,8 +53,8 @@ pub fn enter_canonical_trait_query( ) -> Fallible> where K: TypeFoldable<'tcx>, - R: Debug + Lift<'tcx> + TypeFoldable<'tcx>, - Canonical<'tcx, as Lift<'tcx>>::Lifted>: ArenaAllocatable, + R: Debug + TypeFoldable<'tcx>, + Canonical<'tcx, QueryResponse<'tcx, R>>: ArenaAllocatable, { self.enter_with_canonical( DUMMY_SP, @@ -99,8 +99,8 @@ pub fn make_canonicalized_query_response( fulfill_cx: &mut dyn TraitEngine<'tcx>, ) -> Fallible> where - T: Debug + Lift<'tcx> + TypeFoldable<'tcx>, - Canonical<'tcx, as Lift<'tcx>>::Lifted>: ArenaAllocatable, + T: Debug + TypeFoldable<'tcx>, + Canonical<'tcx, QueryResponse<'tcx, T>>: ArenaAllocatable, { let query_response = self.make_query_response(inference_vars, answer, fulfill_cx)?; let canonical_result = self.canonicalize_response(&query_response); @@ -126,9 +126,9 @@ pub fn make_query_response_ignoring_pending_obligations( &self, inference_vars: CanonicalVarValues<'tcx>, answer: T, - ) -> Canonical<'tcx, QueryResponse<'tcx, >::Lifted>> + ) -> Canonical<'tcx, QueryResponse<'tcx, T>> where - T: Debug + Lift<'tcx> + TypeFoldable<'tcx>, + T: Debug + TypeFoldable<'tcx>, { self.canonicalize_response(&QueryResponse { var_values: inference_vars, @@ -147,7 +147,7 @@ fn make_query_response( fulfill_cx: &mut dyn TraitEngine<'tcx>, ) -> Result, NoSolution> where - T: Debug + TypeFoldable<'tcx> + Lift<'tcx>, + T: Debug + TypeFoldable<'tcx>, { let tcx = self.tcx; diff --git a/src/librustc/infer/opaque_types/mod.rs b/src/librustc/infer/opaque_types/mod.rs index 8e9af8b3938..7b7a9cba76e 100644 --- a/src/librustc/infer/opaque_types/mod.rs +++ b/src/librustc/infer/opaque_types/mod.rs @@ -469,11 +469,6 @@ pub fn infer_opaque_definition_from_instantiation( definition_ty ); - // We can unwrap here because our reverse mapper always - // produces things with 'tcx lifetime, though the type folder - // obscures that. - let definition_ty = gcx.lift(&definition_ty).unwrap(); - definition_ty } } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 3b21b81df7b..0304f76ec96 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -819,10 +819,7 @@ fn cat_upvar( .unwrap_or(ty::ClosureKind::LATTICE_BOTTOM), None => - self.tcx.global_tcx() - .lift(&closure_substs) - .expect("no inference cx, but inference variables in closure ty") - .closure_kind(closure_def_id, self.tcx.global_tcx()), + closure_substs.closure_kind(closure_def_id, self.tcx.global_tcx()), } } _ => span_bug!(span, "unexpected type for fn in mem_categorization: {:?}", ty), diff --git a/src/librustc/traits/codegen/mod.rs b/src/librustc/traits/codegen/mod.rs index bb4095333f1..97fb430a3e0 100644 --- a/src/librustc/traits/codegen/mod.rs +++ b/src/librustc/traits/codegen/mod.rs @@ -141,9 +141,9 @@ fn drain_fulfillment_cx_or_panic( &self, fulfill_cx: &mut FulfillmentContext<'tcx>, result: &T, - ) -> T::Lifted + ) -> T where - T: TypeFoldable<'tcx> + ty::Lift<'tcx>, + T: TypeFoldable<'tcx>, { debug!("drain_fulfillment_cx_or_panic()"); @@ -155,10 +155,6 @@ fn drain_fulfillment_cx_or_panic( } let result = self.resolve_vars_if_possible(result); - let result = self.tcx.erase_regions(&result); - - self.tcx.lift_to_global(&result).unwrap_or_else(|| - bug!("Uninferred types/regions/consts in `{:?}`", result) - ) + self.tcx.erase_regions(&result) } } diff --git a/src/librustc/traits/project.rs b/src/librustc/traits/project.rs index d189bb23116..d6d0d12b2ba 100644 --- a/src/librustc/traits/project.rs +++ b/src/librustc/traits/project.rs @@ -409,7 +409,6 @@ fn fold_const(&mut self, constant: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tc promoted: None }; if let Ok(evaluated) = tcx.const_eval(param_env.and(cid)) { - let substs = tcx.lift_to_global(&substs).unwrap(); let evaluated = evaluated.subst(tcx, substs); return evaluated; } diff --git a/src/librustc/traits/query/normalize.rs b/src/librustc/traits/query/normalize.rs index 50476721e82..1b82c412e98 100644 --- a/src/librustc/traits/query/normalize.rs +++ b/src/librustc/traits/query/normalize.rs @@ -203,7 +203,6 @@ fn fold_const(&mut self, constant: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tc promoted: None, }; if let Ok(evaluated) = tcx.const_eval(param_env.and(cid)) { - let substs = tcx.lift_to_global(&substs).unwrap(); let evaluated = evaluated.subst(tcx, substs); return evaluated; } diff --git a/src/librustc/traits/query/type_op/mod.rs b/src/librustc/traits/query/type_op/mod.rs index b298edfec59..4a07a3120f3 100644 --- a/src/librustc/traits/query/type_op/mod.rs +++ b/src/librustc/traits/query/type_op/mod.rs @@ -8,7 +8,7 @@ use crate::traits::query::Fallible; use crate::traits::ObligationCause; use crate::ty::fold::TypeFoldable; -use crate::ty::{Lift, ParamEnvAnd, TyCtxt}; +use crate::ty::{ParamEnvAnd, TyCtxt}; pub mod ascribe_user_type; pub mod custom; @@ -44,8 +44,8 @@ fn fully_perform( /// which produces the resulting query region constraints. /// /// [c]: https://rust-lang.github.io/rustc-guide/traits/canonicalization.html -pub trait QueryTypeOp<'tcx>: fmt::Debug + Sized + TypeFoldable<'tcx> + Lift<'tcx> { - type QueryResponse: TypeFoldable<'tcx> + Lift<'tcx>; +pub trait QueryTypeOp<'tcx>: fmt::Debug + Sized + TypeFoldable<'tcx> + 'tcx { + type QueryResponse: TypeFoldable<'tcx>; /// Give query the option for a simple fast path that never /// actually hits the tcx cache lookup etc. Return `Some(r)` with diff --git a/src/librustc/traits/query/type_op/normalize.rs b/src/librustc/traits/query/type_op/normalize.rs index 5a768d9d58f..3fe85d8d83e 100644 --- a/src/librustc/traits/query/type_op/normalize.rs +++ b/src/librustc/traits/query/type_op/normalize.rs @@ -20,7 +20,7 @@ pub fn new(value: T) -> Self { impl<'tcx, T> super::QueryTypeOp<'tcx> for Normalize where - T: Normalizable<'tcx>, + T: Normalizable<'tcx> + 'tcx, { type QueryResponse = T; diff --git a/src/librustc/traits/specialize/mod.rs b/src/librustc/traits/specialize/mod.rs index 3d47e94fb00..43bb4edd9b2 100644 --- a/src/librustc/traits/specialize/mod.rs +++ b/src/librustc/traits/specialize/mod.rs @@ -132,12 +132,7 @@ pub fn find_associated_item<'tcx>( let substs = substs.rebase_onto(tcx, trait_def_id, impl_data.substs); let substs = translate_substs(&infcx, param_env, impl_data.impl_def_id, substs, node_item.node); - let substs = infcx.tcx.erase_regions(&substs); - tcx.lift(&substs).unwrap_or_else(|| - bug!("find_method: translate_substs \ - returned {:?} which contains inference types/regions", - substs) - ) + infcx.tcx.erase_regions(&substs) }); (node_item.item.def_id, substs) } diff --git a/src/librustc/ty/error.rs b/src/librustc/ty/error.rs index d5e04500350..b8bdde4a787 100644 --- a/src/librustc/ty/error.rs +++ b/src/librustc/ty/error.rs @@ -192,9 +192,12 @@ pub fn sort_string(&self, tcx: TyCtxt<'_>) -> Cow<'static, str> { ty::Adt(def, _) => format!("{} `{}`", def.descr(), tcx.def_path_str(def.did)).into(), ty::Foreign(def_id) => format!("extern type `{}`", tcx.def_path_str(def_id)).into(), - ty::Array(_, n) => match n.assert_usize(tcx) { - Some(n) => format!("array of {} elements", n).into(), - None => "array".into(), + ty::Array(_, n) => { + let n = tcx.lift_to_global(&n).unwrap(); + match n.assert_usize(tcx) { + Some(n) => format!("array of {} elements", n).into(), + None => "array".into(), + } } ty::Slice(_) => "slice".into(), ty::RawPtr(_) => "*-ptr".into(), diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index 810a26d3736..8bfbd8b854b 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -2262,7 +2262,6 @@ pub fn from_scalar(tcx: TyCtxt<'tcx>, val: Scalar, ty: Ty<'tcx>) -> &'tcx Self { #[inline] pub fn from_bits(tcx: TyCtxt<'tcx>, bits: u128, ty: ParamEnvAnd<'tcx, Ty<'tcx>>) -> &'tcx Self { - let ty = tcx.lift_to_global(&ty).unwrap(); let size = tcx.layout_of(ty).unwrap_or_else(|e| { panic!("could not compute layout for {:?}: {:?}", ty, e) }).size; @@ -2289,7 +2288,6 @@ pub fn to_bits(&self, tcx: TyCtxt<'tcx>, ty: ParamEnvAnd<'tcx, Ty<'tcx>>) -> Opt if self.ty != ty.value { return None; } - let ty = tcx.lift_to_global(&ty).unwrap(); let size = tcx.layout_of(ty).ok()?.size; self.val.try_to_bits(size) } @@ -2300,15 +2298,14 @@ pub fn to_ptr(&self) -> Option { } #[inline] - pub fn assert_bits(&self, tcx: TyCtxt<'_>, ty: ParamEnvAnd<'tcx, Ty<'tcx>>) -> Option { + pub fn assert_bits(&self, tcx: TyCtxt<'tcx>, ty: ParamEnvAnd<'tcx, Ty<'tcx>>) -> Option { assert_eq!(self.ty, ty.value); - let ty = tcx.lift_to_global(&ty).unwrap(); let size = tcx.layout_of(ty).ok()?.size; self.val.try_to_bits(size) } #[inline] - pub fn assert_bool(&self, tcx: TyCtxt<'_>) -> Option { + pub fn assert_bool(&self, tcx: TyCtxt<'tcx>) -> Option { self.assert_bits(tcx, ParamEnv::empty().and(tcx.types.bool)).and_then(|v| match v { 0 => Some(false), 1 => Some(true), @@ -2317,18 +2314,18 @@ pub fn assert_bool(&self, tcx: TyCtxt<'_>) -> Option { } #[inline] - pub fn assert_usize(&self, tcx: TyCtxt<'_>) -> Option { + pub fn assert_usize(&self, tcx: TyCtxt<'tcx>) -> Option { self.assert_bits(tcx, ParamEnv::empty().and(tcx.types.usize)).map(|v| v as u64) } #[inline] - pub fn unwrap_bits(&self, tcx: TyCtxt<'_>, ty: ParamEnvAnd<'tcx, Ty<'tcx>>) -> u128 { + pub fn unwrap_bits(&self, tcx: TyCtxt<'tcx>, ty: ParamEnvAnd<'tcx, Ty<'tcx>>) -> u128 { self.assert_bits(tcx, ty).unwrap_or_else(|| bug!("expected bits of {}, got {:#?}", ty.value, self)) } #[inline] - pub fn unwrap_usize(&self, tcx: TyCtxt<'_>) -> u64 { + pub fn unwrap_usize(&self, tcx: TyCtxt<'tcx>) -> u64 { self.assert_usize(tcx).unwrap_or_else(|| bug!("expected constant usize, got {:#?}", self)) } diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs index 161a08c5773..b05e291710a 100644 --- a/src/librustc_mir/borrow_check/mod.rs +++ b/src/librustc_mir/borrow_check/mod.rs @@ -670,7 +670,7 @@ fn visit_terminator_entry( // "Lift" into the gcx -- once regions are erased, this type should be in the // global arenas; this "lift" operation basically just asserts that is true, but // that is useful later. - let drop_place_ty = gcx.lift(&drop_place_ty).unwrap(); + gcx.lift_to_global(&drop_place_ty).unwrap(); debug!("visit_terminator_drop \ loc: {:?} term: {:?} drop_place: {:?} drop_place_ty: {:?} span: {:?}", diff --git a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs index 2b38fcee479..41ed564d0f0 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs @@ -863,8 +863,8 @@ fn try_promote_type_test_subject( }); debug!("try_promote_type_test_subject: folded ty = {:?}", ty); - // `lift` will only fail if we failed to promote some region. - let ty = gcx.lift(&ty)?; + // `lift_to_global` will only fail if we failed to promote some region. + gcx.lift_to_global(&ty)?; Some(ClosureOutlivesSubject::Ty(ty)) } diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs index 77e0b54781c..9d33b371d9b 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/mod.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/mod.rs @@ -1866,7 +1866,7 @@ fn ensure_place_sized(&mut self, ty: Ty<'tcx>, span: Span) { // `Sized` bound in no way depends on precise regions, so this // shouldn't affect `is_sized`. let gcx = tcx.global_tcx(); - let erased_ty = gcx.lift(&tcx.erase_regions(&ty)).unwrap(); + let erased_ty = tcx.erase_regions(&ty); if !erased_ty.is_sized(gcx.at(span), self.param_env) { // in current MIR construction, all non-control-flow rvalue // expressions evaluate through `as_temp` or `into` a return @@ -2652,7 +2652,7 @@ fn typeck_mir(&mut self, body: &Body<'tcx>) { fn normalize(&mut self, value: T, location: impl NormalizeLocation) -> T where - T: type_op::normalize::Normalizable<'tcx> + Copy, + T: type_op::normalize::Normalizable<'tcx> + Copy + 'tcx, { debug!("normalize(value={:?}, location={:?})", value, location); let param_env = self.param_env; diff --git a/src/librustc_mir/build/expr/as_rvalue.rs b/src/librustc_mir/build/expr/as_rvalue.rs index 6d6e5de4761..243c13c2982 100644 --- a/src/librustc_mir/build/expr/as_rvalue.rs +++ b/src/librustc_mir/build/expr/as_rvalue.rs @@ -569,7 +569,7 @@ fn limit_capture_mutability( // Helper to get a `-1` value of the appropriate type fn neg_1_literal(&mut self, span: Span, ty: Ty<'tcx>) -> Operand<'tcx> { - let param_ty = ty::ParamEnv::empty().and(self.hir.tcx().lift_to_global(&ty).unwrap()); + let param_ty = ty::ParamEnv::empty().and(ty); let bits = self.hir.tcx().layout_of(param_ty).unwrap().size.bits(); let n = (!0u128) >> (128 - bits); let literal = ty::Const::from_bits(self.hir.tcx(), n, param_ty); @@ -580,7 +580,7 @@ fn neg_1_literal(&mut self, span: Span, ty: Ty<'tcx>) -> Operand<'tcx> { // Helper to get the minimum value of the appropriate type fn minval_literal(&mut self, span: Span, ty: Ty<'tcx>) -> Operand<'tcx> { assert!(ty.is_signed()); - let param_ty = ty::ParamEnv::empty().and(self.hir.tcx().lift_to_global(&ty).unwrap()); + let param_ty = ty::ParamEnv::empty().and(ty); let bits = self.hir.tcx().layout_of(param_ty).unwrap().size.bits(); let n = 1 << (bits - 1); let literal = ty::Const::from_bits(self.hir.tcx(), n, param_ty); diff --git a/src/librustc_mir/dataflow/drop_flag_effects.rs b/src/librustc_mir/dataflow/drop_flag_effects.rs index e8a32477f1c..37f2a915782 100644 --- a/src/librustc_mir/dataflow/drop_flag_effects.rs +++ b/src/librustc_mir/dataflow/drop_flag_effects.rs @@ -151,7 +151,7 @@ pub(crate) fn on_all_drop_children_bits<'tcx, F>( debug!("on_all_drop_children_bits({:?}, {:?} : {:?})", path, place, ty); let gcx = tcx.global_tcx(); - let erased_ty = gcx.lift(&tcx.erase_regions(&ty)).unwrap(); + let erased_ty = tcx.erase_regions(&ty); if erased_ty.needs_drop(gcx, ctxt.param_env) { each_child(child); } else { diff --git a/src/librustc_mir/hair/constant.rs b/src/librustc_mir/hair/constant.rs index 2cd04631118..bc01e3ee95b 100644 --- a/src/librustc_mir/hair/constant.rs +++ b/src/librustc_mir/hair/constant.rs @@ -18,7 +18,7 @@ use syntax::ast::*; let trunc = |n| { - let param_ty = ParamEnv::reveal_all().and(tcx.lift_to_global(&ty).unwrap()); + let param_ty = ParamEnv::reveal_all().and(ty); let width = tcx.layout_of(param_ty).map_err(|_| LitToConstError::Reported)?.size; trace!("trunc {} with size {} and shift {}", n, width.bits(), 128 - width.bits()); let result = truncate(n, width); diff --git a/src/librustc_mir/hair/cx/mod.rs b/src/librustc_mir/hair/cx/mod.rs index 7740042c783..1eb5ab0776a 100644 --- a/src/librustc_mir/hair/cx/mod.rs +++ b/src/librustc_mir/hair/cx/mod.rs @@ -191,12 +191,7 @@ pub fn all_fields(&mut self, adt_def: &ty::AdtDef, variant_index: VariantIdx) -> } pub fn needs_drop(&mut self, ty: Ty<'tcx>) -> bool { - let (ty, param_env) = self.tcx.lift_to_global(&(ty, self.param_env)).unwrap_or_else(|| { - bug!("MIR: Cx::needs_drop({:?}, {:?}) got \ - type with inference types/regions", - ty, self.param_env); - }); - ty.needs_drop(self.tcx.global_tcx(), param_env) + ty.needs_drop(self.tcx.global_tcx(), self.param_env) } pub fn tcx(&self) -> TyCtxt<'tcx> { diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs index 1d7c450f695..9349e08b7d0 100644 --- a/src/librustc_mir/hair/pattern/_match.rs +++ b/src/librustc_mir/hair/pattern/_match.rs @@ -1311,7 +1311,7 @@ fn is_useful_specialized<'p, 'a: 'p, 'tcx: 'a>( /// Returns `None` in case of a catch-all, which can't be specialized. fn pat_constructors<'tcx>(cx: &mut MatchCheckCtxt<'_, 'tcx>, pat: &Pattern<'tcx>, - pcx: PatternContext<'_>) + pcx: PatternContext<'tcx>) -> Option>> { match *pat.kind { diff --git a/src/librustc_traits/normalize_erasing_regions.rs b/src/librustc_traits/normalize_erasing_regions.rs index bfa1a80bb32..d138ce753b0 100644 --- a/src/librustc_traits/normalize_erasing_regions.rs +++ b/src/librustc_traits/normalize_erasing_regions.rs @@ -37,8 +37,7 @@ fn normalize_ty_after_erasing_regions<'tcx>( ); let normalized_value = infcx.resolve_vars_if_possible(&normalized_value); - let normalized_value = infcx.tcx.erase_regions(&normalized_value); - tcx.lift_to_global(&normalized_value).unwrap() + infcx.tcx.erase_regions(&normalized_value) } Err(NoSolution) => bug!("could not fully normalize `{:?}`", value), } -- 2.44.0