🔧 Make sure docstrings are ///

Just a minor change, to help with intellisense

src/generics/inline/emph_pair.rs

@@ -135,8 +135,8 @@ impl<const MARKER: char, const CAN_SPLIT_WORD: bool> InlineRule for EmphPairScan
     }
 }
 
-// Assuming last token is a closing delimiter we just inserted,
-// try to find opener(s). If any are found, move stuff to nested emph node.
+/// Assuming last token is a closing delimiter we just inserted,
+/// try to find opener(s). If any are found, move stuff to nested emph node.
 fn scan_and_match_delimiters<const MARKER: char>(state: &mut InlineState, mut closer_token: Node) -> Node {
     if state.node.children.is_empty() { return closer_token; } // must have at least opener and closer
 
@@ -270,14 +270,14 @@ impl CoreRule for FragmentsJoin {
 }
 
 
-// Clean up tokens after emphasis and strikethrough postprocessing:
-// merge adjacent text nodes into one and re-calculate all token levels
-//
-// This is necessary because initially emphasis delimiter markers (*, _, ~)
-// are treated as their own separate text tokens. Then emphasis rule either
-// leaves them as text (needed to merge with adjacent text) or turns them
-// into opening/closing tags (which messes up levels inside).
-//
+/// Clean up tokens after emphasis and strikethrough postprocessing:
+/// merge adjacent text nodes into one and re-calculate all token levels
+///
+/// This is necessary because initially emphasis delimiter markers (*, _, ~)
+/// are treated as their own separate text tokens. Then emphasis rule either
+/// leaves them as text (needed to merge with adjacent text) or turns them
+/// into opening/closing tags (which messes up levels inside).
+///
 fn fragments_join(node: &mut Node) {
     // replace all emph markers with text tokens
     for token in node.children.iter_mut() {

src/generics/inline/full_link.rs

@@ -90,8 +90,8 @@ impl<const PREFIX: char, const ENABLE_NESTED: bool> InlineRule for LinkPrefixSca
 }
 
 #[doc(hidden)]
-// this rule makes sure that parser is stopped on "]" character,
-// but it actually doesn't do anything
+/// this rule makes sure that parser is stopped on "]" character,
+/// but it actually doesn't do anything
 pub struct LinkScannerEnd;
 impl InlineRule for LinkScannerEnd {
     const MARKER: char = ']';

src/parser/block/mod.rs

@@ -31,8 +31,8 @@ impl BlockParser {
         Self::default()
     }
 
-    // Generate tokens for input range
-    //
+    /// Generate tokens for input range
+    ///
     pub fn tokenize(&self, state: &mut BlockState) {
         stacker::maybe_grow(64*1024, 1024*1024, || {
             let mut has_empty_lines = false;
@@ -104,8 +104,8 @@ impl BlockParser {
         });
     }
 
-    // Process input string and push block tokens into `out_tokens`
-    //
+    /// Process input string and push block tokens into `out_tokens`
+    ///
     pub fn parse(&self, src: &str, node: Node, md: &MarkdownIt, root_ext: &mut RootExtSet) -> Node {
         let mut state = BlockState::new(src, md, root_ext, node);
         self.tokenize(&mut state);

src/parser/block/state.rs

@@ -197,8 +197,8 @@ impl<'a, 'b> BlockState<'a, 'b> {
         line
     }
 
-    // return line indent of specific line, taking into account blockquotes and lists;
-    // it may be negative if a text has less indentation than current list item
+    /// return line indent of specific line, taking into account blockquotes and lists;
+    /// it may be negative if a text has less indentation than current list item
     #[must_use]
     #[inline]
     pub fn line_indent(&self, line: usize) -> i32 {
@@ -209,7 +209,7 @@ impl<'a, 'b> BlockState<'a, 'b> {
         }
     }
 
-    // return a single line, trimming initial spaces
+    /// return a single line, trimming initial spaces
     #[must_use]
     #[inline]
     pub fn get_line(&self, line: usize) -> &str {
@@ -222,8 +222,8 @@ impl<'a, 'b> BlockState<'a, 'b> {
         }
     }
 
-    // Cut a range of lines begin..end (not including end) from the source without preceding indent.
-    // Returns a string (lines) plus a mapping (start of each line in result -> start of each line in source).
+    /// Cut a range of lines begin..end (not including end) from the source without preceding indent.
+    /// Returns a string (lines) plus a mapping (start of each line in result -> start of each line in source).
     pub fn get_lines(&self, begin: usize, end: usize, indent: usize, keep_last_lf: bool) -> (String, Vec<(usize, usize)>) {
         debug_assert!(begin <= end);
 

src/parser/inline/builtin/skip_text.rs

@@ -1,6 +1,6 @@
-// Skip text characters for text token, place those to pending buffer
-// and increment current pos
-//
+//! Skip text characters for text token, place those to pending buffer
+//! and increment current pos
+//!
 use regex::{self, Regex};
 
 use crate::parser::inline::{InlineRule, InlineState};
@@ -43,14 +43,14 @@ pub(crate) enum TextScannerImpl {
     SkipRegex(Regex),
 }
 
-// Rule to skip pure text
-// '{}$%@~+=:' reserved for extentions
-//
-// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
-//
-// !!!! Don't confuse with "Markdown ASCII Punctuation" chars
-// http://spec.commonmark.org/0.15/#ascii-punctuation-character
-//
+/// Rule to skip pure text
+/// '{}$%@~+=:' reserved for extensions
+///
+/// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
+///
+/// !!!! Don't confuse with "Markdown ASCII Punctuation" chars
+/// http://spec.commonmark.org/0.15/#ascii-punctuation-character
+///
 pub struct TextScanner;
 
 impl TextScanner {

src/parser/inline/mod.rs

@@ -40,9 +40,9 @@ impl InlineParser {
         Self::default()
     }
 
-    // Skip single token by running all rules in validation mode;
-    // returns `true` if any rule reported success
-    //
+    /// Skip single token by running all rules in validation mode;
+    /// returns `true` if any rule reported success
+    ///
     pub fn skip_token(&self, state: &mut InlineState) {
         stacker::maybe_grow(64*1024, 1024*1024, || {
             let mut ok = None;
@@ -78,8 +78,8 @@ impl InlineParser {
         });
     }
 
-    // Generate tokens for input range
-    //
+    /// Generate tokens for input range
+    ///
     pub fn tokenize(&self, state: &mut InlineState) {
         stacker::maybe_grow(64*1024, 1024*1024, || {
             let end = state.pos_max;
@@ -120,8 +120,8 @@ impl InlineParser {
         });
     }
 
-    // Process input string and push inline tokens into `out_tokens`
-    //
+    /// Process input string and push inline tokens into `out_tokens`
+    ///
     pub fn parse(
         &self,
         src: String,

src/parser/inline/state.rs

@@ -140,12 +140,12 @@ impl<'a, 'b> InlineState<'a, 'b> {
         }
     }
 
-    // Scan a sequence of emphasis-like markers, and determine whether
-    // it can start an emphasis sequence or end an emphasis sequence.
-    //
-    //  - start - position to scan from (it should point at a valid marker);
-    //  - can_split_word - determine if these markers can be found inside a word
-    //
+    /// Scan a sequence of emphasis-like markers, and determine whether
+    /// it can start an emphasis sequence or end an emphasis sequence.
+    ///
+    ///  - start - position to scan from (it should point at a valid marker);
+    ///  - can_split_word - determine if these markers can be found inside a word
+    ///
     #[must_use]
     pub fn scan_delims(&self, start: usize, can_split_word: bool) -> DelimiterRun {
         let mut left_flanking = true;

src/plugins/html/utils/blocks.rs

@@ -1,6 +1,6 @@
-// List of valid html blocks names, accorting to commonmark spec
-// http://jgm.github.io/CommonMark/spec.html#html-blocks
-//
+//! List of valid html blocks names, accorting to commonmark spec
+//! http://jgm.github.io/CommonMark/spec.html#html-blocks
+//!
 
 pub const HTML_BLOCKS: [&str; 62] = [
     "address",

src/plugins/html/utils/regexps.rs

@@ -1,5 +1,5 @@
-// Regexps to match html elements
-//
+//! Regexps to match html elements
+//!
 #![allow(non_upper_case_globals)]
 use const_format::formatcp;
 use once_cell::sync::Lazy;