temp

lcnr · lcnr · commit 95f24cceab7b · 2025-04-17T23:43:45.000+02:00
diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
@@ -62,18 +62,87 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
             constraints,
             deferred_opaque_type_errors,
             universal_region_relations,
-            Rc::clone(location_map),
+            location_map,
         )
     }
 }
 
+struct RegionCtxt<'a, 'tcx> {
+    infcx: &'a BorrowckInferCtxt<'tcx>,
+    definitions: IndexVec<RegionVid, RegionDefinition<'tcx>>,
+    universal_region_relations: &'a UniversalRegionRelations<'tcx>,
+    constraint_sccs: ConstraintSccs,
+    rev_scc_graph: ReverseSccGraph,
+    scc_values: RegionValues<ConstraintSccIndex>,
+}
+
+impl<'a, 'tcx> RegionCtxt<'a, 'tcx> {
+    fn new(
+        infcx: &'a BorrowckInferCtxt<'tcx>,
+        universal_region_relations: &'a Frozen<UniversalRegionRelations<'tcx>>,
+        location_map: Rc<DenseLocationMap>,
+        constraints: &MirTypeckRegionConstraints<'tcx>,
+    ) -> RegionCtxt<'a, 'tcx> {
+        let mut definitions: IndexVec<_, _> = infcx
+            .get_region_var_infos()
+            .iter()
+            .map(|info| RegionDefinition::new(info.universe, info.origin))
+            .collect();
+
+        for (external_name, variable) in
+            universal_region_relations.universal_regions.named_universal_regions_iter()
+        {
+            definitions[variable].external_name = Some(external_name);
+        }
+
+        let universal_regions = &universal_region_relations.universal_regions;
+        let fr_static = universal_regions.fr_static;
+        let constraint_sccs =
+            constraints.outlives_constraints.compute_sccs(fr_static, &definitions);
+        let rev_scc_graph = ReverseSccGraph::compute(&constraint_sccs, universal_regions);
+        // Unlike the `RegionInferenceContext`, we only care about free regions
+        // and fully ignore liveness and placeholders.
+        let placeholder_indices = Default::default();
+        let mut scc_values =
+            RegionValues::new(location_map, universal_regions.len(), placeholder_indices);
+        for variable in definitions.indices() {
+            let scc = constraint_sccs.scc(variable);
+            match definitions[variable].origin {
+                NllRegionVariableOrigin::FreeRegion => {
+                    scc_values.add_element(scc, variable);
+                }
+                _ => {}
+            }
+        }
+        scc_values.propagate_constraints(&constraint_sccs);
+
+        RegionCtxt {
+            infcx,
+            definitions,
+            universal_region_relations,
+            constraint_sccs,
+            rev_scc_graph,
+            scc_values,
+        }
+    }
+
+    fn representative(&self, vid: RegionVid) -> RegionVid {
+        self.constraint_sccs.scc(vid);
+        rcx.constraint_sccs.annotation(scc).representative
+    }
+
+    fn universal_regions(&self) -> &UniversalRegions<'tcx> {
+        &self.universal_region_relations.universal_regions
+    }
+}
+
 pub(crate) fn handle_opaque_type_uses<'tcx>(
     root_cx: &mut BorrowCheckRootCtxt<'tcx>,
     infcx: &BorrowckInferCtxt<'tcx>,
     constraints: &mut MirTypeckRegionConstraints<'tcx>,
     deferred_errors: &mut Vec<DeferredOpaqueTypeError<'tcx>>,
     universal_region_relations: &Frozen<UniversalRegionRelations<'tcx>>,
-    location_map: Rc<DenseLocationMap>,
+    location_map: &Rc<DenseLocationMap>,
 ) {
     let opaque_types = infcx.take_opaque_types();
     if opaque_types.is_empty() {
@@ -97,114 +166,82 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
         })
         .collect::<Vec<_>>();
 
