antlr3 1.2.3

data/test/functional/ast-output/tree-rewrite.rb

@@ -0,0 +1,1662 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+
+class TestASTRewritingTreeParsers < ANTLR3::Test::Functional
+  inline_grammar(<<-'END')
+    grammar FlatList;
+    options {
+      language=Ruby;
+      output=AST;
+    }
+    a : ID INT;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+  
+  inline_grammar(<<-'END')
+    tree grammar FlatListWalker;
+    options {
+      language=Ruby;
+      output=AST;
+      ASTLabelType=CommonTree;
+      tokenVocab=FlatList;
+    }
+    
+    a : ID INT -> INT ID;
+  END
+
+  inline_grammar(<<-'END')
+    grammar SimpleTree;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar SimpleTreeWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=SimpleTree;
+    }
+    a : ^(ID INT) -> ^(INT ID);
+  END
+
+  inline_grammar(<<-END)
+    grammar CombinedRewriteAndAuto;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT) | INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-END)
+    tree grammar CombinedRewriteAndAutoTree;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=CombinedRewriteAndAuto;
+    }
+    a : ^(ID INT) -> ^(INT ID) | INT;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AvoidDup;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AvoidDupWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AvoidDup;
+    }
+    a : ID -> ^(ID ID);
+  END
+
+  inline_grammar(<<-'END')
+    grammar Loop;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID+ INT+ -> (^(ID INT))+ ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar LoopWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=Loop;
+    }
+    a : (^(ID INT))+ -> INT+ ID+;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoDup;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoDupWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AutoDup;
+    }
+    a : ID;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoDupRule;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoDupRuleWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AutoDupRule;
+    }
+    a : b c ;
+    b : ID ;
+    c : INT ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoWildcard;
+    options {language=Ruby;output=AST;}
+    a : ID INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoWildcardWalker;
+    options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcard;}
+    a : ID . 
+      ;
+  END
+  
+  inline_grammar(<<-'END')
+    grammar AutoWildcard2;
+    options {language=Ruby;output=AST;}
+    a : ID INT -> ^(ID INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoWildcard2Walker;
+    options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcard2;}
+    a : ^(ID .) 
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoWildcardWithLabel;
+    options {language=Ruby;output=AST;}
+    a : ID INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoWildcardWithLabelWalker;
+    options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcardWithLabel;}
+    a : ID c=. 
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoWildcardWithListLabel;
+    options {language=Ruby;output=AST;}
+    a : ID INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+  
+  inline_grammar(<<-'END')
+    tree grammar AutoWildcardWithListLabelWalker;
+    options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcardWithListLabel;}
+    a : ID c+=. 
+      ;
+  END
+  
+  inline_grammar(<<-'END')
+    grammar AutoDupMultiple;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID ID INT;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoDupMultipleWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AutoDupMultiple;
+    }
+    a : ID ID INT
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoDupTree;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoDupTreeWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AutoDupTree;
+    }
+    a : ^(ID INT)
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoDupTreeWithLabels;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoDupTreeWithLabelsWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AutoDupTreeWithLabels;
+    }
+    a : ^(x=ID y=INT)
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoDupTreeWithListLabels;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoDupTreeWithListLabelsWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AutoDupTreeWithListLabels;
+    }
+    a : ^(x+=ID y+=INT)
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoDupTreeWithRuleRoot;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoDupTreeWithRuleRootWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AutoDupTreeWithRuleRoot;
+    }
+    a : ^(b INT) ;
+    b : ID ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoDupTreeWithRuleRootAndLabels;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoDupTreeWithRuleRootAndLabelsWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AutoDupTreeWithRuleRootAndLabels;
+    }
+    a : ^(x=b INT) ;
+    b : ID ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoDupTreeWithRuleRootAndListLabels;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoDupTreeWithRuleRootAndListLabelsWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AutoDupTreeWithRuleRootAndListLabels;
+    }
+    a : ^(x+=b y+=c) ;
+    b : ID ;
+    c : INT ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar AutoDupNestedTree;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : x=ID y=ID INT -> ^($x ^($y INT));
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar AutoDupNestedTreeWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=AutoDupNestedTree;
+    }
+    a : ^(ID ^(ID INT))
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar Delete;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar DeleteWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=Delete;
+    }
+    a : ID -> 
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar SetMatchNoRewrite;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar SetMatchNoRewriteWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=SetMatchNoRewrite;
+    }
+    a : b INT;
+    b : ID | INT;
+  END
+
+  inline_grammar(<<-'END')
+    grammar SetOptionalMatchNoRewrite;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar SetOptionalMatchNoRewriteWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=SetOptionalMatchNoRewrite;
+    }
+    a : (ID|INT)? INT ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar SetMatchNoRewriteLevel2;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : x=ID INT -> ^($x INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar SetMatchNoRewriteLevel2Walker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=SetMatchNoRewriteLevel2;
+    }
+    a : ^(ID (ID | INT) ) ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar SetMatchNoRewriteLevel2Root;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : x=ID INT -> ^($x INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar SetMatchNoRewriteLevel2RootWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=SetMatchNoRewriteLevel2Root;
+    }
+    a : ^((ID | INT) INT) ;
+  END
+
+  inline_grammar(<<-END)
+    grammar RewriteModeCombinedRewriteAndAuto;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT) | INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-END)
+    tree grammar RewriteModeCombinedRewriteAndAutoTree;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=RewriteModeCombinedRewriteAndAuto;
+        rewrite=true;
+    }
+    a : ^(ID INT) -> ^(ID["ick"] INT)
+      | INT // leaves it alone, returning $a.start
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteModeFlatTree;
+    options {
+      language=Ruby;
+      output=AST;
+    }
+    a : ID INT -> ID INT | INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteModeFlatTreeWalker;
+    options {
+      language=Ruby;
+      output=AST;
+      ASTLabelType=CommonTree;
+      tokenVocab=RewriteModeFlatTree;
+      rewrite=true;
+    }
+    s : ID a ;
+    a : INT -> INT["1"]
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteModeChainRuleFlatTree;
+    options {language=Ruby; output=AST;}
+    a : ID INT -> ID INT | INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteModeChainRuleFlatTreeWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleFlatTree; rewrite=true;}
+    s : a ;
+    a : b ;
+    b : ID INT -> INT ID
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteModeChainRuleTree;
+    options {language=Ruby; output=AST;}
+    a : ID INT -> ^(ID INT) ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteModeChainRuleTreeWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree; rewrite=true;}
+    s : a ;
+    a : b ; // a.tree must become b.tree
+    b : ^(ID INT) -> INT
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteModeChainRuleTree2;
+    options {language=Ruby; output=AST;}
+    a : ID INT -> ^(ID INT) ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteModeChainRuleTree2Walker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree2; rewrite=true;}
+    tokens { X; }
+    s : a* b ; // only b contributes to tree, but it's after a*; s.tree = b.tree
+    a : X ;
+    b : ^(ID INT) -> INT
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteModeChainRuleTree3;
+    options {language=Ruby; output=AST;}
+    a : 'boo' ID INT -> 'boo' ^(ID INT) ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteModeChainRuleTree3Walker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree3; rewrite=true;}
+    tokens { X; }
+    s : 'boo' a* b ; // don't reset s.tree to b.tree due to 'boo'
+    a : X ;
+    b : ^(ID INT) -> INT
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteModeChainRuleTree4;
+    options {language=Ruby; output=AST;}
+    a : 'boo' ID INT -> ^('boo' ^(ID INT)) ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteModeChainRuleTree4Walker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree4; rewrite=true;}
+    tokens { X; }
+    s : ^('boo' a* b) ; // don't reset s.tree to b.tree due to 'boo'
+    a : X ;
+    b : ^(ID INT) -> INT
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteModeChainRuleTree5;
+    options {language=Ruby; output=AST;}
+    a : 'boo' ID INT -> ^('boo' ^(ID INT)) ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteModeChainRuleTree5Walker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree5; rewrite=true;}
+    tokens { X; }
+    s : ^(a b) ; // s.tree is a.tree
+    a : 'boo' ;
+    b : ^(ID INT) -> INT
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteOfRuleRef;
+    options {language=Ruby; output=AST;}
+    a : ID INT -> ID INT | INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteOfRuleRefWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRef; rewrite=true;}
+    s : a -> a ;
+    a : ID INT -> ID INT ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteOfRuleRefRoot;
+    options {language=Ruby; output=AST;}
+    a : ID INT INT -> ^(INT ^(ID INT));
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteOfRuleRefRootWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefRoot; rewrite=true;}
+    s : ^(a ^(ID INT)) -> a ;
+    a : INT ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteOfRuleRefRootLabeled;
+    options {language=Ruby; output=AST;}
+    a : ID INT INT -> ^(INT ^(ID INT));
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteOfRuleRefRootLabeledWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefRootLabeled; rewrite=true;}
+    s : ^(label=a ^(ID INT)) -> a ;
+    a : INT ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteOfRuleRefRootListLabeled;
+    options {language=Ruby; output=AST;}
+    a : ID INT INT -> ^(INT ^(ID INT));
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteOfRuleRefRootListLabeledWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefRootListLabeled; rewrite=true;}
+    s : ^(label+=a ^(ID INT)) -> a ;
+    a : INT ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteOfRuleRefChild;
+    options {language=Ruby; output=AST;}
+    a : ID INT -> ^(ID ^(INT INT));
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteOfRuleRefChildWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefChild; rewrite=true;}
+    s : ^(ID a) -> a ;
+    a : ^(INT INT) ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteOfRuleRefLabel;
+    options {language=Ruby; output=AST;}
+    a : ID INT -> ^(ID ^(INT INT));
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteOfRuleRefLabelWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefLabel; rewrite=true;}
+    s : ^(ID label=a) -> a ;
+    a : ^(INT INT) ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteOfRuleRefListLabel;
+    options {language=Ruby; output=AST;}
+    a : ID INT -> ^(ID ^(INT INT));
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteOfRuleRefListLabelWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefListLabel; rewrite=true;}
+    s : ^(ID label+=a) -> a ;
+    a : ^(INT INT) ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar RewriteModeWithPredicatedRewrites;
+    options {
+      language=Ruby;
+      output=AST;
+    }
+    a : ID INT -> ^(ID["root"] ^(ID INT)) | INT -> ^(ID["root"] INT) ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar RewriteModeWithPredicatedRewritesWalker;
+    options {
+      language=Ruby;
+      output=AST;
+      ASTLabelType=CommonTree;
+      tokenVocab=RewriteModeWithPredicatedRewrites;
+      rewrite=true;
+    }
+    s : ^(ID a) {
+      # self.buf += $s.start.to_string_tree
+    };
+    a : ^(ID INT) -> {true}? ^(ID["ick"] INT)
+                  -> INT
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar WildcardSingleNode;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID["root"] INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar WildcardSingleNodeWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=WildcardSingleNode;
+    }
+    s : ^(ID c=.) -> $c
+    ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar WildcardUnlabeledSingleNode;
+    options {language=Ruby; output=AST;}
+    a : ID INT -> ^(ID INT);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar WildcardUnlabeledSingleNodeWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardUnlabeledSingleNode;}
+    s : ^(ID .) -> ID
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar WildcardListLabel;
+    options {language=Ruby; output=AST;}
+    a : INT INT INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+  
+  inline_grammar(<<-'END')
+    tree grammar WildcardListLabelWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardListLabel;}
+    s : (c+=.)+ -> $c+
+      ;
+  END
+  
+  inline_grammar(<<-'END')
+    grammar WildcardListLabel2;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree;}
+    a  : x=INT y=INT z=INT -> ^($x ^($y $z) ^($y $z));
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+  
+  inline_grammar(<<-'END')
+    tree grammar WildcardListLabel2Walker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardListLabel2; rewrite=true;}
+    s : ^(INT (c+=.)+) -> $c+
+      ;
+  END
+
+  inline_grammar(<<-'END')
+    grammar WildcardGrabsSubtree;
+    options {language=Ruby; output=AST;}
+    a : ID x=INT y=INT z=INT -> ^(ID[\"root\"] ^($x $y $z));
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar WildcardGrabsSubtreeWalker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardGrabsSubtree;}
+    s : ^(ID c=.) -> $c
+      ;
+  END
+  
+  inline_grammar(<<-'END')
+    grammar WildcardGrabsSubtree2;
+    options {language=Ruby; output=AST;}
+    a : ID x=INT y=INT z=INT -> ID ^($x $y $z);
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\n') {$channel=HIDDEN;} ;
+  END
+  
+  inline_grammar(<<-'END')
+    tree grammar WildcardGrabsSubtree2Walker;
+    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardGrabsSubtree2;}
+    s : ID c=. -> $c
+      ;
+  END
+
+  inline_grammar(<<-END)
+    grammar CombinedRewriteAndAuto;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT) | INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\\n') {$channel=HIDDEN;} ;
+  END
+  
+  inline_grammar(<<-END)
+    tree grammar CombinedRewriteAndAutoWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=CombinedRewriteAndAuto;
+    }
+    a : ^(ID INT) -> ^(INT ID) | INT;
+  END
+
+  inline_grammar(<<-END)
+    grammar RewriteModeCombinedRewriteAndAuto;
+    options {
+        language=Ruby;
+        output=AST;
+    }
+    a : ID INT -> ^(ID INT) | INT ;
+    ID : 'a'..'z'+ ;
+    INT : '0'..'9'+;
+    WS : (' '|'\\n') {$channel=HIDDEN;} ;
+  END
+  
+  inline_grammar(<<-END)
+    tree grammar RewriteModeCombinedRewriteAndAutoWalker;
+    options {
+        language=Ruby;
+        output=AST;
+        ASTLabelType=CommonTree;
+        tokenVocab=RewriteModeCombinedRewriteAndAuto;
+        rewrite=true;
+    }
+    a : ^(ID INT) -> ^(ID["ick"] INT)
+      | INT // leaves it alone, returning $a.start
+      ;
+  END
+  
+  example "flat list" do
+    lexer  = FlatList::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = FlatList::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = FlatListWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "34 abc"
+  end
+
+  example "simple tree" do
+    lexer  = SimpleTree::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = SimpleTree::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = SimpleTreeWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(34 abc)"
+  end
+
+  example "combined rewrite and auto" do
+    lexer  = CombinedRewriteAndAuto::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = CombinedRewriteAndAuto::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = CombinedRewriteAndAutoWalker::TreeParser.new( nodes )
+    result = walker.a.tree
+    result.inspect.should == '(34 abc)'
+    lexer  = CombinedRewriteAndAuto::Lexer.new( "34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = CombinedRewriteAndAuto::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = CombinedRewriteAndAutoWalker::TreeParser.new( nodes )
+    result = walker.a.tree
+    result.inspect.should == '34'
+  end
+
+  example "avoid dup" do
+    lexer  = AvoidDup::Lexer.new( "abc" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AvoidDup::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AvoidDupWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(abc abc)"
+  end
+  
+  example "loop" do
+    lexer  = Loop::Lexer.new( "a b c 3 4 5" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = Loop::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = LoopWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "3 4 5 a b c"
+  end
+  
+  example "auto dup" do
+    lexer  = AutoDup::Lexer.new( "abc" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoDup::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoDupWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "abc"
+  end
+
+  example "auto dup rule" do
+    lexer  = AutoDupRule::Lexer.new( "a 1" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoDupRule::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoDupRuleWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "a 1"
+  end
+
+  example "auto wildcard" do
+    lexer  = AutoWildcard::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoWildcard::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoWildcardWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "abc 34"
+  end
+
+  example "auto wildcard2" do
+    lexer  = AutoWildcard2::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoWildcard2::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoWildcard2Walker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(abc 34)"
+  end
+
+  example "auto wildcard with label" do
+    lexer  = AutoWildcardWithLabel::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoWildcardWithLabel::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoWildcardWithLabelWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "abc 34"
+  end
+
+  example "auto wildcard with list label" do
+    lexer  = AutoWildcardWithListLabel::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoWildcardWithListLabel::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoWildcardWithListLabelWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "abc 34"
+  end
+
+  example "auto dup multiple" do
+    lexer  = AutoDupMultiple::Lexer.new( "a b 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoDupMultiple::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoDupMultipleWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "a b 3"
+  end
+
+  example "auto dup tree" do
+    lexer  = AutoDupTree::Lexer.new( "a 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoDupTree::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoDupTreeWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(a 3)"
+  end
+
+  example "auto dup tree with labels" do
+    lexer  = AutoDupTreeWithLabels::Lexer.new( "a 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoDupTreeWithLabels::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoDupTreeWithLabelsWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(a 3)"
+  end
+
+  example "auto dup tree with list labels" do
+    lexer  = AutoDupTreeWithListLabels::Lexer.new( "a 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoDupTreeWithListLabels::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoDupTreeWithListLabelsWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(a 3)"
+  end
+
+  example "auto dup tree with rule root" do
+    lexer  = AutoDupTreeWithRuleRoot::Lexer.new( "a 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoDupTreeWithRuleRoot::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoDupTreeWithRuleRootWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(a 3)"
+  end
+
+  example "auto dup tree with rule root and labels" do
+    lexer  = AutoDupTreeWithRuleRootAndLabels::Lexer.new( "a 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoDupTreeWithRuleRootAndLabels::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoDupTreeWithRuleRootAndLabelsWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(a 3)"
+  end
+
+  example "auto dup tree with rule root and list labels" do
+    lexer  = AutoDupTreeWithRuleRootAndListLabels::Lexer.new( "a 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoDupTreeWithRuleRootAndListLabels::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoDupTreeWithRuleRootAndListLabelsWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(a 3)"
+  end
+
+  example "auto dup nested tree" do
+    lexer  = AutoDupNestedTree::Lexer.new( "a b 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = AutoDupNestedTree::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = AutoDupNestedTreeWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(a (b 3))"
+  end
+
+  example "delete" do
+    lexer  = Delete::Lexer.new( "abc" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = Delete::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = DeleteWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == ""
+  end
+
+  example "set match no rewrite" do
+    lexer  = SetMatchNoRewrite::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = SetMatchNoRewrite::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = SetMatchNoRewriteWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "abc 34"
+  end
+
+  example "set optional match no rewrite" do
+    lexer  = SetOptionalMatchNoRewrite::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = SetOptionalMatchNoRewrite::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = SetOptionalMatchNoRewriteWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "abc 34"
+  end
+
+  example "set match no rewrite level2" do
+    lexer  = SetMatchNoRewriteLevel2::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = SetMatchNoRewriteLevel2::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = SetMatchNoRewriteLevel2Walker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(abc 34)"
+  end
+
+  example "set match no rewrite level2 root" do
+    lexer  = SetMatchNoRewriteLevel2Root::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = SetMatchNoRewriteLevel2Root::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = SetMatchNoRewriteLevel2RootWalker::TreeParser.new( nodes )
+    result = walker.a
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(abc 34)"
+  end
+
+  example "rewrite mode combined rewrite and auto" do
+    
+    parser_test = proc do |input, expected_output|
+      lexer = RewriteModeCombinedRewriteAndAuto::Lexer.new( input )
+      tokens = ANTLR3::CommonTokenStream.new( lexer )
+      parser = RewriteModeCombinedRewriteAndAuto::Parser.new( tokens )
+      result = parser.a
+      nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+      nodes.token_stream = tokens
+      walker = RewriteModeCombinedRewriteAndAutoWalker::TreeParser.new( nodes )
+      result = walker.a
+      stree = result.tree.nil? ? '' : result.tree.inspect
+      stree.should == expected_output
+    end
+    
+    parser_test[ 'abc 34', '(ick 34)' ]
+    parser_test[ '34', '34' ]
+  end
+  
+  example "rewrite mode flat tree" do
+    lexer  = RewriteModeFlatTree::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteModeFlatTree::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteModeFlatTreeWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "abc 1"
+  end
+  
+  example "rewrite mode chain rule flat tree" do
+    lexer  = RewriteModeChainRuleFlatTree::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteModeChainRuleFlatTree::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteModeChainRuleFlatTreeWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "34 abc"
+  end
+
+  example "rewrite mode chain rule tree" do
+    lexer  = RewriteModeChainRuleTree::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteModeChainRuleTree::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteModeChainRuleTreeWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "34"
+  end
+
+  example "rewrite mode chain rule tree2" do
+    lexer  = RewriteModeChainRuleTree2::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteModeChainRuleTree2::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteModeChainRuleTree2Walker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "34"
+  end
+
+  example "rewrite mode chain rule tree3" do
+    lexer  = RewriteModeChainRuleTree3::Lexer.new( "boo abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteModeChainRuleTree3::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteModeChainRuleTree3Walker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "boo 34"
+  end
+
+  example "rewrite mode chain rule tree4" do
+    lexer  = RewriteModeChainRuleTree4::Lexer.new( "boo abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteModeChainRuleTree4::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteModeChainRuleTree4Walker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(boo 34)"
+  end
+
+  example "rewrite mode chain rule tree5" do
+    lexer  = RewriteModeChainRuleTree5::Lexer.new( "boo abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteModeChainRuleTree5::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteModeChainRuleTree5Walker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(boo 34)"
+  end
+
+  example "rewrite of rule ref" do
+    lexer  = RewriteOfRuleRef::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteOfRuleRef::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteOfRuleRefWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "abc 34"
+  end
+
+  example "rewrite of rule ref root" do
+    lexer  = RewriteOfRuleRefRoot::Lexer.new( "abc 12 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteOfRuleRefRoot::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteOfRuleRefRootWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(12 (abc 34))"
+  end
+
+  example "rewrite of rule ref root labeled" do
+    lexer  = RewriteOfRuleRefRootLabeled::Lexer.new( "abc 12 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteOfRuleRefRootLabeled::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteOfRuleRefRootLabeledWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(12 (abc 34))"
+  end
+
+  example "rewrite of rule ref root list labeled" do
+    lexer  = RewriteOfRuleRefRootListLabeled::Lexer.new( "abc 12 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteOfRuleRefRootListLabeled::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteOfRuleRefRootListLabeledWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(12 (abc 34))"
+  end
+
+  example "rewrite of rule ref child" do
+    lexer  = RewriteOfRuleRefChild::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteOfRuleRefChild::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteOfRuleRefChildWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(34 34)"
+  end
+
+  example "rewrite of rule ref label" do
+    lexer  = RewriteOfRuleRefLabel::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteOfRuleRefLabel::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteOfRuleRefLabelWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(34 34)"
+  end
+
+  example "rewrite of rule ref list label" do
+    lexer  = RewriteOfRuleRefListLabel::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteOfRuleRefListLabel::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteOfRuleRefListLabelWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(34 34)"
+  end
+  
+  example "rewrite mode with predicated rewrites" do
+    lexer  = RewriteModeWithPredicatedRewrites::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = RewriteModeWithPredicatedRewrites::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = RewriteModeWithPredicatedRewritesWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(root (ick 34))"
+  end
+  
+  example "wildcard single node" do
+    lexer  = WildcardSingleNode::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = WildcardSingleNode::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = WildcardSingleNodeWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "34"
+  end
+  
+  example "wildcard unlabeled single node" do
+    lexer  = WildcardUnlabeledSingleNode::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = WildcardUnlabeledSingleNode::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = WildcardUnlabeledSingleNodeWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "abc"
+  end
+
+  example "wildcard grabs subtree" do
+    lexer  = WildcardGrabsSubtree::Lexer.new( "abc 1 2 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = WildcardGrabsSubtree::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = WildcardGrabsSubtreeWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(1 2 3)"
+  end
+
+  example "wildcard grabs subtree2" do
+    lexer  = WildcardGrabsSubtree2::Lexer.new( "abc 1 2 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = WildcardGrabsSubtree2::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = WildcardGrabsSubtree2Walker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(1 2 3)"
+  end
+
+  example "wildcard list label" do
+    lexer  = WildcardListLabel::Lexer.new( "1 2 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = WildcardListLabel::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = WildcardListLabelWalker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "1 2 3"
+  end
+  
+  example "wildcard list label2" do
+    lexer  = WildcardListLabel2::Lexer.new( "1 2 3" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = WildcardListLabel2::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = WildcardListLabel2Walker::TreeParser.new( nodes )
+    result = walker.s
+    stree = result.tree.nil? ? '' : result.tree.inspect
+    stree.should == "(2 3) (2 3)"
+  end
+  
+end