--- old/src/jdk.scripting.nashorn.shell/share/classes/jdk/nashorn/tools/jjs/Main.java 2015-08-17 11:26:26.236088100 +0530 +++ new/src/jdk.scripting.nashorn.shell/share/classes/jdk/nashorn/tools/jjs/Main.java 2015-08-17 11:26:25.892887500 +0530 @@ -31,14 +31,32 @@ import java.io.IOException; import java.io.OutputStream; import java.io.PrintWriter; +import java.util.Iterator; +import java.util.List; import java.util.prefs.Preferences; +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.InstanceOfTree; +import jdk.nashorn.api.tree.MemberSelectTree; +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.internal.objects.Global; import jdk.nashorn.internal.runtime.Context; import jdk.nashorn.internal.runtime.ErrorManager; import jdk.nashorn.internal.runtime.JSType; import jdk.nashorn.internal.runtime.ScriptEnvironment; +import jdk.nashorn.internal.runtime.ScriptObject; import jdk.nashorn.internal.runtime.ScriptRuntime; import jdk.nashorn.tools.Shell; +import jdk.internal.jline.console.completer.Completer; import jdk.internal.jline.console.UserInterruptException; /** @@ -96,8 +114,72 @@ final PrintWriter err = context.getErr(); final Global oldGlobal = Context.getGlobal(); final boolean globalChanged = (oldGlobal != global); + final Parser parser = Parser.create(); - try (final Console in = new Console(System.in, System.out, PREFS)) { + // simple source "tab completer" for nashorn + final Completer completer = new Completer() { + @Override + public int complete(String test, int cursor, List result) { + // check that cursor is at the end of test string. Do not complete in the middle! + if (cursor != test.length()) { + return cursor; + } + + // if it has a ".", then assume it is a member selection expression + final int idx = test.lastIndexOf('.'); + if (idx == -1) { + return cursor; + } + + // stuff before the last "." + final String exprBeforeDot = test.substring(0, idx); + + // Make sure that completed code will have a member expression! Adding ".x" as a + // random property/field name selected to make it possible to be a proper member select + final ExpressionTree topExpr = getTopLevelExpression(parser, exprBeforeDot + ".x"); + if (topExpr == null) { + // did not parse to be a top level expression, no suggestions! + return cursor; + } + + + // Find 'right most' member select expression's start position + final int startPosition = (int) getStartOfMemberSelect(topExpr); + if (startPosition == -1) { + // not a member expression that we can handle for completion + return cursor; + } + + // The part of the right most member select expression before the "." + final String objExpr = test.substring(startPosition, idx); + + // try to evaluate the object expression part as a script + Object obj = null; + try { + obj = context.eval(global, objExpr, global, ""); + } catch (Exception ignored) { + // throw the exception - this is during tab-completion + } + + if (obj != null && obj != ScriptRuntime.UNDEFINED) { + // where is the last dot? Is there a partial property name specified? + final String prefix = test.substring(idx + 1); + if (prefix.isEmpty()) { + // no user specified "prefix". List all properties of the object + result.addAll(PropertiesHelper.getProperties(obj)); + return cursor; + } else { + // list of properties matching the user specified prefix + result.addAll(PropertiesHelper.getProperties(obj, prefix)); + return idx + 1; + } + } + + return cursor; + } + }; + + try (final Console in = new Console(System.in, System.out, PREFS, completer)) { if (globalChanged) { Context.setGlobal(global); } @@ -147,4 +229,66 @@ return SUCCESS; } + + // 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, null); + final List 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; + } + + + private long getStartOfMemberSelect(final ExpressionTree expr) { + if (expr instanceof MemberSelectTree) { + return ((MemberSelectTree)expr).getStartPosition(); + } + + final Tree rightMostExpr = expr.accept(new SimpleTreeVisitorES5_1() { + @Override + public Tree visitAssignment(final AssignmentTree at, final Void v) { + return at.getExpression(); + } + + @Override + public Tree visitCompoundAssignment(final CompoundAssignmentTree cat, final Void v) { + return cat.getExpression(); + } + + @Override + public Tree visitConditionalExpression(final ConditionalExpressionTree cet, final Void v) { + return cet.getFalseExpression(); + } + + @Override + public Tree visitBinary(final BinaryTree bt, final Void v) { + return bt.getRightOperand(); + } + + @Override + public Tree visitInstanceOf(final InstanceOfTree it, final Void v) { + return it.getType(); + } + + @Override + public Tree visitUnary(final UnaryTree ut, final Void v) { + return ut.getExpression(); + } + }, null); + + return (rightMostExpr instanceof MemberSelectTree)? + rightMostExpr.getStartPosition() : -1L; + } }