Mercurial > hg > openjdk > jdk9 > langtools
changeset 3871:9ed8e9a27b00
8171981: JShell: Fails compilation: new Object().getClass().getSuperclass()
Reviewed-by: mcimadamore
line wrap: on
line diff
--- a/src/jdk.jshell/share/classes/jdk/internal/jshell/debug/InternalDebugControl.java Mon Jan 09 16:20:48 2017 -0800 +++ b/src/jdk.jshell/share/classes/jdk/internal/jshell/debug/InternalDebugControl.java Mon Jan 09 18:04:16 2017 -0800 @@ -68,6 +68,11 @@ */ public static final int DBG_EVNT = 0b0010000; + /** + * Event debugging. + */ + public static final int DBG_WRAP = 0b0100000; + private static Map<JShell, Integer> debugMap = null; /**
--- a/src/jdk.jshell/share/classes/jdk/internal/jshell/tool/JShellTool.java Mon Jan 09 16:20:48 2017 -0800 +++ b/src/jdk.jshell/share/classes/jdk/internal/jshell/tool/JShellTool.java Mon Jan 09 18:04:16 2017 -0800 @@ -119,6 +119,7 @@ import static jdk.internal.jshell.debug.InternalDebugControl.DBG_EVNT; import static jdk.internal.jshell.debug.InternalDebugControl.DBG_FMGR; import static jdk.internal.jshell.debug.InternalDebugControl.DBG_GEN; +import static jdk.internal.jshell.debug.InternalDebugControl.DBG_WRAP; import static jdk.internal.jshell.tool.ContinuousCompletionProvider.STARTSWITH_MATCHER; /** @@ -1919,9 +1920,13 @@ flags |= DBG_EVNT; fluff("Event debugging on"); break; + case 'w': + flags |= DBG_WRAP; + fluff("Wrap debugging on"); + break; default: hard("Unknown debugging option: %c", ch); - fluff("Use: 0 r g f c d"); + fluff("Use: 0 r g f c d e w"); return false; } }
--- a/src/jdk.jshell/share/classes/jdk/jshell/Eval.java Mon Jan 09 16:20:48 2017 -0800 +++ b/src/jdk.jshell/share/classes/jdk/jshell/Eval.java Mon Jan 09 18:04:16 2017 -0800 @@ -49,6 +49,7 @@ import java.io.Writer; import java.util.LinkedHashSet; import java.util.Set; +import jdk.jshell.ExpressionToTypeInfo.ExpressionInfo; import jdk.jshell.Key.ErroneousKey; import jdk.jshell.Key.MethodKey; import jdk.jshell.Key.TypeDeclKey; @@ -58,7 +59,6 @@ import jdk.jshell.TaskFactory.BaseTask; import jdk.jshell.TaskFactory.CompileTask; import jdk.jshell.TaskFactory.ParseTask; -import jdk.jshell.TreeDissector.ExpressionInfo; import jdk.jshell.Wrap.Range; import jdk.jshell.Snippet.Status; import jdk.jshell.spi.ExecutionControl.ClassBytecodes; @@ -296,7 +296,7 @@ private List<Snippet> processExpression(String userSource, String compileSource) { String name = null; - ExpressionInfo ei = typeOfExpression(compileSource); + ExpressionInfo ei = ExpressionToTypeInfo.expressionInfo(compileSource, state); ExpressionTree assignVar; Wrap guts; Snippet snip; @@ -499,16 +499,6 @@ return singletonList(snip); } - private ExpressionInfo typeOfExpression(String expression) { - Wrap guts = Wrap.methodReturnWrap(expression); - TaskFactory.AnalyzeTask at = trialCompile(guts); - if (!at.hasErrors() && at.firstCuTree() != null) { - return TreeDissector.createByFirstClass(at) - .typeOfReturnStatement(at, state); - } - return null; - } - /** * Should a temp var wrap the expression. TODO make this user configurable. *
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/jdk.jshell/share/classes/jdk/jshell/ExpressionToTypeInfo.java Mon Jan 09 18:04:16 2017 -0800 @@ -0,0 +1,216 @@ +/* + * Copyright (c) 2016, 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.jshell; + +import com.sun.source.tree.ReturnTree; +import com.sun.source.tree.ClassTree; +import com.sun.source.tree.CompilationUnitTree; +import com.sun.source.tree.ConditionalExpressionTree; +import com.sun.source.tree.ExpressionTree; +import com.sun.source.tree.MethodTree; +import com.sun.source.tree.Tree; +import com.sun.source.util.TreePath; +import com.sun.source.util.TreePathScanner; +import com.sun.tools.javac.code.Symtab; +import com.sun.tools.javac.code.Type; +import com.sun.tools.javac.code.Types; +import jdk.jshell.TaskFactory.AnalyzeTask; + +/** + * Compute information about an expression string, particularly its type name. + */ +class ExpressionToTypeInfo { + + private static final String OBJECT_TYPE_NAME = "Object"; + + final AnalyzeTask at; + final CompilationUnitTree cu; + final JShell state; + final Symtab syms; + final Types types; + + private ExpressionToTypeInfo(AnalyzeTask at, CompilationUnitTree cu, JShell state) { + this.at = at; + this.cu = cu; + this.state = state; + this.syms = Symtab.instance(at.context); + this.types = Types.instance(at.context); + } + + public static class ExpressionInfo { + ExpressionTree tree; + String typeName; + boolean isNonVoid; + } + + // return mechanism and other general structure from TreePath.getPath() + private static class Result extends Error { + + static final long serialVersionUID = -5942088234594905629L; + final TreePath expressionPath; + + Result(TreePath path) { + this.expressionPath = path; + } + } + + private static class PathFinder extends TreePathScanner<TreePath, Boolean> { + + // Optimize out imports etc + @Override + public TreePath visitCompilationUnit(CompilationUnitTree node, Boolean isTargetContext) { + return scan(node.getTypeDecls(), isTargetContext); + } + + // Only care about members + @Override + public TreePath visitClass(ClassTree node, Boolean isTargetContext) { + return scan(node.getMembers(), isTargetContext); + } + + // Only want the doit method where the code is + @Override + public TreePath visitMethod(MethodTree node, Boolean isTargetContext) { + if (Util.isDoIt(node.getName())) { + return scan(node.getBody(), true); + } else { + return null; + } + } + + @Override + public TreePath visitReturn(ReturnTree node, Boolean isTargetContext) { + ExpressionTree tree = node.getExpression(); + TreePath tp = new TreePath(getCurrentPath(), tree); + if (isTargetContext) { + throw new Result(tp); + } else { + return null; + } + } + } + + private Type pathToType(TreePath tp) { + return (Type) at.trees().getTypeMirror(tp); + } + + private Type pathToType(TreePath tp, Tree tree) { + if (tree instanceof ConditionalExpressionTree) { + // Conditionals always wind up as Object -- this corrects + ConditionalExpressionTree cet = (ConditionalExpressionTree) tree; + Type tmt = pathToType(new TreePath(tp, cet.getTrueExpression())); + Type tmf = pathToType(new TreePath(tp, cet.getFalseExpression())); + if (!tmt.isPrimitive() && !tmf.isPrimitive()) { + Type lub = types.lub(tmt, tmf); + // System.err.printf("cond ? %s : %s -- lub = %s\n", + // varTypeName(tmt), varTypeName(tmf), varTypeName(lub)); + return lub; + } + } + return pathToType(tp); + } + + /** + * Entry method: get expression info + * @param code the expression as a string + * @param state a JShell instance + * @return type information + */ + public static ExpressionInfo expressionInfo(String code, JShell state) { + if (code == null || code.isEmpty()) { + return null; + } + try { + OuterWrap codeWrap = state.outerMap.wrapInTrialClass(Wrap.methodReturnWrap(code)); + AnalyzeTask at = state.taskFactory.new AnalyzeTask(codeWrap); + CompilationUnitTree cu = at.firstCuTree(); + if (at.hasErrors() || cu == null) { + return null; + } + return new ExpressionToTypeInfo(at, cu, state).typeOfExpression(); + } catch (Exception ex) { + return null; + } + } + + private ExpressionInfo typeOfExpression() { + return treeToInfo(findExpressionPath()); + } + + private TreePath findExpressionPath() { + try { + new PathFinder().scan(new TreePath(cu), false); + } catch (Result result) { + return result.expressionPath; + } + return null; + } + + private ExpressionInfo treeToInfo(TreePath tp) { + if (tp != null) { + Tree tree = tp.getLeaf(); + if (tree instanceof ExpressionTree) { + ExpressionInfo ei = new ExpressionInfo(); + ei.tree = (ExpressionTree) tree; + Type type = pathToType(tp, tree); + if (type != null) { + switch (type.getKind()) { + case VOID: + case NONE: + case ERROR: + case OTHER: + break; + case NULL: + ei.isNonVoid = true; + ei.typeName = OBJECT_TYPE_NAME; + break; + default: { + ei.isNonVoid = true; + ei.typeName = varTypeName(type); + if (ei.typeName == null) { + ei.typeName = OBJECT_TYPE_NAME; + } + break; + } + } + } + return ei; + } + } + return null; + } + + private String varTypeName(Type type) { + try { + TypePrinter tp = new VarTypePrinter(at.messages(), + state.maps::fullClassNameAndPackageToClass, syms, types); + return tp.toString(type); + } catch (Exception ex) { + return null; + } + } + +}
--- a/src/jdk.jshell/share/classes/jdk/jshell/SourceCodeAnalysisImpl.java Mon Jan 09 16:20:48 2017 -0800 +++ b/src/jdk.jshell/share/classes/jdk/jshell/SourceCodeAnalysisImpl.java Mon Jan 09 18:04:16 2017 -0800 @@ -105,7 +105,6 @@ import java.util.stream.Collectors; import static java.util.stream.Collectors.collectingAndThen; -import static java.util.stream.Collectors.joining; import static java.util.stream.Collectors.toCollection; import static java.util.stream.Collectors.toList; import static java.util.stream.Collectors.toSet; @@ -128,6 +127,7 @@ import javax.tools.JavaFileManager.Location; import javax.tools.StandardLocation; +import jdk.jshell.ExpressionToTypeInfo.ExpressionInfo; import static jdk.jshell.Util.REPL_DOESNOTMATTER_CLASS_NAME; import static jdk.jshell.SourceCodeAnalysis.Completeness.DEFINITELY_INCOMPLETE; import static jdk.jshell.TreeDissector.printType; @@ -1430,47 +1430,17 @@ @Override public String analyzeType(String code, int cursor) { - code = code.substring(0, cursor); - CompletionInfo completionInfo = analyzeCompletion(code); - if (!completionInfo.completeness().isComplete()) - return null; - if (completionInfo.completeness() == Completeness.COMPLETE_WITH_SEMI) { - code += ";"; - } - - OuterWrap codeWrap; switch (guessKind(code)) { case IMPORT: case METHOD: case CLASS: case ENUM: case INTERFACE: case ANNOTATION_TYPE: case VARIABLE: return null; default: - codeWrap = proc.outerMap.wrapInTrialClass(Wrap.methodWrap(code)); break; } - AnalyzeTask at = proc.taskFactory.new AnalyzeTask(codeWrap); - SourcePositions sp = at.trees().getSourcePositions(); - CompilationUnitTree topLevel = at.firstCuTree(); - int pos = codeWrap.snippetIndexToWrapIndex(code.length()); - TreePath tp = pathFor(topLevel, sp, pos); - while (ExpressionTree.class.isAssignableFrom(tp.getParentPath().getLeaf().getKind().asInterface()) && - tp.getParentPath().getLeaf().getKind() != Kind.ERRONEOUS && - tp.getParentPath().getParentPath() != null) - tp = tp.getParentPath(); - TypeMirror type = at.trees().getTypeMirror(tp); - - if (type == null) - return null; - - switch (type.getKind()) { - case ERROR: case NONE: case OTHER: - case PACKAGE: case VOID: - return null; //not usable - case NULL: - type = at.getElements().getTypeElement("java.lang.Object").asType(); - break; - } - - return TreeDissector.printType(at, proc, type); + ExpressionInfo ei = ExpressionToTypeInfo.expressionInfo(code, proc); + return (ei == null || !ei.isNonVoid) + ? null + : ei.typeName; } @Override
--- a/src/jdk.jshell/share/classes/jdk/jshell/TaskFactory.java Mon Jan 09 16:20:48 2017 -0800 +++ b/src/jdk.jshell/share/classes/jdk/jshell/TaskFactory.java Mon Jan 09 18:04:16 2017 -0800 @@ -321,7 +321,7 @@ final JavacTaskImpl task; private DiagList diags = null; private final SourceHandler<?> sourceHandler; - private final Context context = new Context(); + final Context context = new Context(); private Types types; private JavacMessages messages; private Trees trees;
--- a/src/jdk.jshell/share/classes/jdk/jshell/TreeDissector.java Mon Jan 09 16:20:48 2017 -0800 +++ b/src/jdk.jshell/share/classes/jdk/jshell/TreeDissector.java Mon Jan 09 18:04:16 2017 -0800 @@ -28,14 +28,11 @@ import com.sun.source.tree.ClassTree; import com.sun.source.tree.CompilationUnitTree; -import com.sun.source.tree.ExpressionTree; import com.sun.source.tree.MethodTree; -import com.sun.source.tree.ReturnTree; import com.sun.source.tree.StatementTree; import com.sun.source.tree.Tree; import com.sun.source.tree.VariableTree; import com.sun.source.util.SourcePositions; -import com.sun.source.util.TreePath; import com.sun.source.util.Trees; import com.sun.tools.javac.code.Type; import com.sun.tools.javac.code.Type.MethodType; @@ -47,7 +44,6 @@ import jdk.jshell.Wrap.Range; import java.util.List; -import java.util.Locale; import java.util.function.Predicate; import java.util.stream.Stream; @@ -61,16 +57,6 @@ class TreeDissector { - private static final String OBJECT_TYPE = "Object"; - - static class ExpressionInfo { - - boolean isNonVoid; - String typeName; - ExpressionTree tree; - String signature; - } - private final TaskFactory.BaseTask bt; private final ClassTree targetClass; private final CompilationUnitTree targetCompilationUnit; @@ -219,41 +205,6 @@ return null; } - - ExpressionInfo typeOfReturnStatement(AnalyzeTask at, JShell state) { - ExpressionInfo ei = new ExpressionInfo(); - Tree unitTree = firstStatement(); - if (unitTree instanceof ReturnTree) { - ei.tree = ((ReturnTree) unitTree).getExpression(); - if (ei.tree != null) { - TreePath viPath = trees().getPath(targetCompilationUnit, ei.tree); - if (viPath != null) { - TypeMirror tm = trees().getTypeMirror(viPath); - if (tm != null) { - ei.typeName = printType(at, state, tm); - switch (tm.getKind()) { - case VOID: - case NONE: - case ERROR: - case OTHER: - break; - case NULL: - ei.isNonVoid = true; - ei.typeName = OBJECT_TYPE; - break; - default: { - ei.isNonVoid = true; - break; - - } - } - } - } - } - } - return ei; - } - String typeOfMethod(MethodSnippet msn) { Tree unitTree = method(msn); if (unitTree instanceof JCMethodDecl) { @@ -274,8 +225,13 @@ public static String printType(AnalyzeTask at, JShell state, TypeMirror type) { Type typeImpl = (Type) type; - TypePrinter tp = new TypePrinter(at.messages(), state.maps::fullClassNameAndPackageToClass, typeImpl); - return tp.visit(typeImpl, Locale.getDefault()); + try { + TypePrinter tp = new TypePrinter(at.messages(), + state.maps::fullClassNameAndPackageToClass); + return tp.toString(typeImpl); + } catch (Exception ex) { + return null; + } } /**
--- a/src/jdk.jshell/share/classes/jdk/jshell/TypePrinter.java Mon Jan 09 16:20:48 2017 -0800 +++ b/src/jdk.jshell/share/classes/jdk/jshell/TypePrinter.java Mon Jan 09 18:04:16 2017 -0800 @@ -22,7 +22,6 @@ * or visit www.oracle.com if you need additional information or have any * questions. */ - package jdk.jshell; import static com.sun.tools.javac.code.Flags.COMPOUND; @@ -41,17 +40,21 @@ * Print types in source form. */ class TypePrinter extends Printer { + private static final String OBJECT = "Object"; private final JavacMessages messages; private final BinaryOperator<String> fullClassNameAndPackageToClass; - private boolean useWildCard = false; - TypePrinter(JavacMessages messages, BinaryOperator<String> fullClassNameAndPackageToClass, Type typeToPrint) { + TypePrinter(JavacMessages messages, BinaryOperator<String> fullClassNameAndPackageToClass) { this.messages = messages; this.fullClassNameAndPackageToClass = fullClassNameAndPackageToClass; } + String toString(Type t) { + return visit(t, Locale.getDefault()); + } + @Override protected String localize(Locale locale, String key, Object... args) { return messages.getLocalizedString(locale, key, args); @@ -68,18 +71,6 @@ } @Override - public String visitWildcardType(Type.WildcardType wt, Locale locale) { - if (useWildCard) { // at TypeArgument(ex: List<? extends T>) - return super.visitWildcardType(wt, locale); - } else { // at TopLevelType(ex: ? extends List<T>, ? extends Number[][]) - Type extendsBound = wt.getExtendsBound(); - return extendsBound == null - ? OBJECT - : visit(extendsBound, locale); - } - } - - @Override public String visitType(Type t, Locale locale) { String s = (t.tsym == null || t.tsym.name == null) ? OBJECT // none @@ -87,20 +78,9 @@ return s; } - @Override - public String visitClassType(ClassType ct, Locale locale) { - boolean prevUseWildCard = useWildCard; - try { - useWildCard = true; - return super.visitClassType(ct, locale); - } finally { - useWildCard = prevUseWildCard; - } - } - /** - * Converts a class name into a (possibly localized) string. Anonymous - * inner classes get converted into a localized string. + * Converts a class name into a (possibly localized) string. Anonymous inner + * classes get converted into a localized string. * * @param t the type of the class whose name is to be rendered * @param longform if set, the class' fullname is displayed - if unset the @@ -112,21 +92,13 @@ protected String className(ClassType t, boolean longform, Locale locale) { Symbol sym = t.tsym; if (sym.name.length() == 0 && (sym.flags() & COMPOUND) != 0) { - /*** - StringBuilder s = new StringBuilder(visit(t.supertype_field, locale)); - for (List<Type> is = t.interfaces_field; is.nonEmpty(); is = is.tail) { - s.append('&'); - s.append(visit(is.head, locale)); - } - return s.toString(); - ***/ return OBJECT; } else if (sym.name.length() == 0) { // Anonymous String s; ClassType norm = (ClassType) t.tsym.type; if (norm == null) { - s = "object"; + s = OBJECT; } else if (norm.interfaces_field != null && norm.interfaces_field.nonEmpty()) { s = visit(norm.interfaces_field.head, locale); } else { @@ -160,7 +132,7 @@ @Override public String visitPackageSymbol(PackageSymbol s, Locale locale) { return s.isUnnamed() - ? "" // Unnamed package + ? "" // Unnamed package : s.fullname.toString(); }
--- a/src/jdk.jshell/share/classes/jdk/jshell/Unit.java Mon Jan 09 16:20:48 2017 -0800 +++ b/src/jdk.jshell/share/classes/jdk/jshell/Unit.java Mon Jan 09 18:04:16 2017 -0800 @@ -46,6 +46,7 @@ import static java.util.stream.Collectors.toSet; import static jdk.internal.jshell.debug.InternalDebugControl.DBG_EVNT; import static jdk.internal.jshell.debug.InternalDebugControl.DBG_GEN; +import static jdk.internal.jshell.debug.InternalDebugControl.DBG_WRAP; import static jdk.jshell.Snippet.Status.OVERWRITTEN; import static jdk.jshell.Snippet.Status.RECOVERABLE_DEFINED; import static jdk.jshell.Snippet.Status.RECOVERABLE_NOT_DEFINED; @@ -180,6 +181,8 @@ .collect(toList()); // Set the outer wrap for this snippet si.setOuterWrap(state.outerMap.wrapInClass(except, plus, snippets, wraps)); + state.debug(DBG_WRAP, "++setWrap() %s\n%s\n", + si, si.outerWrap().wrapped()); } }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/jdk.jshell/share/classes/jdk/jshell/VarTypePrinter.java Mon Jan 09 18:04:16 2017 -0800 @@ -0,0 +1,267 @@ +/* + * Copyright (c) 2016, 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.jshell; + +import java.util.HashSet; +import com.sun.tools.javac.code.Type; +import com.sun.tools.javac.code.Type.ClassType; +import com.sun.tools.javac.util.JavacMessages; +import java.util.Locale; +import java.util.Set; +import java.util.function.BinaryOperator; +import com.sun.tools.javac.code.BoundKind; +import com.sun.tools.javac.code.Flags; +import com.sun.tools.javac.code.Symtab; +import com.sun.tools.javac.code.Type.CapturedType; +import com.sun.tools.javac.code.Type.TypeMapping; +import com.sun.tools.javac.code.Type.TypeVar; +import com.sun.tools.javac.code.Type.WildcardType; +import com.sun.tools.javac.code.Types; +import com.sun.tools.javac.code.Types.SimpleVisitor; +import com.sun.tools.javac.util.List; +import static com.sun.tools.javac.code.BoundKind.EXTENDS; +import static com.sun.tools.javac.code.BoundKind.SUPER; +import static com.sun.tools.javac.code.BoundKind.UNBOUND; +import static com.sun.tools.javac.code.Type.ArrayType; +import static com.sun.tools.javac.code.TypeTag.BOT; +import static com.sun.tools.javac.code.TypeTag.WILDCARD; + +/** + * Print variable types in source form. + * TypeProjection and CaptureScanner are copied from Types in the JEP-286 + * Sandbox by Maurizio. The checks for Non-Denotable in TypePrinter are + * cribbed from denotableChecker of the same source. + * + * @author Maurizio Cimadamore + * @author Robert Field + */ +class VarTypePrinter extends TypePrinter { + private static final String WILD = "?"; + + private final Symtab syms; + private final Types types; + + VarTypePrinter(JavacMessages messages, BinaryOperator<String> fullClassNameAndPackageToClass, + Symtab syms, Types types) { + super(messages, fullClassNameAndPackageToClass); + this.syms = syms; + this.types = types; + } + + @Override + String toString(Type t) { + return super.toString(upward(t)); + } + + @Override + public String visitTypeVar(TypeVar t, Locale locale) { + /* Any type variable mentioned in the inferred type must have been declared as a type parameter + (i.e cannot have been produced by inference (18.4)) + */ + // and beyond that, there are no global type vars, so if there are any + // type variables left, they need to be eliminated + return WILD; // Non-denotable + } + + @Override + public String visitCapturedType(CapturedType t, Locale locale) { + /* Any type variable mentioned in the inferred type must have been declared as a type parameter + (i.e cannot have been produced by capture conversion (5.1.10)) + */ + return WILD; // Non-denotable + } + + public Type upward(Type t) { + List<Type> captures = captures(t); + return upward(t, captures); + } + + /************* Following from JEP-286 Types.java ***********/ + + public Type upward(Type t, List<Type> vars) { + return t.map(new TypeProjection(vars), true); + } + + public List<Type> captures(Type t) { + CaptureScanner cs = new CaptureScanner(); + Set<Type> captures = new HashSet<>(); + cs.visit(t, captures); + return List.from(captures); + } + + class CaptureScanner extends SimpleVisitor<Void, Set<Type>> { + + @Override + public Void visitType(Type t, Set<Type> types) { + return null; + } + + @Override + public Void visitClassType(ClassType t, Set<Type> seen) { + if (t.isCompound()) { + types.directSupertypes(t).forEach(s -> visit(s, seen)); + } else { + t.allparams().forEach(ta -> visit(ta, seen)); + } + return null; + } + + @Override + public Void visitArrayType(ArrayType t, Set<Type> seen) { + return visit(t.elemtype, seen); + } + + @Override + public Void visitWildcardType(WildcardType t, Set<Type> seen) { + visit(t.type, seen); + return null; + } + + @Override + public Void visitTypeVar(TypeVar t, Set<Type> seen) { + if ((t.tsym.flags() & Flags.SYNTHETIC) != 0 && seen.add(t)) { + visit(t.getUpperBound(), seen); + } + return null; + } + + @Override + public Void visitCapturedType(CapturedType t, Set<Type> seen) { + if (seen.add(t)) { + visit(t.getUpperBound(), seen); + visit(t.getLowerBound(), seen); + } + return null; + } + } + + class TypeProjection extends TypeMapping<Boolean> { + + List<Type> vars; + Set<Type> seen = new HashSet<>(); + + public TypeProjection(List<Type> vars) { + this.vars = vars; + } + + @Override + public Type visitClassType(ClassType t, Boolean upward) { + if (upward && !t.isCompound() && t.tsym.name.isEmpty()) { + //lift anonymous class type to first supertype (class or interface) + return types.directSupertypes(t).last(); + } else if (t.isCompound()) { + List<Type> components = types.directSupertypes(t); + List<Type> components1 = components.map(c -> c.map(this, upward)); + if (components == components1) return t; + else return types.makeIntersectionType(components1); + } else { + Type outer = t.getEnclosingType(); + Type outer1 = visit(outer, upward); + List<Type> typarams = t.getTypeArguments(); + List<Type> typarams1 = typarams.stream() + .map(ta -> mapTypeArgument(ta, upward)) + .collect(List.collector()); + if (typarams1.stream().anyMatch(ta -> ta.hasTag(BOT))) { + //not defined + return syms.botType; + } + if (outer1 == outer && typarams1 == typarams) return t; + else return new ClassType(outer1, typarams1, t.tsym, t.getMetadata()) { + @Override + protected boolean needsStripping() { + return true; + } + }; + } + } + + protected Type makeWildcard(Type upper, Type lower) { + BoundKind bk; + Type bound; + if (upper.hasTag(BOT)) { + upper = syms.objectType; + } + boolean isUpperObject = types.isSameType(upper, syms.objectType); + if (!lower.hasTag(BOT) && isUpperObject) { + bound = lower; + bk = SUPER; + } else { + bound = upper; + bk = isUpperObject ? UNBOUND : EXTENDS; + } + return new WildcardType(bound, bk, syms.boundClass); + } + + @Override + public Type visitTypeVar(TypeVar t, Boolean upward) { + if (vars.contains(t)) { + try { + if (seen.add(t)) { + return (upward ? + t.getUpperBound() : + (t.getLowerBound() == null) ? + syms.botType : + t.getLowerBound()) + .map(this, upward); + } else { + //cycle + return syms.objectType; + } + } finally { + seen.remove(t); + } + } else { + return t; + } + } + + @Override + public Type visitWildcardType(WildcardType wt, Boolean upward) { + if (upward) { + return wt.isExtendsBound() ? + wt.type.map(this, upward) : + syms.objectType; + } else { + return wt.isSuperBound() ? + wt.type.map(this, upward) : + syms.botType; + } + } + + private Type mapTypeArgument(Type t, boolean upward) { + if (!t.containsAny(vars)) { + return t; + } else if (!t.hasTag(WILDCARD) && !upward) { + //not defined + return syms.botType; + } else { + Type upper = t.map(this, upward); + Type lower = t.map(this, !upward); + return makeWildcard(upper, lower); + } + } + } +}
--- a/test/jdk/jshell/TypeNameTest.java Mon Jan 09 16:20:48 2017 -0800 +++ b/test/jdk/jshell/TypeNameTest.java Mon Jan 09 18:04:16 2017 -0800 @@ -23,81 +23,229 @@ /* * @test - * @bug 8144903 + * @bug 8144903 8171981 * @summary Tests for determining the type from the expression * @build KullaTesting TestingInputStream * @run testng TypeNameTest */ -import jdk.jshell.Snippet; -import jdk.jshell.VarSnippet; import org.testng.annotations.Test; -import static jdk.jshell.Snippet.Status.VALID; import static org.testng.Assert.assertEquals; @Test public class TypeNameTest extends KullaTesting { - public void testReplClassName() { - assertEval("class C {}"); - VarSnippet sn = (VarSnippet) varKey(assertEval("new C();")); - assertEquals(sn.typeName(), "C"); + + private void assertType(String expr, String type) { + assertEquals(varKey(assertEval(expr)).typeName(), type); + assertInferredType(expr, type); + } + + public void testTypeInference() { + assertEval("import java.util.List;"); + assertEval("import java.util.ArrayList;"); + assertEval("import java.util.Arrays;"); + + assertType("new Object().getClass().getSuperclass() ", "Class<?>"); + assertType("new ArrayList().getClass().getSuperclass()", "Class<?>"); + assertType("new ArrayList().getClass()", "Class<? extends ArrayList>"); + assertType("ArrayList.class", "Class<ArrayList>"); + assertType("ArrayList.class.getSuperclass()", "Class<? super ArrayList>"); + + assertEval("class D<T extends CharSequence> { D<? super T> getS() { return null; } }"); + assertEval("D<?> d = new D<String>();"); + assertType("d.getS()", "D<? extends CharSequence>"); + assertType("null", "Object"); + assertType("Class.forName( \"java.util.ArrayList\" )", "Class<?>"); + assertType("new ArrayList<Boolean>() {}", "ArrayList<Boolean>"); + assertType("new ArrayList<String>().stream()", "java.util.stream.Stream<String>"); + assertType("Arrays.asList( 1, 2, 3)", "List<Integer>"); + assertType("new ArrayList().getClass().getClass()", "Class<? extends Class>"); + + assertEval("interface A {}"); + assertEval("interface I {}"); + assertEval("interface J extends A, I {}"); + assertEval("interface K extends A, I {}"); + assertEval("class P<T extends A & I> {}"); + assertType("(P<?>) null", "P<? extends Object>"); + } + + public void testConditionals() { + assertEval("import java.util.List;"); + assertEval("import java.util.ArrayList;"); + assertEval("import java.util.Arrays;"); + + assertEval("CharSequence cs = \"hi\";"); + assertEval("String st = \"low\";"); + assertEval("boolean b;"); + assertType("b? cs : st", "CharSequence"); + + assertEval("List<String> l1 = Arrays.asList(\"hi\");"); + assertEval("List<? extends String> l2 = Arrays.asList(\"po\");"); + assertType("b? l1.get(0) : l2.get(0)", "String"); + + assertEval("class X {}"); + assertEval("class B extends X {}"); + assertEval("class C extends X {}"); + assertType("b? new B() : new C()", "X"); + } + + public void testJEP286NonDenotable() { + assertEval("import java.util.List;"); + assertEval("import java.util.Arrays;"); + assertEval("import java.util.Iterator;"); + + assertEval("List<? extends String> extString() { return Arrays.asList( \"hi\", \"low\" ); }"); + assertEval("List<? super String> supString() { return Arrays.asList( \"hi\", \"low\" ); }"); + assertEval("List<?> unbString() { return Arrays.asList( \"hi\", \"low\" ); }"); + assertEval("List<? extends String>[] extStringArr() {" + + " @SuppressWarnings(\"unchecked\") " + + "List<? extends String>[] a = new List[1]; a[0] = Arrays.asList(\"hi\"); return a; }"); + assertEval("List<? super String>[] supStringArr() {" + + " @SuppressWarnings(\"unchecked\") " + + "List<? super String>[] a = new List[1]; a[0] = Arrays.asList(\"hi\"); return a; }"); + assertEval("List<?>[] unbStringArr() {" + + " @SuppressWarnings(\"unchecked\") " + + "List<?>[] a = new List[1]; a[0] = Arrays.asList(\"hi\"); return a; }"); + assertEval("Iterable<? extends List<? extends String>> extStringIter() {" + + "return Arrays.asList( Arrays.asList( \"hi\" ) ); }"); + assertEval("Iterable<? extends List<? super String>> supStringIter() {" + + "return Arrays.asList( Arrays.asList( \"hi\" ) ); }"); + assertEval("Iterable<? extends List<?>> unbStringIter() {" + + "return Arrays.asList( Arrays.asList( \"hi\" ) ); }"); + assertType("extString()", "List<? extends String>"); + assertType("extString().get(0)", "String"); + assertType("supString()", "List<? super String>"); + assertType("supString().get(0)", "Object"); + assertType("unbString()", "List<?>"); + assertType("unbString().get(0)", "Object"); + assertType("supStringArr()", "List<? super String>[]"); + assertType("supStringArr()[0]", "List<? super String>"); + assertType("supStringArr()[0].get(0)", "Object"); + assertType("unbStringArr()", "List<?>[]"); + assertType("unbStringArr()[0]", "List<?>"); + assertType("unbStringArr()[0].get(0)", "Object"); + assertType("extStringIter()", "Iterable<? extends List<? extends String>>"); + assertType("extStringIter().iterator()", "Iterator<? extends List<? extends String>>"); + assertType("extStringIter().iterator().next()", "List<? extends String>"); + assertType("extStringIter().iterator().next().get(0)", "String"); + assertType("supStringIter()", "Iterable<? extends List<? super String>>"); + assertType("supStringIter().iterator()", "Iterator<? extends List<? super String>>"); + assertType("supStringIter().iterator().next()", "List<? super String>"); + assertType("supStringIter().iterator().next().get(0)", "Object"); + assertType("unbStringIter()", "Iterable<? extends List<?>>"); + assertType("unbStringIter().iterator()", "Iterator<? extends List<?>>"); + assertType("unbStringIter().iterator().next()", "List<?>"); + assertType("unbStringIter().iterator().next().get(0)", "Object"); + } + + public void testJEP286NonDenotable2() { + assertEval("import java.util.List;"); + assertEval("import java.util.Arrays;"); + assertEval("import java.lang.reflect.Array;"); + + assertEval("<Z extends Comparable<Z>> List<? extends Z> extFbound() {" + + "return Arrays.asList( (Z)null ); }"); + assertEval("<Z extends Comparable<Z>> List<? super Z> supFbound() {" + + "return Arrays.asList( (Z)null ); }"); + assertEval("<Z extends Comparable<Z>> List<? extends Z>[] extFboundArr() {" + + "@SuppressWarnings(\"unchecked\")" + + "List<? extends Z>[] a = new List[1]; a[0] = Arrays.asList( (Z)null ); return a; }"); + assertEval("<Z extends Comparable<Z>> List<? super Z>[] supFboundArr() {" + + "@SuppressWarnings(\"unchecked\")" + + "List<? super Z>[] a = new List[1]; a[0] = Arrays.asList( (Z)null ); return a; }"); + assertEval("<Z extends Comparable<Z>> Iterable<? extends List<? extends Z>> extFboundIter() {" + + "return Arrays.asList( Arrays.asList( (Z)null ) ); }"); + assertEval("<Z extends Comparable<Z>> Iterable<? extends List<? super Z>> supFboundIter() {" + + "return Arrays.asList( Arrays.asList( (Z)null ) ); }"); + assertEval("<Z> List<Z> listOf(Z z) { return Arrays.asList( z ); }"); + assertEval("<Z> Z[] arrayOf(Z z) {" + + "@SuppressWarnings(\"unchecked\")" + + "final Z[] a = (Z[]) Array.newInstance(z.getClass(), 1); a[0] = z; return a; }"); + assertType("extFbound()", "List<? extends Comparable<?>>"); + assertType("extFbound().get(0)", "Comparable<?>"); + assertType("supFbound()", "List<?>"); + assertType("supFbound().get(0)", "Object"); + assertType("extFboundArr()", "List<? extends Comparable<?>>[]"); + assertType("extFboundArr()[0]", "List<? extends Comparable<?>>"); + assertType("extFboundArr()[0].get(0)", "Comparable<?>"); + assertType("supFboundArr()", "List<?>[]"); + assertType("supFboundArr()[0]", "List<?>"); + assertType("supFboundArr()[0].get(0)", "Object"); + assertType("extFboundIter()", "Iterable<? extends List<? extends Comparable<?>>>"); + assertType("extFboundIter().iterator()", "java.util.Iterator<? extends List<? extends Comparable<?>>>"); + assertType("extFboundIter().iterator().next()", "List<? extends Comparable<?>>"); + assertType("extFboundIter().iterator().next().get(0)", "Comparable<?>"); + assertType("supFboundIter()", "Iterable<? extends List<?>>"); + assertType("supFboundIter().iterator()", "java.util.Iterator<? extends List<?>>"); + assertType("supFboundIter().iterator().next()", "List<?>"); + assertType("supFboundIter().iterator().next().get(0)", "Object"); + assertType("listOf(23)", "List<Integer>"); + assertType("listOf(true)", "List<Boolean>"); + assertType("listOf(true).get(0)", "Boolean"); + assertType("arrayOf(99)", "Integer[]"); + assertType("arrayOf(99)[0]", "Integer"); + + assertEval("<Z> Z choose(Z z1, Z z2) { return z1; }"); + assertType("choose(1, 1L);", "Object"); + } + + public void testVariableTypeName() { + assertType("\"x\"", "String"); + + assertType("java.util.regex.Pattern.compile(\"x\")", "java.util.regex.Pattern"); + assertEval("import java.util.regex.*;"); + assertType("java.util.regex.Pattern.compile(\"x\")", "Pattern"); + + assertType("new java.util.ArrayList()", "java.util.ArrayList"); + assertEval("import java.util.ArrayList;"); + assertType("new java.util.ArrayList()", "ArrayList"); + + assertType("java.util.Locale.Category.FORMAT", "java.util.Locale.Category"); + assertEval("import static java.util.Locale.Category;"); + assertType("java.util.Locale.Category.FORMAT", "Category"); } public void testReplNestedClassName() { assertEval("class D { static class E {} }"); - VarSnippet sn = (VarSnippet) varKey(assertEval("new D.E();")); - assertEquals(sn.typeName(), "D.E"); + assertType("new D.E();", "D.E"); } public void testAnonymousClassName() { assertEval("class C {}"); - VarSnippet sn = (VarSnippet) varKey(assertEval("new C() { int x; };")); - assertEquals(sn.typeName(), "C"); + assertType("new C();", "C"); + assertType("new C() { int x; };", "C"); } public void testCapturedTypeName() { - VarSnippet sn = (VarSnippet) varKey(assertEval("\"\".getClass();")); - assertEquals(sn.typeName(), "Class<? extends String>"); - } - - public void testArrayTypeOfCapturedTypeName() { - VarSnippet sn = (VarSnippet) varKey(assertEval("\"\".getClass().getEnumConstants();")); - assertEquals(sn.typeName(), "String[]"); + assertType("\"\".getClass();", "Class<? extends String>"); + assertType("\"\".getClass().getEnumConstants();", "String[]"); } public void testJavaLang() { - VarSnippet sn = (VarSnippet) varKey(assertEval("\"\";")); - assertEquals(sn.typeName(), "String"); + assertType("\"\";", "String"); } public void testNotOverEagerPackageEating() { - VarSnippet sn = (VarSnippet) varKey(assertEval("\"\".getClass().getDeclaredMethod(\"hashCode\");")); - assertEquals(sn.typeName(), "java.lang.reflect.Method"); + assertType("\"\".getClass().getDeclaredMethod(\"hashCode\");", "java.lang.reflect.Method"); } public void testBounds() { assertEval("java.util.List<? extends String> list1 = java.util.Arrays.asList(\"\");"); - VarSnippet sn1 = (VarSnippet) varKey(assertEval("list1.iterator().next()")); - assertEquals(sn1.typeName(), "String"); + assertType("list1.iterator().next()", "String"); assertEval("java.util.List<? super String> list2 = java.util.Arrays.asList(\"\");"); - VarSnippet sn2 = (VarSnippet) varKey(assertEval("list2.iterator().next()")); - assertEquals(sn2.typeName(), "Object"); + assertType("list2.iterator().next()", "Object"); assertEval("java.util.List<?> list3 = java.util.Arrays.asList(\"\");"); - VarSnippet sn3 = (VarSnippet) varKey(assertEval("list3.iterator().next()")); - assertEquals(sn3.typeName(), "Object"); + assertType("list3.iterator().next()", "Object"); assertEval("class Test1<X extends CharSequence> { public X get() { return null; } }"); - Snippet x = varKey(assertEval("Test1<?> test1 = new Test1<>();")); - VarSnippet sn4 = (VarSnippet) varKey(assertEval("test1.get()")); - assertEquals(sn4.typeName(), "Object"); + assertEval("Test1<?> test1 = new Test1<>();"); + assertType("test1.get()", "CharSequence"); assertEval("class Test2<X extends Number & CharSequence> { public X get() { return null; } }"); assertEval("Test2<?> test2 = new Test2<>();"); - VarSnippet sn5 = (VarSnippet) varKey(assertEval("test2.get()")); - assertEquals(sn5.typeName(), "Object"); - assertEval("class Test3<T> { T[][] get() { return null; } }", added(VALID)); + assertType("test2.get()", "Object"); + assertEval("class Test3<T> { T[][] get() { return null; } }"); assertEval("Test3<? extends String> test3 = new Test3<>();"); - VarSnippet sn6 = (VarSnippet) varKey(assertEval("test3.get()")); - assertEquals(sn6.typeName(), "String[][]"); + assertType("test3.get()", "String[][]"); } }
--- a/test/jdk/jshell/VariablesTest.java Mon Jan 09 16:20:48 2017 -0800 +++ b/test/jdk/jshell/VariablesTest.java Mon Jan 09 18:04:16 2017 -0800 @@ -337,20 +337,4 @@ assertEquals(unr.get(0), "class undefined"); assertVariables(variable("undefined", "d")); } - - public void variableTypeName() { - assertEquals(varKey(assertEval("\"x\"")).typeName(), "String"); - - assertEquals(varKey(assertEval("java.util.regex.Pattern.compile(\"x\")")).typeName(), "java.util.regex.Pattern"); - assertEval("import java.util.regex.*;", added(VALID)); - assertEquals(varKey(assertEval("java.util.regex.Pattern.compile(\"x\")")).typeName(), "Pattern"); - - assertEquals(varKey(assertEval("new java.util.ArrayList()")).typeName(), "java.util.ArrayList"); - assertEval("import java.util.ArrayList;", added(VALID)); - assertEquals(varKey(assertEval("new java.util.ArrayList()")).typeName(), "ArrayList"); - - assertEquals(varKey(assertEval("java.util.Locale.Category.FORMAT")).typeName(), "java.util.Locale.Category"); - assertEval("import static java.util.Locale.Category;", added(VALID)); - assertEquals(varKey(assertEval("java.util.Locale.Category.FORMAT")).typeName(), "Category"); - } }