diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 6e62e50d3af82..190b57ecea4d0 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -1263,6 +1263,21 @@ pub fn suggest_impl_trait<'tcx>(
             infcx.tcx.lang_items().future_output(),
             format_as_assoc,
         ),
+        (
+            infcx.tcx.lang_items().async_fn_trait(),
+            infcx.tcx.lang_items().async_fn_once_output(),
+            format_as_parenthesized,
+        ),
+        (
+            infcx.tcx.lang_items().async_fn_mut_trait(),
+            infcx.tcx.lang_items().async_fn_once_output(),
+            format_as_parenthesized,
+        ),
+        (
+            infcx.tcx.lang_items().async_fn_once_trait(),
+            infcx.tcx.lang_items().async_fn_once_output(),
+            format_as_parenthesized,
+        ),
         (
             infcx.tcx.lang_items().fn_trait(),
             infcx.tcx.lang_items().fn_once_output(),
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index b9a6f67ab0dcc..2e64fc290fcc2 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -698,6 +698,7 @@ impl<'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for MakeSuggestableFolder<'tcx> {
             }
 
             Closure(..)
+            | CoroutineClosure(..)
             | FnDef(..)
             | Infer(..)
             | Coroutine(..)
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
index c9a42dddac42b..221593d6eadb5 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -454,7 +454,16 @@ where
                     self.assemble_object_bound_candidates(goal, &mut candidates);
                 }
             }
-            AssembleCandidatesFrom::EnvAndBounds => {}
+            AssembleCandidatesFrom::EnvAndBounds => {
+                // This is somewhat inconsistent and may make #57893 slightly easier to exploit.
+                // However, it matches the behavior of the old solver. See
+                // `tests/ui/traits/next-solver/normalization-shadowing/use_object_if_empty_env.rs`.
+                if matches!(normalized_self_ty.kind(), ty::Dynamic(..))
+                    && !candidates.iter().any(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
+                {
+                    self.assemble_object_bound_candidates(goal, &mut candidates);
+                }
+            }
         }
 
         (candidates, failed_candidate_info)
diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
index dc5aaa8726032..a85c874d54de1 100644
--- a/library/alloc/src/collections/vec_deque/mod.rs
+++ b/library/alloc/src/collections/vec_deque/mod.rs
@@ -52,7 +52,7 @@ pub use self::iter::Iter;
 
 mod iter;
 
-use self::spec_extend::SpecExtend;
+use self::spec_extend::{SpecExtend, SpecExtendFront};
 
 mod spec_extend;
 
@@ -179,6 +179,21 @@ impl<T, A: Allocator> VecDeque<T, A> {
         self.len += 1;
     }
 
+    /// Prepends an element to the buffer.
+    ///
+    /// # Safety
+    ///
+    /// May only be called if `deque.len() < deque.capacity()`
+    #[inline]
+    unsafe fn push_front_unchecked(&mut self, element: T) {
+        self.head = self.wrap_sub(self.head, 1);
+        // SAFETY: Because of the precondition, it's guaranteed that there is space
+        // in the logical array before the first element (where self.head is now).
+        unsafe { self.buffer_write(self.head, element) };
+        // This can't overflow because `deque.len() < deque.capacity() <= usize::MAX`.
+        self.len += 1;
+    }
+
     /// Moves an element out of the buffer
     #[inline]
     unsafe fn buffer_read(&mut self, off: usize) -> T {
@@ -505,6 +520,35 @@ impl<T, A: Allocator> VecDeque<T, A> {
         }
     }
 
+    /// Copies all values from `src` to `dst` in reversed order, wrapping around if needed.
+    /// Assumes capacity is sufficient.
+    /// Equivalent to calling [`VecDeque::copy_slice`] with a [reversed](https://doc.rust-lang.org/std/primitive.slice.html#method.reverse) slice.
+    #[inline]
+    unsafe fn copy_slice_reversed(&mut self, dst: usize, src: &[T]) {
+        /// # Safety
+        ///
+        /// See [`ptr::copy_nonoverlapping`].
+        unsafe fn copy_nonoverlapping_reversed<T>(src: *const T, dst: *mut T, count: usize) {
+            for i in 0..count {
+                unsafe { ptr::copy_nonoverlapping(src.add(count - 1 - i), dst.add(i), 1) };
+            }
+        }
+
+        debug_assert!(src.len() <= self.capacity());
+        let head_room = self.capacity() - dst;
+        if src.len() <= head_room {
+            unsafe {
+                copy_nonoverlapping_reversed(src.as_ptr(), self.ptr().add(dst), src.len());
+            }
+        } else {
+            let (left, right) = src.split_at(src.len() - head_room);
+            unsafe {
+                copy_nonoverlapping_reversed(right.as_ptr(), self.ptr().add(dst), right.len());
+                copy_nonoverlapping_reversed(left.as_ptr(), self.ptr(), left.len());
+            }
+        }
+    }
+
     /// Writes all values from `iter` to `dst`.
     ///
     /// # Safety
@@ -2122,6 +2166,73 @@ impl<T, A: Allocator> VecDeque<T, A> {
         unsafe { self.buffer_write(self.to_physical_idx(len), value) }
     }
 
