/*

 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 * 

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 * 

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 * 

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 * 

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/**

 * Nashorn parser API - Basic TreeVisitor tests.

 *

 * @test

 * @option -scripting

 * @run

 */

// Java types used

var SimpleTreeVisitor = Java.type("jdk.nashorn.api.tree.SimpleTreeVisitorES5_1");

var Parser = Java.type("jdk.nashorn.api.tree.Parser");

function parse(name, script, visitor) {

    var parser = Parser.create("--empty-statements");

    var tree = parser.parse(name, script, null);

    return tree.accept(visitor, print);

}

parse("arrayaccess.js", "this['eval']",

    new (Java.extend(SimpleTreeVisitor))() {

        visitArrayAccess: function(aa) {

            print("in visitArrayAccess " +

              aa.expression.name + " " + aa.index.value);

        }

    });

parse("arrayliteral.js", "[2, 3, 22]",

    new (Java.extend(SimpleTreeVisitor))() {

        visitArrayLiteral: function(al) {

            print("in visitArrayLiteral");

            for each (var e in al.elements) {

               print(e.value);

            }

        }

    });

parse("assign.js", "x = 33",

    new (Java.extend(SimpleTreeVisitor))() {

        visitAssignment: function(an) {

            print("in visitAssignment " +

                an.variable.name + " " + an.expression.value);

        }

    });

function binaryExpr(name, code) {

    parse(name, code, 

        new (Java.extend(SimpleTreeVisitor))() {

            visitBinary: function(bn) {

                print("in visitBinary " + bn.kind + " " +

                    bn.leftOperand.value + ", " + bn.rightOperand.value);

            }

        });

}

binaryExpr("add.js", "3 + 4");

binaryExpr("sub.js", "3 - 4");

binaryExpr("mul.js", "3 * 4");

binaryExpr("div.js", "3 / 4");

binaryExpr("rem.js", "3 % 4");

binaryExpr("rshift.js", "3 >> 4");

binaryExpr("rshift.js", "3 >>> 4");

binaryExpr("lshift.js", "3 << 4");

binaryExpr("less.js", "3 < 4");

binaryExpr("lessOrEq.js", "3 <= 4");

binaryExpr("greater.js", "3 > 4");

binaryExpr("greaterOrEq.js", "3 >= 4");

binaryExpr("in.js", "3 in this");

binaryExpr("eq.js", "3 == 3");

binaryExpr("ne.js", "3 != 2");

binaryExpr("seq.js", "3 === 2");

binaryExpr("sne.js", "3 !== 2");

binaryExpr("and.js", "3 & 2");

binaryExpr("or.js", "3 | 2");

binaryExpr("xor.js", "3 ^ 2");

binaryExpr("cond_and.js", "3 && 2");

binaryExpr("cond_or.js", "3 || 2");

binaryExpr("comma", "3, 2");

parse("block.js", "{ print('hello'); }", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitBlock: function() {

            print("in visitBlock");

        }

    });

parse("break.js", "while(true) { break; }", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitBreak: function() {

            print("in visitBreak");

        }

    });

function compAssignExpr(name, code) {

    parse(name, code, 

        new (Java.extend(SimpleTreeVisitor))() {

            visitCompoundAssignment: function(bn) {

                print("in visitCompoundAssignment " + bn.kind + " " +

                  bn.variable.name + " " + bn.expression.value);

            }

        });

}

compAssignExpr("mult_assign.js", "x *= 3");

compAssignExpr("div_assign.js", "x /= 3");

compAssignExpr("rem_assign.js", "x %= 3");

compAssignExpr("add_assign.js", "x += 3");

compAssignExpr("sub_assign.js", "x -= 3");

compAssignExpr("lshift_assign.js", "x <<= 3");

compAssignExpr("rshift_assign.js", "x >>= 3");

compAssignExpr("urshift_assign.js", "x >>>= 3");

compAssignExpr("and_assign.js", "x &= 3");

compAssignExpr("xor_assign.js", "x ^= 3");

compAssignExpr("or_assign.js", "x |= 3");

parse("condexpr.js", "foo? x : y", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitConditionalExpression: function() {

            print("in visitConditionalExpression");

        }

    });

parse("continue.js", "while(true) { continue; }", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitContinue: function() {

            print("in visitContinue");

        }

    });

parse("debugger.js", "debugger;", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitDebugger: function() {

            print("in visitDebugger");

        }

    });

parse("dowhile.js", "do {} while(true)", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitDoWhileLoop: function() {

            print("in visitDoWhileLoop");

        }

    });

parse("empty.js", ";", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitEmptyStatement: function() {

            print("in visitEmptyStatement");

        }

    });

parse("exprstat.js", "2+3;", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitExpressionStatement: function() {

            print("in visitExpressionStatement");

        }

    });

