support for visitors that return data

Author: rrevenantt

README.md

@@ -38,6 +38,8 @@ things to consider for next versions:
 - [ ] remove proc macro dependency
 - [ ] move to once_cell completely
 - [ ] rustfmt in antlr tool
+- [ ] make `Node` and associated type in visitors
+- [ ] bulk import for context extension traits
 - [ ] intradoc links
 - [ ] move benches to repository
 - [ ] LexerAtnSimulator position tracking customization
@@ -46,7 +48,7 @@ things to consider for next versions:
 - [ ] arena allocation for tree nodes
 - [ ] tree utils
 - [ ] features
-- [ ] statefull lexer test
+- [ ] stateful lexer test
 - [ ] better downcasting
 - [ ] options for customizing downcast bounds
 - [ ] token stream rewriter

build.rs

@@ -9,14 +9,24 @@ use std::process::Command;
 
 fn main() {
     let grammars = vec![
+        "VisitorBasic",
+        "VisitorCalc",
         "CSV",
         "ReferenceToATN",
         "XMLLexer",
         "SimpleLR",
         "Labels",
         "FHIRPath",
     ];
-    let additional_args = vec![Some("-visitor"), None, None, None, None];
+    let additional_args = vec![
+        Some("-visitor"),
+        Some("-visitor"),
+        Some("-visitor"),
+        None,
+        None,
+        None,
+        None,
+    ];
     let antlr_path = "/home/rrevenantt/dev/antlr4/tool/target/antlr4-4.8-2-SNAPSHOT-complete.jar";
 
     for (grammar, arg) in grammars.into_iter().zip(additional_args) {

grammars/VisitorBasic.g4

@@ -0,0 +1,7 @@
+grammar VisitorBasic;
+
+s
+	:	'A' EOF
+	;
+
+A : 'A';

grammars/VisitorCalc.g4

@@ -0,0 +1,18 @@
+grammar VisitorCalc;
+
+s
+	:	expr EOF
+	;
+
+expr
+	:	INT						# number
+	|	expr (MUL | DIV) expr	# multiply
+	|	expr (ADD | SUB) expr	# add
+	;
+
+INT : [0-9]+;
+MUL : '*';
+DIV : '/';
+ADD : '+';
+SUB : '-';
+WS : [ \t]+ -> channel(HIDDEN);

src/tree.rs

@@ -20,6 +20,7 @@ use crate::token::Token;
 use crate::token_factory::TokenFactory;
 use crate::{interval_set, trees, CoerceTo};
 use better_any::{Tid, TidAble};
+use std::mem;
 
 //todo try to make in more generic
 #[allow(missing_docs)]
@@ -220,25 +221,109 @@ impl<'input, Node: ParserNodeType<'input>, Visitor: ParseTreeVisitor<'input, Nod
     fn accept(&self, visitor: &mut Visitor) { visitor.visit_error_node(self) }
 }
 
+pub trait ParseTreeVisitorCompat<'input>: VisitChildren<'input, Self::Node> {
+    type Node: ParserNodeType<'input>;
+    type Return: Default;
+
+    /// Temporary storage for `ParseTreeVisitor` blanket implementation to work
+    fn temp_result(&mut self) -> &mut Self::Return;
+
+    fn visit(&mut self, node: &<Self::Node as ParserNodeType<'input>>::Type) -> Self::Return {
+        self.visit_node(&node);
+        mem::take(self.temp_result())
+    }
+
+    /// Called on terminal(leaf) node
+    fn visit_terminal(&mut self, _node: &TerminalNode<'input, Self::Node>) -> Self::Return {
+        Self::Return::default()
+    }
+    /// Called on error node
+    fn visit_error_node(&mut self, _node: &ErrorNode<'input, Self::Node>) -> Self::Return {
+        Self::Return::default()
+    }
+
+    fn visit_children(
+        &mut self,
+        node: &<Self::Node as ParserNodeType<'input>>::Type,
+    ) -> Self::Return {
+        let mut result = Self::Return::default();
+        for node in node.get_children() {
+            if !self.should_visit_next_child(&node, &result) {
+                break;
+            }
+
+            let child_result = self.visit(&node);
+            result = self.aggregate_results(result, child_result);
+        }
+        return result;
+    }
+
+    fn aggregate_results(&self, aggregate: Self::Return, next: Self::Return) -> Self::Return {
+        next
+    }
+
+    fn should_visit_next_child(
+        &self,
+        node: &<Self::Node as ParserNodeType<'input>>::Type,
+        current: &Self::Return,
+    ) -> bool {
+        true
+    }
+}
+
+// struct VisitorAdapter<'input, T: ParseTreeVisitorCompat<'input>> {
+//     visitor: T,
+//     pub curr_value: T::Return,
+//     _pd: PhantomData<&'input str>,
+// }
+
+impl<'input, Node, T> ParseTreeVisitor<'input, Node> for T
+where
+    Node: ParserNodeType<'input>,
+    Node::Type: VisitableDyn<Self>,
+    T: ParseTreeVisitorCompat<'input, Node = Node>,
+{
+    fn visit_terminal(&mut self, node: &TerminalNode<'input, Node>) {
+        let result = <Self as ParseTreeVisitorCompat>::visit_terminal(self, node);
+        *<Self as ParseTreeVisitorCompat>::temp_result(self) = result;
+    }
+
+    fn visit_error_node(&mut self, node: &ErrorNode<'input, Node>) {
+        let result = <Self as ParseTreeVisitorCompat>::visit_error_node(self, node);
+        *<Self as ParseTreeVisitorCompat>::temp_result(self) = result;
+    }
+
+    fn visit_children(&mut self, node: &Node::Type) {
+        let result = <Self as ParseTreeVisitorCompat>::visit_children(self, node);
+        *<Self as ParseTreeVisitorCompat>::temp_result(self) = result;
+    }
+}
+
 /// Base interface for visiting over syntax tree
 pub trait ParseTreeVisitor<'input, Node: ParserNodeType<'input>>:
     VisitChildren<'input, Node>
 {
+    /// Basically alias for `node.accept(self)` in visitor implementation
+    /// just to make api closer to java
+
     /// Called on terminal(leaf) node
     fn visit_terminal(&mut self, _node: &TerminalNode<'input, Node>) {}
     /// Called on error node
     fn visit_error_node(&mut self, _node: &ErrorNode<'input, Node>) {}
     /// Implement this only if you want to change children visiting algorithm
-    fn visit_children(&mut self, node: &Node::Type) { self.visit_children_inner(node) }
+    fn visit_children(&mut self, node: &Node::Type) {
+        node.get_children()
+            .for_each(|child| self.visit_node(&child))
+    }
 }
 
 /// Workaround for default recursive children visiting
 ///
 /// Already blanket implemented for all visitors.
 /// To override it you would need to implement `ParseTreeVisitor::visit_children`
 pub trait VisitChildren<'input, Node: ParserNodeType<'input>> {
-    #[doc(hidden)]
-    fn visit_children_inner(&mut self, node: &Node::Type);
+    // fn visit_children_inner(&mut self, node: &Node::Type);
+    fn visit_node(&mut self, node: &Node::Type);
 }
 
 impl<'input, Node, T> VisitChildren<'input, Node> for T
@@ -248,8 +333,13 @@ where
     // for<'a> &'a mut Self: CoerceUnsized<&'a mut Node::Visitor>,
     Node::Type: VisitableDyn<T>,
 {
-    #[inline(always)]
-    fn visit_children_inner(&mut self, node: &Node::Type) { node.accept_children(self) }
+    // #[inline(always)]
+    // fn visit_children_inner(&mut self, node: &Node::Type) {
+    //     // node.accept_children(self)
+    //
+    // }
+
+    fn visit_node(&mut self, node: &Node::Type) { node.accept_dyn(self) }
 }
 
 /// Types that can accept particular visitor

templates/Rust.stg

@@ -100,9 +100,7 @@ use antlr_rust::tree::ParseTreeListener;
 use super::<file.parserName; format="low">::*;
 
 pub trait <file.grammarName>Listener\<'input> : ParseTreeListener\<'input,<file.parserName>ContextType>{
-
 <file.listenerNames:{lname |
-
 /**
 <if(file.listenerLabelRuleNames.(lname))>
  * Enter a parse tree produced by the {@code <lname>\}
@@ -128,6 +126,8 @@ fn exit_<lname>(&mut self, _ctx: &<lname; format="cap">Context\<'input>) { \}};
 
 antlr_rust::coerce_from!{ 'input : <file.grammarName>Listener\<'input> }
 
+
+
 >>
 
 BaseListenerFile(file, header, namedActions) ::= <<>>
@@ -136,8 +136,9 @@ VisitorFile(file, header, namedActions) ::= <<
 #![allow(nonstandard_style)]
 <fileHeader(file.grammarFileName, file.ANTLRVersion)>
 <header>
-use antlr_rust::tree::{ParseTreeVisitor};
+use antlr_rust::tree::{ParseTreeVisitor,ParseTreeVisitorCompat};
 use super::<file.parserName; format="low">::*;
+use std::mem;
 
 /**
  * This interface defines a complete generic visitor for a parse tree produced
@@ -156,7 +157,35 @@ pub trait <file.grammarName>Visitor\<'input>: ParseTreeVisitor\<'input,<file.par
  */
 fn visit_<lname>(&mut self, ctx: &<lname; format="cap">Context\<'input>) { self.visit_children(ctx) \}
 }; separator="\n">
+}
 
+pub trait <file.grammarName>VisitorCompat\<'input>:ParseTreeVisitorCompat\<'input, Node= <file.parserName>ContextType>{
+	<file.visitorNames:{lname |
+/**
+<if(file.visitorLabelRuleNames.(lname))>
+ * Visit a parse tree produced by the {@code <lname>\}
+ * labeled alternative in {@link <file.parserName>#<file.visitorLabelRuleNames.(lname)>\}.
+<else>
+ * Visit a parse tree produced by {@link <file.parserName>#<lname>\}.
+<endif>
+ * @param ctx the parse tree
+ */
+	fn visit_<lname>(&mut self, ctx: &<lname; format="cap">Context\<'input>) -> Self::Return {
+		self.visit_children(ctx)
+	\}
+}; separator="\n">
+}
+
+impl\<'input,T> <file.grammarName>Visitor\<'input> for T
+where
+	T: <file.grammarName>VisitorCompat\<'input>
+{
+<file.visitorNames:{lname |
+	fn visit_<lname>(&mut self, ctx: &<lname; format="cap">Context\<'input>){
+		let result = \<Self as <file.grammarName>VisitorCompat>::visit_<lname>(self, ctx);
+        *\<Self as ParseTreeVisitorCompat>::temp_result(self) = result;
+	\}
+}; separator="\n">
 }
 >>
 

tests/gen/csvlistener.rs

@@ -14,7 +14,6 @@ pub trait CSVListener<'input>: ParseTreeListener<'input, CSVParserContextType> {
      * @param ctx the parse tree
      */
     fn exit_csvFile(&mut self, _ctx: &CsvFileContext<'input>) {}
-
     /**
      * Enter a parse tree produced by {@link CSVParser#hdr}.
      * @param ctx the parse tree
@@ -25,7 +24,6 @@ pub trait CSVListener<'input>: ParseTreeListener<'input, CSVParserContextType> {
      * @param ctx the parse tree
      */
     fn exit_hdr(&mut self, _ctx: &HdrContext<'input>) {}
-
     /**
      * Enter a parse tree produced by {@link CSVParser#row}.
      * @param ctx the parse tree
@@ -36,7 +34,6 @@ pub trait CSVListener<'input>: ParseTreeListener<'input, CSVParserContextType> {
      * @param ctx the parse tree
      */
     fn exit_row(&mut self, _ctx: &RowContext<'input>) {}
-
     /**
      * Enter a parse tree produced by {@link CSVParser#field}.
      * @param ctx the parse tree

tests/gen/csvvisitor.rs

@@ -1,7 +1,8 @@
 #![allow(nonstandard_style)]
 // Generated from CSV.g4 by ANTLR 4.8
 use super::csvparser::*;
-use antlr_rust::tree::ParseTreeVisitor;
+use antlr_rust::tree::{ParseTreeVisitor, ParseTreeVisitorCompat};
+use std::mem;
 
 /**
  * This interface defines a complete generic visitor for a parse tree produced
@@ -32,3 +33,60 @@ pub trait CSVVisitor<'input>: ParseTreeVisitor<'input, CSVParserContextType> {
      */
     fn visit_field(&mut self, ctx: &FieldContext<'input>) { self.visit_children(ctx) }
 }
+
+pub trait CSVVisitorCompat<'input>:
+    ParseTreeVisitorCompat<'input, Node = CSVParserContextType>
+{
+    /**
+     * Visit a parse tree produced by {@link CSVParser#csvFile}.
+     * @param ctx the parse tree
+     */
+    fn visit_csvFile(&mut self, ctx: &CsvFileContext<'input>) -> Self::Return {
+        self.visit_children(ctx)
+    }
+
+    /**
+     * Visit a parse tree produced by {@link CSVParser#hdr}.
+     * @param ctx the parse tree
+     */
+    fn visit_hdr(&mut self, ctx: &HdrContext<'input>) -> Self::Return { self.visit_children(ctx) }
+
+    /**
+     * Visit a parse tree produced by {@link CSVParser#row}.
+     * @param ctx the parse tree
+     */
+    fn visit_row(&mut self, ctx: &RowContext<'input>) -> Self::Return { self.visit_children(ctx) }
+
+    /**
+     * Visit a parse tree produced by {@link CSVParser#field}.
+     * @param ctx the parse tree
+     */
+    fn visit_field(&mut self, ctx: &FieldContext<'input>) -> Self::Return {
+        self.visit_children(ctx)
+    }
+}
+
+impl<'input, T> CSVVisitor<'input> for T
+where
+    T: CSVVisitorCompat<'input>,
+{
+    fn visit_csvFile(&mut self, ctx: &CsvFileContext<'input>) {
+        let result = <Self as CSVVisitorCompat>::visit_csvFile(self, ctx);
+        *<Self as ParseTreeVisitorCompat>::temp_result(self) = result;
+    }
+
+    fn visit_hdr(&mut self, ctx: &HdrContext<'input>) {
+        let result = <Self as CSVVisitorCompat>::visit_hdr(self, ctx);
+        *<Self as ParseTreeVisitorCompat>::temp_result(self) = result;
+    }
+
+    fn visit_row(&mut self, ctx: &RowContext<'input>) {
+        let result = <Self as CSVVisitorCompat>::visit_row(self, ctx);
+        *<Self as ParseTreeVisitorCompat>::temp_result(self) = result;
+    }
+
+    fn visit_field(&mut self, ctx: &FieldContext<'input>) {
+        let result = <Self as CSVVisitorCompat>::visit_field(self, ctx);
+        *<Self as ParseTreeVisitorCompat>::temp_result(self) = result;
+    }
+}