Combine individual limit queries into single limits query

Author: Aaron1011

compiler/rustc_interface/src/passes.rs

@@ -872,13 +872,11 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
                 });
             },
             {
-                // Mark the attributes as used, and ensure that
-                // they're not ill-formed. We force these queries
-                // to run, since they might not otherwise get called.
-                tcx.ensure().recursion_limit(());
-                tcx.ensure().move_size_limit(());
-                tcx.ensure().type_length_limit(());
-                tcx.ensure().const_eval_limit(());
+                // We force these querie to run,
+                // since they might not otherwise get called.
+                // This marks the corresponding crate-level attributes
+                // as used, and ensures that their values are valid.
+                tcx.ensure().limits(());
             }
         );
     });

compiler/rustc_middle/src/middle/limits.rs

@@ -12,20 +12,29 @@
 use crate::bug;
 use crate::ty;
 use rustc_ast::Attribute;
-use rustc_session::Limit;
 use rustc_session::Session;
+use rustc_session::{Limit, Limits};
 use rustc_span::symbol::{sym, Symbol};
 
 use std::num::IntErrorKind;
 
 pub fn provide(providers: &mut ty::query::Providers) {
-    providers.recursion_limit = |tcx, ()| get_recursion_limit(tcx.hir().krate_attrs(), tcx.sess);
-    providers.move_size_limit =
-        |tcx, ()| get_limit(tcx.hir().krate_attrs(), tcx.sess, sym::move_size_limit, 0).0;
-    providers.type_length_limit =
-        |tcx, ()| get_limit(tcx.hir().krate_attrs(), tcx.sess, sym::type_length_limit, 1048576);
-    providers.const_eval_limit =
-        |tcx, ()| get_limit(tcx.hir().krate_attrs(), tcx.sess, sym::const_eval_limit, 1_000_000);
+    providers.limits = |tcx, ()| Limits {
+        recursion_limit: get_recursion_limit(tcx.hir().krate_attrs(), tcx.sess),
+        move_size_limit: get_limit(tcx.hir().krate_attrs(), tcx.sess, sym::move_size_limit, 0),
+        type_length_limit: get_limit(
+            tcx.hir().krate_attrs(),
+            tcx.sess,
+            sym::type_length_limit,
+            1048576,
+        ),
+        const_eval_limit: get_limit(
+            tcx.hir().krate_attrs(),
+            tcx.sess,
+            sym::const_eval_limit,
+            1_000_000,
+        ),
+    }
 }
 
 pub fn get_recursion_limit(krate_attrs: &[Attribute], sess: &Session) -> Limit {

compiler/rustc_middle/src/query/mod.rs

@@ -1713,25 +1713,7 @@ rustc_queries! {
         desc { "conservatively checking if {:?} is privately uninhabited", key }
     }
 
-    /// The maximum recursion limit for potentially infinitely recursive
-    /// operations such as auto-dereference and monomorphization.
-    query recursion_limit(key: ()) -> Limit {
-        desc { "looking up recursion limit" }
-    }
-
-    /// The size at which the `large_assignments` lint starts
-    /// being emitted.
-    query move_size_limit(key: ()) -> usize {
-        desc { "looking up move size limit" }
-    }
-
-    /// The maximum length of types during monomorphization.
-    query type_length_limit(key: ()) -> Limit {
-        desc { "looking up type length limit" }
-    }
-
-    /// The maximum blocks a const expression can evaluate.
-    query const_eval_limit(key: ()) -> Limit {
-        desc { "looking up const eval limit" }
+    query limits(key: ()) -> Limits {
+        desc { "looking up limits" }
     }
 }

compiler/rustc_middle/src/ty/context.rs

@@ -53,6 +53,7 @@ use rustc_middle::ty::OpaqueTypeKey;
 use rustc_serialize::opaque::{FileEncodeResult, FileEncoder};
 use rustc_session::config::{BorrowckMode, CrateType, OutputFilenames};
 use rustc_session::lint::{Level, Lint};
+use rustc_session::Limit;
 use rustc_session::Session;
 use rustc_span::def_id::StableCrateId;
 use rustc_span::source_map::MultiSpan;
@@ -1569,6 +1570,22 @@ impl<'tcx> TyCtxt<'tcx> {
             def_kind => (def_kind.article(), def_kind.descr(def_id)),
         }
     }
