Merge pull request #679 from kivikakk/push-pmyomryuyqnw

prevent unexpected post-processing & simplify internal feed.

Author: kivikakk

fuzz/fuzz_targets/all_options.rs

@@ -122,6 +122,7 @@ struct FuzzParseOptions {
     leave_footnote_definitions: bool,
     default_info_string: bool,
     broken_link_callback: bool,
+    escaped_char_spans: bool,
 }
 
 impl FuzzParseOptions {
@@ -146,6 +147,7 @@ impl FuzzParseOptions {
             } else {
                 None
             },
+            escaped_char_spans: self.escaped_char_spans,
         }
     }
 }

src/arena_tree.rs

@@ -12,7 +12,7 @@
 //! If you need mutability in the node’s `data`,
 //! make it a cell (`Cell` or `RefCell`) or use cells inside of it.
 
-use std::cell::Cell;
+use std::cell::{BorrowError, Cell, Ref, RefCell, RefMut};
 use std::fmt;
 
 /// A node inside a DOM-like tree.
@@ -29,12 +29,12 @@ pub struct Node<'a, T: 'a> {
 
 /// A simple Debug implementation that prints the children as a tree, without
 /// looping through the various interior pointer cycles.
-impl<'a, T: 'a> fmt::Debug for Node<'a, T>
+impl<'a, T: 'a> fmt::Debug for Node<'a, RefCell<T>>
 where
     T: fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        struct Children<'a, T>(Option<&'a Node<'a, T>>);
+        struct Children<'a, T>(Option<&'a Node<'a, RefCell<T>>>);
         impl<T: fmt::Debug> fmt::Debug for Children<'_, T> {
             fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
                 f.debug_list()
@@ -45,11 +45,14 @@ where
             }
         }
 
-        let mut struct_fmt = f.debug_struct("Node");
-        struct_fmt.field("data", &self.data);
-        struct_fmt.field("children", &Children(self.first_child.get()));
-        struct_fmt.finish()?;
-
+        if let Ok(data) = self.data.try_borrow() {
+            write!(f, "{data:?}")?;
+        } else {
+            write!(f, "!!mutably borrowed!!")?;
+        }
+        if let Some(first_child) = self.first_child.get() {
+            write!(f, " {:?}", &Children(Some(first_child)))?;
+        }
         Ok(())
     }
 }
