nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-02 15:32:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

traverse region graph instead of SCCs to compute polonius loan scopes

Browse Source 
By using SCC for better performance, we also have to take into account
SCCs whose representative is an existential region but also contains a
placeholder.

By only checking the representative, we may miss that the loan escapes
the function. This can be fixed by picking a better representative, or
removing placeholders from the main path.

This is the simplest fix: forgo efficiency and traverse the region graph
instead of the SCCs.
This commit is contained in:
Rémy Rakic 2023-11-04 00:55:27 +00:00
parent 5020f7c3b8
commit de7a8305ae
2 changed files with 14 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
compiler/rustc_borrowck/src/dataflow.rs
View File

@ -273,11 +273,10 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
) { ) {
let sccs = self.regioncx.constraint_sccs(); let sccs = self.regioncx.constraint_sccs();
let universal_regions = self.regioncx.universal_regions(); let universal_regions = self.regioncx.universal_regions();
let issuing_region_scc = sccs.scc(issuing_region);
// We first handle the cases where the loan doesn't go out of scope, depending on the issuing // We first handle the cases where the loan doesn't go out of scope, depending on the issuing
// region's successors. // region's successors.
for scc in sccs.depth_first_search(issuing_region_scc) { for successor in self.regioncx.region_graph().depth_first_search(issuing_region) {
// 1. Via applied member constraints // 1. Via applied member constraints
// //
// The issuing region can flow into the choice regions, and they are either: // The issuing region can flow into the choice regions, and they are either:
@ -290,6 +289,7 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
// For additional insurance via fuzzing and crater, we verify that the constraint's min // 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 // 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. // a debug assert and early return as an optimization.
let scc = sccs.scc(successor);
for constraint in self.regioncx.applied_member_constraints(scc) { for constraint in self.regioncx.applied_member_constraints(scc) {
if universal_regions.is_universal_region(constraint.min_choice) { if universal_regions.is_universal_region(constraint.min_choice) {
return; return;
@ -300,7 +300,7 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
// //
// If the issuing region outlives such a region, its loan escapes the function and // If the issuing region outlives such a region, its loan escapes the function and
// cannot go out of scope. We can early return. // cannot go out of scope. We can early return.
if self.regioncx.scc_is_live_at_all_points(scc) { if self.regioncx.is_region_live_at_all_points(successor) {
return; return;
} }
} }

21
compiler/rustc_borrowck/src/region_infer/mod.rs
View File

@ -22,11 +22,10 @@ use rustc_middle::traits::ObligationCauseCode;
use rustc_middle::ty::{self, RegionVid, Ty, TyCtxt, TypeFoldable, TypeVisitableExt}; use rustc_middle::ty::{self, RegionVid, Ty, TyCtxt, TypeFoldable, TypeVisitableExt};
use rustc_span::Span; use rustc_span::Span;
use crate::constraints::graph::{self, NormalConstraintGraph, RegionGraph};
use crate::dataflow::BorrowIndex; use crate::dataflow::BorrowIndex;
use crate::{ use crate::{
constraints::{ constraints::{ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet},
graph::NormalConstraintGraph, ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet,
},
diagnostics::{RegionErrorKind, RegionErrors, UniverseInfo}, diagnostics::{RegionErrorKind, RegionErrors, UniverseInfo},
member_constraints::{MemberConstraintSet, NllMemberConstraintIndex}, member_constraints::{MemberConstraintSet, NllMemberConstraintIndex},
nll::PoloniusOutput, nll::PoloniusOutput,
@ -2293,19 +2292,21 @@ impl<'tcx> RegionInferenceContext<'tcx> {
self.constraint_sccs.as_ref() self.constraint_sccs.as_ref()
} }
/// Returns whether the given SCC is live at all points: whether the representative is a /// 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
/// placeholder or a free region. /// placeholder or a free region.
pub(crate) fn scc_is_live_at_all_points(&self, scc: ConstraintSccIndex) -> bool { pub(crate) fn is_region_live_at_all_points(&self, region: RegionVid) -> bool {
// FIXME: there must be a cleaner way to find this information. At least, when // 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 // higher-ranked subtyping is abstracted away from the borrowck main path, we'll only
// need to check whether this is a universal region. // need to check whether this is a universal region.
let representative = self.scc_representatives[scc]; let origin = self.region_definition(region).origin;
let origin = self.var_infos[representative].origin;
let live_at_all_points = matches!( let live_at_all_points = matches!(
origin, origin,
RegionVariableOrigin::Nll( NllRegionVariableOrigin::Placeholder(_) | NllRegionVariableOrigin::FreeRegion
NllRegionVariableOrigin::Placeholder(_) | NllRegionVariableOrigin::FreeRegion
)
); );
live_at_all_points live_at_all_points
} }