+    /// Prepends all contents of the iterator to the front of the deque.
+    /// The order of the contents is preserved.
+    ///
+    /// To get behavior like [`append`][VecDeque::append] where elements are moved
+    /// from the other collection to this one, use `self.prepend(other.drain(..))`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(deque_extend_front)]
+    /// use std::collections::VecDeque;
+    ///
+    /// let mut deque = VecDeque::from([4, 5, 6]);
+    /// deque.prepend([1, 2, 3]);
+    /// assert_eq!(deque, [1, 2, 3, 4, 5, 6]);
+    /// ```
+    ///
+    /// Move values between collections like [`append`][VecDeque::append] does but prepend to the front:
+    ///
+    /// ```
+    /// #![feature(deque_extend_front)]
+    /// use std::collections::VecDeque;
+    ///
+    /// let mut deque1 = VecDeque::from([4, 5, 6]);
+    /// let mut deque2 = VecDeque::from([1, 2, 3]);
+    /// deque1.prepend(deque2.drain(..));
+    /// assert_eq!(deque1, [1, 2, 3, 4, 5, 6]);
+    /// assert!(deque2.is_empty());
+    /// ```
+    #[unstable(feature = "deque_extend_front", issue = "146975")]
+    #[track_caller]
+    pub fn prepend<I: IntoIterator<Item = T, IntoIter: DoubleEndedIterator>>(&mut self, other: I) {
+        self.extend_front(other.into_iter().rev())
+    }
+
+    /// Prepends all contents of the iterator to the front of the deque,
+    /// as if [`push_front`][VecDeque::push_front] was called repeatedly with
+    /// the values yielded by the iterator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(deque_extend_front)]
+    /// use std::collections::VecDeque;
+    ///
+    /// let mut deque = VecDeque::from([4, 5, 6]);
+    /// deque.extend_front([3, 2, 1]);
+    /// assert_eq!(deque, [1, 2, 3, 4, 5, 6]);
+    /// ```
+    ///
+    /// This behaves like [`push_front`][VecDeque::push_front] was called repeatedly:
+    ///
+    /// ```
+    /// use std::collections::VecDeque;
+    ///
+    /// let mut deque = VecDeque::from([4, 5, 6]);
+    /// for v in [3, 2, 1] {
+    ///     deque.push_front(v);
+    /// }
+    /// assert_eq!(deque, [1, 2, 3, 4, 5, 6]);
+    /// ```
+    #[unstable(feature = "deque_extend_front", issue = "146975")]
+    #[track_caller]
+    pub fn extend_front<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+        <Self as SpecExtendFront<T, I::IntoIter>>::spec_extend_front(self, iter.into_iter());
+    }
+
     #[inline]
     fn is_contiguous(&self) -> bool {
         // Do the calculation like this to avoid overflowing if len + head > usize::MAX
diff --git a/library/alloc/src/collections/vec_deque/spec_extend.rs b/library/alloc/src/collections/vec_deque/spec_extend.rs
index 6c2199135e08a..f73ba795cbea4 100644
--- a/library/alloc/src/collections/vec_deque/spec_extend.rs
+++ b/library/alloc/src/collections/vec_deque/spec_extend.rs
@@ -1,4 +1,4 @@
-use core::iter::TrustedLen;
+use core::iter::{Copied, Rev, TrustedLen};
 use core::slice;
 
 use super::VecDeque;
@@ -114,3 +114,113 @@ where
         }
     }
 }
