support revealing uses in borrowck

Author: lcnr

compiler/rustc_borrowck/src/diagnostics/opaque_types.rs

@@ -28,31 +28,31 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         if errors.is_empty() {
             return;
         }
+
+        let infcx = self.infcx;
         let mut guar = None;
         let mut last_unexpected_hidden_region: Option<(Span, Ty<'_>, ty::OpaqueTypeKey<'tcx>)> =
             None;
         for error in errors {
             guar = Some(match error {
-                DeferredOpaqueTypeError::InvalidOpaqueTypeArgs(err) => err.report(self.infcx),
+                DeferredOpaqueTypeError::InvalidOpaqueTypeArgs(err) => err.report(infcx),
                 DeferredOpaqueTypeError::LifetimeMismatchOpaqueParam(err) => {
-                    self.infcx.dcx().emit_err(err)
+                    infcx.dcx().emit_err(err)
                 }
                 DeferredOpaqueTypeError::UnexpectedHiddenRegion {
                     opaque_type_key,
                     hidden_type,
                     member_region,
                 } => {
-                    let named_ty = self
-                        .regioncx
-                        .name_regions_for_member_constraint(self.infcx.tcx, hidden_type.ty);
+                    let named_ty =
+                        self.regioncx.name_regions_for_member_constraint(infcx.tcx, hidden_type.ty);
                     let named_key = self
                         .regioncx
-                        .name_regions_for_member_constraint(self.infcx.tcx, opaque_type_key);
-                    let named_region = self
-                        .regioncx
-                        .name_regions_for_member_constraint(self.infcx.tcx, member_region);
+                        .name_regions_for_member_constraint(infcx.tcx, opaque_type_key);
+                    let named_region =
+                        self.regioncx.name_regions_for_member_constraint(infcx.tcx, member_region);
                     let diag = unexpected_hidden_region_diagnostic(
-                        self.infcx,
+                        infcx,
                         self.mir_def_id(),
                         hidden_type.span,
                         named_ty,
@@ -69,6 +69,20 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         diag.delay_as_bug()
                     }
                 }
+                DeferredOpaqueTypeError::NonDefiningUseInDefiningScope {
+                    span,
+                    opaque_type_key,
+                } => infcx.dcx().span_err(
+                    span,
+                    format!(
+                        "non-defining use of `{}` in the defining scope",
+                        Ty::new_opaque(
+                            infcx.tcx,
+                            opaque_type_key.def_id.to_def_id(),
+                            opaque_type_key.args
+                        )
+                    ),
+                ),
             });
         }
         let guar = guar.unwrap();

compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs

@@ -11,7 +11,7 @@ use rustc_macros::extension;
 use rustc_middle::mir::{Body, ConstraintCategory};
 use rustc_middle::ty::{
     self, DefiningScopeKind, FallibleTypeFolder, GenericArg, GenericArgsRef, OpaqueHiddenType,
-    OpaqueTypeKey, Region, RegionVid, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable,
+    OpaqueTypeKey, Region, RegionVid, Ty, TyCtxt, TypeFoldable, TypeSuperFoldable,
     TypeVisitableExt, fold_regions,
 };
 use rustc_mir_dataflow::points::DenseLocationMap;
@@ -49,6 +49,10 @@ pub(crate) enum DeferredOpaqueTypeError<'tcx> {
         /// The unexpected region.
         member_region: Region<'tcx>,
     },
+    NonDefiningUseInDefiningScope {
+        span: Span,
+        opaque_type_key: OpaqueTypeKey<'tcx>,
+    },
 }
 
 pub(crate) fn handle_opaque_type_uses<'tcx>(
@@ -99,7 +103,7 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
         return errors;
     }
 
