tools/jjs/NashornCompleter.java

/*
 * 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.
 */

package jdk.nashorn.tools.jjs;

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import jdk.internal.jline.console.completer.Completer;
import jdk.internal.jline.console.UserInterruptException;
import jdk.nashorn.api.tree.AssignmentTree;
import jdk.nashorn.api.tree.BinaryTree;
import jdk.nashorn.api.tree.CompilationUnitTree;
import jdk.nashorn.api.tree.CompoundAssignmentTree;
import jdk.nashorn.api.tree.ConditionalExpressionTree;
import jdk.nashorn.api.tree.ExpressionTree;
import jdk.nashorn.api.tree.ExpressionStatementTree;
import jdk.nashorn.api.tree.FunctionCallTree;
import jdk.nashorn.api.tree.IdentifierTree;
import jdk.nashorn.api.tree.InstanceOfTree;
import jdk.nashorn.api.tree.MemberSelectTree;
import jdk.nashorn.api.tree.NewTree;
import jdk.nashorn.api.tree.SimpleTreeVisitorES5_1;
import jdk.nashorn.api.tree.Tree;
import jdk.nashorn.api.tree.UnaryTree;
import jdk.nashorn.api.tree.Parser;
import jdk.nashorn.api.scripting.NashornException;
import jdk.nashorn.tools.PartialParser;
import jdk.nashorn.internal.objects.NativeSyntaxError;
import jdk.nashorn.internal.objects.Global;
import jdk.nashorn.internal.runtime.ECMAException;
import jdk.nashorn.internal.runtime.Context;
import jdk.nashorn.internal.runtime.ScriptEnvironment;
import jdk.nashorn.internal.runtime.ScriptRuntime;

/**
 * A simple source completer for nashorn. Handles code completion for
 * expressions as well as handles incomplete single line code.
 */
final class NashornCompleter implements Completer {
    private final Context context;
    private final Global global;
    private final ScriptEnvironment env;
    private final PartialParser partialParser;
    private final PropertiesHelper propsHelper;
    private final Parser parser;

    NashornCompleter(final Context context, final Global global,
            final PartialParser partialParser, final PropertiesHelper propsHelper) {
        this.context = context;
        this.global = global;
        this.env = context.getEnv();
        this.partialParser = partialParser;
        this.propsHelper = propsHelper;
        this.parser = createParser(env);
    }


    /**
     * Is this a ECMAScript SyntaxError thrown for parse issue at the given line and column?
     *
     * @param exp Throwable to check
     * @param line line number to check
     * @param column column number to check
     *
     * @return true if the given Throwable is a ECMAScript SyntaxError at given line, column
     */
    boolean isSyntaxErrorAt(final Throwable exp, final int line, final int column) {
        if (exp instanceof ECMAException) {
            final ECMAException eexp = (ECMAException)exp;
            if (eexp.getThrown() instanceof NativeSyntaxError) {
                return isParseErrorAt(eexp.getCause(), line, column);
            }
        }

        return false;
    }

    /**
     * Is this a parse error at the given line and column?
     *
     * @param exp Throwable to check
     * @param line line number to check
     * @param column column number to check
     *
     * @return true if the given Throwable is a parser error at given line, column
     */
    boolean isParseErrorAt(final Throwable exp, final int line, final int column) {
        if (exp instanceof NashornException) {
            final NashornException nexp = (NashornException)exp;
            return nexp.getLineNumber() == line && nexp.getColumnNumber() == column;
        }
        return false;
    }