+
+// Specialization trait used for VecDeque::extend_front
+pub(super) trait SpecExtendFront<T, I> {
+    #[track_caller]
+    fn spec_extend_front(&mut self, iter: I);
+}
+
+impl<T, I, A: Allocator> SpecExtendFront<T, I> for VecDeque<T, A>
+where
+    I: Iterator<Item = T>,
+{
+    #[track_caller]
+    default fn spec_extend_front(&mut self, mut iter: I) {
+        // This function should be the moral equivalent of:
+        //
+        // for item in iter {
+        //     self.push_front(item);
+        // }
+
+        while let Some(element) = iter.next() {
+            let (lower, _) = iter.size_hint();
+            self.reserve(lower.saturating_add(1));
+
+            // SAFETY: We just reserved space for at least one element.
+            unsafe { self.push_front_unchecked(element) };
+
+            // Inner loop to avoid repeatedly calling `reserve`.
+            while self.len < self.capacity() {
+                let Some(element) = iter.next() else {
+                    return;
+                };
+                // SAFETY: The loop condition guarantees that `self.len() < self.capacity()`.
+                unsafe { self.push_front_unchecked(element) };
+            }
+        }
+    }
+}
+
+#[cfg(not(test))]
+impl<T, A: Allocator> SpecExtendFront<T, vec::IntoIter<T>> for VecDeque<T, A> {
+    #[track_caller]
+    fn spec_extend_front(&mut self, mut iterator: vec::IntoIter<T>) {
+        let slice = iterator.as_slice();
+        // SAFETY: elements in the slice are forgotten after this call
+        unsafe { prepend_reversed(self, slice) };
+        iterator.forget_remaining_elements();
+    }
+}
+
+#[cfg(not(test))]
+impl<T, A: Allocator> SpecExtendFront<T, Rev<vec::IntoIter<T>>> for VecDeque<T, A> {
+    #[track_caller]
+    fn spec_extend_front(&mut self, iterator: Rev<vec::IntoIter<T>>) {
+        let mut iterator = iterator.into_inner();
+        let slice = iterator.as_slice();
+        // SAFETY: elements in the slice are forgotten after this call
+        unsafe { prepend(self, slice) };
+        iterator.forget_remaining_elements();
+    }
+}
+
+impl<'a, T, A: Allocator> SpecExtendFront<T, Copied<slice::Iter<'a, T>>> for VecDeque<T, A>
+where
+    Copied<slice::Iter<'a, T>>: Iterator<Item = T>,
+{
+    #[track_caller]
+    fn spec_extend_front(&mut self, iter: Copied<slice::Iter<'a, T>>) {
+        let slice = iter.into_inner().as_slice();
+        // SAFETY: T is Copy because Copied<slice::Iter<'a, T>> is Iterator
+        unsafe { prepend_reversed(self, slice) };
+    }
+}
+
+impl<'a, T, A: Allocator> SpecExtendFront<T, Rev<Copied<slice::Iter<'a, T>>>> for VecDeque<T, A>
+where
+    Rev<Copied<slice::Iter<'a, T>>>: Iterator<Item = T>,
+{
+    #[track_caller]
+    fn spec_extend_front(&mut self, iter: Rev<Copied<slice::Iter<'a, T>>>) {
+        let slice = iter.into_inner().into_inner().as_slice();
+        // SAFETY: T is Copy because Rev<Copied<slice::Iter<'a, T>>> is Iterator
+        unsafe { prepend(self, slice) };
+    }
+}
+
+/// # Safety
+///
+/// Elements of `slice` will be copied into the deque, make sure to forget the items if `T` is not `Copy`.
+unsafe fn prepend<T, A: Allocator>(deque: &mut VecDeque<T, A>, slice: &[T]) {
+    deque.reserve(slice.len());
+
+    unsafe {
+        deque.head = deque.wrap_sub(deque.head, slice.len());
+        deque.copy_slice(deque.head, slice);
+        deque.len += slice.len();
+    }
+}
+
+/// # Safety
+///
+/// Elements of `slice` will be copied into the deque, make sure to forget the items if `T` is not `Copy`.
+unsafe fn prepend_reversed<T, A: Allocator>(deque: &mut VecDeque<T, A>, slice: &[T]) {
+    deque.reserve(slice.len());
+
+    unsafe {
+        deque.head = deque.wrap_sub(deque.head, slice.len());
+        deque.copy_slice_reversed(deque.head, slice);
+        deque.len += slice.len();
+    }
+}
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 786f88c29ef46..73197d021f1a3 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -106,6 +106,7 @@
 #![feature(const_default)]
 #![feature(const_eval_select)]
 #![feature(const_heap)]
+#![feature(copied_into_inner)]
 #![feature(core_intrinsics)]
 #![feature(deprecated_suggestion)]
 #![feature(deref_pure_trait)]
@@ -134,6 +135,7 @@
 #![feature(ptr_alignment_type)]
 #![feature(ptr_internals)]
 #![feature(ptr_metadata)]
+#![feature(rev_into_inner)]
 #![feature(set_ptr_value)]
 #![feature(sized_type_properties)]
 #![feature(slice_from_ptr_range)]
diff --git a/library/alloctests/lib.rs b/library/alloctests/lib.rs
index 0201c8752210c..efdcb893bfeef 100644
--- a/library/alloctests/lib.rs
+++ b/library/alloctests/lib.rs
@@ -20,6 +20,7 @@
 #![feature(assert_matches)]
 #![feature(char_internals)]
 #![feature(char_max_len)]
+#![feature(copied_into_inner)]
 #![feature(core_intrinsics)]
 #![feature(exact_size_is_empty)]
 #![feature(extend_one)]
@@ -32,6 +33,7 @@
 #![feature(maybe_uninit_uninit_array_transpose)]
 #![feature(ptr_alignment_type)]
 #![feature(ptr_internals)]
+#![feature(rev_into_inner)]
 #![feature(sized_type_properties)]
 #![feature(slice_iter_mut_as_mut_slice)]
 #![feature(slice_ptr_get)]
diff --git a/library/alloctests/tests/vec_deque.rs b/library/alloctests/tests/vec_deque.rs
index 0a4a0e0cac4d7..cf31613577f74 100644
--- a/library/alloctests/tests/vec_deque.rs
+++ b/library/alloctests/tests/vec_deque.rs
@@ -2081,3 +2081,77 @@ fn test_extend_and_prepend_from_within() {
     v.extend_from_within(..);
     assert_eq!(v.iter().map(|s| &**s).collect::<String>(), "123123123123");
 }