parse("forin.js", "for(i in this) {}", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitForInLoop: function() {

            print("in visitForInLoop");

        }

    });

parse("for.js", "for(;;) {}", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitForLoop: function() {

            print("in visitForLoop");

        }

    });

parse("funccall.js", "func()", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitFunctionCall: function(fc) {

            print("in visitFunctionCall " + fc.functionSelect.name);

        }

    });

parse("funcdecl.js", "function func() {}", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitFunctionDeclaration: function(fd) {

            print("in visitFunctionDeclaration " + fd.name);

        }

    });

parse("funcexpr.js", "x = function() {}", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitFunctionExpression: function() {

            print("in visitFunctionExpression");

        }

    });

parse("ident.js", "this", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitIdentifier: function(ident) {

            print("in visitIdentifier " + ident.name);

        }

    });

parse("if.js", "if (true) {}", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitIf: function() {

            print("in visitIf");

        }

    });

parse("if2.js", "if (true) print('yes')", 

    new (visitor = Java.extend(SimpleTreeVisitor))() {

        visitBlock: function(node, extra) {

            print("ERROR: No block expected here!");

            Error.dumpStack();

        }

    });

parse("instanceof.js", "this instanceof Object", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitInstanceOf: function() {

            print("in visitInstanceOf");

        }

    });

parse("labeled.js", "foo: print('hello');", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitLabeledStatement: function() {

            print("in visitLabeledStatement");

        }

    });

function literalExpr(name, code) {

    parse(name, code, 

        new (Java.extend(SimpleTreeVisitor))() {

            visitLiteral: function(ln) {

                print("in visitLiteral " + ln.kind + " " + ln.value);

            }

        });

}

literalExpr("bool.js", "true");

literalExpr("num.js", "3.14");

literalExpr("str.js", "'hello'");

literalExpr("null.js", "null");

parse("memselect.js", "this.foo", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitMemberSelect: function(ms) {

            print("in visitMemberSelect " + ms.identifier);

        }

    });

parse("new.js", "new Object()", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitNew: function() {

            print("in visitNew");

        }

    });

parse("obj_literal.js", "({ foo: 343 })", 

    visitor = new (Java.extend(SimpleTreeVisitor))() {

        visitObjectLiteral: function(ol) {

            print("in visitObjectLiteral");

            Java.super(visitor).visitObjectLiteral(ol, null);

        },

        visitProperty: function(pn) {

            print("in visitProperty " + pn.key.name);

        }

    });

parse("regexp.js", "/[a-b]/i", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitRegExpLiteral: function(re) {

            print("in visitRegExpLiteral " + re.pattern + " " + re.options);

        }

    });

parse("ret.js", "function func() { return 33 }", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitReturn: function(ret) {

            print("in visitReturn " + ret.expression.value);

        }

    });

parse("switch.js", "switch(c) { case '1': break; default: }", 

    visitor = new (Java.extend(SimpleTreeVisitor))() {

        visitSwitch: function(sn) {

            print("in visitSwitch");

            Java.super(visitor).visitSwitch(sn, null);

        },

        visitCase: function(cn) {

            if (cn.expression) {

                print("in visitCase");

            } else {

                print("in visitCase (default)");

            }

        }

    });

parse("throw.js", "throw 2", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitThrow: function(tn) {

            print("in visitThrow " + tn.expression.value);

        }

    });

parse("try.js", "try { func() } catch(e) {}", 

    visitor = new (Java.extend(SimpleTreeVisitor))() {

        visitTry: function(tn) {

            print("in visitTry");

            Java.super(visitor).visitTry(tn, null);

        },

        visitCatch: function(cn) {

            print("in visitCatch " + cn.parameter.name);

        }

    });

function unaryExpr(name, code) {

    parse(name, code, 

        new (Java.extend(SimpleTreeVisitor))() {

            visitUnary: function(un) {

                print("in visitUnary " + un.kind + " " + un.expression.name);

            }

        });

}

unaryExpr("postincr.js", "x++");

unaryExpr("postdecr.js", "x--");

unaryExpr("preincr.js", "++x");

unaryExpr("predecr.js", "--x");

unaryExpr("plus.js", "+x");

unaryExpr("minus.js", "-x");

unaryExpr("complement.js", "~x");

unaryExpr("logical_compl.js", "!x");

unaryExpr("delete.js", "delete x");

unaryExpr("typeof.js", "typeof x");

unaryExpr("void.js", "void x");

parse("var.js", "var x = 34;", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitVariable: function(vn) {

            print("in visitVariable " + vn.name + " = " + vn.initializer.value);

        }

    });

parse("while.js", "while(true) {}", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitWhileLoop: function() {

            print("in visitWhileLoop");

        }

    });

parse("with.js", "with({}) {}", 

    new (Java.extend(SimpleTreeVisitor))() {

        visitWith: function() {

            print("in visitWith");

        }

    });