jdk-sandbox: comparison langtools/src/jdk.jshell/share/classes/jdk/internal/jshell/tool/JShellTool.java

equal deleted inserted replaced

-:96a1226aca18
+:0318f4e75c6d
 return fileCompletions(p -> Files.isDirectory(p) ||
 p.getFileName().toString().endsWith(".zip") ||
 p.getFileName().toString().endsWith(".jar"));
 }
-private CompletionProvider snippetCompletion(Supplier<List<? extends Snippet>> snippetsSupplier) {
+private CompletionProvider snippetCompletion(Supplier<Stream<? extends Snippet>> snippetsSupplier) {
 return (prefix, cursor, anchor) -> {
 anchor[0] = 0;
-return snippetsSupplier.get()                        .stream()
+return snippetsSupplier.get()
 .flatMap(k -> (k instanceof DeclarationSnippet)
 ? Stream.of(String.valueOf(k.id()), ((DeclarationSnippet) k).name())
 : Stream.of(String.valueOf(k.id())))
 .filter(k -> k.startsWith(prefix))
 .map(k -> new Suggestion(k, false))
 .collect(Collectors.toList());
 };
 }
-private CompletionProvider snippetKeywordCompletion(Supplier<List<? extends Snippet>> snippetsSupplier) {
+private CompletionProvider snippetKeywordCompletion(Supplier<Stream<? extends Snippet>> snippetsSupplier) {
 return (code, cursor, anchor) -> {
 List<Suggestion> result = new ArrayList<>();
 result.addAll(KEYWORD_COMPLETION_PROVIDER.completionSuggestions(code, cursor, anchor));
 result.addAll(snippetCompletion(snippetsSupplier).completionSuggestions(code, cursor, anchor));
 return result;
 };
 }
 // Snippet lists
-List<Snippet> allSnippets() {
+Stream<Snippet> allSnippets() {
 return state.snippets();
 }
-List<PersistentSnippet> dropableSnippets() {
+Stream<PersistentSnippet> dropableSnippets() {
-return state.snippets().stream()
+return state.snippets()
 .filter(sn -> state.status(sn).isActive() && sn instanceof PersistentSnippet)
-.map(sn -> (PersistentSnippet) sn)
+.map(sn -> (PersistentSnippet) sn);
-.collect(toList());
+}
-}
+Stream<VarSnippet> allVarSnippets() {
-List<VarSnippet> allVarSnippets() {
+return state.snippets()
-return state.snippets().stream()
 .filter(sn -> sn.kind() == Snippet.Kind.VAR)
-.map(sn -> (VarSnippet) sn)
+.map(sn -> (VarSnippet) sn);
-.collect(toList());
+}
-}
+Stream<MethodSnippet> allMethodSnippets() {
-List<MethodSnippet> allMethodSnippets() {
+return state.snippets()
-return state.snippets().stream()
 .filter(sn -> sn.kind() == Snippet.Kind.METHOD)
-.map(sn -> (MethodSnippet) sn)
+.map(sn -> (MethodSnippet) sn);
-.collect(toList());
+}
-}
+Stream<TypeDeclSnippet> allTypeSnippets() {
-List<TypeDeclSnippet> allTypeSnippets() {
+return state.snippets()
-return state.snippets().stream()
 .filter(sn -> sn.kind() == Snippet.Kind.TYPE_DECL)
-.map(sn -> (TypeDeclSnippet) sn)
+.map(sn -> (TypeDeclSnippet) sn);
-.collect(toList());
 }
 // Table of commands -- with command forms, argument kinds, helpKey message, implementation, ...
 {
 * @param defFilter the filter to apply to the arguments if no argument
 * @param rawargs the user's argument to the command, maybe be the empty
 * string
 * @return a Stream of referenced snippets or null if no matches are found
 */
-private <T extends Snippet> Stream<T> argsOptionsToSnippets(List<T> snippets,
+private <T extends Snippet> Stream<T> argsOptionsToSnippets(Supplier<Stream<T>> snippetSupplier,
 Predicate<Snippet> defFilter, String rawargs, String cmd) {
 ArgTokenizer at = new ArgTokenizer(cmd, rawargs.trim());
 at.allowedOptions("-all", "-start");
 List<String> args = new ArrayList<>();
 String s;
 errormsg("jshell.err.conflicting.options", at.whole());
 return null;
 }
 if (at.hasOption("-all")) {
 // all snippets including start-up, failed, and overwritten
-return snippets.stream();
+return snippetSupplier.get();
 }
 if (at.hasOption("-start")) {
 // start-up snippets
-return snippets.stream()
+return snippetSupplier.get()
 .filter(this::inStartUp);
 }
 if (args.isEmpty()) {
 // Default is all active user snippets
-return snippets.stream()
+return snippetSupplier.get()
 .filter(defFilter);
 }
-return argsToSnippets(snippets, args);
+return argsToSnippets(snippetSupplier, args);
 }
 /**
 * Convert user arguments to a Stream of snippets referenced by those
 * arguments.
 *
-* @param snippets the base list of possible snippets
+* @param snippetSupplier the base list of possible snippets
 * @param args the user's argument to the command, maybe be the empty list
 * @return a Stream of referenced snippets or null if no matches to specific
 * arg
 */
-private <T extends Snippet> Stream<T> argsToSnippets(List<T> snippets,
+private <T extends Snippet> Stream<T> argsToSnippets(Supplier<Stream<T>> snippetSupplier,
 List<String> args) {
 Stream<T> result = null;
 for (String arg : args) {
 // Find the best match
-Stream<T> st = layeredSnippetSearch(snippets, arg);
+Stream<T> st = layeredSnippetSearch(snippetSupplier, arg);
 if (st == null) {
-Stream<Snippet> est = layeredSnippetSearch(state.snippets(), arg);
+Stream<Snippet> est = layeredSnippetSearch(state::snippets, arg);
 if (est == null) {
 errormsg("jshell.err.no.such.snippets", arg);
 } else {
 errormsg("jshell.err.the.snippet.cannot.be.used.with.this.command",
 arg, est.findFirst().get().source());
 }
 }
 return result;
 }
-private <T extends Snippet> Stream<T> layeredSnippetSearch(List<T> snippets, String arg) {
+private <T extends Snippet> Stream<T> layeredSnippetSearch(Supplier<Stream<T>> snippetSupplier, String arg) {
 return nonEmptyStream(
 // the stream supplier
-() -> snippets.stream(),
+snippetSupplier,
 // look for active user declarations matching the name
 sn -> isActive(sn) && matchingDeclaration(sn, arg),
 // else, look for any declarations matching the name
 sn -> matchingDeclaration(sn, arg),
 // else, look for an id of this name
 }
 if (args.isEmpty()) {
 errormsg("jshell.err.drop.arg");
 return false;
 }
-Stream<PersistentSnippet> stream = argsToSnippets(dropableSnippets(), args);
+Stream<PersistentSnippet> stream = argsToSnippets(this::dropableSnippets, args);
 if (stream == null) {
 // Snippet not found. Error already printed
 fluffmsg("jshell.msg.see.classes.etc");
 return false;
 }
 .forEach(sn -> state.drop(sn).forEach(this::handleEvent));
 return true;
 }
 private boolean cmdEdit(String arg) {
-Stream<Snippet> stream = argsOptionsToSnippets(state.snippets(),
+Stream<Snippet> stream = argsOptionsToSnippets(state::snippets,
 this::mainActive, arg, "/edit");
 if (stream == null) {
 return false;
 }
 Set<String> srcSet = new LinkedHashSet<>();
 private boolean cmdList(String arg) {
 if (arg.length() >= 2 && "-history".startsWith(arg)) {
 return cmdHistory();
 }
-Stream<Snippet> stream = argsOptionsToSnippets(state.snippets(),
+Stream<Snippet> stream = argsOptionsToSnippets(state::snippets,
 this::mainActive, arg, "/list");
 if (stream == null) {
 return false;
 }
 writer.write("\n");
 }
 } else if (at.hasOption("-start")) {
 writer.append(startup);
 } else {
-List<Snippet> sns = at.hasOption("-all")
+String sources = (at.hasOption("-all")
 ? state.snippets()
-: state.snippets().stream().filter(this::mainActive).collect(toList());
+: state.snippets().filter(this::mainActive))
-for (Snippet sn : sns) {
+.map(Snippet::source)
-writer.write(sn.source());
+.collect(Collectors.joining("\n"));
-writer.write("\n");
+writer.write(sources);
-}
 }
 } catch (FileNotFoundException e) {
 errormsg("jshell.err.file.not.found", "/save", filename, e.getMessage());
 return false;
 } catch (Exception e) {
 }
 return true;
 }
 private boolean cmdVars(String arg) {
-Stream<VarSnippet> stream = argsOptionsToSnippets(allVarSnippets(),
+Stream<VarSnippet> stream = argsOptionsToSnippets(this::allVarSnippets,
 this::isActive, arg, "/vars");
 if (stream == null) {
 return false;
 }
 stream.forEachOrdered(vk ->
 });
 return true;
 }
 private boolean cmdMethods(String arg) {
-Stream<MethodSnippet> stream = argsOptionsToSnippets(allMethodSnippets(),
+Stream<MethodSnippet> stream = argsOptionsToSnippets(this::allMethodSnippets,
 this::isActive, arg, "/methods");
 if (stream == null) {
 return false;
 }
 stream.forEachOrdered(mk
 );
 return true;
 }
 private boolean cmdTypes(String arg) {
-Stream<TypeDeclSnippet> stream = argsOptionsToSnippets(allTypeSnippets(),
+Stream<TypeDeclSnippet> stream = argsOptionsToSnippets(this::allTypeSnippets,
 this::isActive, arg, "/types");
 if (stream == null) {
 return false;
 }
 stream.forEachOrdered(ck
 });
 return true;
 }
 private boolean cmdUseHistoryEntry(int index) {
-List<Snippet> keys = state.snippets();
+List<Snippet> keys = state.snippets().collect(toList());
 if (index < 0)
 index += keys.size();
 else
 index--;
 if (index >= 0 && index < keys.size()) {
 }
 return true;
 }
 private boolean rerunHistoryEntryById(String id) {
-Optional<Snippet> snippet = state.snippets().stream()
+Optional<Snippet> snippet = state.snippets()
 .filter(s -> s.id().equals(id))
 .findFirst();
 return snippet.map(s -> {
 rerunSnippet(s);
 return true;
 Snippet sn = ste.snippet();
 if (sn == null) {
 debug("Event with null key: %s", ste);
 return false;
 }
-List<Diag> diagnostics = state.diagnostics(sn);
+List<Diag> diagnostics = state.diagnostics(sn).collect(toList());
 String source = sn.source();
 if (ste.causeSnippet() == null) {
 // main event
 for (Diag d : diagnostics) {
 hardmsg(d.isError()? "jshell.msg.error" : "jshell.msg.warning");
 }
 }
 //where
 void printUnresolvedException(UnresolvedReferenceException ex) {
 DeclarationSnippet corralled =  ex.getSnippet();
-List<Diag> otherErrors = errorsOnly(state.diagnostics(corralled));
+List<Diag> otherErrors = errorsOnly(state.diagnostics(corralled).collect(toList()));
 new DisplayEvent(corralled, state.status(corralled), FormatAction.USED, true, null, otherErrors)
 .displayDeclarationAndValue();
 }
 //where
 void printEvalException(EvalException ex) {
 this.value = value;
 this.errorLines = new ArrayList<>();
 for (Diag d : errors) {
 displayDiagnostics(sn.source(), d, errorLines);
 }
-int unresolvedCount;
+long unresolvedCount;
 if (sn instanceof DeclarationSnippet && (status == Status.RECOVERABLE_DEFINED || status == Status.RECOVERABLE_NOT_DEFINED)) {
 resolution = (status == Status.RECOVERABLE_NOT_DEFINED)
 ? FormatResolve.NOTDEFINED
 : FormatResolve.DEFINED;
 unresolved = unresolved((DeclarationSnippet) sn);
-unresolvedCount = state.unresolvedDependencies((DeclarationSnippet) sn).size();
+unresolvedCount = state.unresolvedDependencies((DeclarationSnippet) sn).count();
 } else {
 resolution = FormatResolve.OK;
 unresolved = "";
 unresolvedCount = 0;
 }
 ? FormatErrors.ERROR1
 : FormatErrors.ERROR2;
 }
 private String unresolved(DeclarationSnippet key) {
-List<String> unr = state.unresolvedDependencies(key);
+List<String> unr = state.unresolvedDependencies(key).collect(toList());
 StringBuilder sb = new StringBuilder();
 int fromLast = unr.size();
 if (fromLast > 0) {
 sb.append(" ");
 }

changeset 40304	0318f4e75c6d
parent 38912	2ddd6171351e
child 40498	f54048be4a57