mieeeep

Author: lcnr

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -46,7 +46,7 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
     let tcx = infcx.tcx;
     // We need to eagerly map all regions to NLL vars here, as we need to make sure we've
     // introduced nll vars for all used placeholders.
-    let opaque_types = opaque_types
+    let mut opaque_types = opaque_types
         .into_iter()
         .map(|entry| {
             fold_regions(tcx, infcx.resolve_vars_if_possible(entry), |r, _| {
@@ -84,6 +84,14 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
     let mut scc_values =
         RegionValues::new(location_map, universal_regions.len(), placeholder_indices);
     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)
+        })
+    }
 
     let mut unexpected_hidden_regions = Vec::new();
 
@@ -99,8 +107,7 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
         let mut arg_regions = vec![(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 scc = constraint_sccs.scc(region.as_var());
-                let vid = constraint_sccs.annotation(scc).representative;
+                let vid = region.as_var();
                 if matches!(definitions[vid].origin, NllRegionVariableOrigin::FreeRegion)
                     && !matches!(
                         universal_regions.region_classification(vid),
@@ -117,8 +124,7 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
         debug!(?opaque_type_key, ?hidden_type, "check defining use");
 
         let opaque_type_key = opaque_type_key.fold_captured_lifetime_args(tcx, |region| {
-            let scc = constraint_sccs.scc(region.as_var());
-            let vid = constraint_sccs.annotation(scc).representative;
+            let vid = region.as_var();
             if matches!(definitions[vid].origin, NllRegionVariableOrigin::FreeRegion) {
                 definitions[vid].external_name.unwrap()
             } else {
@@ -174,6 +180,15 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
     }
 
     for &(key, hidden_type) in &opaque_types {
+        if !tcx.use_typing_mode_borrowck() {
+            if let ty::Alias(ty::Opaque, alias_ty) = hidden_type.ty.kind()
+                && alias_ty.def_id == key.def_id.to_def_id()
+                && alias_ty.args == key.args
+            {
+                continue;
+            }
+        }
+
         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");
@@ -257,10 +272,9 @@ struct OpaqueHiddenTypeFolder<'a, 'tcx> {
 
 impl<'tcx> OpaqueHiddenTypeFolder<'_, 'tcx> {
     #[instrument(level = "debug", skip(self))]
-    fn apply_member_constraint(&mut self, r: RegionVid) -> Option<Region<'tcx>> {
-        let member = self.constraint_sccs.scc(r);
-        let r = self.constraint_sccs.annotation(member).representative;
-        if let Some((_, reg)) = self.arg_regions.iter().copied().find(|&(vid, _)| vid == r) {
+    fn apply_member_constraint(&mut self, member_vid: RegionVid) -> Option<Region<'tcx>> {
+        let member = self.constraint_sccs.scc(member_vid);
+        if let Some((_, reg)) = self.arg_regions.iter().copied().find(|&(vid, _)| vid == member_vid) {
             debug!("member equal to arg");
             return Some(reg);
         }