Auto merge of rust-lang#81660 - jonas-schievink:rollup-fz2lh78, r=jonas-schievink

Rollup of 11 pull requests

Successful merges:

 - rust-lang#80629 (Add lint for 2229 migrations)
 - rust-lang#81022 (Add Frames Iterator for Backtrace)
 - rust-lang#81481 (move some tests)
 - rust-lang#81485 (Add some tests for associated-type-bounds issues)
 - rust-lang#81492 (rustdoc: Note why `rustdoc::html::markdown` is public)
 - rust-lang#81577 (const_evaluatable: consider sub-expressions to be evaluatable)
 - rust-lang#81599 (Implement `TrustedLen` for `Fuse<I: TrustedLen>`)
 - rust-lang#81608 (Improve handling of spans around macro result parse errors)
 - rust-lang#81609 (Remove the remains of query categories)
 - rust-lang#81630 (Fix overflowing text on mobile when sidebar is displayed)
 - rust-lang#81631 (Remove unneeded `mut` variable)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

core/src/iter/adapters/fuse.rs

@@ -1,6 +1,8 @@
 use crate::intrinsics;
 use crate::iter::adapters::{zip::try_get_unchecked, InPlaceIterable, SourceIter};
-use crate::iter::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, TrustedRandomAccess};
+use crate::iter::{
+    DoubleEndedIterator, ExactSizeIterator, FusedIterator, TrustedLen, TrustedRandomAccess,
+};
 use crate::ops::Try;
 
 /// An iterator that yields `None` forever after the underlying iterator
@@ -182,8 +184,19 @@ where
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+// SAFETY: `TrustedLen` requires that an accurate length is reported via `size_hint()`. As `Fuse`
+// is just forwarding this to the wrapped iterator `I` this property is preserved and it is safe to
+// implement `TrustedLen` here.
+unsafe impl<I> TrustedLen for Fuse<I> where I: TrustedLen {}
+
 #[doc(hidden)]
 #[unstable(feature = "trusted_random_access", issue = "none")]
+// SAFETY: `TrustedRandomAccess` requires that `size_hint()` must be exact and cheap to call, and
+// `Iterator::__iterator_get_unchecked()` must be implemented accordingly.
+//
+// This is safe to implement as `Fuse` is just forwarding these to the wrapped iterator `I`, which
+// preserves these properties.
 unsafe impl<I> TrustedRandomAccess for Fuse<I>
 where
     I: TrustedRandomAccess,

std/src/backtrace.rs

@@ -147,11 +147,14 @@ fn _assert_send_sync() {
     _assert::<Backtrace>();
 }
 
-struct BacktraceFrame {
+/// A single frame of a backtrace.
+#[unstable(feature = "backtrace_frames", issue = "79676")]
+pub struct BacktraceFrame {
     frame: RawFrame,
     symbols: Vec<BacktraceSymbol>,
 }
 
+#[derive(Debug)]
 enum RawFrame {
     Actual(backtrace_rs::Frame),
     #[cfg(test)]
@@ -196,6 +199,14 @@ impl fmt::Debug for Backtrace {
     }
 }
 
+impl fmt::Debug for BacktraceFrame {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut dbg = fmt.debug_list();
+        dbg.entries(&self.symbols);
+        dbg.finish()
+    }
+}
+
 impl fmt::Debug for BacktraceSymbol {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         // FIXME: improve formatting: https://github.com/rust-lang/rust/issues/65280
@@ -353,6 +364,14 @@ impl Backtrace {
     }
 }
 