@@ -259,9 +262,17 @@ impl<'a, T> Node<'a, T> {
 macro_rules! axis_iterator {
     (#[$attr:meta] $name:ident : $next:ident) => {
         #[$attr]
-        #[derive(Debug)]
         pub struct $name<'a, T: 'a>(Option<&'a Node<'a, T>>);
 
+        impl<'a, T: 'a> fmt::Debug for $name<'a, RefCell<T>>
+        where
+            T: fmt::Debug,
+        {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.debug_tuple(stringify!($name)).field(&self.0).finish()
+            }
+        }
+
         impl<'a, T> Iterator for $name<'a, T> {
             type Item = &'a Node<'a, T>;
 
@@ -304,9 +315,17 @@ axis_iterator! {
 }
 
 /// An iterator of references to a given node and its descendants, in tree order.
-#[derive(Debug)]
 pub struct Descendants<'a, T: 'a>(Traverse<'a, T>);
 
+impl<'a, T: 'a> fmt::Debug for Descendants<'a, RefCell<T>>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("Descendants").field(&self.0).finish()
+    }
+}
+
 impl<'a, T> Iterator for Descendants<'a, T> {
     type Item = &'a Node<'a, T>;
 
@@ -338,12 +357,23 @@ pub enum NodeEdge<T> {
 macro_rules! traverse_iterator {
     (#[$attr:meta] $name:ident : $first_child:ident, $next_sibling:ident) => {
         #[$attr]
-        #[derive(Debug)]
         pub struct $name<'a, T: 'a> {
             root: &'a Node<'a, T>,
             next: Option<NodeEdge<&'a Node<'a, T>>>,
         }
 
+        impl<'a, T: 'a> fmt::Debug for $name<'a, RefCell<T>>
+        where
+            T: fmt::Debug,
+        {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.debug_struct(stringify!($name))
+                    .field("root", &self.root)
+                    .field("next", &self.next)
+                    .finish()
+            }
+        }
+
         impl<'a, T> Iterator for $name<'a, T> {
             type Item = NodeEdge<&'a Node<'a, T>>;
 
@@ -434,19 +464,19 @@ fn it_works() {
     assert_eq!(drop_counter.get(), 10);
 }
 
-impl<'a, T> Node<'a, std::cell::RefCell<T>> {
+impl<'a, T> Node<'a, RefCell<T>> {
     /// Shorthand for `node.data.borrow()`.
-    pub fn data(&self) -> std::cell::Ref<'_, T> {
+    pub fn data(&self) -> Ref<'_, T> {
         self.data.borrow()
     }
 
     /// Shorthand for `node.data.try_borrow()`.
-    pub fn try_data(&self) -> Result<std::cell::Ref<'_, T>, std::cell::BorrowError> {
+    pub fn try_data(&self) -> Result<Ref<'_, T>, BorrowError> {
         self.data.try_borrow()
     }
 
     /// Shorthand for `node.data.borrow_mut()`.
-    pub fn data_mut(&self) -> std::cell::RefMut<'_, T> {
+    pub fn data_mut(&self) -> RefMut<'_, T> {
         self.data.borrow_mut()
     }
 }

src/cm.rs

@@ -143,7 +143,6 @@ impl<'a, 'o, 'c> CommonMarkFormatter<'a, 'o, 'c> {
         let mut it = s.char_indices();
 
         while let Some((mut i, c)) = it.next() {
-            // for (i, c) in s.char_indices() {
             if self.begin_line {
                 self.output.push_str(&self.prefix);
                 self.column = self.prefix.len();
@@ -261,7 +260,7 @@ impl<'a, 'o, 'c> CommonMarkFormatter<'a, 'o, 'c> {
             } else if ispunct_char(c) {
                 write!(self.output, "\\{}", c)?;
             } else {
-                write!(self, "&#{};", c as u8)?;
+                write!(self.output, "&#{};", c as u8)?;
             }
             self.column += self.output.len() - len_before;
         } else {
@@ -516,7 +515,7 @@ impl<'a, 'o, 'c> CommonMarkFormatter<'a, 'o, 'c> {
             )?;
             let mut current_len = listmarker.len();
 
-            while current_len < self.options.render.ol_width {
+            while current_len < self.options.render.ol_width.min(12) {
                 write!(listmarker, " ").unwrap();
                 current_len += 1;
             }

src/nodes.rs

@@ -203,7 +203,12 @@ pub enum NodeValue {
 
     /// **Inline**.  A character that has been [escaped](https://github.github.com/gfm/#backslash-escapes)
     ///
-    /// Enabled with [`escaped_char_spans`](crate::options::RenderBuilder::escaped_char_spans).
+    /// Included in the document tree only if the `escaped_char_spans` [parse
+    /// option](crate::options::ParseBuilder::escaped_char_spans) and/or [render
+    /// option](crate::options::RenderBuilder::escaped_char_spans) is enabled.
+    ///
+    /// If the render option is enabled, these are wrapped in distinct `<span>`
+    /// tags in output HTML and XML.
     Escaped,
 
     /// **Inline**.  A wikilink to some URL.
@@ -675,7 +680,7 @@ impl NodeValue {
 ///
 /// The struct contains metadata about the node's position in the original document, and the core
 /// enum, `NodeValue`.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct Ast {
     /// The node value itself.
     pub value: NodeValue,
@@ -690,6 +695,12 @@ pub struct Ast {
     pub(crate) line_offsets: Vec<usize>,
 }
 
+impl std::fmt::Debug for Ast {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "<{:?} ({})>", self.value, self.sourcepos)
+    }
+}
+
 #[allow(dead_code)]
 #[cfg(target_pointer_width = "64")]
 /// Assert the size of Ast is 128 bytes. It's pretty big; let's stop it getting
@@ -706,14 +717,20 @@ const AST_SIZE_ASSERTION: [u8; 128] = [0; std::mem::size_of::<Ast>()];
 const AST_NODE_SIZE_ASSERTION: [u8; 176] = [0; std::mem::size_of::<AstNode<'_>>()];
 
 /// Represents the position in the source Markdown this node was rendered from.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Sourcepos {
     /// The line and column of the first character of this node.
     pub start: LineColumn,
     /// The line and column of the last character of this node.
     pub end: LineColumn,
 }
 
+impl std::fmt::Debug for Sourcepos {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
+    }
+}
+
 impl std::fmt::Display for Sourcepos {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(

src/parser/inlines.rs

@@ -358,12 +358,14 @@ impl<'a, 'r, 'o, 'd, 'c, 'p> Subject<'a, 'r, 'o, 'd, 'c, 'p> {
 
     fn handle_newline(&mut self) -> Node<'a> {
         let nlpos = self.scanner.pos;
-        if self.input.as_bytes()[self.scanner.pos] == b'\r' {
+        if self.peek_byte() == Some(b'\r') {
             self.scanner.pos += 1;
         }
-        if self.input.as_bytes()[self.scanner.pos] == b'\n' {
+        if self.peek_byte() == Some(b'\n') {
             self.scanner.pos += 1;
         }
+        assert_ne!(nlpos, self.scanner.pos);
+
         let inl = if nlpos > 1
             && self.input.as_bytes()[nlpos - 1] == b' '
             && self.input.as_bytes()[nlpos - 2] == b' '
@@ -429,17 +431,13 @@ impl<'a, 'r, 'o, 'd, 'c, 'p> Subject<'a, 'r, 'o, 'd, 'c, 'p> {
                 self.scanner.pos - 1,
             );
 
-            if self.options.render.escaped_char_spans {
-                inl = self.make_inline(
-                    NodeValue::Escaped,
-                    self.scanner.pos - 2,
-                    self.scanner.pos - 1,
-                );
-                inl.append(inline_text);
-                inl
-            } else {
-                inline_text
-            }
+            inl = self.make_inline(
+                NodeValue::Escaped,
+                self.scanner.pos - 2,
+                self.scanner.pos - 1,
+            );
+            inl.append(inline_text);
+            inl
         } else if !self.eof() && self.skip_line_end() {
             let inl = self.make_inline(NodeValue::LineBreak, startpos, self.scanner.pos - 1);
             self.line += 1;
@@ -1016,10 +1014,22 @@ impl<'a, 'r, 'o, 'd, 'c, 'p> Subject<'a, 'r, 'o, 'd, 'c, 'p> {
         );
         // Build line_offsets by scanning for newlines in the content
         para_ast.line_offsets = vec![0];
-        for (i, &byte) in content.as_bytes().iter().enumerate() {
-            if byte == b'\n' {
-                para_ast.line_offsets.push(i + 1);
+
+        let mut i = 0;
+        let bytes = content.as_bytes();
+        let len = content.len();
+        while i < len {
+            match bytes[i] {
+                b'\r' if i + 1 < len && bytes[i + 1] == b'\n' => {
+                    i += 1;
+                    para_ast.line_offsets.push(i + 1);
+                }
+                b'\n' | b'\r' => {
+                    para_ast.line_offsets.push(i + 1);
+                }
+                _ => {}
             }
+            i += 1;
         }
 
         let para_node = self.arena.alloc(para_ast.into());
@@ -2268,7 +2278,7 @@ pub(crate) fn manual_scan_link_url(input: &str) -> Option<(&str, usize)> {
                 break;
             } else if b == b'\\' {
                 i += 2;
-            } else if b == b'\n' || b == b'<' {
+            } else if b == b'\n' || b == b'\r' || b == b'<' {
                 return None;
             } else {
                 i += 1;