Rollup merge of rust-lang#64781 - Mark-Simulacrum:no-global-tcx, r=eddyb

Remove stray references to the old global tcx

src/librustc/dep_graph/graph.rs

@@ -590,7 +590,7 @@ impl DepGraph {
  // mark it as green by recursively marking all of its
  // dependencies green.
  self.try_mark_previous_green(
- tcx.global_tcx(),
+ tcx,
  data,
  prev_index,
  &dep_node

src/librustc/infer/mod.rs

@@ -1462,7 +1462,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  // type-checking closure types are in local tables only.
  if !self.in_progress_tables.is_some() || !ty.has_closure_types() {
  if !(param_env, ty).has_local_value() {
- return ty.is_copy_modulo_regions(self.tcx.global_tcx(), param_env, span);
+ return ty.is_copy_modulo_regions(self.tcx, param_env, span);
  }
  }
 

src/librustc/infer/opaque_types/mod.rs

@@ -561,15 +561,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  def_id, instantiated_ty
  );
 
- let gcx = self.tcx.global_tcx();
-
  // Use substs to build up a reverse map from regions to their
  // identity mappings. This is necessary because of `impl
  // Trait` lifetimes are computed by replacing existing
  // lifetimes with 'static and remapping only those used in the
  // `impl Trait` return type, resulting in the parameters
  // shifting.
- let id_substs = InternalSubsts::identity_for_item(gcx, def_id);
+ let id_substs = InternalSubsts::identity_for_item(self.tcx, def_id);
  let map: FxHashMap<GenericArg<'tcx>, GenericArg<'tcx>> = opaque_defn
  .substs
  .iter()
@@ -854,7 +852,7 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> {
  )
  .emit();
 
- self.tcx().global_tcx().mk_region(ty::ReStatic)
+ self.tcx().mk_region(ty::ReStatic)
  },
  }
  }

src/librustc/middle/intrinsicck.rs

@@ -82,7 +82,7 @@ impl ExprVisitor<'tcx> {
 
  // Special-case transmutting from `typeof(function)` and
  // `Option<typeof(function)>` to present a clearer error.
