move limit to rustc_ast_ir

Author: lcnr

compiler/rustc_ast/src/lib.rs

@@ -44,6 +44,8 @@ pub mod token;
 pub mod tokenstream;
 pub mod visit;
 
+pub use rustc_ast_ir::Limit;
+
 pub use self::ast::*;
 pub use self::ast_traits::{AstDeref, AstNodeWrapper, HasAttrs, HasNodeId, HasTokens};
 

compiler/rustc_ast_ir/src/lib.rs

@@ -5,6 +5,9 @@
 #![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
+use std::fmt;
+use std::ops::{Div, Mul};
+
 #[cfg(feature = "nightly")]
 use rustc_macros::{Decodable, Encodable, HashStable_NoContext};
 
@@ -86,3 +89,51 @@ pub enum Pinnedness {
     Not,
     Pinned,
 }
+
+/// New-type wrapper around `usize` for representing limits. Ensures that comparisons against
+/// limits are consistent throughout the compiler.
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "nightly", derive(Encodable, Decodable, HashStable_NoContext))]
+pub struct Limit(pub usize);
+
+impl Limit {
+    /// Create a new limit from a `usize`.
+    pub fn new(value: usize) -> Self {
+        Limit(value)
+    }
+
+    /// Check that `value` is within the limit. Ensures that the same comparisons are used
+    /// throughout the compiler, as mismatches can cause ICEs, see #72540.
+    #[inline]
+    pub fn value_within_limit(&self, value: usize) -> bool {
+        value <= self.0
+    }
+}
+
+impl From<usize> for Limit {
+    fn from(value: usize) -> Self {
+        Self::new(value)
+    }
+}
+
+impl fmt::Display for Limit {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl Div<usize> for Limit {
+    type Output = Limit;
+
+    fn div(self, rhs: usize) -> Self::Output {
+        Limit::new(self.0 / rhs)
+    }
+}
+
+impl Mul<usize> for Limit {
+    type Output = Limit;
+
+    fn mul(self, rhs: usize) -> Self::Output {
+        Limit::new(self.0 * rhs)
+    }
+}

compiler/rustc_errors/src/diagnostic_impls.rs

@@ -6,6 +6,7 @@ use std::path::{Path, PathBuf};
 use std::process::ExitStatus;
 
 use rustc_abi::TargetDataLayoutErrors;
+use rustc_ast::Limit;
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_ast_pretty::pprust;
 use rustc_macros::Subdiagnostic;
@@ -190,6 +191,12 @@ impl IntoDiagArg for PathBuf {
     }
 }
 
+impl IntoDiagArg for Limit {
+    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+        self.to_string().into_diag_arg()
+    }
+}
+
 impl IntoDiagArg for PanicStrategy {
     fn into_diag_arg(self) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(self.desc().to_string()))

compiler/rustc_middle/src/ty/context.rs

@@ -305,8 +305,8 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.parent(def_id)
     }
 
