Use a reduced recursion limit in the MIR inliner's cycle breaker

saethlin · saethlin · commit 950437a035aa · 2024-08-28T19:52:23.000-04:00
diff --git a/compiler/rustc_mir_transform/src/inline/cycle.rs b/compiler/rustc_mir_transform/src/inline/cycle.rs
@@ -135,6 +135,14 @@ pub(crate) fn mir_callgraph_reachable<'tcx>(
         }
         false
     }
+    // FIXME(-Znext-solver): Remove this hack when trait solver overflow can return an error.
+    // In code like that pointed out in #128887, the type complexity we ask the solver to deal with
+    // grows as we recurse into the call graph. If we use the same recursion limit here and in the
+    // solver, the solver hits the limit first and emits a fatal error. But if we use a reduced
+    // limit, we will hit the limit first and give up on looking for inlining. And in any case,
+    // the default recursion limits are quite generous for us. If we need to recurse 64 times
+    // into the call graph, we're probably not going to find any useful MIR inlining.
+    let recursion_limit = tcx.recursion_limit() / 2;
     process(
         tcx,
         param_env,
@@ -143,7 +151,7 @@ pub(crate) fn mir_callgraph_reachable<'tcx>(
         &mut Vec::new(),
         &mut FxHashSet::default(),
         &mut FxHashMap::default(),
-        tcx.recursion_limit(),
+        recursion_limit,
     )
 }
 

Original file line number	Diff line number	Diff line change
`@@ -135,6 +135,14 @@ pub(crate) fn mir_callgraph_reachable<'tcx>(`
`135`	`135`	`}`
`136`	`136`	`false`
`137`	`137`	`}`
	`138`	`+ // FIXME(-Znext-solver): Remove this hack when trait solver overflow can return an error.`
	`139`	`+ // In code like that pointed out in #128887, the type complexity we ask the solver to deal with`
	`140`	`+ // grows as we recurse into the call graph. If we use the same recursion limit here and in the`
	`141`	`+ // solver, the solver hits the limit first and emits a fatal error. But if we use a reduced`
	`142`	`+ // limit, we will hit the limit first and give up on looking for inlining. And in any case,`
	`143`	`+ // the default recursion limits are quite generous for us. If we need to recurse 64 times`
	`144`	`+ // into the call graph, we're probably not going to find any useful MIR inlining.`
	`145`	`+ let recursion_limit = tcx.recursion_limit() / 2;`
`138`	`146`	`process(`
`139`	`147`	`tcx,`
`140`	`148`	`param_env,`
`@@ -143,7 +151,7 @@ pub(crate) fn mir_callgraph_reachable<'tcx>(`
`143`	`151`	`&mut Vec::new(),`
`144`	`152`	`&mut FxHashSet::default(),`
`145`	`153`	`&mut FxHashMap::default(),`
`146`		`- tcx.recursion_limit(),`
	`154`	`+ recursion_limit,`
`147`	`155`	`)`
`148`	`156`	`}`
`149`	`157`