update type flags

lcnr · lcnr · commit 8935a1be016c · 2023-11-13T14:13:54.000Z
- `HAS_RE_LATE_BOUND` -&gt; `HAS_RE_BOUND`
- `HAS_TY_LATE_BOUND` -&gt; `HAS_TY_BOUND`
- `HAS_CT_LATE_BOUND` -&gt; `HAS_CT_BOUND`
- `HAS_LATE_BOUND` -&gt; `HAS_BOUND_VARS`
- `fn has_late_bound_regions` -&gt; `fn has_bound_regions`
- `fnhas_non_region_late_bound` -&gt; `fn has_non_region_bound_vars`
- `fn has_late_bound_vars` -&gt; `fn has_bound_vars`
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -801,7 +801,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         // a `&self` method will wind up with an argument type like `&dyn Trait`.
         let trait_ref = principal.with_self_ty(self.tcx, self_ty);
         self.elaborate_bounds(iter::once(trait_ref), |this, new_trait_ref, item| {
-            if new_trait_ref.has_non_region_late_bound() {
+            if new_trait_ref.has_non_region_bound_vars() {
                 this.tcx.sess.delay_span_bug(
                     this.span,
                     "tried to select method from HRTB with non-lifetime bound vars",
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
@@ -137,7 +137,7 @@ impl FlagComputation {
 
             &ty::Bound(debruijn, _) => {
                 self.add_bound_var(debruijn);
-                self.add_flags(TypeFlags::HAS_TY_LATE_BOUND);
+                self.add_flags(TypeFlags::HAS_TY_BOUND);
             }
 
             &ty::Placeholder(..) => {
@@ -317,7 +317,7 @@ impl FlagComputation {
             }
             ty::ConstKind::Bound(debruijn, _) => {
                 self.add_bound_var(debruijn);
-                self.add_flags(TypeFlags::HAS_CT_LATE_BOUND);
+                self.add_flags(TypeFlags::HAS_CT_BOUND);
             }
             ty::ConstKind::Param(_) => {
                 self.add_flags(TypeFlags::HAS_CT_PARAM);
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -1815,7 +1815,7 @@ impl<'tcx> Region<'tcx> {
                 flags = flags | TypeFlags::HAS_FREE_REGIONS;
             }
             ty::ReBound(..) => {
-                flags = flags | TypeFlags::HAS_RE_LATE_BOUND;
+                flags = flags | TypeFlags::HAS_RE_BOUND;
             }
             ty::ReErased => {
                 flags = flags | TypeFlags::HAS_RE_ERASED;
diff --git a/compiler/rustc_middle/src/ty/visit.rs b/compiler/rustc_middle/src/ty/visit.rs
@@ -111,16 +111,16 @@ pub trait TypeVisitableExt<'tcx>: TypeVisitable<TyCtxt<'tcx>> {
     }
 
     /// True if there are any late-bound regions
-    fn has_late_bound_regions(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_RE_LATE_BOUND)
+    fn has_bound_regions(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_RE_BOUND)
     }
     /// True if there are any late-bound non-region variables
-    fn has_non_region_late_bound(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_LATE_BOUND - TypeFlags::HAS_RE_LATE_BOUND)
+    fn has_non_region_bound_vars(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_BOUND_VARS - TypeFlags::HAS_RE_BOUND)
     }
-    /// True if there are any late-bound variables
-    fn has_late_bound_vars(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_LATE_BOUND)
+    /// True if there are any bound variables
+    fn has_bound_vars(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_BOUND_VARS)
     }
 
     /// Indicates whether this value still has parameters/placeholders/inference variables
diff --git a/compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs b/compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs
@@ -91,7 +91,7 @@ pub(in crate::solve) fn replace_erased_lifetimes_with_bound_vars<'tcx>(
     tcx: TyCtxt<'tcx>,
     ty: Ty<'tcx>,
 ) -> ty::Binder<'tcx, Ty<'tcx>> {
-    debug_assert!(!ty.has_late_bound_regions());
+    debug_assert!(!ty.has_bound_regions());
     let mut counter = 0;
     let ty = tcx.fold_regions(ty, |r, current_depth| match r.kind() {
         ty::ReErased => {
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -329,7 +329,7 @@ fn super_predicates_have_non_lifetime_binders(
     tcx.super_predicates_of(trait_def_id)
         .predicates
         .iter()
-        .filter_map(|(pred, span)| pred.has_non_region_late_bound().then_some(*span))
+        .filter_map(|(pred, span)| pred.has_non_region_bound_vars().then_some(*span))
         .collect()
 }
 
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -1277,7 +1277,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     let tcx = self.tcx();
                     stack.extend(tcx.coroutine_hidden_types(def_id).map(|bty| {
                         let ty = bty.instantiate(tcx, args);
-                        debug_assert!(!ty.has_late_bound_regions());
+                        debug_assert!(!ty.has_bound_regions());
                         ty
                     }))
                 }
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -799,7 +799,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     // A global type with no free lifetimes or generic parameters
                     // outlives anything.
                     if pred.0.has_free_regions()
-                        || pred.0.has_late_bound_regions()
+                        || pred.0.has_bound_regions()
                         || pred.0.has_non_region_infer()
                         || pred.0.has_non_region_infer()
                     {
@@ -1841,7 +1841,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
         // the param_env so that it can be given the lowest priority. See
         // #50825 for the motivation for this.
         let is_global =
-            |cand: &ty::PolyTraitPredicate<'tcx>| cand.is_global() && !cand.has_late_bound_vars();
+            |cand: &ty::PolyTraitPredicate<'tcx>| cand.is_global() && !cand.has_bound_vars();
 
         // (*) Prefer `BuiltinCandidate { has_nested: false }`, `PointeeCandidate`,
         // `DiscriminantKindCandidate`, `ConstDestructCandidate`
diff --git a/compiler/rustc_type_ir/src/flags.rs b/compiler/rustc_type_ir/src/flags.rs
@@ -89,16 +89,16 @@ bitflags! {
         const HAS_FREE_REGIONS            = 1 << 15;
 
         /// Does this have any `ReBound` regions?
-        const HAS_RE_LATE_BOUND           = 1 << 16;
+        const HAS_RE_BOUND                = 1 << 16;
         /// Does this have any `Bound` types?
-        const HAS_TY_LATE_BOUND           = 1 << 17;
+        const HAS_TY_BOUND                = 1 << 17;
         /// Does this have any `ConstKind::Bound` consts?
-        const HAS_CT_LATE_BOUND           = 1 << 18;
+        const HAS_CT_BOUND                = 1 << 18;
         /// Does this have any bound variables?
         /// Used to check if a global bound is safe to evaluate.
-        const HAS_LATE_BOUND              = TypeFlags::HAS_RE_LATE_BOUND.bits
-                                          | TypeFlags::HAS_TY_LATE_BOUND.bits
-                                          | TypeFlags::HAS_CT_LATE_BOUND.bits;
+        const HAS_BOUND_VARS              = TypeFlags::HAS_RE_BOUND.bits
+                                          | TypeFlags::HAS_TY_BOUND.bits
+                                          | TypeFlags::HAS_CT_BOUND.bits;
 
         /// Does this have any `ReErased` regions?
         const HAS_RE_ERASED               = 1 << 19;
diff --git a/src/tools/clippy/clippy_lints/src/eta_reduction.rs b/src/tools/clippy/clippy_lints/src/eta_reduction.rs
@@ -290,7 +290,7 @@ fn has_late_bound_to_non_late_bound_regions(from_sig: FnSig<'_>, to_sig: FnSig<'
                         .zip(to_tys)
                         .any(|(from_ty, to_ty)| check_ty(from_ty, to_ty))
             },
-            _ => from_ty.has_late_bound_regions(),
+            _ => from_ty.has_bound_regions(),
         }
     }
 
diff --git a/src/tools/clippy/clippy_utils/src/ty.rs b/src/tools/clippy/clippy_utils/src/ty.rs
@@ -1160,7 +1160,7 @@ pub fn make_normalized_projection<'tcx>(
 ) -> Option<Ty<'tcx>> {
     fn helper<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: AliasTy<'tcx>) -> Option<Ty<'tcx>> {
         #[cfg(debug_assertions)]
-        if let Some((i, arg)) = ty.args.iter().enumerate().find(|(_, arg)| arg.has_late_bound_regions()) {
+        if let Some((i, arg)) = ty.args.iter().enumerate().find(|(_, arg)| arg.has_bound_regions()) {
             debug_assert!(
                 false,
                 "args contain late-bound region at index `{i}` which can't be normalized.\n\
@@ -1233,7 +1233,7 @@ pub fn make_normalized_projection_with_regions<'tcx>(
 ) -> Option<Ty<'tcx>> {
     fn helper<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: AliasTy<'tcx>) -> Option<Ty<'tcx>> {
         #[cfg(debug_assertions)]
-        if let Some((i, arg)) = ty.args.iter().enumerate().find(|(_, arg)| arg.has_late_bound_regions()) {
+        if let Some((i, arg)) = ty.args.iter().enumerate().find(|(_, arg)| arg.has_bound_regions()) {
             debug_assert!(
                 false,
                 "args contain late-bound region at index `{i}` which can't be normalized.\n\

Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ impl FlagComputation {`
`137`	`137`
`138`	`138`	`&ty::Bound(debruijn, _) => {`
`139`	`139`	`self.add_bound_var(debruijn);`
`140`		`- self.add_flags(TypeFlags::HAS_TY_LATE_BOUND);`
	`140`	`+ self.add_flags(TypeFlags::HAS_TY_BOUND);`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`&ty::Placeholder(..) => {`
`@@ -317,7 +317,7 @@ impl FlagComputation {`
`317`	`317`	`}`
`318`	`318`	`ty::ConstKind::Bound(debruijn, _) => {`
`319`	`319`	`self.add_bound_var(debruijn);`
`320`		`- self.add_flags(TypeFlags::HAS_CT_LATE_BOUND);`
	`320`	`+ self.add_flags(TypeFlags::HAS_CT_BOUND);`
`321`	`321`	`}`
`322`	`322`	`ty::ConstKind::Param(_) => {`
`323`	`323`	`self.add_flags(TypeFlags::HAS_CT_PARAM);`
Original file line number	Diff line number	Diff line change
`@@ -1815,7 +1815,7 @@ impl<'tcx> Region<'tcx> {`
`1815`	`1815`	`flags = flags \| TypeFlags::HAS_FREE_REGIONS;`
`1816`	`1816`	`}`
`1817`	`1817`	`ty::ReBound(..) => {`
`1818`		`- flags = flags \| TypeFlags::HAS_RE_LATE_BOUND;`
	`1818`	`+ flags = flags \| TypeFlags::HAS_RE_BOUND;`
`1819`	`1819`	`}`
`1820`	`1820`	`ty::ReErased => {`
`1821`	`1821`	`flags = flags \| TypeFlags::HAS_RE_ERASED;`
Original file line number	Diff line number	Diff line change
`@@ -111,16 +111,16 @@ pub trait TypeVisitableExt<'tcx>: TypeVisitable<TyCtxt<'tcx>> {`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`/// True if there are any late-bound regions`
`114`		`- fn has_late_bound_regions(&self) -> bool {`
`115`		`- self.has_type_flags(TypeFlags::HAS_RE_LATE_BOUND)`
	`114`	`+ fn has_bound_regions(&self) -> bool {`
	`115`	`+ self.has_type_flags(TypeFlags::HAS_RE_BOUND)`
`116`	`116`	`}`
`117`	`117`	`/// True if there are any late-bound non-region variables`
`118`		`- fn has_non_region_late_bound(&self) -> bool {`
`119`		`- self.has_type_flags(TypeFlags::HAS_LATE_BOUND - TypeFlags::HAS_RE_LATE_BOUND)`
	`118`	`+ fn has_non_region_bound_vars(&self) -> bool {`
	`119`	`+ self.has_type_flags(TypeFlags::HAS_BOUND_VARS - TypeFlags::HAS_RE_BOUND)`
`120`	`120`	`}`
`121`		`- /// True if there are any late-bound variables`
`122`		`- fn has_late_bound_vars(&self) -> bool {`
`123`		`- self.has_type_flags(TypeFlags::HAS_LATE_BOUND)`
	`121`	`+ /// True if there are any bound variables`
	`122`	`+ fn has_bound_vars(&self) -> bool {`
	`123`	`+ self.has_type_flags(TypeFlags::HAS_BOUND_VARS)`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`/// Indicates whether this value still has parameters/placeholders/inference variables`
Original file line number	Diff line number	Diff line change
`@@ -329,7 +329,7 @@ fn super_predicates_have_non_lifetime_binders(`
`329`	`329`	`tcx.super_predicates_of(trait_def_id)`
`330`	`330`	`.predicates`
`331`	`331`	`.iter()`
`332`		`- .filter_map(\|(pred, span)\| pred.has_non_region_late_bound().then_some(*span))`
	`332`	`+ .filter_map(\|(pred, span)\| pred.has_non_region_bound_vars().then_some(*span))`
`333`	`333`	`.collect()`
`334`	`334`	`}`
`335`	`335`
Original file line number	Diff line number	Diff line change
`@@ -1277,7 +1277,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`1277`	`1277`	`let tcx = self.tcx();`
`1278`	`1278`	`stack.extend(tcx.coroutine_hidden_types(def_id).map(\|bty\| {`
`1279`	`1279`	`let ty = bty.instantiate(tcx, args);`
`1280`		`- debug_assert!(!ty.has_late_bound_regions());`
	`1280`	`+ debug_assert!(!ty.has_bound_regions());`
`1281`	`1281`	`ty`
`1282`	`1282`	`}))`
`1283`	`1283`	`}`
Original file line number	Diff line number	Diff line change
`@@ -290,7 +290,7 @@ fn has_late_bound_to_non_late_bound_regions(from_sig: FnSig<'_>, to_sig: FnSig<'`
`290`	`290`	`.zip(to_tys)`
`291`	`291`	`.any(\|(from_ty, to_ty)\| check_ty(from_ty, to_ty))`
`292`	`292`	`},`
`293`		`- _ => from_ty.has_late_bound_regions(),`
	`293`	`+ _ => from_ty.has_bound_regions(),`
`294`	`294`	`}`
`295`	`295`	`}`
`296`	`296`