Auto merge of #140558 - lcnr:wf-emit-projection, r=<try>

wf: emit projection goal for aliases

To check that their normalization succeeds in the current environment. This eagerly detects ambiguous and diverging aliases.

Fixes #102252, fixes #126268 by removing the assertion in `min_specialization.rs`.

r? `@compiler-errors`

Author: bors

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1508,12 +1508,14 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
             // E.g: `struct Foo<const N: usize, const M: usize = { 1 - 2 }>;`. Here, we should
             // eagerly error but we don't as we have `ConstKind::Unevaluated(.., [N, M])`.
             if !default.has_param() {
-                wfcx.register_wf_obligation(
-                    tcx.def_span(param.def_id),
-                    matches!(param.kind, GenericParamDefKind::Type { .. })
-                        .then(|| WellFormedLoc::Ty(param.def_id.expect_local())),
-                    default.as_term().unwrap(),
-                );
+                let span = tcx.def_span(param.def_id);
+                let wf_loc = matches!(param.kind, GenericParamDefKind::Type { .. })
+                    .then(|| WellFormedLoc::Ty(param.def_id.expect_local()));
+                // We manually normalize the default to detect diverging or ambiguous aliases.
+                // This is not necessary with the new solver as it adds a requirement that
+                // aliases can be normalized when proving the `WellFormed` goal itself.
+                let _ = wfcx.normalize(span, wf_loc, default);
+                wfcx.register_wf_obligation(span, wf_loc, default.as_term().unwrap());
             } else {
                 // If we've got a generic const parameter we still want to check its
                 // type is correct in case both it and the param type are fully concrete.

compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs

@@ -381,8 +381,6 @@ fn check_predicates<'tcx>(
         let obligations =
             wf::obligations(infcx, tcx.param_env(impl1_def_id), impl1_def_id, 0, term, span)
                 .unwrap();
-
-        assert!(!obligations.has_infer());
         impl2_predicates
             .extend(traits::elaborate(tcx, obligations).map(|obligation| obligation.predicate))
     }

compiler/rustc_hir_typeck/src/fn_ctxt/inspect_obligations.rs

@@ -39,7 +39,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.type_matches_expected_vid(expected_vid, data.self_ty())
             }
             ty::PredicateKind::Clause(ty::ClauseKind::Projection(data)) => {
-                self.type_matches_expected_vid(expected_vid, data.projection_term.self_ty())
+                match data.projection_term.kind(self.tcx) {
+                    ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst => {
+                        self.type_matches_expected_vid(expected_vid, data.projection_term.self_ty())
+                    }
+                    ty::AliasTermKind::InherentTy
+                    | ty::AliasTermKind::InherentConst
+                    | ty::AliasTermKind::OpaqueTy
+                    | ty::AliasTermKind::FreeTy
+                    | ty::AliasTermKind::FreeConst
+                    | ty::AliasTermKind::UnevaluatedConst => false,
+                }
             }
             ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(..))
             | ty::PredicateKind::Subtype(..)

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -510,8 +510,6 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
             let obligations = self.nominal_obligations(data.def_id, args);
             self.out.extend(obligations);
         }
-
-        data.args.visit_with(self);
     }
 
     fn add_wf_preds_for_projection_args(&mut self, args: GenericArgsRef<'tcx>) {
@@ -772,13 +770,35 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                 // Simple cases that are WF if their type args are WF.
             }
 
-            ty::Alias(ty::Projection | ty::Opaque | ty::Free, data) => {
-                let obligations = self.nominal_obligations(data.def_id, data.args);
-                self.out.extend(obligations);
-            }
-            ty::Alias(ty::Inherent, data) => {
-                self.add_wf_preds_for_inherent_projection(data.into());
-                return; // Subtree handled by compute_inherent_projection.
+            ty::Alias(kind, data) => {
+                // The new solver require aliases to normalize successfully.
+                // Adding this `ProjectionPredicate` makes sure that ambiguous or
+                // overflowing aliases cause an error in wf-check.
+                if self.infcx.next_trait_solver() && !data.has_escaping_bound_vars() {
+                    let code = ObligationCauseCode::Misc;
+                    let cause = self.cause(code);
+                    let inf = self.infcx.next_ty_var(cause.span);
+                    let obligation: traits::PredicateObligation<'tcx> =
+                        traits::Obligation::with_depth(
+                            self.tcx(),
+                            cause,
+                            self.recursion_depth,
+                            self.param_env,
+                            ty::ProjectionPredicate {
+                                projection_term: data.into(),
+                                term: inf.into(),
+                            },
+                        );
+                    self.out.push(obligation);
+                }
+
+                match kind {
+                    ty::Projection | ty::Opaque | ty::Free => {
+                        let obligations = self.nominal_obligations(data.def_id, data.args);
+                        self.out.extend(obligations);
+                    }
+                    ty::Inherent => self.add_wf_preds_for_inherent_projection(data.into()),
+                }
             }
 
             ty::Adt(def, args) => {

tests/crashes/102252.rs

@@ -1,5 +1,5 @@
 error: overflow evaluating associated type `T::This`
-  --> $DIR/normalization-overflow.rs:9:17
+  --> $DIR/normalization-overflow.rs:12:17
    |
 LL |     type This = Self::This;
    |                 ^^^^^^^^^^

tests/crashes/126268.rs

@@ -0,0 +1,17 @@
+error[E0271]: type mismatch resolving `T::This normalizes-to _`
+  --> $DIR/normalization-overflow.rs:12:17
+   |
+LL |     type This = Self::This;
+   |                 ^^^^^^^^^^ types differ
+
+error[E0271]: type mismatch resolving `T::This normalizes-to _`
+  --> $DIR/normalization-overflow.rs:12:17
+   |
+LL |     type This = Self::This;
+   |                 ^^^^^^^^^^ types differ
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0271`.

tests/ui/associated-inherent-types/normalization-overflow.stderr renamed to tests/ui/associated-inherent-types/normalization-overflow.current.stderr

@@ -1,3 +1,6 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
 #![feature(inherent_associated_types)]
 #![allow(incomplete_features)]
 
@@ -6,7 +9,9 @@
 struct T;
 
 impl T {
-    type This = Self::This; //~ ERROR overflow evaluating associated type `T::This`
+    type This = Self::This;
+    //[current]~^ ERROR overflow evaluating associated type `T::This`
+    //[next]~^^ ERROR type mismatch resolving `T::This normalizes-to _`
 }
 
 fn main() {}

tests/ui/associated-inherent-types/normalization-overflow.next.stderr

@@ -35,7 +35,15 @@ LL |     let _: <() as Trait>::Output = ();
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 4 previous errors
+error[E0271]: type mismatch resolving `<() as Trait>::Output normalizes-to _`
+  --> $DIR/assoc-ty.rs:15:12
+   |
+LL |     let _: <() as Trait>::Output = ();
+   |            ^^^^^^^^^^^^^^^^^^^^^ types differ
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0271, E0380, E0658.
 For more information about an error, try `rustc --explain E0271`.