+impl<'a> Backtrace {
+    /// Returns an iterator over the backtrace frames.
+    #[unstable(feature = "backtrace_frames", issue = "79676")]
+    pub fn frames(&'a self) -> &'a [BacktraceFrame] {
+        if let Inner::Captured(c) = &self.inner { &c.force().frames } else { &[] }
+    }
+}
+
 impl fmt::Display for Backtrace {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let capture = match &self.inner {

std/src/backtrace/tests.rs

@@ -1,48 +1,52 @@
 use super::*;
 
+fn generate_fake_frames() -> Vec<BacktraceFrame> {
+    vec![
+        BacktraceFrame {
+            frame: RawFrame::Fake,
+            symbols: vec![BacktraceSymbol {
+                name: Some(b"std::backtrace::Backtrace::create".to_vec()),
+                filename: Some(BytesOrWide::Bytes(b"rust/backtrace.rs".to_vec())),
+                lineno: Some(100),
+                colno: None,
+            }],
+        },
+        BacktraceFrame {
+            frame: RawFrame::Fake,
+            symbols: vec![BacktraceSymbol {
+                name: Some(b"__rust_maybe_catch_panic".to_vec()),
+                filename: None,
+                lineno: None,
+                colno: None,
+            }],
+        },
+        BacktraceFrame {
+            frame: RawFrame::Fake,
+            symbols: vec![
+                BacktraceSymbol {
+                    name: Some(b"std::rt::lang_start_internal".to_vec()),
+                    filename: Some(BytesOrWide::Bytes(b"rust/rt.rs".to_vec())),
+                    lineno: Some(300),
+                    colno: Some(5),
+                },
+                BacktraceSymbol {
+                    name: Some(b"std::rt::lang_start".to_vec()),
+                    filename: Some(BytesOrWide::Bytes(b"rust/rt.rs".to_vec())),
+                    lineno: Some(400),
+                    colno: None,
+                },
+            ],
+        },
+    ]
+}
+
 #[test]
 fn test_debug() {
     let backtrace = Backtrace {
         inner: Inner::Captured(LazilyResolvedCapture::new(Capture {
             actual_start: 1,
             resolved: true,
-            frames: vec![
-                BacktraceFrame {
-                    frame: RawFrame::Fake,
-                    symbols: vec![BacktraceSymbol {
-                        name: Some(b"std::backtrace::Backtrace::create".to_vec()),
-                        filename: Some(BytesOrWide::Bytes(b"rust/backtrace.rs".to_vec())),
-                        lineno: Some(100),
-                        colno: None,
-                    }],
-                },
-                BacktraceFrame {
-                    frame: RawFrame::Fake,
-                    symbols: vec![BacktraceSymbol {
-                        name: Some(b"__rust_maybe_catch_panic".to_vec()),
-                        filename: None,
-                        lineno: None,
-                        colno: None,
-                    }],
-                },
-                BacktraceFrame {
-                    frame: RawFrame::Fake,
-                    symbols: vec![
-                        BacktraceSymbol {
-                            name: Some(b"std::rt::lang_start_internal".to_vec()),
-                            filename: Some(BytesOrWide::Bytes(b"rust/rt.rs".to_vec())),
-                            lineno: Some(300),
-                            colno: Some(5),
-                        },
-                        BacktraceSymbol {
-                            name: Some(b"std::rt::lang_start".to_vec()),
-                            filename: Some(BytesOrWide::Bytes(b"rust/rt.rs".to_vec())),
-                            lineno: Some(400),
-                            colno: None,
-                        },
-                    ],
-                },
-            ],
+            frames: generate_fake_frames(),
         })),
     };
 
@@ -58,3 +62,34 @@ fn test_debug() {
     // Format the backtrace a second time, just to make sure lazily resolved state is stable
     assert_eq!(format!("{:#?}", backtrace), expected);
 }
+
+#[test]
+fn test_frames() {
+    let backtrace = Backtrace {
+        inner: Inner::Captured(LazilyResolvedCapture::new(Capture {
+            actual_start: 1,
+            resolved: true,
+            frames: generate_fake_frames(),
+        })),
+    };
+
+    let frames = backtrace.frames();
+
+    #[rustfmt::skip]
+    let expected = vec![
+        "[
+    { fn: \"std::backtrace::Backtrace::create\", file: \"rust/backtrace.rs\", line: 100 },
+]",
+        "[
+    { fn: \"__rust_maybe_catch_panic\" },
+]",
+        "[
+    { fn: \"std::rt::lang_start_internal\", file: \"rust/rt.rs\", line: 300 },
+    { fn: \"std::rt::lang_start\", file: \"rust/rt.rs\", line: 400 },
+]"
+    ];
+
+    let mut iter = frames.iter().zip(expected.iter());
+
+    assert!(iter.all(|(f, e)| format!("{:#?}", f) == *e));
+}