    /**
     * Read more lines of code if we got SyntaxError at EOF and we can it fine by
     * by reading more lines of code from the user. This is used for multiline editing.
     *
     * @param firstLine First line of code from the user
     * @param exp       Exception thrown by evaluting first line code
     * @param in        Console to get read more lines from the user
     * @param prompt    Prompt to be printed to read more lines from the user
     * @param err       PrintWriter to print any errors in the proecess of reading
     *
     * @return Complete code read from the user including the first line. This is null
     *         if any error or the user discarded multiline editing by Ctrl-C.
     */
    String readMoreLines(final String firstLine, final Exception exp, final Console in,
            final String prompt, final PrintWriter err) {
        int line = 1;
        final StringBuilder buf = new StringBuilder(firstLine);
        while (true) {
            buf.append('\n');
            String curLine = null;
            try {
                curLine = in.readLine(prompt);
                buf.append(curLine);
                line++;
            } catch (final Throwable th) {
                if (th instanceof UserInterruptException) {
                    // Ctrl-C from user - discard the whole thing silently!
                    return null;
                } else {
                    // print anything else -- but still discard the code
                    err.println(th);
                    if (env._dump_on_error) {
                        th.printStackTrace(err);
                    }
                    return null;
                }
            }

            final String allLines = buf.toString();
            try {
                parser.parse("<shell>", allLines, null);
            } catch (final Exception pexp) {
                // Do we have a parse error at the end of current line?
                // If so, read more lines from the console.
                if (isParseErrorAt(pexp, line, curLine.length())) {
                    continue;
                } else {
                    // print anything else and bail out!
                    err.println(pexp);
                    if (env._dump_on_error) {
                        pexp.printStackTrace(err);
                    }
                    return null;
                }
            }

            // We have complete parseable code!
            return buf.toString();
        }
    }

    // Pattern to match a unfinished member selection expression. object part and "."
    // but property name missing pattern.
    private static final Pattern SELECT_PROP_MISSING = Pattern.compile(".*\\.\\s*");

    @Override
    public int complete(final String test, final int cursor, final List<CharSequence> result) {
        // check that cursor is at the end of test string. Do not complete in the middle!
        if (cursor != test.length()) {
            return cursor;
        }

        // get the start of the last expression embedded in the given code
        // using the partial parsing support - so that we can complete expressions
        // inside statements, function call argument lists, array index etc.
        final int exprStart = partialParser.getLastExpressionStart(context, test);
        if (exprStart == -1) {
            return cursor;
        }


        // extract the last expression string
        final String exprStr = test.substring(exprStart);

        // do we have an incomplete member selection expression that misses property name?
        final boolean endsWithDot = SELECT_PROP_MISSING.matcher(exprStr).matches();

        // If this is an incomplete member selection, then it is not legal code.
        // Make it legal by adding a random property name "x" to it.
        final String completeExpr = endsWithDot? exprStr + "x" : exprStr;

        final ExpressionTree topExpr = getTopLevelExpression(parser, completeExpr);
        if (topExpr == null) {
            // did not parse to be a top level expression, no suggestions!
            return cursor;
        }


        // Find 'right most' expression of the top level expression
        final Tree rightMostExpr = getRightMostExpression(topExpr);
        if (rightMostExpr instanceof MemberSelectTree) {
            return completeMemberSelect(exprStr, cursor, result, (MemberSelectTree)rightMostExpr, endsWithDot);
        } else if (rightMostExpr instanceof IdentifierTree) {
            return completeIdentifier(exprStr, cursor, result, (IdentifierTree)rightMostExpr);
        } else {
            // expression that we cannot handle for completion
            return cursor;
        }
    }

    // Internals only below this point

    // fill properties of the incomplete member expression
    private int completeMemberSelect(final String exprStr, final int cursor, final List<CharSequence> result,
                final MemberSelectTree select, final boolean endsWithDot) {
        final ExpressionTree objExpr = select.getExpression();
        final String objExprCode = exprStr.substring((int)objExpr.getStartPosition(), (int)objExpr.getEndPosition());

        // try to evaluate the object expression part as a script
        Object obj = null;
        try {
            obj = context.eval(global, objExprCode, global, "<suggestions>");
        } catch (Exception exp) {
            // throw away the exception - this is during tab-completion
            if (Main.DEBUG) {
                exp.printStackTrace();
            }
        }

        if (obj != null && obj != ScriptRuntime.UNDEFINED) {
            if (endsWithDot) {
                // no user specified "prefix". List all properties of the object
                result.addAll(propsHelper.getProperties(obj));
                return cursor;
            } else {
                // list of properties matching the user specified prefix
                final String prefix = select.getIdentifier();
                result.addAll(propsHelper.getProperties(obj, prefix));
                return cursor - prefix.length();
            }
        }

        return cursor;
    }

