Auto merge of rust-lang#70860 - lcnr:has_local_value, r=nikomatsakis

remove `KEEP_IN_LOCAL_TCX` flag

closes rust-lang#70285

I did not rename `needs_infer` here as this complex enough as is.
Will probably open a followup for that.

r? @eddyb

Author: bors

src/librustc_infer/infer/canonical/canonicalizer.rs

@@ -488,12 +488,12 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         V: TypeFoldable<'tcx>,
     {
         let needs_canonical_flags = if canonicalize_region_mode.any() {
-            TypeFlags::KEEP_IN_LOCAL_TCX |
+            TypeFlags::NEEDS_INFER |
             TypeFlags::HAS_FREE_REGIONS | // `HAS_RE_PLACEHOLDER` implies `HAS_FREE_REGIONS`
             TypeFlags::HAS_TY_PLACEHOLDER |
             TypeFlags::HAS_CT_PLACEHOLDER
         } else {
-            TypeFlags::KEEP_IN_LOCAL_TCX
+            TypeFlags::NEEDS_INFER
                 | TypeFlags::HAS_RE_PLACEHOLDER
                 | TypeFlags::HAS_TY_PLACEHOLDER
                 | TypeFlags::HAS_CT_PLACEHOLDER
@@ -524,7 +524,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         // 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.
-        debug_assert!(!out_value.has_type_flags(TypeFlags::KEEP_IN_LOCAL_TCX));
+        debug_assert!(!out_value.needs_infer());
 
         let canonical_variables = tcx.intern_canonical_var_infos(&canonicalizer.variables);
 

src/librustc_infer/infer/resolve.rs

@@ -181,10 +181,8 @@ impl<'a, 'tcx> TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {
     }
 
     fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
-        if !t.needs_infer() && !ty::keep_local(&t) {
+        if !t.needs_infer() {
             t // micro-optimize -- if there is nothing in this type that this fold affects...
-        // ^ we need to have the `keep_local` check to un-default
-        // defaulted tuples.
         } else {
             let t = self.infcx.shallow_resolve(t);
             match t.kind {
@@ -222,10 +220,8 @@ impl<'a, 'tcx> TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {
     }
 
     fn fold_const(&mut self, c: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> {
-        if !c.needs_infer() && !ty::keep_local(&c) {
+        if !c.needs_infer() {
             c // micro-optimize -- if there is nothing in this const that this fold affects...
-        // ^ we need to have the `keep_local` check to un-default
-        // defaulted tuples.
         } else {
             let c = self.infcx.shallow_resolve(c);
             match c.val {

src/librustc_middle/ty/context.rs

@@ -2065,10 +2065,6 @@ macro_rules! direct_interners {
     }
 }
 
-pub fn keep_local<'tcx, T: ty::TypeFoldable<'tcx>>(x: &T) -> bool {
-    x.has_type_flags(ty::TypeFlags::KEEP_IN_LOCAL_TCX)
-}
-
 direct_interners!(
     region: mk_region(RegionKind),
     goal: mk_goal(GoalKind<'tcx>),

src/librustc_middle/ty/erase_regions.rs

@@ -40,7 +40,7 @@ impl TypeFolder<'tcx> for RegionEraserVisitor<'tcx> {
     }
 
     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        if ty.has_local_value() { ty.super_fold_with(self) } else { self.tcx.erase_regions_ty(ty) }
+        if ty.needs_infer() { ty.super_fold_with(self) } else { self.tcx.erase_regions_ty(ty) }
     }
 
     fn fold_binder<T>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T>

src/librustc_middle/ty/flags.rs

@@ -109,13 +109,12 @@ impl FlagComputation {
             }
 
             &ty::Infer(infer) => {
-                self.add_flags(TypeFlags::HAS_TY_INFER);
                 self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
                 match infer {
                     ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {}
 
                     ty::TyVar(_) | ty::IntVar(_) | ty::FloatVar(_) => {
-                        self.add_flags(TypeFlags::KEEP_IN_LOCAL_TCX)
+                        self.add_flags(TypeFlags::HAS_TY_INFER)
                     }
                 }
             }
@@ -221,11 +220,10 @@ impl FlagComputation {
                 self.add_flags(TypeFlags::HAS_CT_PROJECTION);
             }
             ty::ConstKind::Infer(infer) => {
-                self.add_flags(TypeFlags::HAS_CT_INFER);
                 self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
                 match infer {
                     InferConst::Fresh(_) => {}
-                    InferConst::Var(_) => self.add_flags(TypeFlags::KEEP_IN_LOCAL_TCX),
+                    InferConst::Var(_) => self.add_flags(TypeFlags::HAS_CT_INFER),
                 }
             }
             ty::ConstKind::Bound(debruijn, _) => {

src/librustc_middle/ty/fold.rs

@@ -96,9 +96,6 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {
     fn has_infer_consts(&self) -> bool {
         self.has_type_flags(TypeFlags::HAS_CT_INFER)
     }
-    fn has_local_value(&self) -> bool {
-        self.has_type_flags(TypeFlags::KEEP_IN_LOCAL_TCX)
-    }
     fn needs_infer(&self) -> bool {
         self.has_type_flags(TypeFlags::NEEDS_INFER)
     }

src/librustc_middle/ty/mod.rs

@@ -71,7 +71,7 @@ pub use crate::ty::diagnostics::*;
 pub use self::binding::BindingMode;
 pub use self::binding::BindingMode::*;
 
-pub use self::context::{keep_local, tls, FreeRegionInfo, TyCtxt};
+pub use self::context::{tls, FreeRegionInfo, TyCtxt};
 pub use self::context::{
     CanonicalUserType, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, ResolvedOpaqueTy,
     UserType, UserTypeAnnotationIndex,
@@ -577,27 +577,23 @@ bitflags! {
                                           | TypeFlags::HAS_TY_OPAQUE.bits
                                           | TypeFlags::HAS_CT_PROJECTION.bits;
 
-        /// Present if the type belongs in a local type context.
-        /// Set for placeholders and inference variables that are not "Fresh".
-        const KEEP_IN_LOCAL_TCX           = 1 << 13;
-
         /// Is an error type reachable?
-        const HAS_TY_ERR                  = 1 << 14;
+        const HAS_TY_ERR                  = 1 << 13;
 
         /// Does this have any region that "appears free" in the type?
         /// Basically anything but [ReLateBound] and [ReErased].
-        const HAS_FREE_REGIONS            = 1 << 15;
+        const HAS_FREE_REGIONS            = 1 << 14;
 
         /// Does this have any [ReLateBound] regions? Used to check
         /// if a global bound is safe to evaluate.
-        const HAS_RE_LATE_BOUND           = 1 << 16;
+        const HAS_RE_LATE_BOUND           = 1 << 15;
 
         /// Does this have any [ReErased] regions?
-        const HAS_RE_ERASED               = 1 << 17;
+        const HAS_RE_ERASED               = 1 << 16;
 
         /// Does this value have parameters/placeholders/inference variables which could be
         /// replaced later, in a way that would change the results of `impl` specialization?
-        const STILL_FURTHER_SPECIALIZABLE = 1 << 18;
+        const STILL_FURTHER_SPECIALIZABLE = 1 << 17;
     }
 }
 

src/librustc_middle/ty/relate.rs

@@ -510,7 +510,7 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
     let tcx = relation.tcx();
 
     let eagerly_eval = |x: &'tcx ty::Const<'tcx>| {
-        if !x.val.has_local_value() {
+        if !x.val.needs_infer() {
             return x.eval(tcx, relation.param_env()).val;
         }
         x.val

src/librustc_middle/ty/sty.rs

@@ -1605,7 +1605,6 @@ impl RegionKind {
                 flags = flags | TypeFlags::HAS_FREE_REGIONS;
                 flags = flags | TypeFlags::HAS_FREE_LOCAL_REGIONS;
                 flags = flags | TypeFlags::HAS_RE_INFER;
-                flags = flags | TypeFlags::KEEP_IN_LOCAL_TCX;
                 flags = flags | TypeFlags::STILL_FURTHER_SPECIALIZABLE;
             }
             ty::RePlaceholder(..) => {
@@ -2361,8 +2360,8 @@ impl<'tcx> Const<'tcx> {
         let try_const_eval = |did, param_env: ParamEnv<'tcx>, substs, promoted| {
             let param_env_and_substs = param_env.with_reveal_all().and(substs);
 
-            // Avoid querying `tcx.const_eval(...)` with any e.g. inference vars.
-            if param_env_and_substs.has_local_value() {
+            // Avoid querying `tcx.const_eval(...)` with any inference vars.
+            if param_env_and_substs.needs_infer() {
                 return None;
             }
 
@@ -2377,12 +2376,12 @@ impl<'tcx> Const<'tcx> {
 
         match self.val {
             ConstKind::Unevaluated(did, substs, promoted) => {
-                // HACK(eddyb) when substs contain e.g. inference variables,
+                // HACK(eddyb) when substs contain inference variables,
                 // attempt using identity substs instead, that will succeed
                 // when the expression doesn't depend on any parameters.
                 // FIXME(eddyb, skinny121) pass `InferCtxt` into here when it's available, so that
                 // we can call `infcx.const_eval_resolve` which handles inference variables.
-                if substs.has_local_value() {
+                if substs.needs_infer() {
                     let identity_substs = InternalSubsts::identity_for_item(tcx, did);
                     // The `ParamEnv` needs to match the `identity_substs`.
                     let identity_param_env = tcx.param_env(did);

src/librustc_mir/borrow_check/region_infer/mod.rs

@@ -995,15 +995,15 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 self.definitions[upper_bound].external_name.unwrap_or(r)
             } else {
                 // In the case of a failure, use a `ReVar` result. This will
-                // cause the `has_local_value` later on to return `None`.
+                // cause the `needs_infer` later on to return `None`.
                 r
             }
         });
 
         debug!("try_promote_type_test_subject: folded ty = {:?}", ty);
 
-        // `has_local_value` will only be true if we failed to promote some region.
-        if ty.has_local_value() {
+        // `needs_infer` will only be true if we failed to promote some region.
+        if ty.needs_infer() {
             return None;
         }