-    let mut definitions: IndexVec<_, _> = infcx
-        .get_region_var_infos()
-        .iter()
-        .map(|info| RegionDefinition::new(info.universe, info.origin))
-        .collect();
-
-    // Update the names (if any)
-    // This iterator has unstable order but we collect it all into an IndexVec
-    for (external_name, variable) in
-        universal_region_relations.universal_regions.named_universal_regions_iter()
-    {
-        definitions[variable].external_name = Some(external_name);
-    }
+    collect_defining_uses(
+        root_cx,
+        infcx,
+        constraints,
+        deferred_errors,
+        universal_region_relations,
+        location_map,
+        &mut opaque_types,
+    );
+
+    apply_defining_uses(root_cx, infcx, constraints, universal_region_relations, &opaque_types);
+}
 
-    let universal_regions = &universal_region_relations.universal_regions;
-    let fr_static = universal_regions.fr_static;
-    let constraint_sccs = &constraints.outlives_constraints.compute_sccs(fr_static, &definitions);
-    let rev_scc_graph = &ReverseSccGraph::compute(&constraint_sccs, universal_regions);
-    // Unlike the `RegionInferenceContext`, we only care about free regions
-    // and fully ignore liveness and placeholders.
-    let placeholder_indices = Default::default();
-    let mut scc_values =
-        RegionValues::new(location_map, universal_regions.len(), placeholder_indices);
-    for variable in definitions.indices() {
-        let scc = constraint_sccs.scc(variable);
-        match definitions[variable].origin {
-            NllRegionVariableOrigin::FreeRegion => {
-                scc_values.add_element(scc, variable);
-            }
-            _ => {}
-        }
-    }
-    scc_values.propagate_constraints(&constraint_sccs);
-    for entry in &mut opaque_types {
-        // Map all opaque types to their SCC representatives.
-        *entry = fold_regions(tcx, *entry, |r, _| {
-            let scc = constraint_sccs.scc(r.as_var());
-            let vid = constraint_sccs.annotation(scc).representative;
-            Region::new_var(tcx, vid)
-        })
-    }
+fn collect_defining_uses<'tcx>(
+    root_cx: &mut BorrowCheckRootCtxt<'tcx>,
+    infcx: &BorrowckInferCtxt<'tcx>,
+    constraints: &mut MirTypeckRegionConstraints<'tcx>,
+    deferred_errors: &mut Vec<DeferredOpaqueTypeError<'tcx>>,
+    universal_region_relations: &Frozen<UniversalRegionRelations<'tcx>>,
+    location_map: &Rc<DenseLocationMap>,
+    opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
+) {
+    let tcx = infcx.tcx;
+    let rcx = RegionCtxt::new(infcx, universal_region_relations, Rc::clone(location_map), constraints);
 
-    // We start by looking for defining uses of the opaque. These are uses where all arguments
-    // of the opaque are free regions. We apply "member constraints" to its hidden region and
-    // map the hidden type to the definition site of the opaque.
-    'entry: for &(opaque_type_key, hidden_type) in &opaque_types {
+    let mut defining_uses = vec![];
+    'all_uses: for &(opaque_type_key, hidden_type) in opaque_types {
         // Check whether the arguments are fully universal.
         //
         // FIXME: We currently treat `Opaque<'a, 'a>` as a defining use and then emit an error
         // as it's not fully universal. We should share this code with `check_opaque_type_parameter_valid`
         // to only consider actual defining uses as defining.
-        let mut arg_regions = vec![(universal_regions.fr_static, tcx.lifetimes.re_static)];
+        let mut arg_regions = vec![(rcx.universal_regions().fr_static, tcx.lifetimes.re_static)];
         for (_idx, captured_arg) in opaque_type_key.iter_captured_args(tcx) {
-            if let Some(region) = captured_arg.as_region() {
-                let vid = region.as_var();
-                if matches!(definitions[vid].origin, NllRegionVariableOrigin::FreeRegion)
-                    && !matches!(
-                        universal_regions.region_classification(vid),
-                        Some(RegionClassification::External)
-                    )
-                {
-                    arg_regions.push((vid, definitions[vid].external_name.unwrap()));
+            if let Some(r) = captured_arg.as_region() {
+                let vid = rcx.representative(r.as_var());
+                let is_non_external_free_region =
+                    matches!(rcx.definitions[vid].origin, NllRegionVariableOrigin::FreeRegion)
+                        && !matches!(
+                            rcx.universal_regions().region_classification(vid),
+                            Some(RegionClassification::External)
+                        );
+
+                if is_non_external_free_region {
+                    arg_regions.push((vid, rcx.definitions[vid].external_name.unwrap()));
                 } else {
-                    continue 'entry;
+                    continue 'all_uses;
                 }
             }
         }
 
-        debug!(?opaque_type_key, ?hidden_type, "check defining use");
-
-        let opaque_type_key = opaque_type_key.fold_captured_lifetime_args(tcx, |region| {
-            let vid = region.as_var();
-            assert!(matches!(definitions[vid].origin, NllRegionVariableOrigin::FreeRegion));
-            definitions[vid].external_name.unwrap()
-        });
+        defining_uses.push((opaque_type_key, arg_regions, hidden_type))
+    }
 
-        let hidden_type = hidden_type.fold_with(&mut OpaqueHiddenTypeFolder {
-            infcx,
+    debug!(?defining_uses);
 
-            opaque_type_key,
-            hidden_type,
-            deferred_errors,
+    apply_member_constraints();
 
-            arg_regions: &arg_regions,
-            universal_region_relations,
-            constraint_sccs,
-            rev_scc_graph,
-            scc_values: &scc_values,
-        });
-
-        let ty = infcx
-            .infer_opaque_definition_from_instantiation(opaque_type_key, hidden_type)
-            .unwrap_or_else(|err| {
-                deferred_errors.push(DeferredOpaqueTypeError::InvalidOpaqueTypeArgs(err));
-                Ty::new_error_with_message(
-                    tcx,
-                    hidden_type.span,
-                    "deferred invalid opaque type args",
-                )
-            });
-
-        root_cx.add_concrete_opaque_type(
-            opaque_type_key.def_id,
-            OpaqueHiddenType { span: hidden_type.span, ty },
-        );
-    }
+    // Applying member constraints may add new region constraints, so we
+    // need to recompute the region context before actually mapping the defining
+    // uses to the definition site.
+    //
+    // FIXME: We should be able to partially reuse and optimize this.
+    let rcx = RegionCtxt::new(infcx, universal_region_relations, Rc::clone(location_map), constraints)
+    map_defining_uses_to_definition_site();
+}
 
