fix node ext propagation from inline rules

Author: rlidwka

src/parser/inline/builtin/inline_parser.rs

@@ -59,6 +59,7 @@ impl InlineParserRule {
                     let mut inline_ext = std::mem::take(&mut data.ext);
 
                     let mut root = std::mem::take(child);
+                    root.ext = std::mem::take(&mut node.ext);
                     root.children = Vec::new();
                     root = if CAN_FAIL {
                         md.inline.try_parse(content, mapping, root, md, root_ext, &mut inline_ext)?
@@ -68,6 +69,7 @@ impl InlineParserRule {
 
                     let len = root.children.len();
                     node.children.splice(idx..=idx, std::mem::take(&mut root.children));
+                    node.ext = std::mem::take(&mut root.ext);
                     idx += len;
                 } else {
                     stacker::maybe_grow(64*1024, 1024*1024, || -> Result<()> {

tests/extras.rs

@@ -111,6 +111,70 @@ r#"<blockquote>
         run("<https://www.reddit.com/r/programming/comments/vxttiq/comment/ifyqsqt/?utm_source=reddit&utm_medium=web2x&context=3>",
             "<p><a href=\"https://www.reddit.com/r/programming/comments/vxttiq/comment/ifyqsqt/?utm_source=reddit&amp;utm_medium=web2x&amp;context=3\">www.reddit.com/r/programming/comments/…/ifyqsqt/?…</a></p>");
     }
+
+    #[test]
+    fn test_node_ext_propagation() {
+        use markdown_it::parser::block::{BlockRule, BlockState};
+        use markdown_it::parser::core::CoreRule;
+        use markdown_it::parser::extset::NodeExt;
+        use markdown_it::parser::inline::{InlineRule, InlineState};
+        use markdown_it::{MarkdownIt, Node};
+
+        #[derive(Debug, Default)]
+        struct NodeErrors(Vec<&'static str>);
+        impl NodeExt for NodeErrors {}
+
+        struct MyInlineRule;
+        impl InlineRule for MyInlineRule {
+            const MARKER: char = '@';
+
+            fn run(state: &mut InlineState) -> Option<(Node, usize)> {
+                let err = state.node.ext.get_or_insert_default::<NodeErrors>();
+                err.0.push("inline");
+                None
+            }
+        }
+
+        struct MyBlockRule;
+        impl BlockRule for MyBlockRule {
+            fn run(state: &mut BlockState) -> Option<(Node, usize)> {
+                let err = state.node.ext.get_or_insert_default::<NodeErrors>();
+                err.0.push("block");
+                None
+            }
+        }
+
+        struct MyCoreRule;
+        impl CoreRule for MyCoreRule {
+            fn run(root: &mut Node, _md: &MarkdownIt) {
+                let err = root.ext.get_or_insert_default::<NodeErrors>();
+                err.0.push("core");
+            }
+        }
+
+        let md = &mut markdown_it::MarkdownIt::new();
+        markdown_it::plugins::cmark::add(md);
+
+        md.inline.add_rule::<MyInlineRule>();
+        md.block.add_rule::<MyBlockRule>();
+        md.add_rule::<MyCoreRule>().after_all();
+
+        let text1 = r#"*hello @world*"#;
+        let ast = md.parse(text1);
+        let mut collected: Vec<&str> = vec![];
+
+        ast.walk_post(|node, _| -> markdown_it::Result<()> {
+            if let Some(errors) = node.ext.get::<NodeErrors>() {
+                collected.extend(errors.0.iter());
+            }
+            Ok(())
+        }).unwrap();
+
+        assert_eq!(
+            collected,
+            vec!["inline", "block", "core"],
+        );
+    }
 }
 
 mod examples {