    // fill properties for the given (partial) identifer
    private int completeIdentifier(final String test, final int cursor, final List<CharSequence> result,
                final IdentifierTree ident) {
        final String name = ident.getName();
        result.addAll(propsHelper.getProperties(global, name));
        return cursor - name.length();
    }

    // returns ExpressionTree if the given code parses to a top level expression.
    // Or else returns null.
    private ExpressionTree getTopLevelExpression(final Parser parser, final String code) {
        try {
            final CompilationUnitTree cut = parser.parse("<code>", code, null);
            final List<? extends Tree> stats = cut.getSourceElements();
            if (stats.size() == 1) {
                final Tree stat = stats.get(0);
                if (stat instanceof ExpressionStatementTree) {
                    return ((ExpressionStatementTree)stat).getExpression();
                }
            }
        } catch (final NashornException ignored) {
            // ignore any parser error. This is for completion anyway!
            // And user will get that error later when the expression is evaluated.
        }

        return null;
    }

    // get the right most expreesion of the given expression
    private Tree getRightMostExpression(final ExpressionTree expr) {
        return expr.accept(new SimpleTreeVisitorES5_1<Tree, Void>() {
            @Override
            public Tree visitAssignment(final AssignmentTree at, final Void v) {
                return getRightMostExpression(at.getExpression());
            }

            @Override
            public Tree visitCompoundAssignment(final CompoundAssignmentTree cat, final Void v) {
                return getRightMostExpression(cat.getExpression());
            }

            @Override
            public Tree visitConditionalExpression(final ConditionalExpressionTree cet, final Void v) {
                return getRightMostExpression(cet.getFalseExpression());
            }

            @Override
            public Tree visitBinary(final BinaryTree bt, final Void v) {
                return getRightMostExpression(bt.getRightOperand());
            }

            @Override
            public Tree visitIdentifier(final IdentifierTree ident, final Void v) {
                return ident;
            }


            @Override
            public Tree visitInstanceOf(final InstanceOfTree it, final Void v) {
                return it.getType();
            }


            @Override
            public Tree visitMemberSelect(final MemberSelectTree select, final Void v) {
                return select;
            }

            @Override
            public Tree visitNew(final NewTree nt, final Void v) {
                final ExpressionTree call = nt.getConstructorExpression();
                if (call instanceof FunctionCallTree) {
                    final ExpressionTree func = ((FunctionCallTree)call).getFunctionSelect();
                    // Is this "new Foo" or "new obj.Foo" with no user arguments?
                    // If so, we may be able to do completion of constructor name.
                    if (func.getEndPosition() == nt.getEndPosition()) {
                        return func;
                    }
                }
                return null;
            }

            @Override
            public Tree visitUnary(final UnaryTree ut, final Void v) {
                return getRightMostExpression(ut.getExpression());
            }
        }, null);
    }

    // create a Parser instance that uses compatible command line options of the
    // current ScriptEnvironment being used for REPL.
    private static Parser createParser(final ScriptEnvironment env) {
        final List<String> args = new ArrayList<>();
        if (env._const_as_var) {
            args.add("--const-as-var");
        }

        if (env._no_syntax_extensions) {
            args.add("-nse");
        }

        if (env._scripting) {
            args.add("-scripting");
        }

        if (env._strict) {
            args.add("-strict");
        }

        return Parser.create(args.toArray(new String[0]));
    }
}