Change:
File: snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details
cc removing the println macro from around the match avoids the ice :thinking:
Fun :)
A more minimal version would be:

Discussion:
) { let sccs = self.regioncx.constraint_sccs(); let universal_regions = self.regioncx.universal_regions(); <del> let issuing_region_scc = sccs.scc(issuing_region); </del> // We first handle the cases where the loan doesn't go out of scope, depending on the issuing // region's successors. <del> for scc in sccs.depth_first_search(issuing_region_scc) { </del> <ins> for successor in self.regioncx.region_graph().depth_first_search(issuing_region) { </ins> // 1. Via applied member constraints // // The issuing region can flow into the choice regions, and they are either:

// For additional insurance via fuzzing and crater, we verify that the constraint's min // choice indeed escapes the function. In the future, we could e.g. turn this check into // a debug assert and early return as an optimization. <ins> let scc = sccs.scc(successor); </ins> for constraint in self.regioncx.applied_member_constraints(scc) { if universal_regions.is_universal_region(constraint.min_choice) { return;

// // If the issuing region outlives such a region, its loan escapes the function and // cannot go out of scope. We can early return. <del> if self.regioncx.scc_is_live_at_all_points(scc) { </del> <ins> if self.regioncx.is_region_live_at_all_points(successor) { </ins> return; } }

use rustc_middle::ty::{self, RegionVid, Ty, TyCtxt, TypeFoldable, TypeVisitableExt}; use rustc_span::Span; <ins> use crate::constraints::graph::{self, NormalConstraintGraph, RegionGraph}; </ins> use crate::dataflow::BorrowIndex; use crate::{ <del> constraints::{ graph::NormalConstraintGraph, ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet, }, </del> <ins> constraints::{ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet}, </ins> diagnostics::{RegionErrorKind, RegionErrors, UniverseInfo}, member_constraints::{MemberConstraintSet, NllMemberConstraintIndex}, nll::PoloniusOutput,

self.constraint_sccs.as_ref() } <del> /// Returns whether the given SCC is live at all points: whether the representative is a </del> <ins> /// Access to the region graph, built from the outlives constraints. pub(crate) fn region_graph(&self) -> RegionGraph<'_, 'tcx, graph::Normal> { self.constraint_graph.region_graph(&self.constraints, self.universal_regions.fr_static) } /// Returns whether the given region is considered live at all points: whether it is a </ins> /// placeholder or a free region. <del> pub(crate) fn scc_is_live_at_all_points(&self, scc: ConstraintSccIndex) -> bool { </del> <ins> pub(crate) fn is_region_live_at_all_points(&self, region: RegionVid) -> bool { </ins> // FIXME: there must be a cleaner way to find this information. At least, when // higher-ranked subtyping is abstracted away from the borrowck main path, we'll only // need to check whether this is a universal region. <del> let representative = self.scc_representatives[scc]; let origin = self.var_infos[representative].origin; </del> <ins> let origin = self.region_definition(region).origin; </ins> let live_at_all_points = matches!( origin, <del> RegionVariableOrigin::Nll( NllRegionVariableOrigin::Placeholder(_) | NllRegionVariableOrigin::FreeRegion ) </del> <ins> NllRegionVariableOrigin::Placeholder(_) | NllRegionVariableOrigin::FreeRegion </ins> ); live_at_all_points }

<ins> error[E0597]: `a` does not live long enough --> $DIR/location-insensitive-scopes-issue-117146.rs:10:18 | LL |     let b = |_| &a; |             --- -^ |             |   || |             |   |borrowed value does not live long enough |             |   returning this value requires that `a` is borrowed for `'static` |             value captured here ... LL | } | - `a` dropped here while still borrowed | note: due to current limitations in the borrow checker, this implies a `'static` lifetime --> $DIR/location-insensitive-scopes-issue-117146.rs:20:22 | LL | fn bad<F: Fn(&()) -> &()>(_: F) {} |                      ^^^ error: implementation of `Fn` is not general enough --> $DIR/location-insensitive-scopes-issue-117146.rs:13:5 | LL |     bad(&b); |     ^^^^^^^ implementation of `Fn` is not general enough | = note: closure with signature `fn(&'2 ()) -> &()` must implement `Fn<(&'1 (),)>`, for any lifetime `'1`... = note: ...but it actually implements `Fn<(&'2 (),)>`, for some specific lifetime `'2` error: implementation of `FnOnce` is not general enough --> $DIR/location-insensitive-scopes-issue-117146.rs:13:5 | LL |     bad(&b); |     ^^^^^^^ implementation of `FnOnce` is not general enough | = note: closure with signature `fn(&'2 ()) -> &()` must implement `FnOnce<(&'1 (),)>`, for any lifetime `'1`... = note: ...but it actually implements `FnOnce<(&'2 (),)>`, for some specific lifetime `'2` error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0597`. </ins>

<ins> // This is a non-regression test for issue #117146, where NLL and `-Zpolonius=next` computed // different loan scopes when a region flowed into an SCC whose representative was an existential // region. // revisions: nll polonius // [polonius] compile-flags: -Zpolonius=next fn main() { let a = (); let b = |_| &a; //[nll]~^ ERROR `a` does not live long enough //[polonius]~^^ ERROR `a` does not live long enough bad(&b); //[nll]~^ ERROR implementation of `Fn` //[nll]~| ERROR implementation of `FnOnce` //[polonius]~^^^ ERROR implementation of `Fn` //[polonius]~| ERROR implementation of `FnOnce` } fn bad<F: Fn(&()) -> &()>(_: F) {} </ins>