move folders to rustc_type_ir

Author: lcnr

compiler/rustc_hir_analysis/src/collect.rs

@@ -42,6 +42,7 @@ use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
 use rustc_trait_selection::error_reporting::traits::suggestions::NextTypeParamName;
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::ObligationCtxt;
+use rustc_type_ir::visit::collect_referenced_late_bound_regions;
 use tracing::{debug, instrument};
 
 use crate::check::intrinsic::intrinsic_operation_unsafety;
@@ -635,11 +636,10 @@ fn get_new_lifetime_name<'tcx>(
     poly_trait_ref: ty::PolyTraitRef<'tcx>,
     generics: &hir::Generics<'tcx>,
 ) -> String {
-    let existing_lifetimes = tcx
-        .collect_referenced_late_bound_regions(poly_trait_ref)
+    let existing_lifetimes = collect_referenced_late_bound_regions(tcx, poly_trait_ref)
         .into_iter()
         .filter_map(|lt| {
-            if let ty::BoundRegionKind::Named(_, name) = lt {
+            if let ty::BoundRegionKind::Named(_, name) = lt.kind {
                 Some(name.as_str().to_string())
             } else {
                 None

compiler/rustc_hir_analysis/src/constrained_generic_params.rs

@@ -3,7 +3,7 @@ use rustc_middle::bug;
 use rustc_middle::ty::visit::{TypeSuperVisitable, TypeVisitor};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::Span;
-use rustc_type_ir::fold::TypeFoldable;
+use rustc_type_ir::fold::{TypeFoldable, expand_weak_alias_tys};
 use tracing::debug;
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
@@ -51,7 +51,7 @@ pub(crate) fn parameters_for<'tcx>(
     include_nonconstraining: bool,
 ) -> Vec<Parameter> {
     let mut collector = ParameterCollector { parameters: vec![], include_nonconstraining };
-    let value = if !include_nonconstraining { tcx.expand_weak_alias_tys(value) } else { value };
+    let value = if !include_nonconstraining { expand_weak_alias_tys(tcx, value) } else { value };
     value.visit_with(&mut collector);
     collector.parameters
 }

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -11,7 +11,10 @@ use rustc_middle::bug;
 use rustc_middle::ty::{self as ty, IsSuggestable, Ty, TyCtxt};
 use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol, kw, sym};
 use rustc_trait_selection::traits;
-use rustc_type_ir::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor};
+use rustc_type_ir::visit::{
+    TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
+    collect_constrained_late_bound_regions, collect_referenced_late_bound_regions,
+};
 use smallvec::SmallVec;
 use tracing::{debug, instrument};
 
@@ -358,9 +361,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 //     for<'a> <T as Iterator>::Item = &'a str // <-- 'a is bad
                 //     for<'a> <T as FnMut<(&'a u32,)>>::Output = &'a str // <-- 'a is ok
                 let late_bound_in_projection_ty =
-                    tcx.collect_constrained_late_bound_regions(projection_term);
+                    collect_constrained_late_bound_regions(tcx, projection_term);
                 let late_bound_in_term =
-                    tcx.collect_referenced_late_bound_regions(trait_ref.rebind(term));
+                    collect_referenced_late_bound_regions(tcx, trait_ref.rebind(term));
                 debug!(?late_bound_in_projection_ty);
                 debug!(?late_bound_in_term);
 

compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs

@@ -13,6 +13,9 @@ use rustc_span::{ErrorGuaranteed, Span};
 use rustc_trait_selection::error_reporting::traits::report_dyn_incompatibility;
 use rustc_trait_selection::traits::{self, hir_ty_lowering_dyn_compatibility_violations};
 use rustc_type_ir::elaborate::ClauseWithSupertraitSpan;
+use rustc_type_ir::visit::{
+    collect_constrained_late_bound_regions, collect_referenced_late_bound_regions,
+};
 use smallvec::{SmallVec, smallvec};
 use tracing::{debug, instrument};
 
@@ -362,10 +365,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         //
         //     for<'a> <T as Iterator>::Item = &'a str // <-- 'a is bad
         //     for<'a> <T as FnMut<(&'a u32,)>>::Output = &'a str // <-- 'a is ok
-        let late_bound_in_projection_term =
-            tcx.collect_constrained_late_bound_regions(pred.map_bound(|pred| pred.projection_term));
+        let late_bound_in_projection_term = collect_constrained_late_bound_regions(
+            tcx,
+            pred.map_bound(|pred| pred.projection_term),
+        );
         let late_bound_in_term =
-            tcx.collect_referenced_late_bound_regions(pred.map_bound(|pred| pred.term));
+            collect_referenced_late_bound_regions(tcx, pred.map_bound(|pred| pred.term));
         debug!(?late_bound_in_projection_term);
         debug!(?late_bound_in_term);
 

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -49,6 +49,9 @@ use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::wf::object_region_bounds;
 use rustc_trait_selection::traits::{self, ObligationCtxt};
+use rustc_type_ir::visit::{
+    collect_constrained_late_bound_regions, collect_referenced_late_bound_regions,
+};
 use tracing::{debug, instrument};
 
 use crate::bounds::Bounds;
@@ -2606,9 +2609,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         //     for<'a> fn(&'a String) -> &'a str <-- 'a is ok
         let inputs = bare_fn_ty.inputs();
         let late_bound_in_args =
-            tcx.collect_constrained_late_bound_regions(inputs.map_bound(|i| i.to_owned()));
+            collect_constrained_late_bound_regions(tcx, inputs.map_bound(|i| i.to_owned()));
         let output = bare_fn_ty.output();
-        let late_bound_in_ret = tcx.collect_referenced_late_bound_regions(output);
+        let late_bound_in_ret = collect_referenced_late_bound_regions(tcx, output);
 
         self.validate_late_bound_regions(late_bound_in_args, late_bound_in_ret, |br_name| {
             struct_span_code_err!(
@@ -2665,12 +2668,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     #[instrument(level = "trace", skip(self, generate_err))]
     fn validate_late_bound_regions<'cx>(
         &'cx self,
-        constrained_regions: FxIndexSet<ty::BoundRegionKind>,
-        referenced_regions: FxIndexSet<ty::BoundRegionKind>,
+        constrained_regions: FxIndexSet<ty::BoundRegion>,
+        referenced_regions: FxIndexSet<ty::BoundRegion>,
         generate_err: impl Fn(&str) -> Diag<'cx>,
     ) {
         for br in referenced_regions.difference(&constrained_regions) {
-            let br_name = match *br {
+            let br_name = match br.kind {
                 ty::BoundRegionKind::Named(_, kw::UnderscoreLifetime)
                 | ty::BoundRegionKind::Anon
                 | ty::BoundRegionKind::ClosureEnv => "an anonymous lifetime".to_string(),
@@ -2680,7 +2683,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             let mut err = generate_err(&br_name);
 
             if let ty::BoundRegionKind::Named(_, kw::UnderscoreLifetime)
-            | ty::BoundRegionKind::Anon = *br
+            | ty::BoundRegionKind::Anon = br.kind
             {
                 // The only way for an anonymous lifetime to wind up
                 // in the return type but **also** be unconstrained is

compiler/rustc_middle/src/ty/util.rs

@@ -6,7 +6,6 @@ use rustc_abi::{ExternAbi, Float, Integer, IntegerType, Size};
 use rustc_apfloat::Float as _;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::stable_hasher::{Hash128, HashStable, StableHasher};
-use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind, Res};
@@ -895,30 +894,6 @@ impl<'tcx> TyCtxt<'tcx> {
             || self.extern_crate(key).is_some_and(|e| e.is_direct())
     }
 
-    /// Expand any [weak alias types][weak] contained within the given `value`.
-    ///
-    /// This should be used over other normalization routines in situations where
-    /// it's important not to normalize other alias types and where the predicates
-    /// on the corresponding type alias shouldn't be taken into consideration.
-    ///
-    /// Whenever possible **prefer not to use this function**! Instead, use standard
-    /// normalization routines or if feasible don't normalize at all.
-    ///
-    /// This function comes in handy if you want to mimic the behavior of eager
-    /// type alias expansion in a localized manner.
-    ///
-    /// <div class="warning">
-    /// This delays a bug on overflow! Therefore you need to be certain that the
-    /// contained types get fully normalized at a later stage. Note that even on
-    /// overflow all well-behaved weak alias types get expanded correctly, so the
-    /// result is still useful.
-    /// </div>
-    ///
-    /// [weak]: ty::Weak
-    pub fn expand_weak_alias_tys<T: TypeFoldable<TyCtxt<'tcx>>>(self, value: T) -> T {
-        value.fold_with(&mut WeakAliasTypeExpander { tcx: self, depth: 0 })
-    }
-
     /// Peel off all [weak alias types] in this type until there are none left.
     ///
     /// This only expands weak alias types in “head” / outermost positions. It can
@@ -1088,42 +1063,6 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for OpaqueTypeExpander<'tcx> {
     }
 }
 
-struct WeakAliasTypeExpander<'tcx> {
-    tcx: TyCtxt<'tcx>,
-    depth: usize,
-}
-
-impl<'tcx> TypeFolder<TyCtxt<'tcx>> for WeakAliasTypeExpander<'tcx> {
-    fn cx(&self) -> TyCtxt<'tcx> {
-        self.tcx
-    }
-
-    fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        if !ty.has_type_flags(ty::TypeFlags::HAS_TY_WEAK) {
-            return ty;
-        }
-        let ty::Alias(ty::Weak, alias) = ty.kind() else {
-            return ty.super_fold_with(self);
-        };
-        if !self.tcx.recursion_limit().value_within_limit(self.depth) {
-            let guar = self.tcx.dcx().delayed_bug("overflow expanding weak alias type");
-            return Ty::new_error(self.tcx, guar);
-        }
-
-        self.depth += 1;
-        ensure_sufficient_stack(|| {
-            self.tcx.type_of(alias.def_id).instantiate(self.tcx, alias.args).fold_with(self)
-        })
-    }
-
-    fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
-        if !ct.has_type_flags(ty::TypeFlags::HAS_TY_WEAK) {
-            return ct;
-        }
-        ct.super_fold_with(self)
-    }
-}
-
 /// Indicates the form of `AsyncDestruct::Destructor`. Used to simplify async
 /// drop glue for types not using async drop.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]