-    apply_defining_uses(
+    let errors = apply_defining_uses(
         root_cx,
         infcx,
         body,
@@ -123,7 +127,7 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
 
     let _ = infcx.take_opaque_types();
 
-    Vec::new()
+    errors
 }
 
 #[derive(Debug)]
@@ -149,21 +153,26 @@ fn collect_defining_uses<'tcx>(
     let mut errors = vec![];
     for &(opaque_type_key, hidden_type) in opaque_types {
         let non_nll_opaque_type_key = opaque_type_key.fold_captured_lifetime_args(infcx.tcx, |r| {
-            nll_var_to_universal_region(&rcx, r.as_var()).unwrap_or_else(|| {
-                ty::Region::new_error_with_message(
-                    infcx.tcx,
-                    hidden_type.span,
-                    "opaque type with non-universal region args",
-                )
-            })
+            nll_var_to_universal_region(&rcx, r.as_var()).unwrap_or(r)
         });
         if let Err(err) = check_opaque_type_parameter_valid(
             infcx,
             non_nll_opaque_type_key,
             hidden_type.span,
             DefiningScopeKind::MirBorrowck,
         ) {
-            errors.push(DeferredOpaqueTypeError::InvalidOpaqueTypeArgs(err));
+            if tcx.use_typing_mode_borrowck() {
+                match err {
+                    InvalidOpaqueTypeArgs::AlreadyReported(guar) => root_cx
+                        .add_concrete_opaque_type(
+                            opaque_type_key.def_id,
+                            OpaqueHiddenType::new_error(tcx, guar),
+                        ),
+                    _ => debug!(?non_nll_opaque_type_key, ?err, "ignoring non-defining use"),
+                }
+            } else {
+                errors.push(DeferredOpaqueTypeError::InvalidOpaqueTypeArgs(err));
+            }
             continue;
         }
 
@@ -432,16 +441,25 @@ fn apply_defining_uses<'tcx>(
     known_type_outlives_obligations: &[ty::PolyTypeOutlivesPredicate<'tcx>],
     constraints: &mut MirTypeckRegionConstraints<'tcx>,
     opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
-) {
+) -> Vec<DeferredOpaqueTypeError<'tcx>> {
     let tcx = infcx.tcx;
+    let mut errors = Vec::new();
     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_delayed_bug(hidden_type.span, "non-defining use in the defining scope");
-            root_cx.add_concrete_opaque_type(key.def_id, OpaqueHiddenType::new_error(tcx, guar));
-            infcx.set_tainted_by_errors(guar);
-            continue;
+            if tcx.use_typing_mode_borrowck() {
+                errors.push(DeferredOpaqueTypeError::NonDefiningUseInDefiningScope {
+                    span: hidden_type.span,
+                    opaque_type_key: key,
+                });
+                let guar = tcx
+                    .dcx()
+                    .span_delayed_bug(hidden_type.span, "non-defining use in the defining scope");
+                root_cx
+                    .add_concrete_opaque_type(key.def_id, OpaqueHiddenType::new_error(tcx, guar));
+                continue;
+            } else {
+                unreachable!()
+            }
         };
 
         let expected = ty::fold_regions(tcx, expected.instantiate(tcx, key.args), |re, _dbi| {
@@ -480,6 +498,7 @@ fn apply_defining_uses<'tcx>(
             root_cx.add_concrete_opaque_type(key.def_id, OpaqueHiddenType::new_error(tcx, guar));
         }
     }
+    errors
 }
 
 impl<'tcx> RegionInferenceContext<'tcx> {

compiler/rustc_trait_selection/src/opaque_types.rs

@@ -13,6 +13,7 @@ use crate::errors::NonGenericOpaqueTypeParam;
 use crate::regions::OutlivesEnvironmentBuildExt;
 use crate::traits::ObligationCtxt;
 
+#[derive(Debug)]
 pub enum InvalidOpaqueTypeArgs<'tcx> {
     AlreadyReported(ErrorGuaranteed),
     NotAParam { opaque_type_key: OpaqueTypeKey<'tcx>, param_index: usize, span: Span },

tests/ui/impl-trait/member-constraints/apply_member_constraint-no-req-eq.rs

@@ -1,5 +1,7 @@
 //@ check-pass
-// FIXME(-Znext-solver): enable this test
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 
 trait Id {
     type This;

tests/ui/impl-trait/member-constraints/nested-impl-trait-pass.rs

@@ -1,7 +1,9 @@
 // Nested impl-traits can impose different member constraints on the same region variable.
 
 //@ check-pass
-// FIXME(-Znext-solver): enable this test
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 
 trait Cap<'a> {}
 impl<T> Cap<'_> for T {}

tests/ui/impl-trait/no-anonymize-regions.rs

@@ -1,5 +1,7 @@
 //@ check-pass
-// FIXME(-Znext-solver): enable this test
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 
 // A regression test for an error in `redis` while working on #139587.
 //

tests/ui/impl-trait/non-defining-uses/as-projection-term.next.stderr

@@ -1,12 +1,8 @@
-error[E0792]: expected generic lifetime parameter, found `'_`
+error: non-defining use of `impl Sized + '_` in the defining scope
   --> $DIR/as-projection-term.rs:14:19
    |
-LL | fn recur<'a>() -> impl Sized + 'a {
-   |                                -- this generic parameter must be used with a generic lifetime parameter
-...
 LL |     prove_proj(|| recur());
    |                   ^^^^^^^
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0792`.

tests/ui/impl-trait/non-defining-uses/as-projection-term.rs

@@ -12,6 +12,6 @@ fn recur<'a>() -> impl Sized + 'a {
     // inference variable at this point, we unify it with `opaque<'1>` and
     // end up ignoring that defining use as the hidden type is equal to its key.
     prove_proj(|| recur());
-    //[next]~^ ERROR expected generic lifetime parameter, found `'_`
+    //[next]~^ ERROR non-defining use of `impl Sized + '_` in the defining scope
 }
 fn main() {}