Merge pull request #594 from Mrmaxmeier/fuzzer-cleanup

kivikakk · web-flow · commit 36b06b8a9466 · 2025-09-13T12:46:17.000+10:00
Cleanup fuzzers, add unresolved `relaxed_autolink_email_in_footnote` test
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
@@ -60,3 +60,15 @@ name = "gfm_footnotes"
 path = "fuzz_targets/gfm_footnotes.rs"
 test = false
 doc = false
+
+[[bin]]
+name = "commonmark"
+path = "fuzz_targets/commonmark.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "parse"
+path = "fuzz_targets/parse.rs"
+test = false
+doc = false
diff --git a/fuzz/fuzz_targets/cli_default.rs b/fuzz/fuzz_targets/cli_default.rs
@@ -7,7 +7,7 @@ use comrak::{markdown_to_html_with_plugins, plugins::syntect::SyntectAdapter, Pl
 // Note that we end up fuzzing Syntect here.
 
 fuzz_target!(|s: &str| {
-    let adapter = SyntectAdapter::new("base16-ocean.dark");
+    let adapter = SyntectAdapter::new(Some("base16-ocean.dark"));
 
     let mut plugins = Plugins::default();
     plugins.render.codefence_syntax_highlighter = Some(&adapter);
diff --git a/fuzz/fuzz_targets/commonmark.rs b/fuzz/fuzz_targets/commonmark.rs
@@ -0,0 +1,18 @@
+#![no_main]
+use comrak::{markdown_to_commonmark, markdown_to_commonmark_xml, Options};
+use libfuzzer_sys::arbitrary::Arbitrary;
+use libfuzzer_sys::fuzz_target;
+
+#[derive(Arbitrary, Debug)]
+struct Input<'a> {
+    options: Options<'a>,
+    markdown: &'a str,
+}
+
+fuzz_target!(|input: Input| {
+    if input.options.render.width > 100 || input.options.render.ol_width > 100 {
+        return;
+    }
+    let _ = markdown_to_commonmark(input.markdown, &input.options);
+    let _ = markdown_to_commonmark_xml(input.markdown, &input.options);
+});
diff --git a/fuzz/fuzz_targets/fuzz_options.rs b/fuzz/fuzz_targets/fuzz_options.rs
@@ -7,7 +7,7 @@ use comrak::{markdown_to_html, Options};
 #[derive(Debug, arbitrary::Arbitrary)]
 struct FuzzInput<'s> {
     s: &'s str,
-    opts: Options,
+    opts: Options<'s>,
 }
 
 fuzz_target!(|i: FuzzInput| {
diff --git a/fuzz/fuzz_targets/gfm.rs b/fuzz/fuzz_targets/gfm.rs
@@ -9,16 +9,20 @@ use comrak::{markdown_to_html, ExtensionOptions, Options, RenderOptions};
 // options are routinely used by Commonmarker users.
 
 fuzz_target!(|s: &str| {
-    let mut extension = ExtensionOptions::default();
-    extension.strikethrough = true;
-    extension.tagfilter = true;
-    extension.table = true;
-    extension.autolink = true;
+    let extension = ExtensionOptions {
+        strikethrough: true,
+        tagfilter: true,
+        table: true,
+        autolink: true,
+        ..Default::default()
+    };
 
-    let mut render = RenderOptions::default();
-    render.hardbreaks = true;
-    render.github_pre_lang = true;
-    render.unsafe_ = true;
+    let render = RenderOptions {
+        hardbreaks: true,
+        github_pre_lang: true,
+        unsafe_: true,
+        ..Default::default()
+    };
 
     markdown_to_html(
         s,
diff --git a/fuzz/fuzz_targets/gfm_footnotes.rs b/fuzz/fuzz_targets/gfm_footnotes.rs
@@ -9,17 +9,21 @@ use comrak::{markdown_to_html, ExtensionOptions, Options, RenderOptions};
 // options are routinely used by Commonmarker users.
 
 fuzz_target!(|s: &str| {
-    let mut extension = ExtensionOptions::default();
-    extension.strikethrough = true;
-    extension.tagfilter = true;
-    extension.table = true;
-    extension.autolink = true;
-    extension.footnotes = true;
+    let extension = ExtensionOptions {
+        strikethrough: true,
+        tagfilter: true,
+        table: true,
+        autolink: true,
+        footnotes: true,
+        ..Default::default()
+    };
 
-    let mut render = RenderOptions::default();
-    render.hardbreaks = true;
-    render.github_pre_lang = true;
-    render.unsafe_ = true;
+    let render = RenderOptions {
+        hardbreaks: true,
+        github_pre_lang: true,
+        unsafe_: true,
+        ..Default::default()
+    };
 
     markdown_to_html(
         s,
diff --git a/fuzz/fuzz_targets/gfm_sourcepos.rs b/fuzz/fuzz_targets/gfm_sourcepos.rs
@@ -9,17 +9,21 @@ use comrak::{markdown_to_html, ExtensionOptions, Options, RenderOptions};
 // options are routinely used by Commonmarker users.
 
 fuzz_target!(|s: &str| {
-    let mut extension = ExtensionOptions::default();
-    extension.strikethrough = true;
-    extension.tagfilter = true;
-    extension.table = true;
-    extension.autolink = true;
+    let extension = ExtensionOptions {
+        strikethrough: true,
+        tagfilter: true,
+        table: true,
+        autolink: true,
+        ..Default::default()
+    };
 
-    let mut render = RenderOptions::default();
-    render.hardbreaks = true;
-    render.github_pre_lang = true;
-    render.unsafe_ = true;
-    render.sourcepos = true;
+    let render = RenderOptions {
+        hardbreaks: true,
+        github_pre_lang: true,
+        unsafe_: true,
+        sourcepos: true,
+        ..Default::default()
+    };
 
     markdown_to_html(
         s,
diff --git a/fuzz/fuzz_targets/parse.rs b/fuzz/fuzz_targets/parse.rs
@@ -0,0 +1,15 @@
+#![no_main]
+use comrak::{parse_document, Arena, Options};
+use libfuzzer_sys::arbitrary::{self, Arbitrary};
+use libfuzzer_sys::fuzz_target;
+
+#[derive(Arbitrary, Debug)]
+struct Input<'a> {
+    options: Options<'a>,
+    markdown: &'a str,
+}
+
+fuzz_target!(|input: Input| {
+    let arena = Arena::new();
+    let _ = parse_document(&arena, input.markdown, &input.options);
+});
diff --git a/fuzz/fuzz_targets/quadratic.rs b/fuzz/fuzz_targets/quadratic.rs
@@ -1,4 +1,3 @@
-#![feature(div_duration)]
 #![feature(int_roundings)]
 #![no_main]
 use comrak::{
@@ -35,6 +34,7 @@ enum Markdown {
     // foofoo
     // foofoofoo
     // foofoofoofoo
+    #[allow(clippy::enum_variant_names)]
     Markdown {
         markdown: String,
     },
@@ -92,11 +92,11 @@ impl Markdown {
 
                     // Place the markdown in `output`
                     for _ in 0..iterations {
-                        output.push_str(&prefix)
+                        output.push_str(prefix)
                     }
-                    output.push_str(&markdown);
+                    output.push_str(markdown);
                     for _ in 0..iterations {
-                        output.push_str(&suffix)
+                        output.push_str(suffix)
                     }
                 }
                 output
@@ -117,9 +117,9 @@ impl Markdown {
 
                     // Place the markdown in `output`
                     for _ in 0..iterations {
-                        output.push_str(&prefix)
+                        output.push_str(prefix)
                     }
-                    output.push_str(&markdown);
+                    output.push_str(markdown);
                 }
                 output
             }
@@ -131,7 +131,7 @@ impl Markdown {
     }
 
     fn should_fuzz_string(s: &str) -> bool {
-        if s.len() == 0 {
+        if s.is_empty() {
             // Repeating a zero-length string is useless
             return false;
         }
@@ -147,18 +147,18 @@ impl Markdown {
     /// A filter to guiding the fuzzer. The fuzzer will skip any input which fails this predicate
     fn should_fuzz(&self) -> bool {
         match self {
-            Markdown::Markdown { markdown } => Markdown::should_fuzz_string(&markdown),
+            Markdown::Markdown { markdown } => Markdown::should_fuzz_string(markdown),
             Markdown::Sandwich {
                 prefix,
                 markdown,
                 suffix,
             } => {
-                Markdown::should_fuzz_string(&prefix)
-                    && Markdown::should_fuzz_string(&markdown)
-                    && Markdown::should_fuzz_string(&suffix)
+                Markdown::should_fuzz_string(prefix)
+                    && Markdown::should_fuzz_string(markdown)
+                    && Markdown::should_fuzz_string(suffix)
             }
             Markdown::Tree { prefix, markdown } => {
-                Markdown::should_fuzz_string(&prefix) && Markdown::should_fuzz_string(&markdown)
+                Markdown::should_fuzz_string(prefix) && Markdown::should_fuzz_string(markdown)
             }
         }
     }
@@ -172,7 +172,7 @@ struct FuzzOptions {
 }
 
 impl FuzzOptions {
-    fn to_options(&self) -> Options {
+    fn to_options(&self) -> Options<'_> {
         Options {
             extension: self.extension.to_options(),
             parse: self.parse.to_options(),
@@ -204,29 +204,30 @@ struct FuzzExtensionOptions {
 }
 
 impl FuzzExtensionOptions {
-    fn to_options(&self) -> ExtensionOptions {
-        let mut extension = ExtensionOptions::default();
-        extension.strikethrough = self.strikethrough;
-        extension.tagfilter = self.tagfilter;
-        extension.table = self.table;
-        extension.autolink = self.autolink;
-        extension.tasklist = self.tasklist;
-        extension.superscript = self.superscript;
-        extension.footnotes = self.footnotes;
-        extension.description_lists = self.description_lists;
-        extension.multiline_block_quotes = self.multiline_block_quotes;
-        extension.math_dollars = self.math_dollars;
-        extension.math_code = self.math_code;
-        extension.shortcodes = self.shortcodes;
-        extension.wikilinks_title_after_pipe = self.wikilinks_title_after_pipe;
-        extension.wikilinks_title_before_pipe = self.wikilinks_title_before_pipe;
-        extension.underline = self.underline;
-        extension.spoiler = self.spoiler;
-        extension.greentext = self.greentext;
-        extension.alerts = self.alerts;
-        extension.front_matter_delimiter = None;
-        extension.header_ids = None;
-        extension
+    fn to_options(&self) -> ExtensionOptions<'_> {
+        ExtensionOptions {
+            strikethrough: self.strikethrough,
+            tagfilter: self.tagfilter,
+            table: self.table,
+            autolink: self.autolink,
+            tasklist: self.tasklist,
+            superscript: self.superscript,
+            footnotes: self.footnotes,
+            description_lists: self.description_lists,
+            multiline_block_quotes: self.multiline_block_quotes,
+            math_dollars: self.math_dollars,
+            math_code: self.math_code,
+            shortcodes: self.shortcodes,
+            wikilinks_title_after_pipe: self.wikilinks_title_after_pipe,
+            wikilinks_title_before_pipe: self.wikilinks_title_before_pipe,
+            underline: self.underline,
+            spoiler: self.spoiler,
+            greentext: self.greentext,
+            alerts: self.alerts,
+            front_matter_delimiter: None,
+            header_ids: None,
+            ..Default::default()
+        }
     }
 }
 
@@ -238,13 +239,14 @@ struct FuzzParseOptions {
 }
 
 impl FuzzParseOptions {
-    fn to_options(&self) -> ParseOptions {
-        let mut parse = ParseOptions::default();
-        parse.smart = self.smart;
-        parse.default_info_string = None;
-        parse.relaxed_tasklist_matching = self.relaxed_tasklist_matching;
-        parse.relaxed_autolinks = self.relaxed_autolinks;
-        parse
+    fn to_options(&self) -> ParseOptions<'_> {
+        ParseOptions {
+            smart: self.smart,
+            default_info_string: None,
+            relaxed_tasklist_matching: self.relaxed_tasklist_matching,
+            relaxed_autolinks: self.relaxed_autolinks,
+            ..Default::default()
+        }
     }
 }
 
@@ -263,17 +265,18 @@ struct FuzzRenderOptions {
 
 impl FuzzRenderOptions {
     fn to_options(&self) -> RenderOptions {
-        let mut render = RenderOptions::default();
-        render.hardbreaks = self.hardbreaks;
-        render.github_pre_lang = self.github_pre_lang;
-        render.full_info_string = self.full_info_string;
-        render.width = self.width;
-        render.unsafe_ = self.unsafe_;
-        render.escape = self.escape;
-        render.list_style = self.list_style;
-        render.sourcepos = self.sourcepos;
-        render.escaped_char_spans = self.escaped_char_spans;
-        render
+        RenderOptions {
+            hardbreaks: self.hardbreaks,
+            github_pre_lang: self.github_pre_lang,
+            full_info_string: self.full_info_string,
+            width: self.width,
+            unsafe_: self.unsafe_,
+            escape: self.escape,
+            list_style: self.list_style,
+            sourcepos: self.sourcepos,
+            escaped_char_spans: self.escaped_char_spans,
+            ..Default::default()
+        }
     }
 }
 
diff --git a/src/html.rs b/src/html.rs
@@ -577,10 +577,7 @@ fn render_code_block<'a, T>(
 
                     highlighter.write_highlighted(
                         context,
-                        match std::str::from_utf8(&info[..first_tag]) {
-                            Ok(lang) => Some(lang),
-                            Err(_) => None,
-                        },
+                        std::str::from_utf8(&info[..first_tag]).ok(),
                         &ncb.literal,
                     )?;
 
diff --git a/src/parser/autolink.rs b/src/parser/autolink.rs
@@ -241,10 +241,7 @@ pub fn www_match<'a>(
         return None;
     }
 
-    let mut link_end = match check_domain(&contents[i..], false) {
-        None => return None,
-        Some(link_end) => link_end,
-    };
+    let mut link_end = check_domain(&contents[i..], false)?;
 
     while i + link_end < contents.len() && !isspace(contents[i + link_end]) {
         // basic test to detect whether we're in a normal markdown link - not exhaustive
@@ -411,10 +408,7 @@ pub fn url_match<'a>(
         }
     }
 
-    let mut link_end = match check_domain(&contents[i + 3..], true) {
-        None => return None,
-        Some(link_end) => link_end,
-    };
+    let mut link_end = check_domain(&contents[i + 3..], true)?;
 
     while link_end < size - i && !isspace(contents[i + link_end]) {
         // basic test to detect whether we're in a normal markdown link - not exhaustive
diff --git a/src/parser/inlines.rs b/src/parser/inlines.rs
@@ -261,9 +261,7 @@ impl<'a, 'r, 'o, 'd, 'i, 'c> Subject<'a, 'r, 'o, 'd, 'i, 'c> {
             skip_chars: [false; 256],
             smart_chars: [false; 256],
         };
-        for &c in &[
-            b'\n', b'\r', b'_', b'*', b'"', b'`', b'\\', b'&', b'<', b'[', b']', b'!', b'$',
-        ] {
+        for &c in b"\n\r_*\"`\\&<[]!$" {
             s.special_chars[c as usize] = true;
         }
         if options.extension.autolink {
diff --git a/src/parser/table.rs b/src/parser/table.rs
diff --git a/src/tests/fuzz.rs b/src/tests/fuzz.rs

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ use comrak::{markdown_to_html, Options};`
`7`	`7`	`#[derive(Debug, arbitrary::Arbitrary)]`
`8`	`8`	`struct FuzzInput<'s> {`
`9`	`9`	`s: &'s str,`
`10`		`- opts: Options,`
	`10`	`+ opts: Options<'s>,`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`fuzz_target!(\|i: FuzzInput\| {`