-    fn recursion_limit(self) -> usize {
-        self.recursion_limit().0
+    fn recursion_limit(self) -> Limit {
+        self.recursion_limit()
     }
 
     type Features = &'tcx rustc_feature::Features;

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs

@@ -168,7 +168,7 @@ where
         if !self.is_normalizes_to_goal {
             let num_non_region_vars =
                 canonical.variables.iter().filter(|c| !c.is_region() && c.is_existential()).count();
-            if num_non_region_vars > self.cx().recursion_limit() {
+            if !self.cx().recursion_limit().value_within_limit(num_non_region_vars) {
                 debug!(?num_non_region_vars, "too many inference variables -> overflow");
                 return Ok(self.make_ambiguous_response_no_constraints(MaybeCause::Overflow {
                     suggest_increasing_limit: true,

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -1,6 +1,7 @@
 use std::ops::ControlFlow;
 
 use derive_where::derive_where;
+use rustc_ast_ir::Limit;
 #[cfg(feature = "nightly")]
 use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
 use rustc_type_ir::data_structures::{HashMap, HashSet, ensure_sufficient_stack};
@@ -148,7 +149,7 @@ pub trait SolverDelegateEvalExt: SolverDelegate {
     /// in coherence checking.
     fn root_goal_may_hold_with_depth(
         &self,
-        root_depth: usize,
+        root_depth: Limit,
         goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
     ) -> bool;
 
@@ -182,7 +183,7 @@ where
 
     fn root_goal_may_hold_with_depth(
         &self,
-        root_depth: usize,
+        root_depth: Limit,
         goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
     ) -> bool {
         self.probe(|| {
@@ -227,7 +228,7 @@ where
     /// over using this manually (such as [`SolverDelegateEvalExt::evaluate_root_goal`]).
     pub(super) fn enter_root<R>(
         delegate: &D,
-        root_depth: usize,
+        root_depth: Limit,
         generate_proof_tree: GenerateProofTree,
         f: impl FnOnce(&mut EvalCtxt<'_, D>) -> R,
     ) -> (R, Option<inspect::GoalEvaluation<I>>) {

compiler/rustc_session/src/session.rs

@@ -1,11 +1,11 @@
 use std::any::Any;
-use std::ops::{Div, Mul};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
-use std::{env, fmt, io};
+use std::{env, io};
 
+pub use rustc_ast::Limit;
 use rustc_data_structures::flock;
 use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
 use rustc_data_structures::profiling::{SelfProfiler, SelfProfilerRef};
@@ -58,59 +58,6 @@ pub enum CtfeBacktrace {
     Immediate,
 }
 
-/// New-type wrapper around `usize` for representing limits. Ensures that comparisons against
-/// limits are consistent throughout the compiler.
-#[derive(Clone, Copy, Debug, HashStable_Generic)]
-pub struct Limit(pub usize);
-
-impl Limit {
-    /// Create a new limit from a `usize`.
-    pub fn new(value: usize) -> Self {
-        Limit(value)
-    }
-
-    /// Check that `value` is within the limit. Ensures that the same comparisons are used
-    /// throughout the compiler, as mismatches can cause ICEs, see #72540.
-    #[inline]
-    pub fn value_within_limit(&self, value: usize) -> bool {
-        value <= self.0
-    }
-}
-
-impl From<usize> for Limit {
-    fn from(value: usize) -> Self {
-        Self::new(value)
-    }
-}
-
-impl fmt::Display for Limit {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl Div<usize> for Limit {
-    type Output = Limit;
-
-    fn div(self, rhs: usize) -> Self::Output {
-        Limit::new(self.0 / rhs)
-    }
-}
-
-impl Mul<usize> for Limit {
-    type Output = Limit;
-
-    fn mul(self, rhs: usize) -> Self::Output {
-        Limit::new(self.0 * rhs)
-    }
-}
-
-impl rustc_errors::IntoDiagArg for Limit {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
-        self.to_string().into_diag_arg()
-    }
-}
-
 #[derive(Clone, Copy, Debug, HashStable_Generic)]
 pub struct Limits {
     /// The maximum recursion limit for potentially infinitely recursive

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -6,6 +6,7 @@
 
 use std::fmt::Debug;
 
+use rustc_ast_ir::Limit;
 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_errors::{Diag, EmissionGuarantee};
 use rustc_hir::def::DefKind;
@@ -350,8 +351,10 @@ fn impl_intersection_has_impossible_obligation<'a, 'cx, 'tcx>(
         // a very low recursion depth and bail if any of them don't
         // hold.
         if !obligations.iter().all(|o| {
-            <&SolverDelegate<'tcx>>::from(infcx)
-                .root_goal_may_hold_with_depth(8, Goal::new(infcx.tcx, o.param_env, o.predicate))
+            <&SolverDelegate<'tcx>>::from(infcx).root_goal_may_hold_with_depth(
+                Limit(8),
+                Goal::new(infcx.tcx, o.param_env, o.predicate),
+            )
         }) {
             return IntersectionHasImpossibleObligations::Yes;
         }

compiler/rustc_type_ir/src/interner.rs

@@ -2,7 +2,7 @@ use std::fmt::Debug;
 use std::hash::Hash;
 use std::ops::Deref;
 
-use rustc_ast_ir::Movability;
+use rustc_ast_ir::{Limit, Movability};
 use rustc_index::bit_set::DenseBitSet;
 use smallvec::SmallVec;
 
@@ -177,7 +177,7 @@ pub trait Interner:
 
     fn parent(self, def_id: Self::DefId) -> Self::DefId;
 
-    fn recursion_limit(self) -> usize;
+    fn recursion_limit(self) -> Limit;
 
     type Features: Features<Self>;
     fn features(self) -> Self::Features;

compiler/rustc_type_ir/src/search_graph/mod.rs

@@ -18,6 +18,7 @@ use std::hash::Hash;
 use std::marker::PhantomData;
 
 use derive_where::derive_where;
+use rustc_ast_ir::Limit;
 use rustc_index::{Idx, IndexVec};
 use tracing::debug;
 
@@ -142,6 +143,11 @@ impl UsageKind {
 
 #[derive(Debug, Clone, Copy)]
 struct AvailableDepth(usize);
+impl From<Limit> for AvailableDepth {
+    fn from(Limit(value): Limit) -> AvailableDepth {
+        AvailableDepth(value)
+    }
+}
 impl AvailableDepth {
     /// Returns the remaining depth allowed for nested goals.
     ///
@@ -368,9 +374,9 @@ pub struct SearchGraph<D: Delegate<Cx = X>, X: Cx = <D as Delegate>::Cx> {
 }
 
 impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
-    pub fn new(root_depth: usize) -> SearchGraph<D> {
+    pub fn new(recursion_limit: Limit) -> SearchGraph<D> {
         Self {
-            root_depth: AvailableDepth(root_depth),
+            root_depth: recursion_limit.into(),
             stack: Default::default(),
             provisional_cache: Default::default(),
             _marker: PhantomData,