- let from = unpack_option_like(self.tcx.global_tcx(), from);
+ let from = unpack_option_like(self.tcx, from);
  if let (&ty::FnDef(..), SizeSkeleton::Known(size_to)) = (&from.kind, sk_to) {
  if size_to == Pointer.size(&self.tcx) {
  struct_span_err!(self.tcx.sess, span, E0591,

src/librustc/middle/mem_categorization.rs

@@ -749,7 +749,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
  .unwrap_or(ty::ClosureKind::LATTICE_BOTTOM),
 
  None =>
- closure_substs.closure_kind(closure_def_id, self.tcx.global_tcx()),
+ closure_substs.closure_kind(closure_def_id, self.tcx),
  }
  }
  _ => span_bug!(span, "unexpected type for fn in mem_categorization: {:?}", ty),

src/librustc/mir/mod.rs

@@ -1504,7 +1504,7 @@ impl<'tcx> TerminatorKind<'tcx> {
  Goto { .. } => vec!["".into()],
  SwitchInt { ref values, switch_ty, .. } => ty::tls::with(|tcx| {
  let param_env = ty::ParamEnv::empty();
- let switch_ty = tcx.lift_to_global(&switch_ty).unwrap();
+ let switch_ty = tcx.lift(&switch_ty).unwrap();
  let size = tcx.layout_of(param_env.and(switch_ty)).unwrap().size;
  values
  .iter()

src/librustc/traits/chalk_fulfill.rs

@@ -108,7 +108,7 @@ impl TraitEngine<'tcx> for FulfillmentContext<'tcx> {
  goal: obligation.goal.predicate,
  }, &mut orig_values);
 
- match infcx.tcx.global_tcx().evaluate_goal(canonical_goal) {
+ match infcx.tcx.evaluate_goal(canonical_goal) {
  Ok(response) => {
  if response.is_proven() {
  making_progress = true;

src/librustc/traits/error_reporting.rs

@@ -497,7 +497,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  4
  };
 
- let normalize = |candidate| self.tcx.global_tcx().infer_ctxt().enter(|ref infcx| {
+ let normalize = |candidate| self.tcx.infer_ctxt().enter(|ref infcx| {
  let normalized = infcx
  .at(&ObligationCause::dummy(), ty::ParamEnv::empty())
  .normalize(candidate)
@@ -783,8 +783,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  }
 
  ty::Predicate::ObjectSafe(trait_def_id) => {
- let violations = self.tcx.global_tcx()
- .object_safety_violations(trait_def_id);
+ let violations = self.tcx.object_safety_violations(trait_def_id);
  if let Some(err) = self.tcx.report_object_safety_error(
  span,
  trait_def_id,
@@ -920,7 +919,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  }
 
  TraitNotObjectSafe(did) => {
- let violations = self.tcx.global_tcx().object_safety_violations(did);
+ let violations = self.tcx.object_safety_violations(did);
  if let Some(err) = self.tcx.report_object_safety_error(span, did, violations) {
  err
  } else {

src/librustc/traits/fulfill.rs

@@ -495,7 +495,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
  } else {
  if !substs.has_local_value() {
  let instance = ty::Instance::resolve(
- self.selcx.tcx().global_tcx(),
+ self.selcx.tcx(),
  obligation.param_env,
  def_id,
  substs,

src/librustc/traits/query/dropck_outlives.rs

@@ -40,12 +40,11 @@ impl<'cx, 'tcx> At<'cx, 'tcx> {
  };
  }
 
- let gcx = tcx.global_tcx();
  let mut orig_values = OriginalQueryValues::default();
  let c_ty = self.infcx.canonicalize_query(&self.param_env.and(ty), &mut orig_values);
  let span = self.cause.span;
  debug!("c_ty = {:?}", c_ty);
- if let Ok(result) = &gcx.dropck_outlives(c_ty) {
+ if let Ok(result) = &tcx.dropck_outlives(c_ty) {
  if result.is_proven() {
  if let Ok(InferOk { value, obligations }) =
  self.infcx.instantiate_query_response_and_region_obligations(

src/librustc/traits/query/evaluate_obligation.rs

@@ -50,7 +50,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
  // Run canonical query. If overflow occurs, rerun from scratch but this time
  // in standard trait query mode so that overflow is handled appropriately
  // within `SelectionContext`.
- self.tcx.global_tcx().evaluate_obligation(c_pred)
+ self.tcx.evaluate_obligation(c_pred)
  }
 
  // Helper function that canonicalizes and runs the query. If an

src/librustc/traits/query/normalize.rs

@@ -141,7 +141,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
  // binder). It would be better to normalize in a
  // binding-aware fashion.
 
- let gcx = self.infcx.tcx.global_tcx();
+ let tcx = self.infcx.tcx;
 
  let mut orig_values = OriginalQueryValues::default();
  // HACK(matthewjasper) `'static` is special-cased in selection,
@@ -150,7 +150,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
  &self.param_env.and(*data), &mut orig_values);
  debug!("QueryNormalizer: c_data = {:#?}", c_data);
  debug!("QueryNormalizer: orig_values = {:#?}", orig_values);
- match gcx.normalize_projection_ty(c_data) {
+ match tcx.normalize_projection_ty(c_data) {
  Ok(result) => {
  // We don't expect ambiguity.
  if result.is_ambiguous() {

src/librustc/traits/query/outlives_bounds.rs

@@ -97,7 +97,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
 
  let mut orig_values = OriginalQueryValues::default();
  let key = self.canonicalize_query(&param_env.and(ty), &mut orig_values);
- let result = match self.tcx.global_tcx().implied_outlives_bounds(key) {
+ let result = match self.tcx.implied_outlives_bounds(key) {
  Ok(r) => r,
  Err(NoSolution) => {
  self.tcx.sess.delay_span_bug(

src/librustc/traits/query/type_op/ascribe_user_type.rs

@@ -1,4 +1,4 @@
-use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse};
+use crate::infer::canonical::{Canonicalized, CanonicalizedQueryResponse};
 use crate::traits::query::Fallible;
 use crate::hir::def_id::DefId;
 use crate::ty::{ParamEnvAnd, Ty, TyCtxt};
@@ -37,12 +37,6 @@ impl<'tcx> super::QueryTypeOp<'tcx> for AscribeUserType<'tcx> {
  ) -> Fallible<CanonicalizedQueryResponse<'tcx, ()>> {
  tcx.type_op_ascribe_user_type(canonicalized)
  }
-
- fn shrink_to_tcx_lifetime(
- v: &'a CanonicalizedQueryResponse<'tcx, ()>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, ()>> {
- v
- }
 }
 
 BraceStructTypeFoldableImpl! {

src/librustc/traits/query/type_op/eq.rs

@@ -1,4 +1,4 @@
-use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse};
+use crate::infer::canonical::{Canonicalized, CanonicalizedQueryResponse};
 use crate::traits::query::Fallible;
 use crate::ty::{ParamEnvAnd, Ty, TyCtxt};
 
@@ -34,12 +34,6 @@ impl<'tcx> super::QueryTypeOp<'tcx> for Eq<'tcx> {
  ) -> Fallible<CanonicalizedQueryResponse<'tcx, ()>> {
  tcx.type_op_eq(canonicalized)
  }
-
- fn shrink_to_tcx_lifetime(
- v: &'a CanonicalizedQueryResponse<'tcx, ()>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, ()>> {
- v
- }
 }
 
 BraceStructTypeFoldableImpl! {

src/librustc/traits/query/type_op/implied_outlives_bounds.rs

@@ -1,4 +1,4 @@
-use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse};
+use crate::infer::canonical::{Canonicalized, CanonicalizedQueryResponse};
 use crate::traits::query::outlives_bounds::OutlivesBound;
 use crate::traits::query::Fallible;
 use crate::ty::{ParamEnvAnd, Ty, TyCtxt};
@@ -38,12 +38,6 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ImpliedOutlivesBounds<'tcx> {
 
  tcx.implied_outlives_bounds(canonicalized)
  }
-
- fn shrink_to_tcx_lifetime(
- v: &'a CanonicalizedQueryResponse<'tcx, Self::QueryResponse>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self::QueryResponse>> {
- v
- }
 }
 
 BraceStructTypeFoldableImpl! {

src/librustc/traits/query/type_op/mod.rs

@@ -1,6 +1,6 @@
 use crate::infer::canonical::{
- Canonical, Canonicalized, CanonicalizedQueryResponse, OriginalQueryValues,
- QueryRegionConstraints, QueryResponse,
+ Canonicalized, CanonicalizedQueryResponse, OriginalQueryValues,
+ QueryRegionConstraints,
 };
 use crate::infer::{InferCtxt, InferOk};
 use std::fmt;
@@ -66,22 +66,6 @@ pub trait QueryTypeOp<'tcx>: fmt::Debug + Sized + TypeFoldable<'tcx> + 'tcx {
  canonicalized: Canonicalized<'tcx, ParamEnvAnd<'tcx, Self>>,
  ) -> Fallible<CanonicalizedQueryResponse<'tcx, Self::QueryResponse>>;
 
- /// 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<'tcx, 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<'tcx>`, is a subtype of `Ty<'tcx>`). So we have to push
- /// the operation into the impls that know more specifically what
- /// `QueryResponse` is. This operation would (maybe) be nicer with
- /// something like HKTs or GATs, since then we could make
- /// `QueryResponse` parametric and `'tcx` and `'tcx` etc.
- fn shrink_to_tcx_lifetime(
- lifted_query_result: &'a CanonicalizedQueryResponse<'tcx, Self::QueryResponse>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self::QueryResponse>>;
-
  fn fully_perform_into(
  query_key: ParamEnvAnd<'tcx, Self>,
  infcx: &InferCtxt<'_, 'tcx>,
@@ -99,7 +83,6 @@ pub trait QueryTypeOp<'tcx>: fmt::Debug + Sized + TypeFoldable<'tcx> + 'tcx {
  let canonical_self =
  infcx.canonicalize_hr_query_hack(&query_key, &mut canonical_var_values);
  let canonical_result = Self::perform_query(infcx.tcx, canonical_self)?;
- let canonical_result = Self::shrink_to_tcx_lifetime(&canonical_result);
 
  let param_env = query_key.param_env;
 

src/librustc/traits/query/type_op/normalize.rs

@@ -1,4 +1,4 @@
-use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse};
+use crate::infer::canonical::{Canonicalized, CanonicalizedQueryResponse};
 use std::fmt;
 use crate::traits::query::Fallible;
 use crate::ty::fold::TypeFoldable;
@@ -38,25 +38,13 @@ where
  ) -> Fallible<CanonicalizedQueryResponse<'tcx, Self::QueryResponse>> {
  T::type_op_method(tcx, canonicalized)
  }
-
- fn shrink_to_tcx_lifetime(
- v: &'a CanonicalizedQueryResponse<'tcx, T>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, T>> {
- T::shrink_to_tcx_lifetime(v)
- }
 }
 
 pub trait Normalizable<'tcx>: fmt::Debug + TypeFoldable<'tcx> + Lift<'tcx> + Copy {
  fn type_op_method(
  tcx: TyCtxt<'tcx>,
  canonicalized: Canonicalized<'tcx, ParamEnvAnd<'tcx, Normalize<Self>>>,
  ) -> Fallible<CanonicalizedQueryResponse<'tcx, Self>>;
-
- /// Converts from the `'tcx` (lifted) form of `Self` into the `tcx`
- /// form of `Self`.
- fn shrink_to_tcx_lifetime(
- v: &'a CanonicalizedQueryResponse<'tcx, Self>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self>>;
 }
 
 impl Normalizable<'tcx> for Ty<'tcx> {
@@ -66,12 +54,6 @@ impl Normalizable<'tcx> for Ty<'tcx> {
  ) -> Fallible<CanonicalizedQueryResponse<'tcx, Self>> {
  tcx.type_op_normalize_ty(canonicalized)
  }
-
- fn shrink_to_tcx_lifetime(
- v: &'a CanonicalizedQueryResponse<'tcx, Self>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self>> {
- v
- }
 }
 
 impl Normalizable<'tcx> for ty::Predicate<'tcx> {
@@ -81,12 +63,6 @@ impl Normalizable<'tcx> for ty::Predicate<'tcx> {
  ) -> Fallible<CanonicalizedQueryResponse<'tcx, Self>> {
  tcx.type_op_normalize_predicate(canonicalized)
  }
-
- fn shrink_to_tcx_lifetime(
- v: &'a CanonicalizedQueryResponse<'tcx, Self>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self>> {
- v
- }
 }
 
 impl Normalizable<'tcx> for ty::PolyFnSig<'tcx> {
@@ -96,12 +72,6 @@ impl Normalizable<'tcx> for ty::PolyFnSig<'tcx> {
  ) -> Fallible<CanonicalizedQueryResponse<'tcx, Self>> {
  tcx.type_op_normalize_poly_fn_sig(canonicalized)
  }
-
- fn shrink_to_tcx_lifetime(
- v: &'a CanonicalizedQueryResponse<'tcx, Self>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self>> {
- v
- }
 }
 
 impl Normalizable<'tcx> for ty::FnSig<'tcx> {
@@ -111,12 +81,6 @@ impl Normalizable<'tcx> for ty::FnSig<'tcx> {
  ) -> Fallible<CanonicalizedQueryResponse<'tcx, Self>> {
  tcx.type_op_normalize_fn_sig(canonicalized)
  }
-
- fn shrink_to_tcx_lifetime(
- v: &'a CanonicalizedQueryResponse<'tcx, Self>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self>> {
- v
- }
 }
 
 BraceStructTypeFoldableImpl! {

src/librustc/traits/query/type_op/outlives.rs

@@ -1,4 +1,4 @@
-use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse};
+use crate::infer::canonical::{Canonicalized, CanonicalizedQueryResponse};
 use crate::traits::query::dropck_outlives::trivial_dropck_outlives;
 use crate::traits::query::dropck_outlives::DropckOutlivesResult;
 use crate::traits::query::Fallible;
@@ -53,12 +53,6 @@ impl super::QueryTypeOp<'tcx> for DropckOutlives<'tcx> {
 
  tcx.dropck_outlives(canonicalized)
  }
-
- fn shrink_to_tcx_lifetime(
- lifted_query_result: &'a CanonicalizedQueryResponse<'tcx, Self::QueryResponse>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, Self::QueryResponse>> {
- lifted_query_result
- }
 }
 
 BraceStructTypeFoldableImpl! {

src/librustc/traits/query/type_op/prove_predicate.rs

@@ -1,4 +1,4 @@
-use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse};
+use crate::infer::canonical::{Canonicalized, CanonicalizedQueryResponse};
 use crate::traits::query::Fallible;
 use crate::ty::{ParamEnvAnd, Predicate, TyCtxt};
 
@@ -43,12 +43,6 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ProvePredicate<'tcx> {
  ) -> Fallible<CanonicalizedQueryResponse<'tcx, ()>> {
  tcx.type_op_prove_predicate(canonicalized)
  }
-
- fn shrink_to_tcx_lifetime(
- v: &'a CanonicalizedQueryResponse<'tcx, ()>,
- ) -> &'a Canonical<'tcx, QueryResponse<'tcx, ()>> {
- v
- }
 }
 
 BraceStructTypeFoldableImpl! {