compiler/rustc_middle/src/ty/visit.rs

@@ -1,7 +1,5 @@
 use std::ops::ControlFlow;
 
-use rustc_data_structures::fx::FxIndexSet;
-use rustc_type_ir::fold::TypeFoldable;
 pub use rustc_type_ir::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor};
 
 use crate::ty::{self, Binder, Ty, TyCtxt, TypeFlags};
@@ -102,114 +100,6 @@ impl<'tcx> TyCtxt<'tcx> {
 
         value.visit_with(&mut RegionVisitor { outer_index: ty::INNERMOST, callback }).is_break()
     }
-
-    /// Returns a set of all late-bound regions that are constrained
-    /// by `value`, meaning that if we instantiate those LBR with
-    /// variables and equate `value` with something else, those
-    /// variables will also be equated.
-    pub fn collect_constrained_late_bound_regions<T>(
-        self,
-        value: Binder<'tcx, T>,
-    ) -> FxIndexSet<ty::BoundRegionKind>
-    where
-        T: TypeFoldable<TyCtxt<'tcx>>,
-    {
-        self.collect_late_bound_regions(value, true)
-    }
-
-    /// Returns a set of all late-bound regions that appear in `value` anywhere.
-    pub fn collect_referenced_late_bound_regions<T>(
-        self,
-        value: Binder<'tcx, T>,
-    ) -> FxIndexSet<ty::BoundRegionKind>
-    where
-        T: TypeFoldable<TyCtxt<'tcx>>,
-    {
-        self.collect_late_bound_regions(value, false)
-    }
-
-    fn collect_late_bound_regions<T>(
-        self,
-        value: Binder<'tcx, T>,
-        just_constrained: bool,
-    ) -> FxIndexSet<ty::BoundRegionKind>
-    where
-        T: TypeFoldable<TyCtxt<'tcx>>,
-    {
-        let mut collector = LateBoundRegionsCollector::new(just_constrained);
-        let value = value.skip_binder();
-        let value = if just_constrained { self.expand_weak_alias_tys(value) } else { value };
-        value.visit_with(&mut collector);
-        collector.regions
-    }
-}
-
-/// Collects all the late-bound regions at the innermost binding level
-/// into a hash set.
-struct LateBoundRegionsCollector {
-    current_index: ty::DebruijnIndex,
-    regions: FxIndexSet<ty::BoundRegionKind>,
-
-    /// `true` if we only want regions that are known to be
-    /// "constrained" when you equate this type with another type. In
-    /// particular, if you have e.g., `&'a u32` and `&'b u32`, equating
-    /// them constraints `'a == 'b`. But if you have `<&'a u32 as
-    /// Trait>::Foo` and `<&'b u32 as Trait>::Foo`, normalizing those
-    /// types may mean that `'a` and `'b` don't appear in the results,
-    /// so they are not considered *constrained*.
-    just_constrained: bool,
-}
-
-impl LateBoundRegionsCollector {
-    fn new(just_constrained: bool) -> Self {
-        Self { current_index: ty::INNERMOST, regions: Default::default(), just_constrained }
-    }
-}
-
-impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for LateBoundRegionsCollector {
-    fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(&mut self, t: &Binder<'tcx, T>) {
-        self.current_index.shift_in(1);
-        t.super_visit_with(self);
-        self.current_index.shift_out(1);
-    }
-
-    fn visit_ty(&mut self, t: Ty<'tcx>) {
-        if self.just_constrained {
-            match t.kind() {
-                // If we are only looking for "constrained" regions, we have to ignore the
-                // inputs to a projection as they may not appear in the normalized form.
-                ty::Alias(ty::Projection | ty::Inherent | ty::Opaque, _) => {
-                    return;
-                }
-                // All weak alias types should've been expanded beforehand.
-                ty::Alias(ty::Weak, _) => bug!("unexpected weak alias type"),
-                _ => {}
-            }
-        }
-
-        t.super_visit_with(self)
-    }
-
-    fn visit_const(&mut self, c: ty::Const<'tcx>) {
-        // if we are only looking for "constrained" region, we have to
-        // ignore the inputs of an unevaluated const, as they may not appear
-        // in the normalized form
-        if self.just_constrained {
-            if let ty::ConstKind::Unevaluated(..) = c.kind() {
-                return;
-            }
-        }
-
-        c.super_visit_with(self)
-    }
-
-    fn visit_region(&mut self, r: ty::Region<'tcx>) {
-        if let ty::ReBound(debruijn, br) = *r {
-            if debruijn == self.current_index {
-                self.regions.insert(br.kind);
-            }
-        }
-    }
 }
 
 /// Finds the max universe present

compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/util.rs

@@ -6,6 +6,7 @@ use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_middle::ty::fold::fold_regions;
 use rustc_middle::ty::{self, Binder, Region, Ty, TyCtxt, TypeFoldable};
 use rustc_span::Span;
+use rustc_type_ir::visit::collect_referenced_late_bound_regions;
 use tracing::instrument;
 
 use crate::error_reporting::infer::nice_region_error::NiceRegionError;
@@ -142,10 +143,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
         ty: Binder<'tcx, impl TypeFoldable<TyCtxt<'tcx>>>,
         region_def_id: DefId,
     ) -> bool {
-        let late_bound_regions = self.tcx().collect_referenced_late_bound_regions(ty);
-        // We are only checking is any region meets the condition so order doesn't matter
-        #[allow(rustc::potential_query_instability)]
-        late_bound_regions.iter().any(|r| match *r {
+        collect_referenced_late_bound_regions(self.tcx(), ty).iter().any(|r| match r.kind {
             ty::BoundRegionKind::Named(def_id, _) => def_id == region_def_id,
             _ => false,
         })

compiler/rustc_type_ir/src/data_structures/mod.rs

@@ -11,6 +11,9 @@ mod delayed_map;
 #[cfg(feature = "nightly")]
 mod impl_ {
     pub use rustc_data_structures::sso::{SsoHashMap, SsoHashSet};
+    pub mod fx {
+        pub use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
+    }
     pub use rustc_data_structures::stack::ensure_sufficient_stack;
     pub use rustc_data_structures::sync::Lrc;
 }
@@ -19,6 +22,11 @@ mod impl_ {
 mod impl_ {
     pub use std::collections::{HashMap as SsoHashMap, HashSet as SsoHashSet};
     pub use std::sync::Arc as Lrc;
+    pub mod fx {
+        pub use std::collections::{HashMap as FxHashMap, HashSet as FxHashSet};
+
+        pub use indexmap::{IndexMap as FxIndexMap, IndexSet as FxIndexSet};
+    }
 
     #[inline]
     pub fn ensure_sufficient_stack<R>(f: impl FnOnce() -> R) -> R {