-    for &(key, hidden_type) in &opaque_types {
+fn apply_defining_uses<'tcx>(
+    root_cx: &mut BorrowCheckRootCtxt<'tcx>,
+    infcx: &BorrowckInferCtxt<'tcx>,
+    constraints: &mut MirTypeckRegionConstraints<'tcx>,
+    universal_region_relations: &Frozen<UniversalRegionRelations<'tcx>>,
+    opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
+) {
+    let tcx = infcx.tcx;
+    for &(key, hidden_type) in opaque_types {
         let Some(expected) = root_cx.get_concrete_opaque_type(key.def_id) else {
             let guar =
                 tcx.dcx().span_err(hidden_type.span, "non-defining use in the defining scope");
@@ -223,6 +260,7 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
             }
         });
 
+        let universal_regions = &universal_region_relations.universal_regions;
         let mut relation =
             EquateRegions { infcx, span: hidden_type.span, universal_regions, constraints };
         match TypeRelation::relate(&mut relation, hidden_type.ty, expected.ty) {
@@ -259,23 +297,20 @@ fn to_region_vid<'tcx>(
 }
 
 struct OpaqueHiddenTypeFolder<'a, 'tcx> {
-    infcx: &'a BorrowckInferCtxt<'tcx>,
+    rcx: &'a RegionCtxt<'a, 'tcx>,
+
     // For diagnostics.
     opaque_type_key: OpaqueTypeKey<'tcx>,
     hidden_type: OpaqueHiddenType<'tcx>,
     deferred_errors: &'a mut Vec<DeferredOpaqueTypeError<'tcx>>,
 
     arg_regions: &'a [(RegionVid, Region<'tcx>)],
-    universal_region_relations: &'a UniversalRegionRelations<'tcx>,
-    constraint_sccs: &'a ConstraintSccs,
-    rev_scc_graph: &'a ReverseSccGraph,
-    scc_values: &'a RegionValues<ConstraintSccIndex>,
 }
 
 impl<'tcx> OpaqueHiddenTypeFolder<'_, 'tcx> {
     #[instrument(level = "debug", skip(self))]
     fn apply_member_constraint(&mut self, member_vid: RegionVid) -> Option<Region<'tcx>> {
