Expose Frames Iterator for the Backtrace Type

library/std/src/backtrace.rs

@@ -103,6 +103,7 @@ use crate::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 use crate::sync::Once;
 use crate::sys_common::backtrace::{lock, output_filename};
 use crate::vec::Vec;
+use crate::marker::PhantomData;
 
 /// A captured OS thread stack backtrace.
 ///
@@ -147,24 +148,39 @@ fn _assert_send_sync() {
     _assert::<Backtrace>();
 }
 
-struct BacktraceFrame {
+/// A single frame of a backtrace.
+#[derive(Debug)]
+#[unstable(feature = "backtrace_frames", issue = "79676")]
+pub struct BacktraceFrame {
     frame: RawFrame,
     symbols: Vec<BacktraceSymbol>,
 }
 
+/// An iterator over the frames of a backtrace, created 
+/// by the [`frames`] method on [`Backtrace`].
+#[derive(Debug)]
+#[unstable(feature = "backtrace_frames", issue = "79676")]
+pub struct Frames<'a> {
+    inner: Vec<BacktraceFrame>,
+    _backtrace: PhantomData<&'a Backtrace>
+}
+
+#[derive(Debug, Clone)]
 enum RawFrame {
     Actual(backtrace_rs::Frame),
     #[cfg(test)]
     Fake,
 }
 
+#[derive(Clone)]
 struct BacktraceSymbol {
     name: Option<Vec<u8>>,
     filename: Option<BytesOrWide>,
     lineno: Option<u32>,
     colno: Option<u32>,
 }
 
+#[derive(Clone)]
 enum BytesOrWide {
     Bytes(Vec<u8>),
     Wide(Vec<u16>),
@@ -353,6 +369,25 @@ impl Backtrace {
     }
 }
 
+impl<'a> Backtrace {
+    /// Returns an iterator over the backtrace frames.
+    #[unstable(feature = "backtrace_frames", issue = "79676")]
+    pub fn frames(&self) -> Frames<'a> {
+        if let Inner::Captured(captured) = &self.inner {
+            let frames = &captured.lock().unwrap().frames;
+            Frames {
+                inner: frames.iter().map(|frame| frame.clone()).collect::<Vec<BacktraceFrame>>(),
+                _backtrace: PhantomData
+            }
+        } else {
+            Frames {
+                inner: vec![],
+                _backtrace: PhantomData
+            }
+        }
+    }
+}
+
 impl fmt::Display for Backtrace {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let capture = match &self.inner {
@@ -476,3 +511,24 @@ impl RawFrame {
         }
     }
 }
+
+#[unstable(feature = "backtrace_frames", issue = "79676")]
+impl<'a> AsRef<[BacktraceFrame]> for Frames<'a> {
+    fn as_ref(&self) -> &[BacktraceFrame] {
+        &self.inner
+    }
+}
+
+
+#[unstable(feature = "backtrace_frames", issue = "79676")]
+impl BacktraceFrame {
+    // Private clone method so that we don't expose a
+    // public BacktraceFrame.clone() by deriving Clone
+    fn clone(&self) -> Self {
+        BacktraceFrame {
+            frame: self.frame.clone(),
+            symbols: self.symbols.clone(),
+        }
+    }
+}
+

library/std/src/backtrace/tests.rs

@@ -44,7 +44,12 @@ fn test_debug() {
                 },
             ],
         })),
-    };
+    }
+}
+
+#[test]
+fn test_debug() {
+    let backtrace = generate_fake_backtrace();
 
     #[rustfmt::skip]
     let expected = "Backtrace [\