Auto merge of rust-lang#135899 - compiler-errors:post-borrowck-new-solver, r=<try>

Fix `PostBorrowckAnalysis` for old solver

~~branch name is typo'd~~

This "fixes" the `PostBorrowckAnalysis` mode for the old solver, and begins to use it in `check_opaque_well_formed` and `check_coroutine_obligations`.

There are several curiosities here that result.

r? lcnr

Author: bors

compiler/rustc_hir_analysis/src/check/check.rs

@@ -17,20 +17,17 @@ use rustc_lint_defs::builtin::{
 use rustc_middle::hir::nested_filter;
 use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
 use rustc_middle::middle::stability::EvalResult;
-use rustc_middle::ty::error::TypeErrorToStringExt;
 use rustc_middle::ty::layout::{LayoutError, MAX_SIMD_LANES};
 use rustc_middle::ty::util::{Discr, IntTypeExt};
 use rustc_middle::ty::{
-    AdtDef, BottomUpFolder, GenericArgKind, RegionKind, TypeFoldable, TypeSuperVisitable,
-    TypeVisitable, TypeVisitableExt, fold_regions,
+    AdtDef, GenericArgKind, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, fold_regions,
 };
 use rustc_session::lint::builtin::UNINHABITED_STATIC;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::error_reporting::traits::on_unimplemented::OnUnimplementedDirective;
 use rustc_trait_selection::traits;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 use tracing::{debug, instrument};
-use ty::TypingMode;
 use {rustc_attr_parsing as attr, rustc_hir as hir};
 
 use super::compare_impl_item::check_type_bounds;
@@ -254,14 +251,18 @@ fn check_opaque_meets_bounds<'tcx>(
         | hir::OpaqueTyOrigin::AsyncFn { parent, .. }
         | hir::OpaqueTyOrigin::TyAlias { parent, .. } => parent,
     };
+
+    let misc_cause = ObligationCause::misc(span, def_id);
+
+    // FIXME: We should reveal the TAITs that end up in where clauses here, otherwise we
+    // will not be able to match param-env candidates in the old solver, since we don't
+    // have eq-modulo-normalization. This is less of a problem than it seems, since this
+    // only matters if we have TAITs in where clauses, which isn't achievable with RPIT
+    // anyways.
     let param_env = tcx.param_env(defining_use_anchor);
 
-    // FIXME(#132279): Once `PostBorrowckAnalysis` is supported in the old solver, this branch should be removed.
-    let infcx = tcx.infer_ctxt().build(if tcx.next_trait_solver_globally() {
-        TypingMode::post_borrowck_analysis(tcx, defining_use_anchor)
-    } else {
-        TypingMode::analysis_in_body(tcx, defining_use_anchor)
-    });
+    let infcx =
+        tcx.infer_ctxt().build(TypingMode::post_borrowck_analysis(tcx, defining_use_anchor));
     let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
 
     let args = match origin {
@@ -275,8 +276,6 @@ fn check_opaque_meets_bounds<'tcx>(
         }),
     };
 
-    let opaque_ty = Ty::new_opaque(tcx, def_id.to_def_id(), args);
-
     // `ReErased` regions appear in the "parent_args" of closures/coroutines.
     // We're ignoring them here and replacing them with fresh region variables.
     // See tests in ui/type-alias-impl-trait/closure_{parent_args,wf_outlives}.rs.
@@ -289,19 +288,11 @@ fn check_opaque_meets_bounds<'tcx>(
         _ => re,
     });
 
-    // HACK: We eagerly instantiate some bounds to report better errors for them...
-    // This isn't necessary for correctness, since we register these bounds when
-    // equating the opaque below, but we should clean this up in the new solver.
+    // NOTE: We elaborate the explicit item bounds for better spans.
     for (predicate, pred_span) in