+
+#[test]
+fn test_extend_front() {
+    let mut v = VecDeque::new();
+    v.extend_front(0..3);
+    assert_eq!(v, [2, 1, 0]);
+    v.extend_front(3..6);
+    assert_eq!(v, [5, 4, 3, 2, 1, 0]);
+    v.prepend([1; 4]);
+    assert_eq!(v, [1, 1, 1, 1, 5, 4, 3, 2, 1, 0]);
+
+    let mut v = VecDeque::with_capacity(8);
+    let cap = v.capacity();
+    v.extend(0..4);
+    v.truncate_front(2);
+    v.extend_front(4..8);
+    assert_eq!(v.as_slices(), ([7, 6].as_slice(), [5, 4, 2, 3].as_slice()));
+    assert_eq!(v.capacity(), cap);
+
+    let mut v = VecDeque::new();
+    v.extend_front([]);
+    v.extend_front(None);
+    v.extend_front(vec![]);
+    v.prepend([]);
+    v.prepend(None);
+    v.prepend(vec![]);
+    assert_eq!(v.capacity(), 0);
+    v.extend_front(Some(123));
+    assert_eq!(v, [123]);
+}
+
+#[test]
+fn test_extend_front_specialization_vec_into_iter() {
+    // trigger 4 code paths: all combinations of prepend and extend_front, wrap and no wrap
+    let mut v = VecDeque::with_capacity(4);
+    v.prepend(vec![1, 2, 3]);
+    assert_eq!(v, [1, 2, 3]);
+    v.pop_back();
+    // this should wrap around the physical buffer
+    v.prepend(vec![-1, 0]);
+    // check it really wrapped
+    assert_eq!(v.as_slices(), ([-1].as_slice(), [0, 1, 2].as_slice()));
+
+    let mut v = VecDeque::with_capacity(4);
+    v.extend_front(vec![1, 2, 3]);
+    assert_eq!(v, [3, 2, 1]);
+    v.pop_back();
+    // this should wrap around the physical buffer
+    v.extend_front(vec![4, 5]);
+    // check it really wrapped
+    assert_eq!(v.as_slices(), ([5].as_slice(), [4, 3, 2].as_slice()));
+}
+
+#[test]
+fn test_extend_front_specialization_copy_slice() {
+    // trigger 4 code paths: all combinations of prepend and extend_front, wrap and no wrap
+    let mut v = VecDeque::with_capacity(4);
+    v.prepend([1, 2, 3].as_slice().iter().copied());
+    assert_eq!(v, [1, 2, 3]);
+    v.pop_back();
+    // this should wrap around the physical buffer
+    v.prepend([-1, 0].as_slice().iter().copied());
+    // check it really wrapped
+    assert_eq!(v.as_slices(), ([-1].as_slice(), [0, 1, 2].as_slice()));
+
+    let mut v = VecDeque::with_capacity(4);
+    v.extend_front([1, 2, 3].as_slice().iter().copied());
+    assert_eq!(v, [3, 2, 1]);
+    v.pop_back();
+    // this should wrap around the physical buffer
+    v.extend_front([4, 5].as_slice().iter().copied());
+    // check it really wrapped
+    assert_eq!(v.as_slices(), ([5].as_slice(), [4, 3, 2].as_slice()));
+}
diff --git a/library/core/src/iter/adapters/copied.rs b/library/core/src/iter/adapters/copied.rs
index 23e4e25ab5388..9627ace29795c 100644
--- a/library/core/src/iter/adapters/copied.rs
+++ b/library/core/src/iter/adapters/copied.rs
@@ -24,6 +24,12 @@ impl<I> Copied<I> {
     pub(in crate::iter) fn new(it: I) -> Copied<I> {
         Copied { it }
     }
+
+    #[doc(hidden)]
+    #[unstable(feature = "copied_into_inner", issue = "none")]
+    pub fn into_inner(self) -> I {
+        self.it
+    }
 }
 
 fn copy_fold<T: Copy, Acc>(mut f: impl FnMut(Acc, T) -> Acc) -> impl FnMut(Acc, &T) -> Acc {
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 0363418f91647..5e42bb9861bfa 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -427,6 +427,27 @@ impl<'a, F: Write> TokenHandler<'a, '_, F> {
             }
         }
     }
+
+    /// Used when we're done with the current expansion "original code" (ie code before expansion).
+    /// We close all tags inside `Class::Original` and only keep the ones that were not closed yet.
+    fn close_original_tag(&mut self) {
+        let mut classes_to_reopen = Vec::new();
+        while let Some(mut class_info) = self.class_stack.open_classes.pop() {
+            if class_info.class == Class::Original {
+                while let Some(class_info) = classes_to_reopen.pop() {
+                    self.class_stack.open_classes.push(class_info);
+                }
+                class_info.close_tag(self.out);
+                return;
+            }
+            class_info.close_tag(self.out);
+            if !class_info.pending_exit {
+                class_info.closing_tag = None;
+                classes_to_reopen.push(class_info);
+            }
+        }
+        panic!("Didn't find `Class::Original` to close");
+    }
 }
 
 impl<F: Write> Drop for TokenHandler<'_, '_, F> {
@@ -484,7 +505,9 @@ fn end_expansion<'a, W: Write>(
     expanded_codes: &'a [ExpandedCode],
     span: Span,
 ) -> Option<&'a ExpandedCode> {
