Auto merge of #115787 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum 1.72.1

[stable] 1.72.1 release

This backports:

*  Remove assert that checks type equality #115215
*  implied bounds: do not ICE on unconstrained region vars #115559
*  rustdoc: correctly deal with self ty params when eliding default object lifetimes #115276
*  Stop emitting non-power-of-two vectors in (non-portable-SIMD) codegen #115236
*  Normalize before checking if local is freeze in deduced_param_attrs #114948

Some cherry-picks required merge conflict resolution, we'll see if I got it right based on CI (rustdoc fix and LLVM codegen test).

r? `@Mark-Simulacrum`

5 files changed, 276 insertions, 0 deletions

diff --git a/tests/ui/async-await/deep-futures-are-freeze.rs b/tests/ui/async-await/deep-futures-are-freeze.rs
new file mode 100644
index 00000000000..dd676d5e18c
--- /dev/null
+++ b/tests/ui/async-await/deep-futures-are-freeze.rs
@@ -0,0 +1,179 @@
+// build-pass
+// compile-flags: -Copt-level=s -Clto=fat
+// no-prefer-dynamic
+// edition: 2021
+
+#![recursion_limit = "256"]
+
+fn main() {
+    spawn(move || main0())
+}
+
+fn spawn<F>(future: impl FnOnce() -> F) {
+    future();
+}
+
+async fn main0() {
+    main1().await;
+    main2().await;
+}
+async fn main1() {
+    main2().await;
+    main3().await;
+}
+async fn main2() {
+    main3().await;
+    main4().await;
+}
+async fn main3() {
+    main4().await;
+    main5().await;
+}
+async fn main4() {
+    main5().await;
+    main6().await;
+}
+async fn main5() {
+    main6().await;
+    main7().await;
+}
+async fn main6() {
+    main7().await;
+    main8().await;
+}
+async fn main7() {
+    main8().await;
+    main9().await;
+}
+async fn main8() {
+    main9().await;
+    main10().await;
+}
+async fn main9() {
+    main10().await;
+    main11().await;
+}
+async fn main10() {
+    main11().await;
+    main12().await;
+}
+async fn main11() {
+    main12().await;
+    main13().await;
+}
+async fn main12() {
+    main13().await;
+    main14().await;
+}
+async fn main13() {
+    main14().await;
+    main15().await;
+}
+async fn main14() {
+    main15().await;
+    main16().await;
+}
+async fn main15() {
+    main16().await;
+    main17().await;
+}
+async fn main16() {
+    main17().await;
+    main18().await;
+}
+async fn main17() {
+    main18().await;
+    main19().await;
+}
+async fn main18() {
+    main19().await;
+    main20().await;
+}
+async fn main19() {
+    main20().await;
+    main21().await;
+}
+async fn main20() {
+    main21().await;
+    main22().await;
+}
+async fn main21() {
+    main22().await;
+    main23().await;
+}
+async fn main22() {
+    main23().await;
+    main24().await;
+}
+async fn main23() {
+    main24().await;
+    main25().await;
+}
+async fn main24() {
+    main25().await;
+    main26().await;
+}
+async fn main25() {
+    main26().await;
+    main27().await;
+}
+async fn main26() {
+    main27().await;
+    main28().await;
+}
+async fn main27() {
+    main28().await;
+    main29().await;
+}
+async fn main28() {
+    main29().await;
+    main30().await;
+}
+async fn main29() {
+    main30().await;
+    main31().await;
+}
+async fn main30() {
+    main31().await;
+    main32().await;
+}
+async fn main31() {
+    main32().await;
+    main33().await;
+}
+async fn main32() {
+    main33().await;
+    main34().await;
+}
+async fn main33() {
+    main34().await;
+    main35().await;
+}
+async fn main34() {
+    main35().await;
+    main36().await;
+}
+async fn main35() {
+    main36().await;
+    main37().await;
+}
+async fn main36() {
+    main37().await;
+    main38().await;
+}
+async fn main37() {
+    main38().await;
+    main39().await;
+}
+async fn main38() {
+    main39().await;
+    main40().await;
+}
+async fn main39() {
+    main40().await;
+}
+async fn main40() {
+    boom(&mut ()).await;
+}
+
+async fn boom(f: &mut ()) {}
diff --git a/tests/ui/codegen/subtyping-enforces-type-equality.rs b/tests/ui/codegen/subtyping-enforces-type-equality.rs
new file mode 100644
index 00000000000..a5ffcb3f854
--- /dev/null
+++ b/tests/ui/codegen/subtyping-enforces-type-equality.rs
@@ -0,0 +1,48 @@
+// ignore-pass
+// build-pass
+// edition:2021
+use std::future::Future;
+use std::pin::Pin;
+
+type BoxFuture<T> = Pin<Box<dyn Future<Output = T>>>;
+
+fn main() {
+    let _ = wrapper_call(handler);
+}
+
+async fn wrapper_call(handler: impl Handler) {
+    handler.call().await;
+}
+async fn handler() {
+    f(&()).await;
+}
+async fn f<'a>(db: impl Acquire<'a>) {
+    db.acquire().await;
+}
+
+trait Handler {
+    type Future: Future;
+    fn call(self) -> Self::Future;
+}
+
+impl<Fut, F> Handler for F
+where
+    F: Fn() -> Fut,
+    Fut: Future,
+{
+    type Future = Fut;
+    fn call(self) -> Self::Future {
+        loop {}
+    }
+}
+
+trait Acquire<'a> {
+    type Connection;
+    fn acquire(self) -> BoxFuture<Self::Connection>;
+}
+impl<'a> Acquire<'a> for &'a () {
+    type Connection = Self;
+    fn acquire(self) -> BoxFuture<Self> {
+        loop {}
+    }
+}
diff --git a/tests/ui/codegen/subtyping-enforces-type-equality.stderr b/tests/ui/codegen/subtyping-enforces-type-equality.stderr
new file mode 100644
index 00000000000..870ca0f839f
--- /dev/null
+++ b/tests/ui/codegen/subtyping-enforces-type-equality.stderr
@@ -0,0 +1 @@
+WARN rustc_codegen_ssa::mir::locals Unexpected initial operand type. See the issues/114858
diff --git a/tests/ui/implied-bounds/implied-bounds-unconstrained-1.rs b/tests/ui/implied-bounds/implied-bounds-unconstrained-1.rs
new file mode 100644
index 00000000000..025e5176ff7
--- /dev/null
+++ b/tests/ui/implied-bounds/implied-bounds-unconstrained-1.rs
@@ -0,0 +1,28 @@
+// check-pass
+
+// Regression test for #112832.
+pub trait QueryDb {
+    type Db;
+}
+
+pub struct QueryTable<Q, DB> {
+    db: DB,
+    storage: Q,
+}
+
+// We normalize `<Q as QueryDb>::Db` to `<Q as AsyncQueryFunction<'d>>::SendDb`
+// using the where-bound. 'd is an unconstrained region variable which previously
+// triggered an assert.
+impl<Q> QueryTable<Q, <Q as QueryDb>::Db> where Q: for<'d> AsyncQueryFunction<'d> {}
+
+pub trait AsyncQueryFunction<'d>: QueryDb<Db = <Self as AsyncQueryFunction<'d>>::SendDb> {
+    type SendDb: 'd;
+}
+
+pub trait QueryStorageOpsAsync<Q>
+where
+    Q: for<'d> AsyncQueryFunction<'d>,
+{
+}
+
+fn main() {}
diff --git a/tests/ui/implied-bounds/implied-bounds-unconstrained-2.rs b/tests/ui/implied-bounds/implied-bounds-unconstrained-2.rs
new file mode 100644
index 00000000000..976054facee
--- /dev/null
+++ b/tests/ui/implied-bounds/implied-bounds-unconstrained-2.rs
@@ -0,0 +1,20 @@
+// check-pass
+
+// Another minimized regression test for #112832.
+trait Trait {
+    type Assoc;
+}
+
+trait Sub<'a>: Trait<Assoc = <Self as Sub<'a>>::SubAssoc> {
+    type SubAssoc;
+}
+
+// By using the where-clause we normalize `<T as Trait>::Assoc` to
+// `<T as Sub<'a>>::SubAssoc` where `'a` is an unconstrained region
+// variable.
+fn foo<T>(x: <T as Trait>::Assoc)
+where
+    for<'a> T: Sub<'a>,
+{}
+
+fn main() {}