+
+    pub fn type_length_limit(self) -> Limit {
+        self.limits(()).type_length_limit
+    }
+
+    pub fn recursion_limit(self) -> Limit {
+        self.limits(()).recursion_limit
+    }
+
+    pub fn move_size_limit(self) -> Limit {
+        self.limits(()).move_size_limit
+    }
+
+    pub fn const_eval_limit(self) -> Limit {
+        self.limits(()).const_eval_limit
+    }
 }
 
 /// A trait implemented for all `X<'a>` types that can be safely and

compiler/rustc_middle/src/ty/layout.rs

@@ -221,7 +221,7 @@ fn layout_raw<'tcx>(
     ty::tls::with_related_context(tcx, move |icx| {
         let (param_env, ty) = query.into_parts();
 
-        if !tcx.recursion_limit(()).value_within_limit(icx.layout_depth) {
+        if !tcx.recursion_limit().value_within_limit(icx.layout_depth) {
             tcx.sess.fatal(&format!("overflow representing the type `{}`", ty));
         }
 

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -1437,7 +1437,7 @@ impl<F: fmt::Write> Printer<'tcx> for FmtPrinter<'_, 'tcx, F> {
     }
 
     fn print_type(mut self, ty: Ty<'tcx>) -> Result<Self::Type, Self::Error> {
-        let type_length_limit = self.tcx.type_length_limit(());
+        let type_length_limit = self.tcx.type_length_limit();
         if type_length_limit.value_within_limit(self.printed_type_count) {
             self.printed_type_count += 1;
             self.pretty_print_type(ty)

compiler/rustc_middle/src/ty/query/mod.rs

@@ -49,7 +49,7 @@ use rustc_serialize::opaque;
 use rustc_session::config::{EntryFnType, OptLevel, OutputFilenames, SymbolManglingVersion};
 use rustc_session::utils::NativeLibKind;
 use rustc_session::CrateDisambiguator;
-use rustc_session::Limit;
+use rustc_session::Limits;
 use rustc_target::spec::PanicStrategy;
 
 use rustc_ast as ast;

compiler/rustc_middle/src/ty/util.rs

@@ -206,7 +206,7 @@ impl<'tcx> TyCtxt<'tcx> {
         mut ty: Ty<'tcx>,
         normalize: impl Fn(Ty<'tcx>) -> Ty<'tcx>,
     ) -> Ty<'tcx> {
-        let recursion_limit = self.recursion_limit(());
+        let recursion_limit = self.recursion_limit();
         for iteration in 0.. {
             if !recursion_limit.value_within_limit(iteration) {
                 return self.ty_error_with_message(

compiler/rustc_mir/src/const_eval/eval_queries.rs

@@ -98,7 +98,7 @@ pub(super) fn mk_eval_cx<'mir, 'tcx>(
         tcx,
         root_span,
         param_env,
-        CompileTimeInterpreter::new(tcx.const_eval_limit(())),
+        CompileTimeInterpreter::new(tcx.const_eval_limit()),
         MemoryExtra { can_access_statics },
     )
 }
@@ -300,7 +300,7 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
         tcx,
         tcx.def_span(def.did),
         key.param_env,
-        CompileTimeInterpreter::new(tcx.const_eval_limit(())),
+        CompileTimeInterpreter::new(tcx.const_eval_limit()),
         // Statics (and promoteds inside statics) may access other statics, because unlike consts
         // they do not have to behave "as if" they were evaluated at runtime.
         MemoryExtra { can_access_statics: is_static },

compiler/rustc_mir/src/interpret/eval_context.rs

@@ -392,7 +392,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             tcx: tcx.at(root_span),
             param_env,
             memory: Memory::new(tcx, memory_extra),
-            recursion_limit: tcx.recursion_limit(()),
+            recursion_limit: tcx.recursion_limit(),
         }
     }