-    token_handler.class_stack.exit_elem();
+    // We close `Class::Original` and everything open inside it.
+    token_handler.close_original_tag();
+    // Then we check if we have another macro expansion on the same line.
     let expansion = get_next_expansion(expanded_codes, token_handler.line, span);
     if expansion.is_none() {
         token_handler.close_expansion();
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 96e941b598ad1..9c072eed51aec 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -1051,28 +1051,21 @@ impl Serialize for TypeData {
     where
         S: Serializer,
     {
-        if self.search_unbox
-            || !self.inverted_function_inputs_index.is_empty()
-            || !self.inverted_function_output_index.is_empty()
-        {
-            let mut seq = serializer.serialize_seq(None)?;
-            let mut buf = Vec::new();
-            encode::write_postings_to_string(&self.inverted_function_inputs_index, &mut buf);
-            let mut serialized_result = Vec::new();
-            stringdex_internals::encode::write_base64_to_bytes(&buf, &mut serialized_result);
-            seq.serialize_element(&str::from_utf8(&serialized_result).unwrap())?;
-            buf.clear();
-            serialized_result.clear();
-            encode::write_postings_to_string(&self.inverted_function_output_index, &mut buf);
-            stringdex_internals::encode::write_base64_to_bytes(&buf, &mut serialized_result);
-            seq.serialize_element(&str::from_utf8(&serialized_result).unwrap())?;
-            if self.search_unbox {
-                seq.serialize_element(&1)?;
-            }
-            seq.end()
-        } else {
-            None::<()>.serialize(serializer)
+        let mut seq = serializer.serialize_seq(None)?;
+        let mut buf = Vec::new();
+        encode::write_postings_to_string(&self.inverted_function_inputs_index, &mut buf);
+        let mut serialized_result = Vec::new();
+        stringdex_internals::encode::write_base64_to_bytes(&buf, &mut serialized_result);
+        seq.serialize_element(&str::from_utf8(&serialized_result).unwrap())?;
+        buf.clear();
+        serialized_result.clear();
+        encode::write_postings_to_string(&self.inverted_function_output_index, &mut buf);
+        stringdex_internals::encode::write_base64_to_bytes(&buf, &mut serialized_result);
+        seq.serialize_element(&str::from_utf8(&serialized_result).unwrap())?;
+        if self.search_unbox {
+            seq.serialize_element(&1)?;
         }
+        seq.end()
     }
 }
 
diff --git a/tests/run-make/alloc-no-oom-handling/rmake.rs b/tests/run-make/alloc-no-oom-handling/rmake.rs
index 89a6636d9a0cc..94002eca5736f 100644
--- a/tests/run-make/alloc-no-oom-handling/rmake.rs
+++ b/tests/run-make/alloc-no-oom-handling/rmake.rs
@@ -6,7 +6,7 @@ use run_make_support::{rustc, source_root};
 
 fn main() {
     rustc()
-        .edition("2021")
+        .edition("2024")
         .arg("-Dwarnings")
         .crate_type("rlib")
         .input(source_root().join("library/alloc/src/lib.rs"))
diff --git a/tests/run-make/alloc-no-rc/rmake.rs b/tests/run-make/alloc-no-rc/rmake.rs
index 12171c2148f1d..8d8cd4990bc65 100644
--- a/tests/run-make/alloc-no-rc/rmake.rs
+++ b/tests/run-make/alloc-no-rc/rmake.rs
@@ -6,7 +6,7 @@ use run_make_support::{rustc, source_root};
 
 fn main() {
     rustc()
-        .edition("2021")
+        .edition("2024")
         .arg("-Dwarnings")
         .crate_type("rlib")
         .input(source_root().join("library/alloc/src/lib.rs"))
diff --git a/tests/run-make/alloc-no-sync/rmake.rs b/tests/run-make/alloc-no-sync/rmake.rs
index 29f204f30673e..a096d3941d466 100644
--- a/tests/run-make/alloc-no-sync/rmake.rs
+++ b/tests/run-make/alloc-no-sync/rmake.rs
@@ -6,7 +6,7 @@ use run_make_support::{rustc, source_root};
 
 fn main() {
     rustc()
-        .edition("2021")
+        .edition("2024")
         .arg("-Dwarnings")
         .crate_type("rlib")
         .input(source_root().join("library/alloc/src/lib.rs"))
diff --git a/tests/run-make/llvm-location-discriminator-limit-dummy-span/rmake.rs b/tests/run-make/llvm-location-discriminator-limit-dummy-span/rmake.rs
index d28c8463016cb..00ae400f71d20 100644
--- a/tests/run-make/llvm-location-discriminator-limit-dummy-span/rmake.rs
+++ b/tests/run-make/llvm-location-discriminator-limit-dummy-span/rmake.rs
@@ -49,21 +49,21 @@ fn main() {
     rustc()
         .input("proc.rs")
         .crate_type("proc-macro")
-        .edition("2021")
+        .edition("2024")
         .arg("-Cdebuginfo=line-tables-only")
         .run();
     rustc()
         .extern_("proc", dynamic_lib_name("proc"))
         .input("other.rs")
         .crate_type("rlib")
-        .edition("2021")
+        .edition("2024")
         .opt_level("3")
         .arg("-Cdebuginfo=line-tables-only")
         .run();
     rustc()
         .extern_("other", rust_lib_name("other"))
         .input("main.rs")
-        .edition("2021")
+        .edition("2024")
         .opt_level("3")
         .arg("-Cdebuginfo=line-tables-only")
         .arg("-Clto=fat")
diff --git a/tests/run-make/panic-abort-eh_frame/rmake.rs b/tests/run-make/panic-abort-eh_frame/rmake.rs
index 2eccde627955c..5c859a7482674 100644
--- a/tests/run-make/panic-abort-eh_frame/rmake.rs
+++ b/tests/run-make/panic-abort-eh_frame/rmake.rs
@@ -19,7 +19,7 @@ fn main() {
         .crate_type("lib")
         .emit("obj=foo.o")
         .panic("abort")
-        .edition("2021")
+        .edition("2024")
         .arg("-Zvalidate-mir")
         .arg("-Cforce-unwind-tables=no")
         .run();
diff --git a/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs b/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs
index 546a0685b4ee5..4f85bf6bef8f9 100644
--- a/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs
+++ b/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs
@@ -19,14 +19,14 @@ fn main() {
     rustc()
         .input("src/proc.rs")
         .crate_name(proc_crate_name)
-        .edition("2021")
+        .edition("2024")
         .crate_type("proc-macro")
         .emit("dep-info,link")
         .run();
     rustc()
         .input("src/lib.rs")
         .crate_name(crate_name)
-        .edition("2021")
+        .edition("2024")
         .crate_type("lib")
         .emit("dep-info,link")
         .run();
diff --git a/tests/rustdoc-js/auxiliary/emptytype.rs b/tests/rustdoc-js/auxiliary/emptytype.rs
new file mode 100644
index 0000000000000..2a06b4ec9f8ca
--- /dev/null
+++ b/tests/rustdoc-js/auxiliary/emptytype.rs
@@ -0,0 +1,41 @@
+// https://github.com/rust-lang/rust/issues/148431
+
+// This test is designed to hit a case where, thanks to the
+// recursion limit, the where clause gets generated, but not
+// used, because we run out of fuel.
+//
+// This results in a reverse index with nothing in it, which
+// used to crash when we parsed it.
+pub fn foobar1<A: T1<B>, B: T2<C>, C: T3<D>, D: T4<A>>(a: A) {}
+
+pub trait T1<T: ?Sized> {}
+pub trait T2<T: ?Sized> {}
+pub trait T3<T: ?Sized> {}
+pub trait T4<T: ?Sized> {}
+
+// foobar1 is the version that worked at the time this test was written
+// the rest are here to try to make the test at least a little more
+// robust, in the sense that it actually tests the code and isn't magically
+// fixed by the recursion limit changing
+pub fn foobar2<A: U1<B>, B: U2<C>, C: U3<D>, D: U4<E>, E: U5<A>>(a: A) {}
+
+pub trait U1<T: ?Sized> {}
+pub trait U2<T: ?Sized> {}
+pub trait U3<T: ?Sized> {}
+pub trait U4<T: ?Sized> {}
+pub trait U5<T: ?Sized> {}
+
+pub fn foobar3<A: V1<B>, B: V2<C>, C: V3<D>, D: V4<E>, E: V5<F>, F: V6<A>>(a: A) {}
+
+pub trait V1<T: ?Sized> {}
+pub trait V2<T: ?Sized> {}
+pub trait V3<T: ?Sized> {}
+pub trait V4<T: ?Sized> {}
+pub trait V5<T: ?Sized> {}
+pub trait V6<T: ?Sized> {}
+
+pub fn foobar4<A: W1<B>, B: W2<C>, C: W3<A>>(a: A) {}
+
+pub trait W1<T: ?Sized> {}
+pub trait W2<T: ?Sized> {}
+pub trait W3<T: ?Sized> {}
diff --git a/tests/rustdoc-js/empty-type.js b/tests/rustdoc-js/empty-type.js
new file mode 100644
index 0000000000000..e4c8f9954cb7f
--- /dev/null
+++ b/tests/rustdoc-js/empty-type.js
@@ -0,0 +1,8 @@
+const EXPECTED = [
+    {
+        query: 'baz',
+        others: [
+            { name: 'baz' }
+        ],
+    },
+];
diff --git a/tests/rustdoc-js/empty-type.rs b/tests/rustdoc-js/empty-type.rs
new file mode 100644
index 0000000000000..87ea73709b6bb
--- /dev/null
+++ b/tests/rustdoc-js/empty-type.rs
@@ -0,0 +1,8 @@
+//@ aux-crate:emptytype=emptytype.rs
+//@ compile-flags: --extern emptytype
+//@ aux-build:emptytype.rs
+//@ build-aux-docs
+
+extern crate emptytype;
+
+pub fn baz() {}
diff --git a/tests/rustdoc/macro/auxiliary/one-line-expand.rs b/tests/rustdoc/macro/auxiliary/one-line-expand.rs
new file mode 100644
index 0000000000000..14df0f2d4f20e
--- /dev/null
+++ b/tests/rustdoc/macro/auxiliary/one-line-expand.rs
@@ -0,0 +1,15 @@
+//@ force-host
+//@ no-prefer-dynamic
+//@ compile-flags: --crate-type proc-macro
+
+#![crate_type = "proc-macro"]
+#![crate_name = "just_some_proc"]
+
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+
+#[proc_macro_attribute]
+pub fn repro(_args: TokenStream, _input: TokenStream) -> TokenStream {
+    "struct Repro;".parse().unwrap()
+}
diff --git a/tests/rustdoc/macro/one-line-expand.rs b/tests/rustdoc/macro/one-line-expand.rs
new file mode 100644
index 0000000000000..ceb9521820d61
--- /dev/null
+++ b/tests/rustdoc/macro/one-line-expand.rs
@@ -0,0 +1,19 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/148184>.
+// It ensures that the macro expansion correctly handles its "class stack".
+
+//@ compile-flags: -Zunstable-options --generate-macro-expansion
+//@ aux-build:one-line-expand.rs
+
+#![crate_name = "foo"]
+
+extern crate just_some_proc;
+
+//@ has 'src/foo/one-line-expand.rs.html'
+//@ has - '//*[@class="comment"]' '//'
+//@ has - '//*[@class="original"]' '#[just_some_proc::repro]'
+//@ has - '//*[@class="original"]/*[@class="attr"]' '#[just_some_proc::repro]'
+//@ has - '//code/*[@class="kw"]' 'struct '
+
+//
+#[just_some_proc::repro]
+struct Repro;
diff --git a/tests/ui/async-await/async-closures/ice-async-closure-variance-issue-148488.rs b/tests/ui/async-await/async-closures/ice-async-closure-variance-issue-148488.rs
new file mode 100644
index 0000000000000..f5926e19a150a
--- /dev/null
+++ b/tests/ui/async-await/async-closures/ice-async-closure-variance-issue-148488.rs
@@ -0,0 +1,12 @@
+//@ edition: 2024
+
+struct T<'g>();
+//~^ ERROR lifetime parameter `'g` is never used
+
+fn ord<a>() -> _ {
+    //~^ WARN type parameter `a` should have an upper camel case name
+    //~| ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    async || {}
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/async-closures/ice-async-closure-variance-issue-148488.stderr b/tests/ui/async-await/async-closures/ice-async-closure-variance-issue-148488.stderr
new file mode 100644
index 0000000000000..ca98d210579f3
--- /dev/null
+++ b/tests/ui/async-await/async-closures/ice-async-closure-variance-issue-148488.stderr
@@ -0,0 +1,26 @@
+warning: type parameter `a` should have an upper camel case name
+  --> $DIR/ice-async-closure-variance-issue-148488.rs:6:8
+   |
+LL | fn ord<a>() -> _ {
+   |        ^ help: convert the identifier to upper camel case: `A`
+   |
+   = note: `#[warn(non_camel_case_types)]` (part of `#[warn(nonstandard_style)]`) on by default
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/ice-async-closure-variance-issue-148488.rs:6:16
+   |
+LL | fn ord<a>() -> _ {
+   |                ^ not allowed in type signatures
+
+error[E0392]: lifetime parameter `'g` is never used
+  --> $DIR/ice-async-closure-variance-issue-148488.rs:3:10
+   |
+LL | struct T<'g>();
+   |          ^^ unused lifetime parameter
+   |
+   = help: consider removing `'g`, referring to it in a field, or using a marker such as `PhantomData`
+
+error: aborting due to 2 previous errors; 1 warning emitted
+
+Some errors have detailed explanations: E0121, E0392.
+For more information about an error, try `rustc --explain E0121`.
diff --git a/tests/ui/async-await/async-closures/suggest-impl-async-fn-issue-148493.fixed b/tests/ui/async-await/async-closures/suggest-impl-async-fn-issue-148493.fixed
new file mode 100644
index 0000000000000..db5091f6b7f6c
--- /dev/null
+++ b/tests/ui/async-await/async-closures/suggest-impl-async-fn-issue-148493.fixed
@@ -0,0 +1,64 @@
+#![allow(dead_code)]
+//@ run-rustfix
+//@ edition: 2021
+
+// The suggestion should be `impl AsyncFn()` instead of something like `{async closure@...}`
+
+fn test1() -> impl AsyncFn() {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFn()
+    async || {}
+}
+
+fn test2() -> impl AsyncFn(i32) -> i32 {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFn(i32) -> i32
+    async |x: i32| x + 1
+}
+
+fn test3() -> impl AsyncFn(i32, i32) -> i32 {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFn(i32, i32) -> i32
+    async |x: i32, y: i32| x + y
+}
+
+fn test4() -> impl AsyncFn() {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFn()
+    async || -> () { () }
+}
+
+fn test5() -> impl AsyncFn() -> i32 {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFn() -> i32
+    let z = 42;
+    async move || z
+}
+
+fn test6() -> impl AsyncFnMut() -> i32 {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFnMut() -> i32
+    let mut x = 0;
+    async move || {
+        x += 1;
+        x
+    }
+}
+
+fn test7() -> impl AsyncFnOnce() {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFnOnce()
+    let s = String::from("hello");
+    async move || {
+        drop(s);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/async-closures/suggest-impl-async-fn-issue-148493.rs b/tests/ui/async-await/async-closures/suggest-impl-async-fn-issue-148493.rs
new file mode 100644
index 0000000000000..1109904398dab
--- /dev/null
+++ b/tests/ui/async-await/async-closures/suggest-impl-async-fn-issue-148493.rs
@@ -0,0 +1,64 @@
+#![allow(dead_code)]
+//@ run-rustfix
+//@ edition: 2021
+
+// The suggestion should be `impl AsyncFn()` instead of something like `{async closure@...}`
+
+fn test1() -> _ {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFn()
+    async || {}
+}
+
+fn test2() -> _ {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFn(i32) -> i32
+    async |x: i32| x + 1
+}
+
+fn test3() -> _ {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFn(i32, i32) -> i32
+    async |x: i32, y: i32| x + y
+}
+
+fn test4() -> _ {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFn()
+    async || -> () { () }
+}
+
+fn test5() -> _ {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFn() -> i32
+    let z = 42;
+    async move || z
+}
+
+fn test6() -> _ {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFnMut() -> i32
+    let mut x = 0;
+    async move || {
+        x += 1;
+        x
+    }
+}
+
+fn test7() -> _ {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    //~| HELP replace with an appropriate return type
+    //~| SUGGESTION impl AsyncFnOnce()
+    let s = String::from("hello");
+    async move || {
+        drop(s);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/async-closures/suggest-impl-async-fn-issue-148493.stderr b/tests/ui/async-await/async-closures/suggest-impl-async-fn-issue-148493.stderr
new file mode 100644
index 0000000000000..abe775cec082b
--- /dev/null
+++ b/tests/ui/async-await/async-closures/suggest-impl-async-fn-issue-148493.stderr
@@ -0,0 +1,87 @@
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/suggest-impl-async-fn-issue-148493.rs:7:15
+   |
+LL | fn test1() -> _ {
+   |               ^ not allowed in type signatures
+   |
+help: replace with an appropriate return type
+   |
+LL - fn test1() -> _ {
+LL + fn test1() -> impl AsyncFn() {
+   |
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/suggest-impl-async-fn-issue-148493.rs:14:15
+   |
+LL | fn test2() -> _ {
+   |               ^ not allowed in type signatures
+   |
+help: replace with an appropriate return type
+   |
+LL - fn test2() -> _ {
+LL + fn test2() -> impl AsyncFn(i32) -> i32 {
+   |
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/suggest-impl-async-fn-issue-148493.rs:21:15
+   |
+LL | fn test3() -> _ {
+   |               ^ not allowed in type signatures
+   |
+help: replace with an appropriate return type
+   |
+LL - fn test3() -> _ {
+LL + fn test3() -> impl AsyncFn(i32, i32) -> i32 {
+   |
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/suggest-impl-async-fn-issue-148493.rs:28:15
+   |
+LL | fn test4() -> _ {
+   |               ^ not allowed in type signatures
+   |
+help: replace with an appropriate return type
+   |
+LL - fn test4() -> _ {
+LL + fn test4() -> impl AsyncFn() {
+   |
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/suggest-impl-async-fn-issue-148493.rs:35:15
+   |
+LL | fn test5() -> _ {
+   |               ^ not allowed in type signatures
+   |
+help: replace with an appropriate return type
+   |
+LL - fn test5() -> _ {
+LL + fn test5() -> impl AsyncFn() -> i32 {
+   |
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/suggest-impl-async-fn-issue-148493.rs:43:15
+   |
+LL | fn test6() -> _ {
+   |               ^ not allowed in type signatures
+   |
+help: replace with an appropriate return type
+   |
+LL - fn test6() -> _ {
+LL + fn test6() -> impl AsyncFnMut() -> i32 {
+   |
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/suggest-impl-async-fn-issue-148493.rs:54:15
+   |
+LL | fn test7() -> _ {
+   |               ^ not allowed in type signatures
+   |
+help: replace with an appropriate return type
+   |
+LL - fn test7() -> _ {
+LL + fn test7() -> impl AsyncFnOnce() {
+   |
+
+error: aborting due to 7 previous errors
+
+For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/pattern/const-error-ice-issue-148542.rs b/tests/ui/pattern/const-error-ice-issue-148542.rs
new file mode 100644
index 0000000000000..3c3645dc2c018
--- /dev/null
+++ b/tests/ui/pattern/const-error-ice-issue-148542.rs
@@ -0,0 +1,13 @@
+//@ edition: 2021
+
+// Regression test for #148542
+// Ensure we don't ICE with "Invalid `ConstKind` for `const_to_pat`: {const error}"
+
+fn foo() where &str:, {
+    //~^ ERROR `&` without an explicit lifetime name cannot be used here
+    match 42_u8 {
+        -10.. => {}
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/pattern/const-error-ice-issue-148542.stderr b/tests/ui/pattern/const-error-ice-issue-148542.stderr
new file mode 100644
index 0000000000000..ee39ba4feb093
--- /dev/null
+++ b/tests/ui/pattern/const-error-ice-issue-148542.stderr
@@ -0,0 +1,14 @@
+error[E0637]: `&` without an explicit lifetime name cannot be used here
+  --> $DIR/const-error-ice-issue-148542.rs:6:16
+   |
+LL | fn foo() where &str:, {
+   |                ^ explicit lifetime name needed here
+   |
+help: consider introducing a higher-ranked lifetime here
+   |
+LL | fn foo() where for<'a> &'a str:, {
+   |                +++++++  ++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/traits/next-solver/normalization-shadowing/use_object_if_empty_env.rs b/tests/ui/traits/next-solver/normalization-shadowing/use_object_if_empty_env.rs
new file mode 100644
index 0000000000000..f8f6ed9a09887
--- /dev/null
+++ b/tests/ui/traits/next-solver/normalization-shadowing/use_object_if_empty_env.rs
@@ -0,0 +1,36 @@
+//@ compile-flags: -Znext-solver
+//@ check-pass
+
+// Regression test for trait-system-refactor-initiative#244
+
+trait Trait {
+    type Assoc;
+}
+
+// We have param env candidate for the trait goal but not the projection.
+// Under such circumstance, consider object candidate if the self_ty is trait object.
+fn foo<T>(x: <dyn Trait<Assoc = T> as Trait>::Assoc) -> T
+where
+    dyn Trait<Assoc = T>: Trait,
+{
+    x
+}
+
+trait Id<'a> {
+    type This: ?Sized;
+}
+impl<T: ?Sized> Id<'_> for T {
+    type This = T;
+}
+
+// Ensure that we properly normalize alias self_ty before evaluating the goal.
+fn alias_foo<T>(x: for<'a> fn(
+    <<dyn Trait<Assoc = T> as Id<'a>>::This as Trait>::Assoc
+)) -> fn(T)
+where
+    dyn Trait<Assoc = T>: Trait,
+{
+    x
+}
+
+fn main() {}