/*

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

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 *   - Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *

 *   - Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 *   - Neither the name of Oracle nor the names of its

 *     contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

// Usage: jjs --language=es6 staticchecker.js -- <file>

//    or  jjs --language=es6 staticchecker.js -- <directory>

// default argument is the current directory

if (arguments.length == 0) {

    arguments[0] = ".";

}

const File = Java.type("java.io.File");

const file = new File(arguments[0]);

if (!file.exists()) {

    print(arguments[0] + " is neither a file nor a directory");

    exit(1);

}

// A simple static checker for javascript best practices.

// static checks performed are:

//

// *  __proto__ magic property is bad (non-standard)

// * 'with' statements are bad

// * 'eval' calls are bad

// * 'delete foo' (scope variable delete) is bad

// * assignment to standard globals is bad (eg. Object = "hello")

// * assignment to property on standard prototype is bad (eg. String.prototype.foo = 45)

// * exception swallow (empty catch block in try-catch statements)

const Files = Java.type("java.nio.file.Files");

const EmptyStatementTree = Java.type("jdk.nashorn.api.tree.EmptyStatementTree");

const IdentifierTree = Java.type("jdk.nashorn.api.tree.IdentifierTree");

const MemberSelectTree = Java.type("jdk.nashorn.api.tree.MemberSelectTree");

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

const SimpleTreeVisitor = Java.type("jdk.nashorn.api.tree.SimpleTreeVisitorES6");

const Tree = Java.type("jdk.nashorn.api.tree.Tree");

const parser = Parser.create("-scripting", "--language=es6");

// capture standard global upfront

const globals = new Set();

for (let name of Object.getOwnPropertyNames(this)) {

    globals.add(name);

}

const checkFile = function(file) {

    print("Parsing " + file);

    const ast = parser.parse(file, print);

    if (!ast) {

        print("FAILED to parse: " + file);

        return;

    }

    const checker = new (Java.extend(SimpleTreeVisitor)) {

        lineMap: null,

        printWarning(node, msg) {

            var pos = node.startPosition;

            var line = this.lineMap.getLineNumber(pos);

            var column = this.lineMap.getColumnNumber(pos);

            print(`WARNING: ${msg} in ${file} @ ${line}:${column}`);

        },

        printWithWarning(node) {

            this.printWarning(node, "'with' usage");

        },

        printProtoWarning(node) {

            this.printWarning(node, "__proto__ usage");

        },

        printScopeDeleteWarning(node, varName) {

            this.printWarning(node, `delete ${varName}`);

        },

        hasOnlyEmptyStats(stats) {

            const itr = stats.iterator();

            while (itr.hasNext()) {

                if (! (itr.next() instanceof EmptyStatementTree)) {

                    return false;

                }

            }

            return true;

        },

        checkProto(node, name) {

            if (name == "__proto__") {

                this.printProtoWarning(node);

            }

        },

        checkAssignment(lhs) {

            if (lhs instanceof IdentifierTree && globals.has(lhs.name)) {

                this.printWarning(lhs, `assignment to standard global "${lhs.name}"`);

            } else if (lhs instanceof MemberSelectTree) {

                const expr = lhs.expression;

                if (expr instanceof MemberSelectTree &&

                    expr.expression instanceof IdentifierTree &&

                    globals.has(expr.expression.name) && 

                    "prototype" == expr.identifier) {

                    this.printWarning(lhs, 

                        `property set "${expr.expression.name}.prototype.${lhs.identifier}"`);

                }

            }

        },

        visitAssignment(node, extra) {

            this.checkAssignment(node.variable);

            Java.super(checker).visitAssignment(node, extra);

        },

        visitCatch(node, extra) {

            var stats = node.block.statements;

            if (stats.empty || this.hasOnlyEmptyStats(stats)) {

                this.printWarning(node, "exception swallow");

            }

            Java.super(checker).visitCatch(node, extra);

        },

        visitCompilationUnit(node, extra) {

            this.lineMap = node.lineMap;

            Java.super(checker).visitCompilationUnit(node, extra);

        },

        visitFunctionCall(node, extra) {

           var func = node.functionSelect;

           if (func instanceof IdentifierTree && func.name == "eval") {

               this.printWarning(node, "eval call found");

           }

           Java.super(checker).visitFunctionCall(node, extra);

        },

        visitIdentifier(node, extra) {

            this.checkProto(node, node.name);

            Java.super(checker).visitIdentifier(node, extra);

        },

        visitMemberSelect(node, extra) {

            this.checkProto(node, node.identifier);

            Java.super(checker).visitMemberSelect(node, extra);

        },

        visitProperty(node, extra) {

            this.checkProto(node, node.key);

            Java.super(checker).visitProperty(node, extra);

        },

        visitUnary(node, extra) {

            if (node.kind == Tree.Kind.DELETE &&

                node.expression instanceof IdentifierTree) {

                this.printScopeDeleteWarning(node, node.expression.name);

            }

            Java.super(checker).visitUnary(node, extra);

        },

        visitWith(node, extra) {

            this.printWithWarning(node);

            Java.super(checker).visitWith(node, extra);

        }

    };

    try {

        ast.accept(checker, null);

    } catch (e) {

        print(e);

        if (e.printStackTrace) e.printStackTrace();

        if (e.stack) print(e.stack);

    }

}

if (file.isDirectory()) {

    Files.walk(file.toPath())

        .filter(function(p) Files.isRegularFile(p))

        .filter(function(p) p.toFile().name.endsWith('.js'))

        .forEach(checkFile);

} else {

    checkFile(file);

}