gaming

Author: lcnr

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -32,7 +32,7 @@ use crate::constraints::ConstraintSccIndex;
 use crate::type_check::canonical::fully_perform_op_raw;
 use crate::type_check::free_region_relations::UniversalRegionRelations;
 use crate::type_check::{Locations, MirTypeckRegionConstraints};
-use crate::universal_regions::{RegionClassification, UniversalRegions};
+use crate::universal_regions::UniversalRegions;
 use crate::{BorrowCheckRootCtxt, BorrowckInferCtxt, BorrowckState};
 
 pub(crate) enum DeferredOpaqueTypeError<'tcx> {
@@ -261,31 +261,30 @@ fn collect_defining_uses<'tcx>(
 
     let mut defining_uses = vec![];
     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 is_non_external_free_region = |r| {
-            let vid = rcx.representative(r);
-            matches!(rcx.definitions[vid].origin, NllRegionVariableOrigin::FreeRegion)
-                && !matches!(
-                    rcx.universal_regions().region_classification(vid),
-                    Some(RegionClassification::External)
-                )
-        };
-        let arg_regions = opaque_type_key
-            .iter_captured_args(tcx)
-            .filter_map(|(_, arg)| arg.as_region())
-            .map(Region::as_var)
-            .map(|r| if is_non_external_free_region(r) { Some(r) } else { None });
-        let arg_regions =
-            iter::once(Some(rcx.universal_regions().fr_static)).chain(arg_regions).collect();
-
-        if let Some(arg_regions) = arg_regions {
-            defining_uses.push(DefiningUse { opaque_type_key, arg_regions, hidden_type });
+        let non_nll_opaque_type_key =
+            opaque_type_key.fold_captured_lifetime_args(rcx.infcx.tcx, |r| {
+                let vid = rcx.representative(r.as_var());
+                rcx.definitions[vid].external_name.unwrap_or(r)
+            });
+        if let Err(_) = check_opaque_type_parameter_valid(
+            infcx,
+            non_nll_opaque_type_key,
+            hidden_type.span,
+            DefiningScopeKind::MirBorrowck,
+        ) {
+            debug!(?non_nll_opaque_type_key, "not a defining use");
+            continue;
         }
+
+        let arg_regions = iter::once(rcx.universal_regions().fr_static)
+            .chain(
+                opaque_type_key
+                    .iter_captured_args(tcx)
+                    .filter_map(|(_, arg)| arg.as_region())
+                    .map(Region::as_var),
+            )
+            .collect();
+        defining_uses.push(DefiningUse { opaque_type_key, arg_regions, hidden_type });
     }
 
     debug!(?defining_uses);

compiler/rustc_borrowck/src/root_cx.rs

@@ -193,7 +193,10 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
         // never check closures in dead code.
         let nested_bodies = self.tcx.nested_bodies_within(root_def_id);
         for def_id in nested_bodies {
-            let _ = self.get_or_insert_final(def_id);
+            if !self.final_results.contains_key(&def_id) {
+                self.compute_partial_results(def_id);
+                let _ = self.get_or_insert_final(def_id);
+            }
         }
 
         #[allow(rustc::potential_query_instability)]