Support more parsers for debug nodes

Author: zesterer

src/blanket.rs

@@ -6,6 +6,10 @@ where
     I: Input<'src>,
     E: ParserExtra<'src, I>,
 {
+    fn node_info(&self, scope: &mut debug::NodeScope) -> debug::NodeInfo {
+        (*self).node_info(scope)
+    }
+
     fn go<M: Mode>(&self, inp: &mut InputRef<'src, '_, I, E>) -> PResult<M, O>
     where
         Self: Sized,

src/combinator.rs

@@ -1309,6 +1309,15 @@ where
         >,
     >,
 {
+    #[doc(hidden)]
+    #[cfg(feature = "debug")]
+    fn node_info(&self, scope: &mut debug::NodeScope) -> debug::NodeInfo {
+        debug::NodeInfo::NestedIn(
+            Box::new(self.parser_a.node_info(scope)),
+            Box::new(self.parser_b.node_info(scope)),
+        )
+    }
+
     #[inline(always)]
     fn go<M: Mode>(&self, inp: &mut InputRef<'src, '_, I, E>) -> PResult<M, O> {
         let before = inp.save();

src/debug.rs

@@ -44,6 +44,7 @@ pub enum NodeInfo {
     OrNot(Box<Self>),
     Labelled(String, Box<Self>),
     Builtin(String),
+    NestedIn(Box<Self>, Box<Self>),
 }
 
 impl NodeInfo {
@@ -92,6 +93,11 @@ impl NodeInfo {
             }
             Self::Any => "any".to_string(),
             Self::Builtin(s) => s.to_string(),
+            Self::NestedIn(a, b) => format!(
+                "({}).nested_in({})",
+                a.bnf_inner(depth, defs, 0),
+                b.bnf_inner(depth, defs, 0)
+            ),
             Self::Padded(inner) | Self::Filter(inner) | Self::Labelled(_, inner) => {
                 inner.bnf_inner(depth, defs, ctx)
             }
@@ -146,6 +152,20 @@ impl NodeInfo {
                 NonTerminal::new(label.to_string()),
             )),
             Self::Builtin(s) => Box::new(Terminal::new(s.to_string())),
+            Self::NestedIn(inner, outer) => Box::new(LabeledBox::new(
+                Box::new(LabeledBox::new(
+                    outer.railroad_inner(defs),
+                    NonTerminal::new("outer".to_string()),
+                )),
+                Box::new(LabeledBox::new(
+                    Sequence::new(vec![
+                        Box::new(SimpleStart) as Box<dyn Node>,
+                        inner.railroad_inner(defs),
+                        Box::new(SimpleEnd),
+                    ]),
+                    NonTerminal::new("inner".to_string()),
+                )),
+            )),
             Self::Any => Box::new(Terminal::new("any".to_string())),
             Self::OrNot(inner) => Box::new(Optional::new(inner.railroad_inner(defs))),
         }

src/recursive.rs

@@ -159,6 +159,25 @@ where
     I: Input<'src>,
     E: ParserExtra<'src, I>,
 {
+    #[doc(hidden)]
+    #[cfg(feature = "debug")]
+    fn node_info(&self, scope: &mut debug::NodeScope) -> debug::NodeInfo {
+        // Debug features don't fall under MSRV
+        #[allow(clippy::incompatible_msrv)]
+        let ptr = match &self.inner {
+            RecursiveInner::Owned(x) => Rc::as_ptr(x).addr(),
+            RecursiveInner::Unowned(x) => rc::Weak::as_ptr(x).addr(),
+        };
+        scope.lookup_rec(ptr, |scope| {
+            self.parser()
+                .inner
+                .get()
+                .expect("Recursive parser used before being defined")
+                .as_ref()
+                .node_info(scope)
+        })
+    }
+
     #[inline]
     fn go<M: Mode>(&self, inp: &mut InputRef<'src, '_, I, E>) -> PResult<M, O> {
         recurse(move || {