-        tcx.explicit_item_bounds(def_id).iter_instantiated_copied(tcx, args)
+        traits::elaborate(tcx, tcx.explicit_item_bounds(def_id).iter_instantiated_copied(tcx, args))
     {
-        let predicate = predicate.fold_with(&mut BottomUpFolder {
-            tcx,
-            ty_op: |ty| if ty == opaque_ty { hidden_ty } else { ty },
-            lt_op: |lt| lt,
-            ct_op: |ct| ct,
-        });
-
+        let predicate = ocx.normalize(&misc_cause, param_env, predicate);
         ocx.register_obligation(Obligation::new(
             tcx,
             ObligationCause::new(
@@ -314,24 +305,24 @@ fn check_opaque_meets_bounds<'tcx>(
         ));
     }
 
-    let misc_cause = ObligationCause::misc(span, def_id);
-    // FIXME: We should just register the item bounds here, rather than equating.
-    // FIXME(const_trait_impl): When we do that, please make sure to also register
-    // the `~const` bounds.
-    match ocx.eq(&misc_cause, param_env, opaque_ty, hidden_ty) {
-        Ok(()) => {}
-        Err(ty_err) => {
-            // Some types may be left "stranded" if they can't be reached
-            // from a lowered rustc_middle bound but they're mentioned in the HIR.
-            // This will happen, e.g., when a nested opaque is inside of a non-
-            // existent associated type, like `impl Trait<Missing = impl Trait>`.
-            // See <tests/ui/impl-trait/stranded-opaque.rs>.
-            let ty_err = ty_err.to_string(tcx);
-            let guar = tcx.dcx().span_delayed_bug(
-                span,
-                format!("could not unify `{hidden_ty}` with revealed type:\n{ty_err}"),
+    // And check the `~const` bounds for an RPIT.
+    if tcx.is_conditionally_const(def_id) {
+        for (predicate, pred_span) in tcx.const_conditions(def_id).instantiate(tcx, args) {
+            let predicate = ocx.normalize(
+                &misc_cause,
+                param_env,
+                predicate.to_host_effect_clause(tcx, ty::BoundConstness::Maybe),
             );
-            return Err(guar);
+            ocx.register_obligation(Obligation::new(
+                tcx,
+                ObligationCause::new(
+                    span,
+                    def_id,
+                    ObligationCauseCode::OpaqueTypeBound(pred_span, definition_def_id),
+                ),
+                param_env,
+                predicate,
+            ));
         }
     }
 
@@ -353,27 +344,7 @@ fn check_opaque_meets_bounds<'tcx>(
     let wf_tys = ocx.assumed_wf_types_and_report_errors(param_env, defining_use_anchor)?;
     ocx.resolve_regions_and_report_errors(defining_use_anchor, param_env, wf_tys)?;
 
-    if infcx.next_trait_solver() {
-        Ok(())
-    } else if let hir::OpaqueTyOrigin::FnReturn { .. } | hir::OpaqueTyOrigin::AsyncFn { .. } =
-        origin
-    {
-        // HACK: this should also fall through to the hidden type check below, but the original
-        // implementation had a bug where equivalent lifetimes are not identical. This caused us
-        // to reject existing stable code that is otherwise completely fine. The real fix is to
-        // compare the hidden types via our type equivalence/relation infra instead of doing an
-        // identity check.
-        let _ = infcx.take_opaque_types();
-        Ok(())
-    } else {
-        // Check that any hidden types found during wf checking match the hidden types that `type_of` sees.
-        for (mut key, mut ty) in infcx.take_opaque_types() {
-            ty.ty = infcx.resolve_vars_if_possible(ty.ty);
-            key = infcx.resolve_vars_if_possible(key);
-            sanity_check_found_hidden_type(tcx, key, ty)?;
-        }
-        Ok(())
-    }
+    Ok(())
 }
 
 fn best_definition_site_of_opaque<'tcx>(
@@ -461,50 +432,6 @@ fn best_definition_site_of_opaque<'tcx>(
     }
 }
 
-fn sanity_check_found_hidden_type<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    key: ty::OpaqueTypeKey<'tcx>,
-    mut ty: ty::OpaqueHiddenType<'tcx>,
-) -> Result<(), ErrorGuaranteed> {
-    if ty.ty.is_ty_var() {
-        // Nothing was actually constrained.
-        return Ok(());
-    }
-    if let ty::Alias(ty::Opaque, alias) = ty.ty.kind() {
-        if alias.def_id == key.def_id.to_def_id() && alias.args == key.args {
-            // Nothing was actually constrained, this is an opaque usage that was
-            // only discovered to be opaque after inference vars resolved.
-            return Ok(());
-        }
-    }
-    let strip_vars = |ty: Ty<'tcx>| {
-        ty.fold_with(&mut BottomUpFolder {
-            tcx,
-            ty_op: |t| t,
-            ct_op: |c| c,
-            lt_op: |l| match l.kind() {
-                RegionKind::ReVar(_) => tcx.lifetimes.re_erased,
-                _ => l,
-            },
-        })
-    };
-    // Closures frequently end up containing erased lifetimes in their final representation.
-    // These correspond to lifetime variables that never got resolved, so we patch this up here.
-    ty.ty = strip_vars(ty.ty);
-    // Get the hidden type.
-    let hidden_ty = tcx.type_of(key.def_id).instantiate(tcx, key.args);
-    let hidden_ty = strip_vars(hidden_ty);
-
-    // If the hidden types differ, emit a type mismatch diagnostic.
-    if hidden_ty == ty.ty {
-        Ok(())
-    } else {
-        let span = tcx.def_span(key.def_id);
-        let other = ty::OpaqueHiddenType { ty: hidden_ty, span };
-        Err(ty.build_mismatch_error(&other, tcx)?.emit())
-    }
-}
-
 /// Check that the opaque's precise captures list is valid (if present).
 /// We check this for regular `impl Trait`s and also RPITITs, even though the latter
 /// are technically GATs.
