fix all the overruns.

Author: kivikakk

fuzz/fuzz_targets/all_options.rs

@@ -54,6 +54,8 @@ struct FuzzExtensionOptions {
     subscript: bool,
     subtext: bool,
     cjk_friendly_emphasis: bool,
+    highlight: bool,
+    // non-bool below
     header_ids: bool,
     front_matter_delimiter: bool,
     image_url_rewriter: bool,
@@ -88,6 +90,8 @@ impl FuzzExtensionOptions {
             subscript: self.subscript,
             subtext: self.subtext,
             cjk_friendly_emphasis: self.cjk_friendly_emphasis,
+            highlight: self.highlight,
+            // non-bool below
             header_ids: if self.header_ids {
                 Some("user-content-".into())
             } else {

src/html.rs

@@ -1622,9 +1622,10 @@ fn tagfilter(literal: &str) -> bool {
     for t in TAGFILTER_BLACKLIST.iter() {
         if lc.starts_with(t) {
             let j = i + t.len();
-            return isspace(bytes[j])
-                || bytes[j] == b'>'
-                || (bytes[j] == b'/' && bytes.len() >= j + 2 && bytes[j + 1] == b'>');
+            let Some(&b) = bytes.get(j) else {
+                return false;
+            };
+            return isspace(b) || b == b'>' || (b == b'/' && bytes.get(j + 1) == Some(&b'>'));
         }
     }
 

src/parser/mod.rs

@@ -56,6 +56,7 @@ pub fn parse_document<'a>(arena: &'a Arena<'a>, md: &str, options: &Options) ->
 
 pub struct Parser<'a, 'o, 'c> {
     arena: &'a Arena<'a>,
+    options: &'o Options<'c>,
     refmap: RefMap,
     footnote_defs: inlines::FootnoteDefs<'a>,
     root: Node<'a>,
@@ -73,7 +74,6 @@ pub struct Parser<'a, 'o, 'c> {
     curline_end_col: usize,
     last_line_length: usize,
     total_size: usize,
-    options: &'o Options<'c>,
 }
 
 /// A reference link's resolved details.
@@ -100,6 +100,7 @@ where
     fn new(arena: &'a Arena<'a>, root: Node<'a>, options: &'o Options<'c>) -> Self {
         Parser {
             arena,
+            options,
             refmap: RefMap::new(),
             footnote_defs: inlines::FootnoteDefs::new(),
             root,
@@ -117,7 +118,6 @@ where
             curline_end_col: 0,
             last_line_length: 0,
             total_size: 0,
-            options,
         }
     }
 
@@ -371,17 +371,24 @@ where
         }
 
         self.indent = self.first_nonspace_column - self.column;
-        self.blank = self.first_nonspace < line.len()
-            && strings::is_line_end_char(bytes[self.first_nonspace]);
+        self.blank = bytes
+            .get(self.first_nonspace)
+            .map_or(true, |&b| strings::is_line_end_char(b));
     }
 
     fn parse_block_quote_prefix(&mut self, line: &str) -> bool {
         let bytes = line.as_bytes();
         let indent = self.indent;
-        if indent <= 3 && bytes[self.first_nonspace] == b'>' && self.is_not_greentext(line) {
+        if indent <= 3
+            && bytes.get(self.first_nonspace) == Some(&b'>')
+            && self.is_not_greentext(line)
+        {
             self.advance_offset(line, indent + 1, true);
 
-            if strings::is_space_or_tab(bytes[self.offset]) {
+            if bytes
+                .get(self.offset)
+                .map_or(false, |&b| strings::is_space_or_tab(b))
+            {
                 self.advance_offset(line, 1, true);
             }
 
@@ -393,7 +400,10 @@ where
 
     fn is_not_greentext(&self, line: &str) -> bool {
         !self.options.extension.greentext
-            || strings::is_space_or_tab(line.as_bytes()[self.first_nonspace + 1])
+            || line
+                .as_bytes()
+                .get(self.first_nonspace + 1)
+                .map_or(false, |&b| strings::is_space_or_tab(b))
     }
 
     fn parse_node_item_prefix(&mut self, line: &str, container: Node<'a>, nl: &NodeList) -> bool {
@@ -456,7 +466,7 @@ where
         }
 
         let bytes = line.as_bytes();
-        let matched = if self.indent <= 3 && bytes[self.first_nonspace] == fence_char {
+        let matched = if self.indent <= 3 && bytes.get(self.first_nonspace) == Some(&fence_char) {
             scanners::close_code_fence(&line[self.first_nonspace..]).unwrap_or(0)
         } else {
             0
@@ -472,7 +482,11 @@ where
         }
 
         let mut i = fence_offset;
-        while i > 0 && strings::is_space_or_tab(bytes[self.offset]) {
+        while i > 0
+            && bytes
+                .get(self.offset)
+                .map_or(false, |&b| strings::is_space_or_tab(b))
+        {
             self.advance_offset(line, 1, true);
             i -= 1;
         }
@@ -515,7 +529,7 @@ where
         };
 
         let bytes = line.as_bytes();
-        let matched = if self.indent <= 3 && bytes[self.first_nonspace] == b'>' {
+        let matched = if self.indent <= 3 && bytes.get(self.first_nonspace) == Some(&b'>') {
             scanners::close_multiline_block_quote_fence(&line[self.first_nonspace..]).unwrap_or(0)
         } else {
             0
@@ -540,7 +554,11 @@ where
         }
 
         let mut i = fence_offset;
-        while i > 0 && strings::is_space_or_tab(bytes[self.offset]) {
+        while i > 0
+            && bytes
+                .get(self.offset)
+                .map_or(false, |&b| strings::is_space_or_tab(b))
+        {
             self.advance_offset(line, 1, true);
             i -= 1;
         }
@@ -586,14 +604,16 @@ where
             }
         }
 
-        // Compute a candidate end position for the container by looking
-        // at its deepest-last descendant. Return it only if it has a
-        // non-zero column; the caller can fall back to the container's
-        // start position if desired.
-        if let Some(mut last_desc) = container.last_child() {
-            while let Some(ld) = last_desc.last_child() {
-                last_desc = ld;
-            }
+        // Compute a candidate end position for the container by looking at
+        // its last child. Return it only if it has a non-zero column; the
+        // caller can fall back to the container's start position if desired.
+        //
+        // We originally looked at the deepest-last descendant, but there
+        // may be intermediate containers that are larger than it, which we
+        // should use instead. If looking just at the last child isn't
+        // enough in some circumstances, we should consider using the widest
+        // of the last descendants.
+        if let Some(last_desc) = container.last_child() {
             let last_end = last_desc.data().sourcepos.end;
             if last_end.column != 0 {
                 return Some(last_end);
@@ -695,7 +715,8 @@ where
     }
 
     fn detect_alert(&self, line: &str) -> Option<AlertType> {
-        if self.options.extension.alerts && line.as_bytes()[self.first_nonspace] == b'>' {
+        if self.options.extension.alerts && line.as_bytes().get(self.first_nonspace) == Some(&b'>')
+        {
             scanners::alert_start(&line[self.first_nonspace..])
         } else {
             None
@@ -1033,7 +1054,11 @@ where
 
         let offset = self.first_nonspace + matched - self.offset;
         self.advance_offset(line, offset, false);
-        if strings::is_space_or_tab(line.as_bytes()[self.offset]) {
+        if line
+            .as_bytes()
+            .get(self.offset)
+            .map_or(false, |&b| strings::is_space_or_tab(b))
+        {
             self.advance_offset(line, 1, true);
         }
 
@@ -1172,12 +1197,20 @@ where
             (self.partially_consumed_tab, self.offset, self.column);
 
         let bytes = line.as_bytes();
-        while self.column - save_column <= 5 && strings::is_space_or_tab(bytes[self.offset]) {
+        while self.column - save_column <= 5
+            && bytes
+                .get(self.offset)
+                .map_or(false, |&b| strings::is_space_or_tab(b))
+        {
             self.advance_offset(line, 1, true);
         }
 
         let i = self.column - save_column;
-        if !(1..5).contains(&i) || strings::is_line_end_char(bytes[self.offset]) {
+        if !(1..5).contains(&i)
+            || bytes
+                .get(self.offset)
+                .map_or(false, |&b| strings::is_line_end_char(b))
+        {
             nl.padding = matched + 1;
             self.offset = save_offset;
             self.column = save_column;
@@ -1559,8 +1592,11 @@ where
             _ => false,
         } {
             ast.sourcepos.end = (self.line_number, self.curline_end_col).into();
-        } else if matches!(ast.value, NodeValue::ThematicBreak) {
-            // sourcepos.end set during opening.
+        } else if matches!(
+            ast.value,
+            NodeValue::ThematicBreak | NodeValue::TableRow(..) | NodeValue::Table(..)
+        ) {
+            // sourcepos.end set by itself or managed below.
         } else {
             ast.sourcepos.end = (self.line_number - 1, self.last_line_length).into();
         }
@@ -1630,7 +1666,7 @@ where
                 }
                 nl.tight = self.determine_list_tight(node);
             }
-            NodeValue::FootnoteDefinition(_) => {
+            NodeValue::Table(..) | NodeValue::FootnoteDefinition(_) => {
                 if let Some(candidate_end) = self.fix_zero_end_columns(node) {
                     ast.sourcepos.end = candidate_end;
                 }
@@ -2134,6 +2170,9 @@ fn parse_list_marker(
             let mut i = pos;
             while strings::is_space_or_tab(bytes[i]) {
                 i += 1;
+                if i == bytes.len() {
+                    return None;
+                }
             }
             if strings::is_line_end_char(bytes[i]) {
                 return None;

src/parser/table.rs

@@ -166,9 +166,7 @@ fn try_opening_row<'a>(
         NodeValue::TableRow(false),
         sourcepos.start.column,
     );
-    {
-        new_row.data_mut().sourcepos.end.column = sourcepos.end.column;
-    }
+    new_row.data_mut().sourcepos.end.column = parser.curline_end_col;
 
     let mut i = 0;
     let mut last_column = sourcepos.start.column;

src/strings.rs

@@ -126,6 +126,9 @@ pub fn remove_trailing_blank_lines_slice(line: &str) -> &str {
 
 fn remove_trailing_blank_lines_ix(line: &str) -> usize {
     let line_bytes = line.as_bytes();
+    if line.len() == 0 {
+        return 0;
+    }
     let mut i = line.len() - 1;
     loop {
         let c = line_bytes[i];

src/tests/fuzz.rs

@@ -496,3 +496,47 @@ fn tasklist_and_escapes_do_not_play() {
         ])
     );
 }
+
+#[test]
+fn dont_try_this_at_home() {
+    assert_ast_match!(
+        [extension.alerts, extension.table, parse.ignore_setext],
+        "\u{3}\n--\nT",
+        (document (1:1-3:1) [
+            (table (1:1-3:1) [
+                (table_row (1:1-1:1) [
+                    (table_cell (1:1-1:1) [
+                        (text (1:1-1:1) "\u{3}")
+                    ])
+                ])
+                (table_row (3:1-3:1) [
+                    (table_cell (3:1-3:1) [
+                        (text (3:1-3:1) "T")
+                    ])
+                ])
+            ])
+        ])
+    );
+}
+
+#[test]
+fn cargo_run_no_cargo_road() {
+    assert_ast_match!(
+        [],
+        "\t",
+        (document (1:1-1:1))
+    );
+}
+
+#[test]
+fn oye_siri_prende_las_luces() {
+    assert_ast_match!(
+        [],
+        "* ",
+        (document (1:1-1:2) [
+            (list (1:1-1:2) [
+                (item (1:1-1:2))
+            ])
+        ])
+    );
+}