-        let member = self.constraint_sccs.scc(member_vid);
+        let member = self.rcx.constraint_sccs.scc(member_vid);
         if let Some((_, reg)) = self.arg_regions.iter().copied().find(|&(vid, _)| vid == member_vid)
         {
             debug!("member equal to arg");
@@ -284,7 +319,7 @@ impl<'tcx> OpaqueHiddenTypeFolder<'_, 'tcx> {
 
         // If the member region lives in a higher universe, we currently choose
         // the most conservative option by leaving it unchanged.
-        if !self.constraint_sccs.annotation(member).min_universe().is_root() {
+        if !self.rcx.constraint_sccs.annotation(member).min_universe().is_root() {
             debug!("member not in root universe");
             return None;
         }
@@ -297,8 +332,8 @@ impl<'tcx> OpaqueHiddenTypeFolder<'_, 'tcx> {
             .iter()
             .copied()
             .filter(|&(choice_region, _)| {
-                self.scc_values.universal_regions_outlived_by(member).all(|lower_bound| {
-                    self.universal_region_relations.outlives(choice_region, lower_bound)
+                self.rcx.scc_values.universal_regions_outlived_by(member).all(|lower_bound| {
+                    self.rcx.universal_region_relations.outlives(choice_region, lower_bound)
                 })
             })
             .collect::<Vec<_>>();
@@ -312,9 +347,9 @@ impl<'tcx> OpaqueHiddenTypeFolder<'_, 'tcx> {
         // If we have a requirement `'upper_bound: 'member`, equating `'member`
         // with some region `'choice` means we now also require `'upper_bound: 'choice`.
         // Avoid choice regions for which this does not hold.
-        for ub in self.rev_scc_graph.upper_bounds(member) {
+        for ub in self.rcx.rev_scc_graph.upper_bounds(member) {
             choice_regions.retain(|&(choice_region, _)| {
-                self.universal_region_relations.outlives(ub, choice_region)
+                self.rcx.universal_region_relations.outlives(ub, choice_region)
             });
         }
 
@@ -333,14 +368,14 @@ impl<'tcx> OpaqueHiddenTypeFolder<'_, 'tcx> {
         // `['d, 'e]` are ignored because they do not compare - the same goes for `['a, 'b]`.
         let totally_ordered_subset = choice_regions.iter().copied().filter(|&(r1, _)| {
             choice_regions.iter().all(|&(r2, _)| {
-                self.universal_region_relations.outlives(r1, r2)
-                    || self.universal_region_relations.outlives(r2, r1)
+                self.rcx.universal_region_relations.outlives(r1, r2)
+                    || self.rcx.universal_region_relations.outlives(r2, r1)
             })
         });
         // Now we're left with `['static, 'c]`. Pick `'c` as the minimum!
         let Some((_, min_choice)) = totally_ordered_subset.reduce(|(r1, r1_reg), (r2, r2_reg)| {
-            let r1_outlives_r2 = self.universal_region_relations.outlives(r1, r2);
-            let r2_outlives_r1 = self.universal_region_relations.outlives(r2, r1);
+            let r1_outlives_r2 = self.rcx.universal_region_relations.outlives(r1, r2);
+            let r2_outlives_r1 = self.rcx.universal_region_relations.outlives(r2, r1);
             match (r1_outlives_r2, r2_outlives_r1) {
                 (true, true) => {
                     if r1 < r2 {
@@ -379,7 +414,7 @@ impl<'tcx> OpaqueHiddenTypeFolder<'_, 'tcx> {
 
 impl<'tcx> TypeFolder<TyCtxt<'tcx>> for OpaqueHiddenTypeFolder<'_, 'tcx> {
     fn cx(&self) -> TyCtxt<'tcx> {
-        self.infcx.tcx
+        self.rcx.infcx.tcx
     }
 
     fn fold_region(&mut self, r: Region<'tcx>) -> Region<'tcx> {
