From f4e886323cf98366c392919e494eac5b7c3fafdd Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 30 Jan 2024 15:59:07 +0000
Subject: [PATCH 1/3] Uplift TypeVisitableExt into rustc_type_ir
---
compiler/rustc_middle/src/ty/consts.rs | 12 +
compiler/rustc_middle/src/ty/context.rs | 7 +
compiler/rustc_middle/src/ty/mod.rs | 10 +
compiler/rustc_middle/src/ty/predicate.rs | 12 +
compiler/rustc_middle/src/ty/region.rs | 13 +
compiler/rustc_middle/src/ty/sty.rs | 11 +
compiler/rustc_middle/src/ty/util.rs | 1 +
compiler/rustc_middle/src/ty/visit.rs | 311 +----------------
compiler/rustc_type_ir/src/binder.rs | 7 +
compiler/rustc_type_ir/src/interner.rs | 12 +-
compiler/rustc_type_ir/src/lib.rs | 2 +
compiler/rustc_type_ir/src/visit.rs | 393 +++++++++++++++++++++-
12 files changed, 476 insertions(+), 315 deletions(-)
create mode 100644 compiler/rustc_type_ir/src/binder.rs
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index 23771073745ff..5e4d899f51768 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -35,6 +35,16 @@ impl<'tcx> IntoKind for Const<'tcx> {
}
}
+impl<'tcx> rustc_type_ir::visit::Flags for Const<'tcx> {
+ fn flags(&self) -> TypeFlags {
+ self.0.flags
+ }
+
+ fn outer_exclusive_binder(&self) -> rustc_type_ir::DebruijnIndex {
+ self.0.outer_exclusive_binder
+ }
+}
+
impl<'tcx> ConstTy<TyCtxt<'tcx>> for Const<'tcx> {
fn ty(self) -> Ty<'tcx> {
self.ty()
@@ -63,11 +73,13 @@ impl<'tcx> Const<'tcx> {
self.0.kind
}
+ // FIXME(compiler-errors): Think about removing this.
#[inline]
pub fn flags(self) -> TypeFlags {
self.0.flags
}
+ // FIXME(compiler-errors): Think about removing this.
#[inline]
pub fn outer_exclusive_binder(self) -> ty::DebruijnIndex {
self.0.outer_exclusive_binder
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index bd86c1c284e6e..0b1050a030775 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -88,6 +88,8 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
type Term = ty::Term<'tcx>;
type Binder<T> = Binder<'tcx, T>;
+ type BoundVars = &'tcx List<ty::BoundVariableKind>;
+ type BoundVar = ty::BoundVariableKind;
type CanonicalVars = CanonicalVarInfos<'tcx>;
type Ty = Ty<'tcx>;
@@ -151,6 +153,11 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
) -> Self::Const {
Const::new_bound(self, debruijn, var, ty)
}
+
+ fn expect_error_or_delayed_bug() {
+ let has_errors = ty::tls::with(|tcx| tcx.dcx().has_errors_or_lint_errors_or_delayed_bugs());
+ assert!(has_errors.is_some());
+ }
}
type InternedSet<'tcx, T> = ShardedHashMap<InternedInSet<'tcx, T>, ()>;
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 6ee74ef2fb648..10e1889eccad5 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -503,6 +503,16 @@ impl<'tcx> IntoKind for Ty<'tcx> {
}
}
+impl<'tcx> rustc_type_ir::visit::Flags for Ty<'tcx> {
+ fn flags(&self) -> TypeFlags {
+ self.0.flags
+ }
+
+ fn outer_exclusive_binder(&self) -> DebruijnIndex {
+ self.0.outer_exclusive_binder
+ }
+}
+
impl EarlyParamRegion {
/// Does this early bound region have a name? Early bound regions normally
/// always have names except when using anonymous lifetimes (`'_`).
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
index 200811940ed76..b63f9c6dfa01a 100644
--- a/compiler/rustc_middle/src/ty/predicate.rs
+++ b/compiler/rustc_middle/src/ty/predicate.rs
@@ -29,6 +29,16 @@ pub struct Predicate<'tcx>(
pub(super) Interned<'tcx, WithCachedTypeInfo<ty::Binder<'tcx, PredicateKind<'tcx>>>>,
);
+impl<'tcx> rustc_type_ir::visit::Flags for Predicate<'tcx> {
+ fn flags(&self) -> TypeFlags {
+ self.0.flags
+ }
+
+ fn outer_exclusive_binder(&self) -> ty::DebruijnIndex {
+ self.0.outer_exclusive_binder
+ }
+}
+
impl<'tcx> Predicate<'tcx> {
/// Gets the inner `ty::Binder<'tcx, PredicateKind<'tcx>>`.
#[inline]
@@ -36,11 +46,13 @@ impl<'tcx> Predicate<'tcx> {
self.0.internee
}
+ // FIXME(compiler-errors): Think about removing this.
#[inline(always)]
pub fn flags(self) -> TypeFlags {
self.0.flags
}
+ // FIXME(compiler-errors): Think about removing this.
#[inline(always)]
pub fn outer_exclusive_binder(self) -> DebruijnIndex {
self.0.outer_exclusive_binder
diff --git a/compiler/rustc_middle/src/ty/region.rs b/compiler/rustc_middle/src/ty/region.rs
index 1191d7fca32a4..b206727f0514e 100644
--- a/compiler/rustc_middle/src/ty/region.rs
+++ b/compiler/rustc_middle/src/ty/region.rs
@@ -26,6 +26,19 @@ impl<'tcx> rustc_type_ir::IntoKind for Region<'tcx> {
}
}
+impl<'tcx> rustc_type_ir::visit::Flags for Region<'tcx> {
+ fn flags(&self) -> TypeFlags {
+ self.type_flags()
+ }
+
+ fn outer_exclusive_binder(&self) -> ty::DebruijnIndex {
+ match **self {
+ ty::ReBound(debruijn, _) => debruijn.shifted_in(1),
+ _ => ty::INNERMOST,
+ }
+ }
+}
+
impl<'tcx> Region<'tcx> {
#[inline]
pub fn new_early_param(
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index a3d5f1f195510..ae6544b9dbea0 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -942,6 +942,16 @@ where
}
}
+impl<'tcx, T> rustc_type_ir::BoundVars<TyCtxt<'tcx>> for ty::Binder<'tcx, T> {
+ fn bound_vars(&self) -> &'tcx List<ty::BoundVariableKind> {
+ self.bound_vars
+ }
+
+ fn has_no_bound_vars(&self) -> bool {
+ self.bound_vars.is_empty()
+ }
+}
+
impl<'tcx, T> Binder<'tcx, T> {
/// Skips the binder and returns the "bound" value. This is a
/// risky thing to do because it's easy to get confused about
@@ -1808,6 +1818,7 @@ impl<'tcx> Ty<'tcx> {
self.0.0
}
+ // FIXME(compiler-errors): Think about removing this.
#[inline(always)]
pub fn flags(self) -> TypeFlags {
self.0.0.flags
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index c674a868d9fa2..09bb06de483a8 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -1320,6 +1320,7 @@ impl<'tcx> Ty<'tcx> {
ty
}
+ // FIXME(compiler-errors): Think about removing this.
#[inline]
pub fn outer_exclusive_binder(self) -> ty::DebruijnIndex {
self.0.outer_exclusive_binder
diff --git a/compiler/rustc_middle/src/ty/visit.rs b/compiler/rustc_middle/src/ty/visit.rs
index 7acdb931f1ae7..59292a281edec 100644
--- a/compiler/rustc_middle/src/ty/visit.rs
+++ b/compiler/rustc_middle/src/ty/visit.rs
@@ -1,140 +1,10 @@
use crate::ty::{self, Binder, Ty, TyCtxt, TypeFlags};
-use rustc_errors::ErrorGuaranteed;
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::sso::SsoHashSet;
use std::ops::ControlFlow;
-pub use rustc_type_ir::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor};
-
-pub trait TypeVisitableExt<'tcx>: TypeVisitable<TyCtxt<'tcx>> {
- /// Returns `true` if `self` has any late-bound regions that are either
- /// bound by `binder` or bound by some binder outside of `binder`.
- /// If `binder` is `ty::INNERMOST`, this indicates whether
- /// there are any late-bound regions that appear free.
- fn has_vars_bound_at_or_above(&self, binder: ty::DebruijnIndex) -> bool {
- self.visit_with(&mut HasEscapingVarsVisitor { outer_index: binder }).is_break()
- }
-
- /// Returns `true` if this type has any regions that escape `binder` (and
- /// hence are not bound by it).
- fn has_vars_bound_above(&self, binder: ty::DebruijnIndex) -> bool {
- self.has_vars_bound_at_or_above(binder.shifted_in(1))
- }
-
- /// Return `true` if this type has regions that are not a part of the type.
- /// For example, `for<'a> fn(&'a i32)` return `false`, while `fn(&'a i32)`
- /// would return `true`. The latter can occur when traversing through the
- /// former.
- ///
- /// See [`HasEscapingVarsVisitor`] for more information.
- fn has_escaping_bound_vars(&self) -> bool {
- self.has_vars_bound_at_or_above(ty::INNERMOST)
- }
-
- fn has_type_flags(&self, flags: TypeFlags) -> bool {
- let res =
- self.visit_with(&mut HasTypeFlagsVisitor { flags }).break_value() == Some(FoundFlags);
- trace!(?self, ?flags, ?res, "has_type_flags");
- res
- }
- fn has_projections(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_PROJECTION)
- }
- fn has_inherent_projections(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_TY_INHERENT)
- }
- fn has_opaque_types(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_TY_OPAQUE)
- }
- fn has_coroutines(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_TY_COROUTINE)
- }
- fn references_error(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_ERROR)
- }
- fn error_reported(&self) -> Result<(), ErrorGuaranteed> {
- if self.references_error() {
- // We must include lint errors and delayed bugs here.
- if let Some(reported) =
- ty::tls::with(|tcx| tcx.dcx().has_errors_or_lint_errors_or_delayed_bugs())
- {
- Err(reported)
- } else {
- bug!("expected some kind of error in `error_reported`");
- }
- } else {
- Ok(())
- }
- }
- fn has_non_region_param(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_PARAM - TypeFlags::HAS_RE_PARAM)
- }
- fn has_infer_regions(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_RE_INFER)
- }
- fn has_infer_types(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_TY_INFER)
- }
- fn has_non_region_infer(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_INFER - TypeFlags::HAS_RE_INFER)
- }
- fn has_infer(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_INFER)
- }
- fn has_placeholders(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_PLACEHOLDER)
- }
- fn has_non_region_placeholders(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_PLACEHOLDER - TypeFlags::HAS_RE_PLACEHOLDER)
- }
- fn has_param(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_PARAM)
- }
- /// "Free" regions in this context means that it has any region
- /// that is not (a) erased or (b) late-bound.
- fn has_free_regions(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_FREE_REGIONS)
- }
-
- fn has_erased_regions(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_RE_ERASED)
- }
-
- /// True if there are any un-erased free regions.
- fn has_erasable_regions(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_FREE_REGIONS)
- }
-
- /// Indicates whether this value references only 'global'
- /// generic parameters that are the same regardless of what fn we are
- /// in. This is used for caching.
- fn is_global(&self) -> bool {
- !self.has_type_flags(TypeFlags::HAS_FREE_LOCAL_NAMES)
- }
-
- /// True if there are any late-bound regions
- 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_bound_vars(&self) -> bool {
- self.has_type_flags(TypeFlags::HAS_BOUND_VARS - TypeFlags::HAS_RE_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
- /// which could be replaced later, in a way that would change the results of `impl`
- /// specialization.
- fn still_further_specializable(&self) -> bool {
- self.has_type_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE)
- }
-}
-
-impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeVisitableExt<'tcx> for T {}
+pub use rustc_type_ir::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor};
///////////////////////////////////////////////////////////////////////////
// Region folder
@@ -370,185 +240,6 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ValidateBoundVars<'tcx> {
}
}
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-struct FoundEscapingVars;
-
-/// An "escaping var" is a bound var whose binder is not part of `t`. A bound var can be a
-/// bound region or a bound type.
-///
-/// So, for example, consider a type like the following, which has two binders:
-///
-/// for<'a> fn(x: for<'b> fn(&'a isize, &'b isize))
-/// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ outer scope
-/// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ inner scope
-///
-/// This type has *bound regions* (`'a`, `'b`), but it does not have escaping regions, because the
-/// binders of both `'a` and `'b` are part of the type itself. However, if we consider the *inner
-/// fn type*, that type has an escaping region: `'a`.
-///
-/// Note that what I'm calling an "escaping var" is often just called a "free var". However,
-/// we already use the term "free var". It refers to the regions or types that we use to represent
-/// bound regions or type params on a fn definition while we are type checking its body.
-///
-/// To clarify, conceptually there is no particular difference between
-/// an "escaping" var and a "free" var. However, there is a big
-/// difference in practice. Basically, when "entering" a binding
-/// level, one is generally required to do some sort of processing to
-/// a bound var, such as replacing it with a fresh/placeholder
-/// var, or making an entry in the environment to represent the
-/// scope to which it is attached, etc. An escaping var represents
-/// a bound var for which this processing has not yet been done.
-struct HasEscapingVarsVisitor {
- /// Anything bound by `outer_index` or "above" is escaping.
- outer_index: ty::DebruijnIndex,
-}
-
-impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for HasEscapingVarsVisitor {
- type BreakTy = FoundEscapingVars;
-
- fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(
- &mut self,
- t: &Binder<'tcx, T>,
- ) -> ControlFlow<Self::BreakTy> {
- self.outer_index.shift_in(1);
- let result = t.super_visit_with(self);
- self.outer_index.shift_out(1);
- result
- }
-
- #[inline]
- fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
- // If the outer-exclusive-binder is *strictly greater* than
- // `outer_index`, that means that `t` contains some content
- // bound at `outer_index` or above (because
- // `outer_exclusive_binder` is always 1 higher than the
- // content in `t`). Therefore, `t` has some escaping vars.
- if t.outer_exclusive_binder() > self.outer_index {
- ControlFlow::Break(FoundEscapingVars)
- } else {
- ControlFlow::Continue(())
- }
- }
-
- #[inline]
- fn visit_region(&mut self, r: ty::Region<'tcx>) -> ControlFlow<Self::BreakTy> {
- // If the region is bound by `outer_index` or anything outside
- // of outer index, then it escapes the binders we have
- // visited.
- if r.bound_at_or_above_binder(self.outer_index) {
- ControlFlow::Break(FoundEscapingVars)
- } else {
- ControlFlow::Continue(())
- }
- }
-
- fn visit_const(&mut self, ct: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
- // If the outer-exclusive-binder is *strictly greater* than
- // `outer_index`, that means that `ct` contains some content
- // bound at `outer_index` or above (because
- // `outer_exclusive_binder` is always 1 higher than the
- // content in `t`). Therefore, `t` has some escaping vars.
- if ct.outer_exclusive_binder() > self.outer_index {
- ControlFlow::Break(FoundEscapingVars)
- } else {
- ControlFlow::Continue(())
- }
- }
-
- #[inline]
- fn visit_predicate(&mut self, predicate: ty::Predicate<'tcx>) -> ControlFlow<Self::BreakTy> {
- if predicate.outer_exclusive_binder() > self.outer_index {
- ControlFlow::Break(FoundEscapingVars)
- } else {
- ControlFlow::Continue(())
- }
- }
-}
-
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-struct FoundFlags;
-
-// FIXME: Optimize for checking for infer flags
-struct HasTypeFlagsVisitor {
- flags: ty::TypeFlags,
-}
-
-impl std::fmt::Debug for HasTypeFlagsVisitor {
- fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- self.flags.fmt(fmt)
- }
-}
-
-// Note: this visitor traverses values down to the level of
-// `Ty`/`Const`/`Predicate`, but not within those types. This is because the
-// type flags at the outer layer are enough. So it's faster than it first
-// looks, particular for `Ty`/`Predicate` where it's just a field access.
-//
-// N.B. The only case where this isn't totally true is binders, which also
-// add `HAS_{RE,TY,CT}_LATE_BOUND` flag depending on the *bound variables* that
-// are present, regardless of whether those bound variables are used. This
-// is important for anonymization of binders in `TyCtxt::erase_regions`. We
-// specifically detect this case in `visit_binder`.
-impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for HasTypeFlagsVisitor {
- type BreakTy = FoundFlags;
-
- fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(
- &mut self,
- t: &Binder<'tcx, T>,
- ) -> ControlFlow<Self::BreakTy> {
- // If we're looking for the HAS_BINDER_VARS flag, check if the
- // binder has vars. This won't be present in the binder's bound
- // value, so we need to check here too.
- if self.flags.intersects(TypeFlags::HAS_BINDER_VARS) && !t.bound_vars().is_empty() {
- return ControlFlow::Break(FoundFlags);
- }
-
- t.super_visit_with(self)
- }
-
- #[inline]
- fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
- // Note: no `super_visit_with` call.
- let flags = t.flags();
- if flags.intersects(self.flags) {
- ControlFlow::Break(FoundFlags)
- } else {
- ControlFlow::Continue(())
- }
- }
-
- #[inline]
- fn visit_region(&mut self, r: ty::Region<'tcx>) -> ControlFlow<Self::BreakTy> {
- // Note: no `super_visit_with` call, as usual for `Region`.
- let flags = r.type_flags();
- if flags.intersects(self.flags) {
- ControlFlow::Break(FoundFlags)
- } else {
- ControlFlow::Continue(())
- }
- }
-
- #[inline]
- fn visit_const(&mut self, c: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
- // Note: no `super_visit_with` call.
- if c.flags().intersects(self.flags) {
- ControlFlow::Break(FoundFlags)
- } else {
- ControlFlow::Continue(())
- }
- }
-
- #[inline]
- fn visit_predicate(&mut self, predicate: ty::Predicate<'tcx>) -> ControlFlow<Self::BreakTy> {
- // Note: no `super_visit_with` call.
- if predicate.flags().intersects(self.flags) {
- ControlFlow::Break(FoundFlags)
- } else {
- ControlFlow::Continue(())
- }
- }
-}
-
/// Collects all the late-bound regions at the innermost binding level
/// into a hash set.
struct LateBoundRegionsCollector {
diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
new file mode 100644
index 0000000000000..57f961ac97ec5
--- /dev/null
+++ b/compiler/rustc_type_ir/src/binder.rs
@@ -0,0 +1,7 @@
+use crate::Interner;
+
+pub trait BoundVars<I: Interner> {
+ fn bound_vars(&self) -> I::BoundVars;
+
+ fn has_no_bound_vars(&self) -> bool;
+}
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index 188910ecc52d1..ce82e91f9c6cd 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -3,8 +3,8 @@ use std::fmt::Debug;
use std::hash::Hash;
use crate::{
- BoundVar, CanonicalVarInfo, ConstKind, DebruijnIndex, DebugWithInfcx, RegionKind, TyKind,
- UniverseIndex,
+ BoundVar, BoundVars, CanonicalVarInfo, ConstKind, DebruijnIndex, DebugWithInfcx, RegionKind,
+ TyKind, UniverseIndex,
};
pub trait Interner: Sized {
@@ -19,7 +19,10 @@ pub trait Interner: Sized {
type GenericArg: Copy + DebugWithInfcx<Self> + Hash + Ord;
type Term: Copy + Debug + Hash + Ord;
- type Binder<T>;
+ type Binder<T>: BoundVars<Self>;
+ type BoundVars: IntoIterator<Item = Self::BoundVar>;
+ type BoundVar;
+
type CanonicalVars: Copy + Debug + Hash + Eq + IntoIterator<Item = CanonicalVarInfo<Self>>;
// Kinds of tys
@@ -86,6 +89,9 @@ pub trait Interner: Sized {
fn mk_bound_ty(self, debruijn: DebruijnIndex, var: BoundVar) -> Self::Ty;
fn mk_bound_region(self, debruijn: DebruijnIndex, var: BoundVar) -> Self::Region;
fn mk_bound_const(self, debruijn: DebruijnIndex, var: BoundVar, ty: Self::Ty) -> Self::Const;
+
+ /// Assert that an error has been delayed or emitted.
+ fn expect_error_or_delayed_bug();
}
/// Common capabilities of placeholder kinds
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs
index f498c5531fcff..94ccbcbd8a570 100644
--- a/compiler/rustc_type_ir/src/lib.rs
+++ b/compiler/rustc_type_ir/src/lib.rs
@@ -30,6 +30,7 @@ pub mod visit;
#[macro_use]
mod macros;
+mod binder;
mod canonical;
mod const_kind;
mod debug;
@@ -39,6 +40,7 @@ mod interner;
mod predicate_kind;
mod region_kind;
+pub use binder::*;
pub use canonical::*;
#[cfg(feature = "nightly")]
pub use codec::*;
diff --git a/compiler/rustc_type_ir/src/visit.rs b/compiler/rustc_type_ir/src/visit.rs
index 7aa990046675f..5f7c507e739b4 100644
--- a/compiler/rustc_type_ir/src/visit.rs
+++ b/compiler/rustc_type_ir/src/visit.rs
@@ -45,8 +45,7 @@ use rustc_index::{Idx, IndexVec};
use std::fmt;
use std::ops::ControlFlow;
-use crate::Interner;
-use crate::Lrc;
+use crate::{self as ty, BoundVars, Interner, IntoKind, Lrc, TypeFlags};
/// This trait is implemented for every type that can be visited,
/// providing the skeleton of the traversal.
@@ -200,3 +199,393 @@ impl<I: Interner, T: TypeVisitable<I>, Ix: Idx> TypeVisitable<I> for IndexVec<Ix
self.iter().try_for_each(|t| t.visit_with(visitor))
}
}
+
+pub trait Flags {
+ fn flags(&self) -> TypeFlags;
+ fn outer_exclusive_binder(&self) -> ty::DebruijnIndex;
+}
+
+pub trait TypeVisitableExt<I: Interner>: TypeVisitable<I> {
+ fn has_type_flags(&self, flags: TypeFlags) -> bool;
+
+ /// Returns `true` if `self` has any late-bound regions that are either
+ /// bound by `binder` or bound by some binder outside of `binder`.
+ /// If `binder` is `ty::INNERMOST`, this indicates whether
+ /// there are any late-bound regions that appear free.
+ fn has_vars_bound_at_or_above(&self, binder: ty::DebruijnIndex) -> bool;
+
+ /// Returns `true` if this type has any regions that escape `binder` (and
+ /// hence are not bound by it).
+ fn has_vars_bound_above(&self, binder: ty::DebruijnIndex) -> bool {
+ self.has_vars_bound_at_or_above(binder.shifted_in(1))
+ }
+
+ /// Return `true` if this type has regions that are not a part of the type.
+ /// For example, `for<'a> fn(&'a i32)` return `false`, while `fn(&'a i32)`
+ /// would return `true`. The latter can occur when traversing through the
+ /// former.
+ ///
+ /// See [`HasEscapingVarsVisitor`] for more information.
+ fn has_escaping_bound_vars(&self) -> bool {
+ self.has_vars_bound_at_or_above(ty::INNERMOST)
+ }
+
+ fn has_projections(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_PROJECTION)
+ }
+
+ fn has_inherent_projections(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_TY_INHERENT)
+ }
+
+ fn has_opaque_types(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_TY_OPAQUE)
+ }
+
+ fn has_coroutines(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_TY_COROUTINE)
+ }
+
+ fn references_error(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_ERROR)
+ }
+
+ fn error_reported(&self) -> Result<(), I::ErrorGuaranteed>;
+
+ fn has_non_region_param(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_PARAM - TypeFlags::HAS_RE_PARAM)
+ }
+
+ fn has_infer_regions(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_RE_INFER)
+ }
+
+ fn has_infer_types(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_TY_INFER)
+ }
+
+ fn has_non_region_infer(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_INFER - TypeFlags::HAS_RE_INFER)
+ }
+
+ fn has_infer(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_INFER)
+ }
+
+ fn has_placeholders(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_PLACEHOLDER)
+ }
+
+ fn has_non_region_placeholders(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_PLACEHOLDER - TypeFlags::HAS_RE_PLACEHOLDER)
+ }
+
+ fn has_param(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_PARAM)
+ }
+
+ /// "Free" regions in this context means that it has any region
+ /// that is not (a) erased or (b) late-bound.
+ fn has_free_regions(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_FREE_REGIONS)
+ }
+
+ fn has_erased_regions(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_RE_ERASED)
+ }
+
+ /// True if there are any un-erased free regions.
+ fn has_erasable_regions(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_FREE_REGIONS)
+ }
+
+ /// Indicates whether this value references only 'global'
+ /// generic parameters that are the same regardless of what fn we are
+ /// in. This is used for caching.
+ fn is_global(&self) -> bool {
+ !self.has_type_flags(TypeFlags::HAS_FREE_LOCAL_NAMES)
+ }
+
+ /// True if there are any late-bound regions
+ 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_bound_vars(&self) -> bool {
+ self.has_type_flags(TypeFlags::HAS_BOUND_VARS - TypeFlags::HAS_RE_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
+ /// which could be replaced later, in a way that would change the results of `impl`
+ /// specialization.
+ fn still_further_specializable(&self) -> bool {
+ self.has_type_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE)
+ }
+}
+
+impl<I: Interner, T: TypeVisitable<I>> TypeVisitableExt<I> for T
+where
+ I::Ty: Flags,
+ I::Region: Flags,
+ I::Const: Flags,
+ I::Predicate: Flags,
+{
+ fn has_type_flags(&self, flags: TypeFlags) -> bool {
+ let res =
+ self.visit_with(&mut HasTypeFlagsVisitor { flags }) == ControlFlow::Break(FoundFlags);
+ res
+ }
+
+ fn has_vars_bound_at_or_above(&self, binder: ty::DebruijnIndex) -> bool {
+ self.visit_with(&mut HasEscapingVarsVisitor { outer_index: binder }).is_break()
+ }
+
+ fn error_reported(&self) -> Result<(), I::ErrorGuaranteed> {
+ if self.references_error() {
+ if let ControlFlow::Break(guar) = self.visit_with(&mut HasErrorVisitor) {
+ Err(guar)
+ } else {
+ panic!("type flags said there was an error, but now there is not")
+ }
+ } else {
+ Ok(())
+ }
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+struct FoundFlags;
+
+// FIXME: Optimize for checking for infer flags
+struct HasTypeFlagsVisitor {
+ flags: ty::TypeFlags,
+}
+
+impl std::fmt::Debug for HasTypeFlagsVisitor {
+ fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ self.flags.fmt(fmt)
+ }
+}
+
+// Note: this visitor traverses values down to the level of
+// `Ty`/`Const`/`Predicate`, but not within those types. This is because the
+// type flags at the outer layer are enough. So it's faster than it first
+// looks, particular for `Ty`/`Predicate` where it's just a field access.
+//
+// N.B. The only case where this isn't totally true is binders, which also
+// add `HAS_{RE,TY,CT}_LATE_BOUND` flag depending on the *bound variables* that
+// are present, regardless of whether those bound variables are used. This
+// is important for anonymization of binders in `TyCtxt::erase_regions`. We
+// specifically detect this case in `visit_binder`.
+impl<I: Interner> TypeVisitor<I> for HasTypeFlagsVisitor
+where
+ I::Ty: Flags,
+ I::Region: Flags,
+ I::Const: Flags,
+ I::Predicate: Flags,
+{
+ type BreakTy = FoundFlags;
+
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &I::Binder<T>) -> ControlFlow<Self::BreakTy>
+ where
+ I::Binder<T>: TypeSuperVisitable<I>,
+ {
+ // If we're looking for the HAS_BINDER_VARS flag, check if the
+ // binder has vars. This won't be present in the binder's bound
+ // value, so we need to check here too.
+ if self.flags.intersects(TypeFlags::HAS_BINDER_VARS) && !t.has_no_bound_vars() {
+ return ControlFlow::Break(FoundFlags);
+ }
+
+ t.super_visit_with(self)
+ }
+
+ #[inline]
+ fn visit_ty(&mut self, t: I::Ty) -> ControlFlow<Self::BreakTy> {
+ // Note: no `super_visit_with` call.
+ let flags = t.flags();
+ if flags.intersects(self.flags) {
+ ControlFlow::Break(FoundFlags)
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
+
+ #[inline]
+ fn visit_region(&mut self, r: I::Region) -> ControlFlow<Self::BreakTy> {
+ // Note: no `super_visit_with` call, as usual for `Region`.
+ let flags = r.flags();
+ if flags.intersects(self.flags) {
+ ControlFlow::Break(FoundFlags)
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
+
+ #[inline]
+ fn visit_const(&mut self, c: I::Const) -> ControlFlow<Self::BreakTy> {
+ // Note: no `super_visit_with` call.
+ if c.flags().intersects(self.flags) {
+ ControlFlow::Break(FoundFlags)
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
+
+ #[inline]
+ fn visit_predicate(&mut self, predicate: I::Predicate) -> ControlFlow<Self::BreakTy> {
+ // Note: no `super_visit_with` call.
+ if predicate.flags().intersects(self.flags) {
+ ControlFlow::Break(FoundFlags)
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+struct FoundEscapingVars;
+
+/// An "escaping var" is a bound var whose binder is not part of `t`. A bound var can be a
+/// bound region or a bound type.
+///
+/// So, for example, consider a type like the following, which has two binders:
+///
+/// for<'a> fn(x: for<'b> fn(&'a isize, &'b isize))
+/// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ outer scope
+/// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ inner scope
+///
+/// This type has *bound regions* (`'a`, `'b`), but it does not have escaping regions, because the
+/// binders of both `'a` and `'b` are part of the type itself. However, if we consider the *inner
+/// fn type*, that type has an escaping region: `'a`.
+///
+/// Note that what I'm calling an "escaping var" is often just called a "free var". However,
+/// we already use the term "free var". It refers to the regions or types that we use to represent
+/// bound regions or type params on a fn definition while we are type checking its body.
+///
+/// To clarify, conceptually there is no particular difference between
+/// an "escaping" var and a "free" var. However, there is a big
+/// difference in practice. Basically, when "entering" a binding
+/// level, one is generally required to do some sort of processing to
+/// a bound var, such as replacing it with a fresh/placeholder
+/// var, or making an entry in the environment to represent the
+/// scope to which it is attached, etc. An escaping var represents
+/// a bound var for which this processing has not yet been done.
+struct HasEscapingVarsVisitor {
+ /// Anything bound by `outer_index` or "above" is escaping.
+ outer_index: ty::DebruijnIndex,
+}
+
+impl<I: Interner> TypeVisitor<I> for HasEscapingVarsVisitor
+where
+ I::Ty: Flags,
+ I::Region: Flags,
+ I::Const: Flags,
+ I::Predicate: Flags,
+{
+ type BreakTy = FoundEscapingVars;
+
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &I::Binder<T>) -> ControlFlow<Self::BreakTy>
+ where
+ I::Binder<T>: TypeSuperVisitable<I>,
+ {
+ self.outer_index.shift_in(1);
+ let result = t.super_visit_with(self);
+ self.outer_index.shift_out(1);
+ result
+ }
+
+ #[inline]
+ fn visit_ty(&mut self, t: I::Ty) -> ControlFlow<Self::BreakTy> {
+ // If the outer-exclusive-binder is *strictly greater* than
+ // `outer_index`, that means that `t` contains some content
+ // bound at `outer_index` or above (because
+ // `outer_exclusive_binder` is always 1 higher than the
+ // content in `t`). Therefore, `t` has some escaping vars.
+ if t.outer_exclusive_binder() > self.outer_index {
+ ControlFlow::Break(FoundEscapingVars)
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
+
+ #[inline]
+ fn visit_region(&mut self, r: I::Region) -> ControlFlow<Self::BreakTy> {
+ // If the region is bound by `outer_index` or anything outside
+ // of outer index, then it escapes the binders we have
+ // visited.
+ if r.outer_exclusive_binder() > self.outer_index {
+ ControlFlow::Break(FoundEscapingVars)
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
+
+ fn visit_const(&mut self, ct: I::Const) -> ControlFlow<Self::BreakTy> {
+ // If the outer-exclusive-binder is *strictly greater* than
+ // `outer_index`, that means that `ct` contains some content
+ // bound at `outer_index` or above (because
+ // `outer_exclusive_binder` is always 1 higher than the
+ // content in `t`). Therefore, `t` has some escaping vars.
+ if ct.outer_exclusive_binder() > self.outer_index {
+ ControlFlow::Break(FoundEscapingVars)
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
+
+ #[inline]
+ fn visit_predicate(&mut self, predicate: I::Predicate) -> ControlFlow<Self::BreakTy> {
+ if predicate.outer_exclusive_binder() > self.outer_index {
+ ControlFlow::Break(FoundEscapingVars)
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
+}
+
+struct HasErrorVisitor;
+
+impl<I: Interner> TypeVisitor<I> for HasErrorVisitor
+where
+ I::Ty: Flags,
+ I::Region: Flags,
+ I::Const: Flags,
+ I::Predicate: Flags,
+{
+ type BreakTy = I::ErrorGuaranteed;
+
+ fn visit_ty(&mut self, t: <I as Interner>::Ty) -> ControlFlow<Self::BreakTy>
+ where
+ <I as Interner>::Ty: TypeSuperVisitable<I>,
+ {
+ if let ty::Error(guar) = t.kind() {
+ ControlFlow::Break(guar)
+ } else {
+ t.super_visit_with(self)
+ }
+ }
+
+ fn visit_const(&mut self, c: <I as Interner>::Const) -> ControlFlow<Self::BreakTy>
+ where
+ <I as Interner>::Const: TypeSuperVisitable<I>,
+ {
+ if let ty::ConstKind::Error(guar) = c.kind() {
+ ControlFlow::Break(guar)
+ } else {
+ c.super_visit_with(self)
+ }
+ }
+
+ fn visit_region(&mut self, r: <I as Interner>::Region) -> ControlFlow<Self::BreakTy> {
+ if let ty::ReError(guar) = r.kind() {
+ ControlFlow::Break(guar)
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
+}
From edc5053352831c761bd0c30aa9998d1efdd37877 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 30 Jan 2024 15:59:19 +0000
Subject: [PATCH 2/3] Add assertions back to canonicalizer
---
.../rustc_next_trait_solver/src/canonicalizer.rs | 13 ++++++++++---
1 file changed, 10 insertions(+), 3 deletions(-)
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index 42edbeaa622c2..75b0fc39140e8 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -1,6 +1,7 @@
use std::cmp::Ordering;
use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
+use rustc_type_ir::visit::{Flags, TypeVisitableExt};
use rustc_type_ir::{
self as ty, Canonical, CanonicalTyVarKind, CanonicalVarInfo, CanonicalVarKind, ConstTy,
InferCtxtLike, Interner, IntoKind, PlaceholderLike,
@@ -44,7 +45,13 @@ pub struct Canonicalizer<'a, Infcx: InferCtxtLike<Interner = I>, I: Interner> {
binder_index: ty::DebruijnIndex,
}
-impl<'a, Infcx: InferCtxtLike<Interner = I>, I: Interner> Canonicalizer<'a, Infcx, I> {
+impl<'a, Infcx: InferCtxtLike<Interner = I>, I: Interner> Canonicalizer<'a, Infcx, I>
+where
+ I::Ty: Flags,
+ I::Region: Flags,
+ I::Const: Flags,
+ I::Predicate: Flags,
+{
pub fn canonicalize<T: TypeFoldable<I>>(
infcx: &'a Infcx,
canonicalize_mode: CanonicalizeMode,
@@ -62,8 +69,8 @@ impl<'a, Infcx: InferCtxtLike<Interner = I>, I: Interner> Canonicalizer<'a, Infc
let value = value.fold_with(&mut canonicalizer);
// FIXME: Restore these assertions. Should we uplift type flags?
- // assert!(!value.has_infer(), "unexpected infer in {value:?}");
- // assert!(!value.has_placeholders(), "unexpected placeholders in {value:?}");
+ assert!(!value.has_infer(), "unexpected infer in {value:?}");
+ assert!(!value.has_placeholders(), "unexpected placeholders in {value:?}");
let (max_universe, variables) = canonicalizer.finalize();
From 7e80867f3c270f360a64294e421d4a9b010e28f8 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 13 Feb 2024 15:53:15 +0000
Subject: [PATCH 3/3] Move visitable bounds up into interner
---
compiler/rustc_middle/src/ty/context.rs | 4 +-
.../src/canonicalizer.rs | 10 +--
compiler/rustc_type_ir/src/interner.rs | 16 ++--
compiler/rustc_type_ir/src/visit.rs | 84 +++++--------------
4 files changed, 37 insertions(+), 77 deletions(-)
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 0b1050a030775..61e449b8b565f 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -28,7 +28,7 @@ use crate::ty::{
self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Const, ConstData, GenericParamDefKind,
ImplPolarity, List, ParamConst, ParamTy, PolyExistentialPredicate, PolyFnSig, Predicate,
PredicateKind, Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyVid,
- Visibility,
+ TypeVisitable, Visibility,
};
use crate::ty::{GenericArg, GenericArgs, GenericArgsRef};
use rustc_ast::{self as ast, attr};
@@ -87,7 +87,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
type GenericArg = ty::GenericArg<'tcx>;
type Term = ty::Term<'tcx>;
- type Binder<T> = Binder<'tcx, T>;
+ type Binder<T: TypeVisitable<TyCtxt<'tcx>>> = Binder<'tcx, T>;
type BoundVars = &'tcx List<ty::BoundVariableKind>;
type BoundVar = ty::BoundVariableKind;
type CanonicalVars = CanonicalVarInfos<'tcx>;
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index 75b0fc39140e8..cd434fecce2cb 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -1,7 +1,7 @@
use std::cmp::Ordering;
use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
-use rustc_type_ir::visit::{Flags, TypeVisitableExt};
+use rustc_type_ir::visit::TypeVisitableExt;
use rustc_type_ir::{
self as ty, Canonical, CanonicalTyVarKind, CanonicalVarInfo, CanonicalVarKind, ConstTy,
InferCtxtLike, Interner, IntoKind, PlaceholderLike,
@@ -45,13 +45,7 @@ pub struct Canonicalizer<'a, Infcx: InferCtxtLike<Interner = I>, I: Interner> {
binder_index: ty::DebruijnIndex,
}
-impl<'a, Infcx: InferCtxtLike<Interner = I>, I: Interner> Canonicalizer<'a, Infcx, I>
-where
- I::Ty: Flags,
- I::Region: Flags,
- I::Const: Flags,
- I::Predicate: Flags,
-{
+impl<'a, Infcx: InferCtxtLike<Interner = I>, I: Interner> Canonicalizer<'a, Infcx, I> {
pub fn canonicalize<T: TypeFoldable<I>>(
infcx: &'a Infcx,
canonicalize_mode: CanonicalizeMode,
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index ce82e91f9c6cd..7728ee0e842a8 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -2,6 +2,7 @@ use smallvec::SmallVec;
use std::fmt::Debug;
use std::hash::Hash;
+use crate::visit::{Flags, TypeSuperVisitable, TypeVisitable};
use crate::{
BoundVar, BoundVars, CanonicalVarInfo, ConstKind, DebruijnIndex, DebugWithInfcx, RegionKind,
TyKind, UniverseIndex,
@@ -19,7 +20,7 @@ pub trait Interner: Sized {
type GenericArg: Copy + DebugWithInfcx<Self> + Hash + Ord;
type Term: Copy + Debug + Hash + Ord;
- type Binder<T>: BoundVars<Self>;
+ type Binder<T: TypeVisitable<Self>>: BoundVars<Self> + TypeSuperVisitable<Self>;
type BoundVars: IntoIterator<Item = Self::BoundVar>;
type BoundVar;
@@ -31,7 +32,9 @@ pub trait Interner: Sized {
+ Hash
+ Ord
+ Into<Self::GenericArg>
- + IntoKind<Kind = TyKind<Self>>;
+ + IntoKind<Kind = TyKind<Self>>
+ + TypeSuperVisitable<Self>
+ + Flags;
type Tys: Copy + Debug + Hash + Ord + IntoIterator<Item = Self::Ty>;
type AliasTy: Copy + DebugWithInfcx<Self> + Hash + Ord;
type ParamTy: Copy + Debug + Hash + Ord;
@@ -51,7 +54,9 @@ pub trait Interner: Sized {
+ Ord
+ Into<Self::GenericArg>
+ IntoKind<Kind = ConstKind<Self>>
- + ConstTy<Self>;
+ + ConstTy<Self>
+ + TypeSuperVisitable<Self>
+ + Flags;
type AliasConst: Copy + DebugWithInfcx<Self> + Hash + Ord;
type PlaceholderConst: Copy + Debug + Hash + Ord + PlaceholderLike;
type ParamConst: Copy + Debug + Hash + Ord;
@@ -65,7 +70,8 @@ pub trait Interner: Sized {
+ Hash
+ Ord
+ Into<Self::GenericArg>
- + IntoKind<Kind = RegionKind<Self>>;
+ + IntoKind<Kind = RegionKind<Self>>
+ + Flags;
type EarlyParamRegion: Copy + Debug + Hash + Ord;
type LateParamRegion: Copy + Debug + Hash + Ord;
type BoundRegion: Copy + Debug + Hash + Ord;
@@ -73,7 +79,7 @@ pub trait Interner: Sized {
type PlaceholderRegion: Copy + Debug + Hash + Ord + PlaceholderLike;
// Predicates
- type Predicate: Copy + Debug + Hash + Eq;
+ type Predicate: Copy + Debug + Hash + Eq + TypeSuperVisitable<Self> + Flags;
type TraitPredicate: Copy + Debug + Hash + Eq;
type RegionOutlivesPredicate: Copy + Debug + Hash + Eq;
type TypeOutlivesPredicate: Copy + Debug + Hash + Eq;
diff --git a/compiler/rustc_type_ir/src/visit.rs b/compiler/rustc_type_ir/src/visit.rs
index 5f7c507e739b4..638fb9f7fa9db 100644
--- a/compiler/rustc_type_ir/src/visit.rs
+++ b/compiler/rustc_type_ir/src/visit.rs
@@ -87,38 +87,28 @@ pub trait TypeVisitor<I: Interner>: Sized {
#[cfg(not(feature = "nightly"))]
type BreakTy;
- fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &I::Binder<T>) -> ControlFlow<Self::BreakTy>
- where
- I::Binder<T>: TypeSuperVisitable<I>,
- {
+ fn visit_binder<T: TypeVisitable<I>>(
+ &mut self,
+ t: &I::Binder<T>,
+ ) -> ControlFlow<Self::BreakTy> {
t.super_visit_with(self)
}
- fn visit_ty(&mut self, t: I::Ty) -> ControlFlow<Self::BreakTy>
- where
- I::Ty: TypeSuperVisitable<I>,
- {
+ fn visit_ty(&mut self, t: I::Ty) -> ControlFlow<Self::BreakTy> {
t.super_visit_with(self)
}
// The default region visitor is a no-op because `Region` is non-recursive
- // and has no `super_visit_with` method to call. That also explains the
- // lack of `I::Region: TypeSuperVisitable<I>` bound.
+ // and has no `super_visit_with` method to call.
fn visit_region(&mut self, _r: I::Region) -> ControlFlow<Self::BreakTy> {
ControlFlow::Continue(())
}
- fn visit_const(&mut self, c: I::Const) -> ControlFlow<Self::BreakTy>
- where
- I::Const: TypeSuperVisitable<I>,
- {
+ fn visit_const(&mut self, c: I::Const) -> ControlFlow<Self::BreakTy> {
c.super_visit_with(self)
}
- fn visit_predicate(&mut self, p: I::Predicate) -> ControlFlow<Self::BreakTy>
- where
- I::Predicate: TypeSuperVisitable<I>,
- {
+ fn visit_predicate(&mut self, p: I::Predicate) -> ControlFlow<Self::BreakTy> {
p.super_visit_with(self)
}
}
@@ -327,13 +317,7 @@ pub trait TypeVisitableExt<I: Interner>: TypeVisitable<I> {
}
}
-impl<I: Interner, T: TypeVisitable<I>> TypeVisitableExt<I> for T
-where
- I::Ty: Flags,
- I::Region: Flags,
- I::Const: Flags,
- I::Predicate: Flags,
-{
+impl<I: Interner, T: TypeVisitable<I>> TypeVisitableExt<I> for T {
fn has_type_flags(&self, flags: TypeFlags) -> bool {
let res =
self.visit_with(&mut HasTypeFlagsVisitor { flags }) == ControlFlow::Break(FoundFlags);
@@ -381,19 +365,13 @@ impl std::fmt::Debug for HasTypeFlagsVisitor {
// are present, regardless of whether those bound variables are used. This
// is important for anonymization of binders in `TyCtxt::erase_regions`. We
// specifically detect this case in `visit_binder`.
-impl<I: Interner> TypeVisitor<I> for HasTypeFlagsVisitor
-where
- I::Ty: Flags,
- I::Region: Flags,
- I::Const: Flags,
- I::Predicate: Flags,
-{
+impl<I: Interner> TypeVisitor<I> for HasTypeFlagsVisitor {
type BreakTy = FoundFlags;
- fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &I::Binder<T>) -> ControlFlow<Self::BreakTy>
- where
- I::Binder<T>: TypeSuperVisitable<I>,
- {
+ fn visit_binder<T: TypeVisitable<I>>(
+ &mut self,
+ t: &I::Binder<T>,
+ ) -> ControlFlow<Self::BreakTy> {
// If we're looking for the HAS_BINDER_VARS flag, check if the
// binder has vars. This won't be present in the binder's bound
// value, so we need to check here too.
@@ -480,19 +458,13 @@ struct HasEscapingVarsVisitor {
outer_index: ty::DebruijnIndex,
}
-impl<I: Interner> TypeVisitor<I> for HasEscapingVarsVisitor
-where
- I::Ty: Flags,
- I::Region: Flags,
- I::Const: Flags,
- I::Predicate: Flags,
-{
+impl<I: Interner> TypeVisitor<I> for HasEscapingVarsVisitor {
type BreakTy = FoundEscapingVars;
- fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &I::Binder<T>) -> ControlFlow<Self::BreakTy>
- where
- I::Binder<T>: TypeSuperVisitable<I>,
- {
+ fn visit_binder<T: TypeVisitable<I>>(
+ &mut self,
+ t: &I::Binder<T>,
+ ) -> ControlFlow<Self::BreakTy> {
self.outer_index.shift_in(1);
let result = t.super_visit_with(self);
self.outer_index.shift_out(1);
@@ -550,19 +522,10 @@ where
struct HasErrorVisitor;
-impl<I: Interner> TypeVisitor<I> for HasErrorVisitor
-where
- I::Ty: Flags,
- I::Region: Flags,
- I::Const: Flags,
- I::Predicate: Flags,
-{
+impl<I: Interner> TypeVisitor<I> for HasErrorVisitor {
type BreakTy = I::ErrorGuaranteed;
- fn visit_ty(&mut self, t: <I as Interner>::Ty) -> ControlFlow<Self::BreakTy>
- where
- <I as Interner>::Ty: TypeSuperVisitable<I>,
- {
+ fn visit_ty(&mut self, t: <I as Interner>::Ty) -> ControlFlow<Self::BreakTy> {
if let ty::Error(guar) = t.kind() {
ControlFlow::Break(guar)
} else {
@@ -570,10 +533,7 @@ where
}
}
- fn visit_const(&mut self, c: <I as Interner>::Const) -> ControlFlow<Self::BreakTy>
- where
- <I as Interner>::Const: TypeSuperVisitable<I>,
- {
+ fn visit_const(&mut self, c: <I as Interner>::Const) -> ControlFlow<Self::BreakTy> {
if let ty::ConstKind::Error(guar) = c.kind() {
ControlFlow::Break(guar)
} else {