@@ -1801,11 +1728,7 @@ pub(super) fn check_coroutine_obligations(
 
     debug!(?typeck_results.coroutine_stalled_predicates);
 
-    let mode = if tcx.next_trait_solver_globally() {
-        TypingMode::post_borrowck_analysis(tcx, def_id)
-    } else {
-        TypingMode::analysis_in_body(tcx, def_id)
-    };
+    let mode = TypingMode::post_borrowck_analysis(tcx, def_id);
 
     let infcx = tcx
         .infer_ctxt()
@@ -1825,15 +1748,5 @@ pub(super) fn check_coroutine_obligations(
         return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
     }
 
-    if !tcx.next_trait_solver_globally() {
-        // Check that any hidden types found when checking these stalled coroutine obligations
-        // are valid.
-        for (key, ty) in infcx.take_opaque_types() {
-            let hidden_type = infcx.resolve_vars_if_possible(ty);
-            let key = infcx.resolve_vars_if_possible(key);
-            sanity_check_found_hidden_type(tcx, key, hidden_type)?;
-        }
-    }
-
     Ok(())
 }

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -711,14 +711,18 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             // Already reported.
             Overflow(OverflowError::Error(guar)) => {
                 self.set_tainted_by_errors(guar);
-                return guar
+                return guar;
             },
 
             Overflow(_) => {
                 bug!("overflow should be handled before the `report_selection_error` path");
             }
 
             SelectionError::ConstArgHasWrongType { ct, ct_ty, expected_ty } => {
+                if let Err(guar) = expected_ty.error_reported() {
+                    return guar;
+                }
+
                 let mut diag = self.dcx().struct_span_err(
                     span,
                     format!("the constant `{ct}` is not of type `{expected_ty}`"),

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -2,7 +2,7 @@
 
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_infer::infer::at::At;
-use rustc_infer::infer::{InferCtxt, InferOk};
+use rustc_infer::infer::{InferCtxt, InferOk, RegionVariableOrigin};
 use rustc_infer::traits::{
     FromSolverError, Normalized, Obligation, PredicateObligations, TraitEngine,
 };
@@ -11,7 +11,7 @@ use rustc_middle::span_bug;
 use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty::{
     self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitable, TypeVisitableExt,
-    TypingMode,
+    TypingMode, fold_regions,
 };
 use tracing::{debug, instrument};
 
@@ -127,11 +127,10 @@ pub(super) fn needs_normalization<'tcx, T: TypeVisitable<TyCtxt<'tcx>>>(
     // Opaques are treated as rigid outside of `TypingMode::PostAnalysis`,
     // so we can ignore those.
     match infcx.typing_mode() {
-        // FIXME(#132279): We likely want to reveal opaques during post borrowck analysis
-        TypingMode::Coherence
-        | TypingMode::Analysis { .. }
-        | TypingMode::PostBorrowckAnalysis { .. } => flags.remove(ty::TypeFlags::HAS_TY_OPAQUE),
-        TypingMode::PostAnalysis => {}
+        TypingMode::Coherence | TypingMode::Analysis { .. } => {
+            flags.remove(ty::TypeFlags::HAS_TY_OPAQUE)
+        }
+        TypingMode::PostBorrowckAnalysis { .. } | TypingMode::PostAnalysis => {}
     }
 
     value.has_type_flags(flags)
@@ -169,6 +168,39 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
 
         if !needs_normalization(self.selcx.infcx, &value) { value } else { value.fold_with(self) }
     }
+
+    fn normalize_opaque_ty(&mut self, ty: Ty<'tcx>, data: ty::AliasTy<'tcx>) -> Ty<'tcx> {
+        let recursion_limit = self.cx().recursion_limit();
+        if !recursion_limit.value_within_limit(self.depth) {
+            self.selcx.infcx.err_ctxt().report_overflow_error(
+                OverflowCause::DeeplyNormalize(data.into()),
+                self.cause.span,
+                true,
+                |_| {},
+            );
+        }
+
+        let args = data.args.fold_with(self);
+        let generic_ty = self.cx().type_of(data.def_id);
+        let mut concrete_ty = generic_ty.instantiate(self.cx(), args);
+
+        if concrete_ty == ty {
+            concrete_ty =
+                Ty::new_error_with_message(self.cx(), self.cause.span, "recursive opaque type");
+        }
+
+        let concrete_ty = fold_regions(self.cx(), concrete_ty, |re, _dbi| match re.kind() {
+            ty::ReErased => self.selcx.infcx.next_region_var_in_universe(
+                RegionVariableOrigin::MiscVariable(self.cause.span),
+                ty::UniverseIndex::ROOT,
+            ),
+            _ => re,
+        });
+        self.depth += 1;
+        let folded_ty = self.fold_ty(concrete_ty);
+        self.depth -= 1;
+        folded_ty
+    }
 }
 
 impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx> {
@@ -223,29 +255,20 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
             ty::Opaque => {
                 // Only normalize `impl Trait` outside of type inference, usually in codegen.
                 match self.selcx.infcx.typing_mode() {
-                    // FIXME(#132279): We likely want to reveal opaques during post borrowck analysis
-                    TypingMode::Coherence
-                    | TypingMode::Analysis { .. }
-                    | TypingMode::PostBorrowckAnalysis { .. } => ty.super_fold_with(self),
-                    TypingMode::PostAnalysis => {
-                        let recursion_limit = self.cx().recursion_limit();
-                        if !recursion_limit.value_within_limit(self.depth) {
-                            self.selcx.infcx.err_ctxt().report_overflow_error(
-                                OverflowCause::DeeplyNormalize(data.into()),
-                                self.cause.span,
-                                true,
-                                |_| {},
-                            );
+                    TypingMode::Coherence | TypingMode::Analysis { .. } => ty.super_fold_with(self),
+                    TypingMode::PostBorrowckAnalysis { defined_opaque_types } => {
+                        if data
+                            .def_id
+                            .as_local()
+                            .is_some_and(|def_id| defined_opaque_types.contains(&def_id))
+                        {
+                            self.normalize_opaque_ty(ty, data)
+                        } else {
+                            // Treat non-defining opaques as rigid
+                            ty.super_fold_with(self)
                         }
-
-                        let args = data.args.fold_with(self);
-                        let generic_ty = self.cx().type_of(data.def_id);
-                        let concrete_ty = generic_ty.instantiate(self.cx(), args);
-                        self.depth += 1;
-                        let folded_ty = self.fold_ty(concrete_ty);
-                        self.depth -= 1;
-                        folded_ty
                     }
+                    TypingMode::PostAnalysis => self.normalize_opaque_ty(ty, data),
                 }
             }