Auto merge of #140313 - lcnr:wf-normalize-first, r=<try>

change false trivial bounds detection

fixes #140309

TODO

r? `@compiler-errors`

Author: bors

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -19,9 +19,8 @@ use rustc_middle::query::Providers;
 use rustc_middle::traits::solve::NoSolution;
 use rustc_middle::ty::trait_def::TraitSpecializationKind;
 use rustc_middle::ty::{
-    self, AdtKind, GenericArgKind, GenericArgs, GenericParamDefKind, Ty, TyCtxt, TypeFlags,
-    TypeFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode,
-    Upcast,
+    self, AdtKind, GenericArgKind, GenericArgs, GenericParamDefKind, Ty, TyCtxt, TypeFoldable,
+    TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode, Upcast,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::parse::feature_err;
@@ -111,16 +110,17 @@ where
 
     let mut wfcx = WfCheckingCtxt { ocx, span, body_def_id, param_env };
 
-    if !tcx.features().trivial_bounds() {
-        wfcx.check_false_global_bounds()
-    }
     f(&mut wfcx)?;
 
     let errors = wfcx.select_all_or_error();
     if !errors.is_empty() {
         return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
     }
 
+    if !tcx.features().trivial_bounds() {
+        wfcx.check_false_global_bounds()?;
+    }
+
     let assumed_wf_types = wfcx.ocx.assumed_wf_types_and_report_errors(param_env, body_def_id)?;
     debug!(?assumed_wf_types);
 
@@ -2274,7 +2274,7 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
     /// Feature gates RFC 2056 -- trivial bounds, checking for global bounds that
     /// aren't true.
     #[instrument(level = "debug", skip(self))]
-    fn check_false_global_bounds(&mut self) {
+    fn check_false_global_bounds(&mut self) -> Result<(), ErrorGuaranteed> {
         let tcx = self.ocx.infcx.tcx;
         let mut span = self.span;
         let empty_env = ty::ParamEnv::empty();
@@ -2283,17 +2283,22 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
         // Check elaborated bounds.
         let implied_obligations = traits::elaborate(tcx, predicates_with_span);
 
+        let mut global_obligations = vec![];
         for (pred, obligation_span) in implied_obligations {
             // We lower empty bounds like `Vec<dyn Copy>:` as
             // `WellFormed(Vec<dyn Copy>)`, which will later get checked by
             // regular WF checking
             if let ty::ClauseKind::WellFormed(..) = pred.kind().skip_binder() {
                 continue;
             }
-            // Match the existing behavior.
-            if pred.is_global() && !pred.has_type_flags(TypeFlags::HAS_BINDER_VARS) {
-                let pred = self.normalize(span, None, pred);
-
+            // Match the existing behavior. We normalize first to handle where-bounds
+            // like `u32: Trait<Assoc = T>`.
+            let clause = ObligationCause::misc(span, self.body_def_id);
+            let Ok(pred) = self.deeply_normalize(&clause, self.param_env, pred) else {
+                tcx.dcx().delayed_bug("encountered errors when normalizing where-clauses");
+                continue;
+            };
+            if pred.is_global() && pred.kind().bound_vars().is_empty() {
                 // only use the span of the predicate clause (#90869)
                 let hir_node = tcx.hir_node_by_def_id(self.body_def_id);
                 if let Some(hir::Generics { predicates, .. }) = hir_node.generics() {
@@ -2315,9 +2320,17 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
                     empty_env,
                     pred,
                 );
-                self.ocx.register_obligation(obligation);
+                global_obligations.push(obligation);
             }
         }
+
+        self.register_obligations(global_obligations);
+        let errors = self.select_all_or_error();
+        if !errors.is_empty() {
+            Err(self.infcx.err_ctxt().report_fulfillment_errors(errors))
+        } else {
+            Ok(())
+        }
     }
 }
 

tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty-not-wf.rs

@@ -12,8 +12,7 @@ fn take(
         K = { () }
     >,
 ) {}
-//~^^^^^^ ERROR implementation of `Project` is not general enough
-//~^^^^ ERROR higher-ranked subtype error
+//~^^^ ERROR higher-ranked subtype error
 //~| ERROR higher-ranked subtype error
 
 trait Project { type Out; }

tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty-not-wf.stderr

@@ -12,14 +12,5 @@ LL |         K = { () }
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: implementation of `Project` is not general enough
-  --> $DIR/assoc-const-eq-bound-var-in-ty-not-wf.rs:9:4
-   |
-LL | fn take(
-   |    ^^^^ implementation of `Project` is not general enough
-   |
-   = note: `Project` would have to be implemented for the type `for<'a> fn(&'a str) -> &'a str`
-   = note: ...but `Project` is actually implemented for the type `fn(&'0 str) -> &'0 str`, for some specific lifetime `'0`
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 

tests/ui/associated-types/issue-69398.rs

@@ -1,4 +1,5 @@
 //@ check-pass
+#![feature(trivial_bounds)]
 
 pub trait Foo {
     type Bar;

tests/ui/consts/issue-67696-const-prop-ice.rs

@@ -2,7 +2,7 @@
 //@ compile-flags: --emit=mir,link -Zmir-opt-level=4
 // Checks that we don't ICE due to attempting to run const prop
 // on a function with unsatisifable 'where' clauses
-
+#![feature(trivial_bounds)]
 #![allow(unused)]
 
 trait A {

tests/ui/feature-gates/feature-gate-trivial_bounds.rs

@@ -60,9 +60,7 @@ fn return_str() -> str where str: Sized { //~ ERROR
     *"Sized".to_string().into_boxed_str()
 }
 
-// This is currently accepted because the function pointer isn't
-// considered global.
-fn global_hr(x: fn(&())) where fn(&()): Foo { // OK
+fn global_hr(x: fn(&())) where fn(&()): Foo { //~ ERROR
     x.test();
 }
 

tests/ui/feature-gates/feature-gate-trivial_bounds.stderr

@@ -145,6 +145,19 @@ help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
 LL + #![feature(trivial_bounds)]
    |
 
-error: aborting due to 11 previous errors
+error[E0277]: the trait bound `for<'a> fn(&'a ()): Foo` is not satisfied
+  --> $DIR/feature-gate-trivial_bounds.rs:63:32
+   |
+LL | fn global_hr(x: fn(&())) where fn(&()): Foo {
+   |                                ^^^^^^^^^^^^ the trait `Foo` is not implemented for `for<'a> fn(&'a ())`
+   |
+   = help: the trait `Foo` is implemented for `()`
+   = help: see issue #48214
+help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+   |
+LL + #![feature(trivial_bounds)]
+   |
+
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0277`.

tests/ui/issues/issue-36839.rs

@@ -1,4 +1,5 @@
 //@ check-pass
+#![feature(trivial_bounds)]
 
 pub trait Foo {
     type Bar;

tests/ui/issues/issue-42796.rs

@@ -1,3 +1,4 @@
+#![feature(trivial_bounds)]
 pub trait Mirror<Smoke> {
     type Image;
 }

tests/ui/issues/issue-42796.stderr

@@ -1,5 +1,5 @@
 error[E0382]: borrow of moved value: `s`
-  --> $DIR/issue-42796.rs:18:20
+  --> $DIR/issue-42796.rs:19:20
    |
 LL |     let s = "Hello!".to_owned();
    |         - move occurs because `s` has type `String`, which does not implement the `Copy` trait