import unittest
import textwrap
import antlr3
import antlr3.tree
import testbase

class T(testbase.ANTLRTest):
    def walkerClass(self, base):
        class TWalker(base):
            def __init__(self, *args, **kwargs):
                base.__init__(self, *args, **kwargs)
                self.buf = ""

            def traceIn(self, ruleName, ruleIndex):
                self.traces.append('>'+ruleName)


            def traceOut(self, ruleName, ruleIndex):
                self.traces.append('<'+ruleName)


            def recover(self, input, re):
                # no error recovery yet, just crash!
                raise

        return TWalker


    def execTreeParser(self, grammar, grammarEntry, treeGrammar, treeEntry, input):
        lexerCls, parserCls = self.compileInlineGrammar(grammar)
        walkerCls = self.compileInlineGrammar(treeGrammar)

        cStream = antlr3.StringStream(input)
        lexer = lexerCls(cStream)
        tStream = antlr3.CommonTokenStream(lexer)
        parser = parserCls(tStream)
        r = getattr(parser, grammarEntry)()
        nodes = antlr3.tree.CommonTreeNodeStream(r.tree)
        nodes.setTokenStream(tStream)
        walker = walkerCls(nodes)
        r = getattr(walker, treeEntry)()

        if r.tree is not None:
            return r.tree.toStringTree()

        return ""


    def testFlatList(self):
        grammar = textwrap.dedent(
        r'''
        grammar T1;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP1;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T1;
        }

        a : ID INT -> INT ID;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34"
            )

        self.failUnlessEqual("34 abc", found)


    def testSimpleTree(self):
        grammar = textwrap.dedent(
        r'''
        grammar T2;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT -> ^(ID INT);
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP2;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T2;
        }
        a : ^(ID INT) -> ^(INT ID);
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34"
            )

        self.failUnlessEqual("(34 abc)", found)


    def testCombinedRewriteAndAuto(self):
        grammar = textwrap.dedent(
        r'''
        grammar T3;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT -> ^(ID INT) | INT ;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP3;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T3;
        }
        a : ^(ID INT) -> ^(INT ID) | INT;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34"
            )

        self.failUnlessEqual("(34 abc)", found)


        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "34"
            )

        self.failUnlessEqual("34", found)


    def testAvoidDup(self):
        grammar = textwrap.dedent(
        r'''
        grammar T4;
        options {
            language=Python;
            output=AST;
        }
        a : ID ;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP4;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T4;
        }
        a : ID -> ^(ID ID);
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc"
            )

        self.failUnlessEqual("(abc abc)", found)


    def testLoop(self):
        grammar = textwrap.dedent(
        r'''
        grammar T5;
        options {
            language=Python;
            output=AST;
        }
        a : ID+ INT+ -> (^(ID INT))+ ;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP5;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T5;
        }
        a : (^(ID INT))+ -> INT+ ID+;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "a b c 3 4 5"
            )

        self.failUnlessEqual("3 4 5 a b c", found)


    def testAutoDup(self):
        grammar = textwrap.dedent(
        r'''
        grammar T6;
        options {
            language=Python;
            output=AST;
        }
        a : ID ;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP6;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T6;
        }
        a : ID;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc"
            )

        self.failUnlessEqual("abc", found)


    def testAutoDupRule(self):
        grammar = textwrap.dedent(
        r'''
        grammar T7;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT ;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP7;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T7;
        }
        a : b c ;
        b : ID ;
        c : INT ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "a 1"
            )

        self.failUnlessEqual("a 1", found)


    def testAutoWildcard(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python;output=AST; ASTLabelType=CommonTree; tokenVocab=T;}
            a : ID .
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34")
        self.assertEquals("abc 34", found)


#     def testNoWildcardAsRootError(self):
#         ErrorQueue equeue = new ErrorQueue();
#         ErrorManager.setErrorListener(equeue);
# >
#         String treeGrammar =
#             "tree grammar TP;\n"+
#             "options {language=Python;output=AST;}
#             "a : ^(. INT)
#             "  ;\n";
# >
#         Grammar g = new Grammar(treeGrammar);
#         Tool antlr = newTool();
#         antlr.setOutputDirectory(null); // write to /dev/null
#         CodeGenerator generator = new CodeGenerator(antlr, g, "Java");
#         g.setCodeGenerator(generator);
#         generator.genRecognizer();
# >
#         assertEquals("unexpected errors: "+equeue, 1, equeue.errors.size());
# >
#         int expectedMsgID = ErrorManager.MSG_WILDCARD_AS_ROOT;
#         Object expectedArg = null;
#         antlr.RecognitionException expectedExc = null;
#         GrammarSyntaxMessage expectedMessage =
#             new GrammarSyntaxMessage(expectedMsgID, g, null, expectedArg, expectedExc);
# >
#         checkError(equeue, expectedMessage);
#     }

    def testAutoWildcard2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID INT -> ^(ID INT);
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python;output=AST; ASTLabelType=CommonTree; tokenVocab=T;}
            a : ^(ID .)
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34")
        self.assertEquals("(abc 34)", found)


    def testAutoWildcardWithLabel(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python;output=AST; ASTLabelType=CommonTree; tokenVocab=T;}
            a : ID c=.
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34")
        self.assertEquals("abc 34", found)


    def testAutoWildcardWithListLabel(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python;output=AST; ASTLabelType=CommonTree; tokenVocab=T;}
            a : ID c+=.
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34")
        self.assertEquals("abc 34", found)


    def testAutoDupMultiple(self):
        grammar = textwrap.dedent(
        r'''
        grammar T8;
        options {
            language=Python;
            output=AST;
        }
        a : ID ID INT;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP8;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T8;
        }
        a : ID ID INT
          ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "a b 3"
            )

        self.failUnlessEqual("a b 3", found)


    def testAutoDupTree(self):
        grammar = textwrap.dedent(
        r'''
        grammar T9;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT -> ^(ID INT);
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP9;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T9;
        }
        a : ^(ID INT)
          ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "a 3"
            )

        self.failUnlessEqual("(a 3)", found)


    def testAutoDupTreeWithLabels(self):
        grammar = textwrap.dedent(
        r'''
        grammar T10;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT -> ^(ID INT);
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP10;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T10;
        }
        a : ^(x=ID y=INT)
          ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "a 3"
            )

        self.failUnlessEqual("(a 3)", found)


    def testAutoDupTreeWithListLabels(self):
        grammar = textwrap.dedent(
        r'''
        grammar T11;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT -> ^(ID INT);
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP11;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T11;
        }
        a : ^(x+=ID y+=INT)
          ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "a 3"
            )

        self.failUnlessEqual("(a 3)", found)


    def testAutoDupTreeWithRuleRoot(self):
        grammar = textwrap.dedent(
        r'''
        grammar T12;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT -> ^(ID INT);
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP12;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T12;
        }
        a : ^(b INT) ;
        b : ID ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "a 3"
            )

        self.failUnlessEqual("(a 3)", found)


    def testAutoDupTreeWithRuleRootAndLabels(self):
        grammar = textwrap.dedent(
        r'''
        grammar T13;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT -> ^(ID INT);
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP13;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T13;
        }
        a : ^(x=b INT) ;
        b : ID ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "a 3"
            )

        self.failUnlessEqual("(a 3)", found)


    def testAutoDupTreeWithRuleRootAndListLabels(self):
        grammar = textwrap.dedent(
        r'''
        grammar T14;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT -> ^(ID INT);
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP14;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T14;
        }
        a : ^(x+=b y+=c) ;
        b : ID ;
        c : INT ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "a 3"
            )

        self.failUnlessEqual("(a 3)", found)


    def testAutoDupNestedTree(self):
        grammar = textwrap.dedent(
        r'''
        grammar T15;
        options {
            language=Python;
            output=AST;
        }
        a : x=ID y=ID INT -> ^($x ^($y INT));
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP15;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T15;
        }
        a : ^(ID ^(ID INT))
          ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "a b 3"
            )

        self.failUnlessEqual("(a (b 3))", found)


    def testDelete(self):
        grammar = textwrap.dedent(
        r'''
        grammar T16;
        options {
            language=Python;
            output=AST;
        }
        a : ID ;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP16;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T16;
        }
        a : ID ->
          ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc"
            )

        self.failUnlessEqual("", found)

    def testSetMatchNoRewrite(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {
                language=Python;
                output=AST;
            }
            a : ID INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {
                language=Python;
                output=AST;
                ASTLabelType=CommonTree;
                tokenVocab=T;
            }
            a : b INT;
            b : ID | INT;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34"
            )

        self.failUnlessEqual("abc 34", found)


    def testSetOptionalMatchNoRewrite(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {
                language=Python;
                output=AST;
            }
            a : ID INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {
                language=Python;
                output=AST;
                ASTLabelType=CommonTree;
                tokenVocab=T;
            }
            a : (ID|INT)? INT ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34")

        self.failUnlessEqual("abc 34", found)


    def testSetMatchNoRewriteLevel2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {
                language=Python;
                output=AST;
            }
            a : x=ID INT -> ^($x INT);
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {
                language=Python;
                output=AST;
                ASTLabelType=CommonTree;
                tokenVocab=T;
            }
            a : ^(ID (ID | INT) ) ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34"
            )

        self.failUnlessEqual("(abc 34)", found)


    def testSetMatchNoRewriteLevel2Root(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {
                language=Python;
                output=AST;
            }
            a : x=ID INT -> ^($x INT);
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {
                language=Python;
                output=AST;
                ASTLabelType=CommonTree;
                tokenVocab=T;
            }
            a : ^((ID | INT) INT) ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34"
            )

        self.failUnlessEqual("(abc 34)", found)


    ## REWRITE MODE

    def testRewriteModeCombinedRewriteAndAuto(self):
        grammar = textwrap.dedent(
        r'''
        grammar T17;
        options {
            language=Python;
            output=AST;
        }
        a : ID INT -> ^(ID INT) | INT ;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+;
        WS : (' '|'\\n') {$channel=HIDDEN;} ;
        ''')

        treeGrammar = textwrap.dedent(
        r'''
        tree grammar TP17;
        options {
            language=Python;
            output=AST;
            ASTLabelType=CommonTree;
            tokenVocab=T17;
            rewrite=true;
        }
        a : ^(ID INT) -> ^(ID["ick"] INT)
          | INT // leaves it alone, returning $a.start
          ;
        ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc 34"
            )

        self.failUnlessEqual("(ick 34)", found)


        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "34"
            )

        self.failUnlessEqual("34", found)


    def testRewriteModeFlatTree(self):
        grammar = textwrap.dedent(
            r'''
            grammar T18;
            options {
              language=Python;
              output=AST;
            }
            a : ID INT -> ID INT | INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP18;
            options {
              language=Python;
              output=AST;
              ASTLabelType=CommonTree;
              tokenVocab=T18;
              rewrite=true;
            }
            s : ID a ;
            a : INT -> INT["1"]
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34"
            )
        self.assertEquals("abc 1", found)


    def testRewriteModeChainRuleFlatTree(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT -> ID INT | INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            s : a ;
            a : b ;
            b : ID INT -> INT ID
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34")
        self.assertEquals("34 abc", found)


    def testRewriteModeChainRuleTree(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT -> ^(ID INT) ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            s : a ;
            a : b ; // a.tree must become b.tree
            b : ^(ID INT) -> INT
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34")
        self.assertEquals("34", found)


    def testRewriteModeChainRuleTree2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT -> ^(ID INT) ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; 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
              ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34")
        self.assertEquals("34", found)


    def testRewriteModeChainRuleTree3(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python; output=AST;}
            a : 'boo' ID INT -> 'boo' ^(ID INT) ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; 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
              ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "boo abc 34")
        self.assertEquals("boo 34", found)


    def testRewriteModeChainRuleTree4(self):
        grammar = textwrap.dedent(
            r"""
            grammar T;
            options {language=Python; output=AST;}
            a : 'boo' ID INT -> ^('boo' ^(ID INT)) ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            """)

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; 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
              ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "boo abc 34")
        self.assertEquals("(boo 34)", found)


    def testRewriteModeChainRuleTree5(self):
        grammar = textwrap.dedent(
            r"""
            grammar T;
            options {language=Python; output=AST;}
            a : 'boo' ID INT -> ^('boo' ^(ID INT)) ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            """)

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            tokens { X; }
            s : ^(a b) ; // s.tree is a.tree
            a : 'boo' ;
            b : ^(ID INT) -> INT
              ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "boo abc 34")
        self.assertEquals("(boo 34)", found)


    def testRewriteOfRuleRef(self):
        grammar = textwrap.dedent(
            r"""
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT -> ID INT | INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            """)

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            s : a -> a ;
            a : ID INT -> ID INT ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34")
        self.failUnlessEqual("abc 34", found)


    def testRewriteOfRuleRefRoot(self):
        grammar = textwrap.dedent(
            r"""
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT INT -> ^(INT ^(ID INT));
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            """)

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            s : ^(a ^(ID INT)) -> a ;
            a : INT ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 12 34")
        # emits whole tree when you ref the root since I can't know whether
        # you want the children or not.  You might be returning a whole new
        # tree.  Hmm...still seems weird.  oh well.
        self.failUnlessEqual("(12 (abc 34))", found)


    def testRewriteOfRuleRefRootLabeled(self):
        grammar = textwrap.dedent(
            r"""
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT INT -> ^(INT ^(ID INT));
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            """)

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            s : ^(label=a ^(ID INT)) -> a ;
            a : INT ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 12 34")
        # emits whole tree when you ref the root since I can't know whether
        # you want the children or not.  You might be returning a whole new
        # tree.  Hmm...still seems weird.  oh well.
        self.failUnlessEqual("(12 (abc 34))", found)


    def testRewriteOfRuleRefRootListLabeled(self):
        grammar = textwrap.dedent(
            r"""
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT INT -> ^(INT ^(ID INT));
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            """)

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            s : ^(label+=a ^(ID INT)) -> a ;
            a : INT ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 12 34")
        # emits whole tree when you ref the root since I can't know whether
        # you want the children or not.  You might be returning a whole new
        # tree.  Hmm...still seems weird.  oh well.
        self.failUnlessEqual("(12 (abc 34))", found)


    def testRewriteOfRuleRefChild(self):
        grammar = textwrap.dedent(
            r"""
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT -> ^(ID ^(INT INT));
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            """)

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            s : ^(ID a) -> a ;
            a : ^(INT INT) ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34")
        self.failUnlessEqual("(34 34)", found)


    def testRewriteOfRuleRefLabel(self):
        grammar = textwrap.dedent(
            r"""
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT -> ^(ID ^(INT INT));
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            """)

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            s : ^(ID label=a) -> a ;
            a : ^(INT INT) ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34")
        self.failUnlessEqual("(34 34)", found)


    def testRewriteOfRuleRefListLabel(self):
        grammar = textwrap.dedent(
            r"""
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT -> ^(ID ^(INT INT));
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            """)

        treeGrammar = textwrap.dedent(
            r"""
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            s : ^(ID label+=a) -> a ;
            a : ^(INT INT) ;
            """)

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34")
        self.failUnlessEqual("(34 34)", found)


    def testRewriteModeWithPredicatedRewrites(self):
        grammar = textwrap.dedent(
            r'''
            grammar T19;
            options {
              language=Python;
              output=AST;
            }
            a : ID INT -> ^(ID["root"] ^(ID INT)) | INT -> ^(ID["root"] INT) ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP19;
            options {
              language=Python;
              output=AST;
              ASTLabelType=CommonTree;
              tokenVocab=T19;
              rewrite=true;
            }
            s : ^(ID a) { self.buf += $s.start.toStringTree() };
            a : ^(ID INT) -> {True}? ^(ID["ick"] INT)
                          -> INT
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34"
            )

        self.failUnlessEqual("(root (ick 34))", found)


    def testWildcardSingleNode(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {
                language=Python;
                output=AST;
            }
            a : ID INT -> ^(ID["root"] INT);
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {
                language=Python;
                output=AST;
                ASTLabelType=CommonTree;
                tokenVocab=T;
            }
            s : ^(ID c=.) -> $c
            ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34"
            )

        self.failUnlessEqual("34", found)

    def testWildcardUnlabeledSingleNode(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python; output=AST;}
            a : ID INT -> ^(ID INT);
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T;}
            s : ^(ID .) -> ID
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 34")
        self.assertEquals("abc", found)


    def testWildcardGrabsSubtree(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python; 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;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T;}
            s : ^(ID c=.) -> $c
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 1 2 3")
        self.assertEquals("(1 2 3)", found)


    def testWildcardGrabsSubtree2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python; output=AST;}
            a : ID x=INT y=INT z=INT -> ID ^($x $y $z);
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T;}
            s : ID c=. -> $c
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "abc 1 2 3")
        self.assertEquals("(1 2 3)", found)


    def testWildcardListLabel(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python; output=AST;}
            a : INT INT INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T;}
            s : (c+=.)+ -> $c+
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "1 2 3")
        self.assertEquals("1 2 3", found)


    def testWildcardListLabel2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python; 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;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}
            s : ^(INT (c+=.)+) -> $c+
              ;
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 's',
            "1 2 3")
        self.assertEquals("(2 3) (2 3)", found)


    def testRuleResultAsRoot(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {
                language=Python;
                output=AST;
            }
            a : ID '=' INT -> ^('=' ID INT);
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            COLON : ':' ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        treeGrammar = textwrap.dedent(
            r'''
            tree grammar TP;
            options {
                language=Python;
                output=AST;
                rewrite=true;
                ASTLabelType=CommonTree;
                tokenVocab=T;
            }
            a : ^(eq e1=ID e2=.) -> ^(eq $e2 $e1) ;
            eq : '=' | ':' {pass} ;  // bug in set match, doesn't add to tree!! booh. force nonset.
            ''')

        found = self.execTreeParser(
            grammar, 'a',
            treeGrammar, 'a',
            "abc = 34")
        self.assertEquals("(= 34 abc)", found)


if __name__ == '__main__':
    unittest.main()