rarw

Author: lcnr

compiler/rustc_borrowck/src/dataflow.rs

@@ -1,7 +1,6 @@
 use std::fmt;
 
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_data_structures::graph;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::mir::{
     self, BasicBlock, Body, CallReturnPlaces, Location, Place, TerminatorEdges,

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -58,7 +58,9 @@ pub(crate) use bound_region_errors::{ToUniverseInfo, UniverseInfo};
 pub(crate) use move_errors::{IllegalMoveOriginKind, MoveError};
 pub(crate) use mutability_errors::AccessKind;
 pub(crate) use outlives_suggestion::OutlivesSuggestionBuilder;
-pub(crate) use region_errors::{ErrorConstraintInfo, RegionErrorKind, RegionErrors};
+pub(crate) use region_errors::{
+    ErrorConstraintInfo, RegionErrorKind, RegionErrors, approx_universal_upper_bound,
+};
 pub(crate) use region_name::{RegionName, RegionNameSource};
 pub(crate) use rustc_trait_selection::error_reporting::traits::call_kind::CallKind;
 

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -1,5 +1,6 @@
 //! Error reporting machinery for lifetime errors.
 
+use rustc_data_structures::frozen::Frozen;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::{Applicability, Diag, ErrorGuaranteed, MultiSpan};
 use rustc_hir as hir;
@@ -10,6 +11,7 @@ use rustc_hir::def::Res::Def;
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::{PolyTraitRef, TyKind, WhereBoundPredicate};
+use rustc_index::IndexVec;
 use rustc_infer::infer::{NllRegionVariableOrigin, RelateParamBound};
 use rustc_middle::bug;
 use rustc_middle::hir::place::PlaceBase;
@@ -23,19 +25,20 @@ use rustc_trait_selection::error_reporting::infer::nice_region_error::{
     self, HirTraitObjectVisitor, NiceRegionError, TraitObjectVisitor, find_anon_type,
     find_param_with_region, suggest_adding_lifetime_params,
 };
-use rustc_trait_selection::error_reporting::infer::region::unexpected_hidden_region_diagnostic;
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{Obligation, ObligationCtxt};
 use tracing::{debug, instrument, trace};
 
 use super::{OutlivesSuggestionBuilder, RegionName, RegionNameSource};
+use crate::constraints::ConstraintSccIndex;
 use crate::nll::ConstraintDescription;
-use crate::region_infer::values::RegionElement;
-use crate::region_infer::{BlameConstraint, TypeTest};
+use crate::region_infer::values::{RegionElement, RegionValues};
+use crate::region_infer::{BlameConstraint, ConstraintSccs, RegionDefinition, TypeTest};
 use crate::session_diagnostics::{
     FnMutError, FnMutReturnTypeErr, GenericDoesNotLiveLongEnough, LifetimeOutliveErr,
     LifetimeReturnCategoryErr, RequireStaticErr, VarHereDenote,
 };
+use crate::type_check::free_region_relations::UniversalRegionRelations;
 use crate::universal_regions::DefiningTy;
 use crate::{MirBorrowckCtxt, borrowck_errors, fluent_generated as fluent};
 
@@ -108,18 +111,6 @@ pub(crate) enum RegionErrorKind<'tcx> {
     /// A generic bound failure for a type test (`T: 'a`).
     TypeTestError { type_test: TypeTest<'tcx> },
 
-    /// An unexpected hidden region for an opaque type.
-    UnexpectedHiddenRegion {
-        /// The span for the member constraint.
-        span: Span,
-        /// The hidden type.
-        hidden_ty: Ty<'tcx>,
-        /// The opaque type.
-        key: ty::OpaqueTypeKey<'tcx>,
-        /// The unexpected region.
-        member_region: ty::Region<'tcx>,
-    },
-
     /// Higher-ranked subtyping error.
     BoundUniversalRegionError {
         /// The placeholder free region.
@@ -156,6 +147,64 @@ pub(crate) struct ErrorConstraintInfo<'tcx> {
     pub(super) span: Span,
 }
 
+/// Like `universal_upper_bound`, but returns an approximation more suitable
+/// for diagnostics. If `r` contains multiple disjoint universal regions
+/// (e.g. 'a and 'b in `fn foo<'a, 'b> { ... }`, we pick the lower-numbered region.
+/// This corresponds to picking named regions over unnamed regions
+/// (e.g. picking early-bound regions over a closure late-bound region).
+///
+/// This means that the returned value may not be a true upper bound, since
+/// only 'static is known to outlive disjoint universal regions.
+/// Therefore, this method should only be used in diagnostic code,
+/// where displaying *some* named universal region is better than
+/// falling back to 'static.
+#[instrument(
+    level = "debug",
+    skip(universal_region_relations, constraint_sccs, scc_values, definitions)
+)]
+pub(crate) fn approx_universal_upper_bound<'tcx>(
+    universal_region_relations: &Frozen<UniversalRegionRelations<'tcx>>,
+    constraint_sccs: &ConstraintSccs,
+    scc_values: &RegionValues<ConstraintSccIndex>,
+    definitions: &IndexVec<RegionVid, RegionDefinition<'tcx>>,
+    r: RegionVid,
+) -> RegionVid {
+    // Find the smallest universal region that contains all other
+    // universal regions within `region`.
+    let mut lub = universal_region_relations.universal_regions.fr_fn_body;
+    let r_scc = constraint_sccs.scc(r);
+    let static_r = universal_region_relations.universal_regions.fr_static;
+    for ur in scc_values.universal_regions_outlived_by(r_scc) {
+        let new_lub = universal_region_relations.postdom_upper_bound(lub, ur);
+        debug!(?ur, ?lub, ?new_lub);
+        // The upper bound of two non-static regions is static: this
+        // means we know nothing about the relationship between these
+        // two regions. Pick a 'better' one to use when constructing
+        // a diagnostic
+        if ur != static_r && lub != static_r && new_lub == static_r {
+            // Prefer the region with an `external_name` - this
+            // indicates that the region is early-bound, so working with
+            // it can produce a nicer error.
+            if definitions[ur].external_name.is_some() {
+                lub = ur;
+            } else if definitions[lub].external_name.is_some() {
+                // Leave lub unchanged
+            } else {
+                // If we get here, we don't have any reason to prefer
+                // one region over the other. Just pick the
+                // one with the lower index for now.
+                lub = std::cmp::min(ur, lub);
+            }
+        } else {
+            lub = new_lub;
+        }
+    }
+
+    debug!(?r, ?lub);
+
+    lub
+}
+
 impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     /// Converts a region inference variable into a `ty::Region` that
     /// we can use for error reporting. If `r` is universally bound,
@@ -311,9 +360,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         // buffered in the `MirBorrowckCtxt`.
 
         let mut outlives_suggestion = OutlivesSuggestionBuilder::default();
-        let mut last_unexpected_hidden_region: Option<(Span, Ty<'_>, ty::OpaqueTypeKey<'tcx>)> =
-            None;
-
         for (nll_error, _) in nll_errors.into_iter() {
             match nll_error {
                 RegionErrorKind::TypeTestError { type_test } => {
@@ -363,30 +409,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     }
                 }
 
-                RegionErrorKind::UnexpectedHiddenRegion { span, hidden_ty, key, member_region } => {
-                    let named_ty =
-                        self.regioncx.name_regions_for_member_constraint(self.infcx.tcx, hidden_ty);
-                    let named_key =
-                        self.regioncx.name_regions_for_member_constraint(self.infcx.tcx, key);
-                    let named_region = self
-                        .regioncx
-                        .name_regions_for_member_constraint(self.infcx.tcx, member_region);
-                    let diag = unexpected_hidden_region_diagnostic(
-                        self.infcx,
-                        self.mir_def_id(),
-                        span,
-                        named_ty,
-                        named_region,
-                        named_key,
-                    );
-                    if last_unexpected_hidden_region != Some((span, named_ty, named_key)) {
-                        self.buffer_error(diag);
-                        last_unexpected_hidden_region = Some((span, named_ty, named_key));
-                    } else {
-                        diag.delay_as_bug();
-                    }
-                }
-
                 RegionErrorKind::BoundUniversalRegionError {
                     longer_fr,
                     placeholder,

compiler/rustc_borrowck/src/nll.rs

@@ -6,7 +6,7 @@ use std::rc::Rc;
 use std::str::FromStr;
 
 use polonius_engine::{Algorithm, Output};
-use rustc_index::{IndexSlice, IndexVec};
+use rustc_index::IndexSlice;
 use rustc_middle::mir::pretty::{PrettyPrintMirOptions, dump_mir_with_options};
 use rustc_middle::mir::{Body, PassWhere, Promoted, create_dump_file, dump_enabled, dump_mir};
 use rustc_middle::ty::print::with_no_trimmed_paths;
@@ -26,8 +26,8 @@ use crate::polonius::PoloniusDiagnosticsContext;
 use crate::polonius::legacy::{
     PoloniusFacts, PoloniusFactsExt, PoloniusLocationTable, PoloniusOutput,
 };
+use crate::region_infer::RegionInferenceContext;
 use crate::region_infer::opaque_types::handle_opaque_type_uses;
-use crate::region_infer::{RegionDefinition, RegionInferenceContext};
 use crate::type_check::{self, MirTypeckResults};
 use crate::universal_regions::UniversalRegions;
 use crate::{

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -8,7 +8,7 @@ use rustc_errors::Diag;
 use rustc_hir::def_id::CRATE_DEF_ID;
 use rustc_index::IndexVec;
 use rustc_infer::infer::outlives::test_type_match;
-use rustc_infer::infer::region_constraints::{GenericKind, VarInfos, VerifyBound, VerifyIfEq};
+use rustc_infer::infer::region_constraints::{GenericKind, VerifyBound, VerifyIfEq};
 use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin};
 use rustc_middle::bug;
 use rustc_middle::mir::{
@@ -28,7 +28,6 @@ use crate::dataflow::BorrowIndex;
 use crate::diagnostics::{RegionErrorKind, RegionErrors, UniverseInfo};
 use crate::polonius::LiveLoans;
 use crate::polonius::legacy::PoloniusOutput;
-use crate::region_infer::reverse_sccs::ReverseSccGraph;
 use crate::region_infer::values::{LivenessValues, RegionElement, RegionValues, ToElementIndex};
 use crate::type_check::free_region_relations::UniversalRegionRelations;
 use crate::type_check::{Locations, MirTypeckRegionConstraints};
@@ -870,41 +869,13 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     #[instrument(level = "debug", skip(self))]
     pub(crate) fn approx_universal_upper_bound(&self, r: RegionVid) -> RegionVid {
         debug!("{}", self.region_value_str(r));
-
-        // Find the smallest universal region that contains all other
-        // universal regions within `region`.
-        let mut lub = self.universal_regions().fr_fn_body;
-        let r_scc = self.constraint_sccs.scc(r);
-        let static_r = self.universal_regions().fr_static;
-        for ur in self.scc_values.universal_regions_outlived_by(r_scc) {
-            let new_lub = self.universal_region_relations.postdom_upper_bound(lub, ur);
-            debug!(?ur, ?lub, ?new_lub);
-            // The upper bound of two non-static regions is static: this
-            // means we know nothing about the relationship between these
-            // two regions. Pick a 'better' one to use when constructing
-            // a diagnostic
-            if ur != static_r && lub != static_r && new_lub == static_r {
-                // Prefer the region with an `external_name` - this
-                // indicates that the region is early-bound, so working with
-                // it can produce a nicer error.
-                if self.region_definition(ur).external_name.is_some() {
-                    lub = ur;
-                } else if self.region_definition(lub).external_name.is_some() {
-                    // Leave lub unchanged
-                } else {
-                    // If we get here, we don't have any reason to prefer
-                    // one region over the other. Just pick the
-                    // one with the lower index for now.
-                    lub = std::cmp::min(ur, lub);
-                }
-            } else {
-                lub = new_lub;
-            }
-        }
-
-        debug!(?r, ?lub);
-
-        lub
+        crate::diagnostics::approx_universal_upper_bound(
+            &self.universal_region_relations,
+            &self.constraint_sccs,
+            &self.scc_values,
+            &self.definitions,
+            r,
+        )
     }
 
     /// Tests if `test` is true when applied to `lower_bound` at