# HG changeset patch # User lana # Date 1360628109 28800 # Node ID 89c66415168925dffe492356ff893ff248bb5603 # Parent 6fde2039801573813a17b3a84d6ac9671db226c4# Parent 2480aec9a3f193eb8ee4d40c58c927ecdb6d0cb7 Merge diff -r 6fde20398015 -r 89c664151689 make/Makefile-classic --- a/make/Makefile-classic Thu Feb 07 12:33:21 2013 -0800 +++ b/make/Makefile-classic Mon Feb 11 16:15:09 2013 -0800 @@ -241,6 +241,7 @@ javax/annotation/processing \ javax/lang/model \ javax/tools \ + jdk/ \ com/sun/source \ com/sun/tools/javac diff -r 6fde20398015 -r 89c664151689 make/build.properties --- a/make/build.properties Thu Feb 07 12:33:21 2013 -0800 +++ b/make/build.properties Mon Feb 11 16:15:09 2013 -0800 @@ -116,6 +116,7 @@ javax/annotation/processing/ \ javax/lang/model/ \ javax/tools/ \ + jdk/ \ com/sun/source/ \ com/sun/tools/javac/ \ com/sun/tools/doclint/ diff -r 6fde20398015 -r 89c664151689 src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java --- a/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java Thu Feb 07 12:33:21 2013 -0800 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java Mon Feb 11 16:15:09 2013 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2013, 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 @@ -196,10 +196,7 @@ protected void addOverviewComment(Content htmltree) { if (root.inlineTags().length > 0) { htmltree.addContent(getMarkerAnchor("overview_description")); - HtmlTree div = new HtmlTree(HtmlTag.DIV); - div.addStyle(HtmlStyle.subTitle); - addInlineComment(root, div); - htmltree.addContent(div); + addInlineComment(root, htmltree); } } @@ -211,7 +208,7 @@ */ protected void addOverview(Content body) throws IOException { HtmlTree div = new HtmlTree(HtmlTag.DIV); - div.addStyle(HtmlStyle.footer); + div.addStyle(HtmlStyle.contentContainer); addOverviewComment(div); addTagsInfo(root, div); body.addContent(div); diff -r 6fde20398015 -r 89c664151689 src/share/classes/com/sun/tools/javac/code/Symbol.java --- a/src/share/classes/com/sun/tools/javac/code/Symbol.java Thu Feb 07 12:33:21 2013 -0800 +++ b/src/share/classes/com/sun/tools/javac/code/Symbol.java Mon Feb 11 16:15:09 2013 -0800 @@ -496,9 +496,9 @@ return l.toList(); } - public static class DelegatedSymbol extends Symbol { - protected Symbol other; - public DelegatedSymbol(Symbol other) { + public static class DelegatedSymbol extends Symbol { + protected T other; + public DelegatedSymbol(T other) { super(other.kind, other.flags_field, other.name, other.type, other.owner); this.other = other; } @@ -532,6 +532,10 @@ public R accept(Symbol.Visitor v, P p) { return v.visitSymbol(other, p); } + + public T getUnderlyingSymbol() { + return other; + } } /** A class for type symbols. Type variables are represented by instances diff -r 6fde20398015 -r 89c664151689 src/share/classes/com/sun/tools/javac/comp/Lower.java --- a/src/share/classes/com/sun/tools/javac/comp/Lower.java Thu Feb 07 12:33:21 2013 -0800 +++ b/src/share/classes/com/sun/tools/javac/comp/Lower.java Mon Feb 11 16:15:09 2013 -0800 @@ -570,10 +570,19 @@ * @param flags The class symbol's flags * @param owner The class symbol's owner */ - ClassSymbol makeEmptyClass(long flags, ClassSymbol owner) { + JCClassDecl makeEmptyClass(long flags, ClassSymbol owner) { + return makeEmptyClass(flags, owner, null, true); + } + + JCClassDecl makeEmptyClass(long flags, ClassSymbol owner, Name flatname, + boolean addToDefs) { // Create class symbol. ClassSymbol c = reader.defineClass(names.empty, owner); - c.flatname = chk.localClassName(c); + if (flatname != null) { + c.flatname = flatname; + } else { + c.flatname = chk.localClassName(c); + } c.sourcefile = owner.sourcefile; c.completer = null; c.members_field = new Scope(c); @@ -597,9 +606,8 @@ cdef.type = c.type; // Append class definition tree to owner's definitions. - odef.defs = odef.defs.prepend(cdef); - - return c; + if (addToDefs) odef.defs = odef.defs.prepend(cdef); + return cdef; } /************************************************************************** @@ -706,7 +714,7 @@ * and synthethise a class (with makeEmptyClass) if one is not available. * However, there is a small possibility that an existing class will not * be generated as expected if it is inside a conditional with a constant - * expression. If that is found to be the case, create an empty class here. + * expression. If that is found to be the case, create an empty class tree here. */ private void checkAccessConstructorTags() { for (List l = accessConstrTags; l.nonEmpty(); l = l.tail) { @@ -714,14 +722,10 @@ if (isTranslatedClassAvailable(c)) continue; // Create class definition tree. - JCClassDecl cdef = make.ClassDef( - make.Modifiers(STATIC | SYNTHETIC), names.empty, - List.nil(), - null, List.nil(), List.nil()); - cdef.sym = c; - cdef.type = c.type; - // add it to the list of classes to be generated - translated.append(cdef); + JCClassDecl cdec = makeEmptyClass(STATIC | SYNTHETIC, + c.outermostClass(), c.flatname, false); + swapAccessConstructorTag(c, cdec.sym); + translated.append(cdec); } } // where @@ -735,6 +739,19 @@ return false; } + void swapAccessConstructorTag(ClassSymbol oldCTag, ClassSymbol newCTag) { + for (MethodSymbol methodSymbol : accessConstrs.values()) { + Assert.check(methodSymbol.type.hasTag(METHOD)); + MethodType oldMethodType = + (MethodType)methodSymbol.type; + if (oldMethodType.argtypes.head.tsym == oldCTag) + methodSymbol.type = + types.createMethodTypeWithParameters(oldMethodType, + oldMethodType.getParameterTypes().tail + .prepend(newCTag.erasure(types))); + } + } + /************************************************************************** * Access methods *************************************************************************/ @@ -1211,7 +1228,7 @@ "1"); ClassSymbol ctag = chk.compiled.get(flatname); if (ctag == null) - ctag = makeEmptyClass(STATIC | SYNTHETIC, topClass); + ctag = makeEmptyClass(STATIC | SYNTHETIC, topClass).sym; // keep a record of all tags, to verify that all are generated as required accessConstrTags = accessConstrTags.prepend(ctag); return ctag; @@ -1778,7 +1795,7 @@ if (e.sym.kind == TYP && e.sym.name == names.empty && (e.sym.flags() & INTERFACE) == 0) return (ClassSymbol) e.sym; - return makeEmptyClass(STATIC | SYNTHETIC, clazz); + return makeEmptyClass(STATIC | SYNTHETIC, clazz).sym; } /** Return symbol for "class$" method. If there is no method definition diff -r 6fde20398015 -r 89c664151689 src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java --- a/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java Thu Feb 07 12:33:21 2013 -0800 +++ b/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java Mon Feb 11 16:15:09 2013 -0800 @@ -482,10 +482,8 @@ while (i < pool.pp) { Object value = pool.pool[i]; Assert.checkNonNull(value); - if (value instanceof Method) - value = ((Method)value).m; - else if (value instanceof Variable) - value = ((Variable)value).v; + if (value instanceof Method || value instanceof Variable) + value = ((DelegatedSymbol)value).getUnderlyingSymbol(); if (value instanceof MethodSymbol) { MethodSymbol m = (MethodSymbol)value; diff -r 6fde20398015 -r 89c664151689 src/share/classes/com/sun/tools/javac/jvm/Pool.java --- a/src/share/classes/com/sun/tools/javac/jvm/Pool.java Thu Feb 07 12:33:21 2013 -0800 +++ b/src/share/classes/com/sun/tools/javac/jvm/Pool.java Mon Feb 11 16:15:09 2013 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2013, 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 @@ -140,23 +140,23 @@ return n == null ? -1 : n.intValue(); } - static class Method extends DelegatedSymbol { - MethodSymbol m; + static class Method extends DelegatedSymbol { UniqueType uniqueType; Method(MethodSymbol m, Types types) { super(m); - this.m = m; this.uniqueType = new UniqueType(m.type, types); } - public boolean equals(Object other) { - if (!(other instanceof Method)) return false; - MethodSymbol o = ((Method)other).m; + public boolean equals(Object any) { + if (!(any instanceof Method)) return false; + MethodSymbol o = ((Method)any).other; + MethodSymbol m = this.other; return o.name == m.name && o.owner == m.owner && - ((Method)other).uniqueType.equals(uniqueType); + ((Method)any).uniqueType.equals(uniqueType); } public int hashCode() { + MethodSymbol m = this.other; return m.name.hashCode() * 33 + m.owner.hashCode() * 9 + @@ -173,21 +173,21 @@ } @Override - public boolean equals(Object other) { - if (!super.equals(other)) return false; - if (!(other instanceof DynamicMethod)) return false; - DynamicMethodSymbol dm1 = (DynamicMethodSymbol)m; - DynamicMethodSymbol dm2 = (DynamicMethodSymbol)((DynamicMethod)other).m; + public boolean equals(Object any) { + if (!super.equals(any)) return false; + if (!(any instanceof DynamicMethod)) return false; + DynamicMethodSymbol dm1 = (DynamicMethodSymbol)other; + DynamicMethodSymbol dm2 = (DynamicMethodSymbol)((DynamicMethod)any).other; return dm1.bsm == dm2.bsm && dm1.bsmKind == dm2.bsmKind && Arrays.equals(uniqueStaticArgs, - ((DynamicMethod)other).uniqueStaticArgs); + ((DynamicMethod)any).uniqueStaticArgs); } @Override public int hashCode() { int hash = super.hashCode(); - DynamicMethodSymbol dm = (DynamicMethodSymbol)m; + DynamicMethodSymbol dm = (DynamicMethodSymbol)other; hash += dm.bsmKind * 7 + dm.bsm.hashCode() * 11; for (int i = 0; i < dm.staticArgs.length; i++) { @@ -209,23 +209,23 @@ } } - static class Variable extends DelegatedSymbol { - VarSymbol v; + static class Variable extends DelegatedSymbol { UniqueType uniqueType; Variable(VarSymbol v, Types types) { super(v); - this.v = v; this.uniqueType = new UniqueType(v.type, types); } - public boolean equals(Object other) { - if (!(other instanceof Variable)) return false; - VarSymbol o = ((Variable)other).v; + public boolean equals(Object any) { + if (!(any instanceof Variable)) return false; + VarSymbol o = ((Variable)any).other; + VarSymbol v = other; return o.name == v.name && o.owner == v.owner && - ((Variable)other).uniqueType.equals(uniqueType); + ((Variable)any).uniqueType.equals(uniqueType); } public int hashCode() { + VarSymbol v = other; return v.name.hashCode() * 33 + v.owner.hashCode() * 9 + diff -r 6fde20398015 -r 89c664151689 src/share/classes/com/sun/tools/javac/main/JavaCompiler.java --- a/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java Thu Feb 07 12:33:21 2013 -0800 +++ b/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java Mon Feb 11 16:15:09 2013 -0800 @@ -629,6 +629,8 @@ if (!taskListener.isEmpty()) { TaskEvent e = new TaskEvent(TaskEvent.Kind.PARSE, filename); taskListener.started(e); + keepComments = true; + genEndPos = true; } Parser parser = parserFactory.newParser(content, keepComments(), genEndPos, lineDebugInfo); tree = parser.parseCompilationUnit(); diff -r 6fde20398015 -r 89c664151689 src/share/classes/com/sun/tools/javac/parser/DocCommentParser.java --- a/src/share/classes/com/sun/tools/javac/parser/DocCommentParser.java Thu Feb 07 12:33:21 2013 -0800 +++ b/src/share/classes/com/sun/tools/javac/parser/DocCommentParser.java Mon Feb 11 16:15:09 2013 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2013, 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 @@ -279,13 +279,7 @@ try { nextChar(); if (isIdentifierStart(ch)) { - int namePos = bp; - nextChar(); - while (isIdentifierPart(ch)) - nextChar(); - int nameLen = bp - namePos; - - Name name = names.fromChars(buf, namePos, nameLen); + Name name = readIdentifier(); TagParser tp = tagParsers.get(name); if (tp == null) { List content = blockContent(); @@ -334,14 +328,9 @@ try { nextChar(); if (isIdentifierStart(ch)) { - int namePos = bp; - nextChar(); - while (isIdentifierPart(ch)) - nextChar(); - int nameLen = bp - namePos; + Name name = readIdentifier(); skipWhitespace(); - Name name = names.fromChars(buf, namePos, nameLen); TagParser tp = tagParsers.get(name); if (tp == null) { DCTree text = inlineText(); @@ -575,10 +564,8 @@ int pos = bp; if (isJavaIdentifierStart(ch)) { - nextChar(); - while (isJavaIdentifierPart(ch)) - nextChar(); - return m.at(pos).Identifier(names.fromChars(buf, pos, bp - pos)); + Name name = readJavaIdentifier(); + return m.at(pos).Identifier(name); } throw new ParseException("dc.identifier.expected"); @@ -703,39 +690,36 @@ protected DCTree entity() { int p = bp; nextChar(); - int namep = bp; + Name name = null; boolean checkSemi = false; if (ch == '#') { + int namep = bp; nextChar(); if (isDecimalDigit(ch)) { nextChar(); while (isDecimalDigit(ch)) nextChar(); - checkSemi = true; + name = names.fromChars(buf, namep, bp - namep); } else if (ch == 'x' || ch == 'X') { nextChar(); if (isHexDigit(ch)) { nextChar(); while (isHexDigit(ch)) nextChar(); - checkSemi = true; + name = names.fromChars(buf, namep, bp - namep); } } } else if (isIdentifierStart(ch)) { - nextChar(); - while (isIdentifierPart(ch)) - nextChar(); - checkSemi = true; + name = readIdentifier(); } - if (checkSemi && ch == ';') { + if (name == null) + return erroneous("dc.bad.entity", p); + else { + if (ch != ';') + return erroneous("dc.missing.semicolon", p); nextChar(); - return m.at(p).Entity(names.fromChars(buf, namep, bp - namep - 1)); - } else { - String code = checkSemi - ? "dc.missing.semicolon" - : "dc.bad.entity"; - return erroneous(code, p); + return m.at(p).Entity(name); } } @@ -747,11 +731,7 @@ int p = bp; nextChar(); if (isIdentifierStart(ch)) { - int namePos = bp; - nextChar(); - while (isIdentifierPart(ch)) - nextChar(); - int nameLen = bp - namePos; + Name name = readIdentifier(); List attrs = htmlAttrs(); if (attrs != null) { boolean selfClosing = false; @@ -761,22 +741,16 @@ } if (ch == '>') { nextChar(); - Name name = names.fromChars(buf, namePos, nameLen); return m.at(p).StartElement(name, attrs, selfClosing); } } } else if (ch == '/') { nextChar(); if (isIdentifierStart(ch)) { - int namePos = bp; - nextChar(); - while (isIdentifierPart(ch)) - nextChar(); - int nameLen = bp - namePos; + Name name = readIdentifier(); skipWhitespace(); if (ch == '>') { nextChar(); - Name name = names.fromChars(buf, namePos, nameLen); return m.at(p).EndElement(name); } } @@ -822,10 +796,7 @@ loop: while (isIdentifierStart(ch)) { int namePos = bp; - nextChar(); - while (isIdentifierPart(ch)) - nextChar(); - int nameLen = bp - namePos; + Name name = readIdentifier(); skipWhitespace(); List value = null; ValueKind vkind = ValueKind.EMPTY; @@ -862,7 +833,6 @@ skipWhitespace(); value = v.toList(); } - Name name = names.fromChars(buf, namePos, nameLen); DCAttribute attr = m.at(namePos).Attribute(name, vkind, value); attrs.add(attr); } @@ -897,7 +867,7 @@ protected DCErroneous erroneous(String code, int pos) { int i = bp - 1; loop: - while (i > 0) { + while (i > pos) { switch (buf[i]) { case '\f': case '\n': case '\r': newline = true; @@ -926,16 +896,24 @@ return Character.isUnicodeIdentifierStart(ch); } - protected boolean isIdentifierPart(char ch) { - return Character.isUnicodeIdentifierPart(ch); + protected Name readIdentifier() { + int start = bp; + nextChar(); + while (bp < buflen && Character.isUnicodeIdentifierPart(ch)) + nextChar(); + return names.fromChars(buf, start, bp - start); } protected boolean isJavaIdentifierStart(char ch) { return Character.isJavaIdentifierStart(ch); } - protected boolean isJavaIdentifierPart(char ch) { - return Character.isJavaIdentifierPart(ch); + protected Name readJavaIdentifier() { + int start = bp; + nextChar(); + while (bp < buflen && Character.isJavaIdentifierPart(ch)) + nextChar(); + return names.fromChars(buf, start, bp - start); } protected boolean isDecimalDigit(char ch) { diff -r 6fde20398015 -r 89c664151689 src/share/classes/com/sun/tools/javac/parser/JavadocTokenizer.java --- a/src/share/classes/com/sun/tools/javac/parser/JavadocTokenizer.java Thu Feb 07 12:33:21 2013 -0800 +++ b/src/share/classes/com/sun/tools/javac/parser/JavadocTokenizer.java Mon Feb 11 16:15:09 2013 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2004, 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2004, 2013, 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 @@ -236,7 +236,7 @@ // relative to the best match found in the array. if (pos == Position.NOPOS) return Position.NOPOS; - if (pos < 0 || pos >= docComment.length()) + if (pos < 0 || pos > docComment.length()) throw new StringIndexOutOfBoundsException(String.valueOf(pos)); if (docPosns == null) return Position.NOPOS; diff -r 6fde20398015 -r 89c664151689 src/share/classes/com/sun/tools/javac/tree/DCTree.java --- a/src/share/classes/com/sun/tools/javac/tree/DCTree.java Thu Feb 07 12:33:21 2013 -0800 +++ b/src/share/classes/com/sun/tools/javac/tree/DCTree.java Mon Feb 11 16:15:09 2013 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2013, 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 @@ -119,7 +119,7 @@ } - public static abstract class DCBlockTag extends DCTree implements InlineTagTree { + public static abstract class DCBlockTag extends DCTree implements BlockTagTree { public String getTagName() { return getKind().tagName; } @@ -169,7 +169,7 @@ } } - public static class DCAuthor extends DCInlineTag implements AuthorTree { + public static class DCAuthor extends DCBlockTag implements AuthorTree { public final List name; DCAuthor(List name) { @@ -640,7 +640,7 @@ } } - public static class DCSince extends DCInlineTag implements SinceTree { + public static class DCSince extends DCBlockTag implements SinceTree { public final List body; DCSince(List body) { diff -r 6fde20398015 -r 89c664151689 src/share/classes/com/sun/tools/javadoc/api/JavadocTool.java --- a/src/share/classes/com/sun/tools/javadoc/api/JavadocTool.java Thu Feb 07 12:33:21 2013 -0800 +++ b/src/share/classes/com/sun/tools/javadoc/api/JavadocTool.java Mon Feb 11 16:15:09 2013 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2013, 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 @@ -139,12 +139,13 @@ @Override public int run(InputStream in, OutputStream out, OutputStream err, String... arguments) { - PrintWriter err_pw = new PrintWriter(err, true); - PrintWriter out_pw = new PrintWriter(out); + PrintWriter err_pw = new PrintWriter(err == null ? System.err : err, true); + PrintWriter out_pw = new PrintWriter(out == null ? System.out : out); try { String standardDocletName = "com.sun.tools.doclets.standard.Standard"; + ClassLoader cl = getClass().getClassLoader(); return com.sun.tools.javadoc.Main.execute( - "javadoc", err_pw, err_pw, out_pw, standardDocletName, arguments); + "javadoc", err_pw, err_pw, out_pw, standardDocletName, cl, arguments); } finally { err_pw.flush(); out_pw.flush(); diff -r 6fde20398015 -r 89c664151689 src/share/classes/jdk/Supported.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/jdk/Supported.java Mon Feb 11 16:15:09 2013 -0800 @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2013, 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; + +import java.lang.annotation.*; + +/** + * Indicates whether or not a JDK specific type or package is a + * supported part of the JDK. + * + * This annotation should only be applied to types and packages + * outside of the Java SE namespaces of {@code java.*} and + * {@code javax.*} packages. For example, certain portions of {@code + * com.sun.*} are official parts of the JDK meant to be generally + * usable while other portions of {@code com.sun.*} are not. This + * annotation type allows those portions to be easily and + * programmaticly distinguished. + * + * @since 1.8 + */ +@Documented +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.TYPE, ElementType.PACKAGE}) +@Supported +public @interface Supported { + /** + * Whether or not this package or type is a supported part of the JDK. + */ + boolean value() default true; +} diff -r 6fde20398015 -r 89c664151689 test/tools/doclint/EndWithIdentifierTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/doclint/EndWithIdentifierTest.java Mon Feb 11 16:15:09 2013 -0800 @@ -0,0 +1,32 @@ +/* + * @test /nodynamiccopyright/ + * @bug 8007096 + * @summary DocLint parsing problems with some comments + * @build DocLintTester + * @run main DocLintTester -Xmsgs:-html EndWithIdentifierTest.java + * @run main DocLintTester -Xmsgs -ref EndWithIdentifierTest.out EndWithIdentifierTest.java + * @author jlahoda + */ + +/**@deprecated*/ +public class EndWithIdentifierTest { + + /**{@link*/ + private void unfinishedInlineTagName() {} + + /**@see List*/ + private void endsWithIdentifier() {} + + /**&*/ + private void entityName() {} + + /** fos = fm.getJavaFileObjects(thisFile); + testAnnoProcessor(javac, fm, fos, out, EXPECT_DOC_COMMENTS); + testTaskListener(javac, fm, fos, out, EXPECT_DOC_COMMENTS); + + if (errors > 0) + throw new Exception(errors + " errors occurred"); + } + + void testAnnoProcessor(JavacTool javac, StandardJavaFileManager fm, + Iterable files, PrintWriter out, + int expectedDocComments) { + out.println("Test annotation processor"); + JavacTask task = javac.getTask(out, fm, null, null, null, files); + AnnoProc ap = new AnnoProc(DocTrees.instance(task)); + task.setProcessors(Arrays.asList(ap)); + task.call(); + ap.checker.checkDocComments(expectedDocComments); + } + + void testTaskListener(JavacTool javac, StandardJavaFileManager fm, + Iterable files, PrintWriter out, + int expectedDocComments) { + out.println("Test task listener"); + JavacTask task = javac.getTask(out, fm, null, null, null, files); + TaskListnr tl = new TaskListnr(DocTrees.instance(task)); + task.addTaskListener(tl); + task.call(); + tl.checker.checkDocComments(expectedDocComments); + } + + void error(String msg) { + out.println("Error: " + msg); + errors++; + } + + class AnnoProc extends JavacTestingAbstractProcessor { + Checker checker; + + AnnoProc(DocTrees trees) { + checker = new Checker(trees); + } + + @Override + public boolean process(Set annotations, RoundEnvironment roundEnv) { + for (Element e : roundEnv.getRootElements()) { + checker.scan(checker.trees.getPath(e), null); + } + return true; + } + } + + class TaskListnr implements TaskListener { + Checker checker; + + TaskListnr(DocTrees trees) { + checker = new Checker(trees); + } + + public void started(TaskEvent e) { + if (e.getKind() == TaskEvent.Kind.ANALYZE) + checker.scan(new TreePath(e.getCompilationUnit()), null); + } + + public void finished(TaskEvent e) { + } + } + + class Checker extends TreePathScanner { + DocTrees trees; + SourcePositions srcPosns; + + int docComments = 0; + + Checker(DocTrees trees) { + this.trees = trees; + srcPosns = trees.getSourcePositions(); + } + + @Override + public Void scan(Tree tree, Void ignore) { + if (tree != null) { + switch (tree.getKind()) { + // HACK: Workaround 8007350 + // Some tree nodes do not have endpos set + case ASSIGNMENT: + case BLOCK: + case IDENTIFIER: + case METHOD_INVOCATION: + break; + + default: + checkEndPos(getCurrentPath().getCompilationUnit(), tree); + } + } + return super.scan(tree, ignore); + } + + @Override + public Void visitClass(ClassTree tree, Void ignore) { + checkComment(); + return super.visitClass(tree, ignore); + } + + @Override + public Void visitMethod(MethodTree tree, Void ignore) { + checkComment(); + return super.visitMethod(tree, ignore); + } + + @Override + public Void visitVariable(VariableTree tree, Void ignore) { + checkComment(); + return super.visitVariable(tree, ignore); + } + + void checkComment() { + DocCommentTree dc = trees.getDocCommentTree(getCurrentPath()); + if (dc != null) { + out.println("comment: " + dc.toString().replaceAll("\\s+", " ")); + docComments++; + } + } + + void checkEndPos(CompilationUnitTree unit, Tree tree) { + long sp = srcPosns.getStartPosition(unit, tree); + long ep = srcPosns.getEndPosition(unit, tree); + if (sp >= 0 && ep == Position.NOPOS) { + error("endpos not set for " + tree.getKind() + + " " + Pretty.toSimpleString(((JCTree) tree)) + +", start:" + sp); + } + } + + void checkDocComments(int expected) { + if (docComments != expected) { + error("Unexpected number of doc comments received: " + + docComments + ", expected: " + expected); + } + } + + } +} diff -r 6fde20398015 -r 89c664151689 test/tools/javac/api/T6306137.java --- a/test/tools/javac/api/T6306137.java Thu Feb 07 12:33:21 2013 -0800 +++ b/test/tools/javac/api/T6306137.java Mon Feb 11 16:15:09 2013 -0800 @@ -26,9 +26,6 @@ * @bug 6306137 * @summary JSR 199: encoding option doesn't affect standard file manager * @author Peter von der Ahé - * @ignore - * Need to make the contentCache in JavacFileManager be aware of changes to the encoding. - * Need to propogate -source (and -encoding?) down to the JavacFileManager */ import java.io.File; diff -r 6fde20398015 -r 89c664151689 test/tools/javac/defaultMethods/TestNoBridgeOnDefaults.java --- a/test/tools/javac/defaultMethods/TestNoBridgeOnDefaults.java Thu Feb 07 12:33:21 2013 -0800 +++ b/test/tools/javac/defaultMethods/TestNoBridgeOnDefaults.java Mon Feb 11 16:15:09 2013 -0800 @@ -23,7 +23,6 @@ /* * @test - * @ignore awaits for VM support * @summary check that javac does not generate bridge methods for defaults */ diff -r 6fde20398015 -r 89c664151689 test/tools/javac/lambda/LambdaCapture06.java --- a/test/tools/javac/lambda/LambdaCapture06.java Thu Feb 07 12:33:21 2013 -0800 +++ b/test/tools/javac/lambda/LambdaCapture06.java Mon Feb 11 16:15:09 2013 -0800 @@ -23,7 +23,6 @@ /* * @test - * @ignore investigate as to whether code generation fails * @bug 8003280 * @summary Add lambda tests * Compiler crash when local inner class nested inside lambda captures local variables from enclosing scope diff -r 6fde20398015 -r 89c664151689 test/tools/javac/lambda/LambdaExpr15.java --- a/test/tools/javac/lambda/LambdaExpr15.java Thu Feb 07 12:33:21 2013 -0800 +++ b/test/tools/javac/lambda/LambdaExpr15.java Mon Feb 11 16:15:09 2013 -0800 @@ -23,7 +23,6 @@ /* * @test - * @ignore investigate as to whether code generation fails * @bug 8003280 * @summary Add lambda tests * check that nested inner class in statement lambdas don't get corrupted return statements diff -r 6fde20398015 -r 89c664151689 test/tools/javac/lib/DPrinter.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/javac/lib/DPrinter.java Mon Feb 11 16:15:09 2013 -0800 @@ -0,0 +1,1331 @@ +/* + * Copyright (c) 2013, 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. + * + * 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. + */ + +import java.io.File; +import java.io.IOException; +import java.io.PrintWriter; +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.EnumSet; +import java.util.HashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Set; + +import javax.lang.model.element.Name; +import javax.lang.model.element.TypeElement; +import javax.tools.FileObject; +import javax.tools.JavaCompiler; +import javax.tools.JavaFileObject; +import javax.tools.StandardJavaFileManager; +import javax.tools.StandardLocation; +import javax.tools.ToolProvider; + +import com.sun.source.util.JavacTask; +import com.sun.source.util.TaskEvent; +import com.sun.source.util.TaskListener; +import com.sun.source.util.Trees; +import com.sun.tools.javac.api.JavacTrees; +import com.sun.tools.javac.code.Annotations; +import com.sun.tools.javac.code.Attribute; +import com.sun.tools.javac.code.Flags; +import com.sun.tools.javac.code.Kinds; +import com.sun.tools.javac.code.Printer; +import com.sun.tools.javac.code.Scope; +import com.sun.tools.javac.code.Scope.CompoundScope; +import com.sun.tools.javac.code.Symbol; +import com.sun.tools.javac.code.Symbol.*; +import com.sun.tools.javac.code.Type; +import com.sun.tools.javac.code.Type.*; +import com.sun.tools.javac.code.TypeTag; +import com.sun.tools.javac.tree.JCTree; +import com.sun.tools.javac.tree.JCTree.*; +import com.sun.tools.javac.tree.Pretty; +import com.sun.tools.javac.tree.TreeInfo; +import com.sun.tools.javac.tree.TreeScanner; +import com.sun.tools.javac.util.Assert; +import com.sun.tools.javac.util.Context; +import com.sun.tools.javac.util.Log; + + +/** + * Debug printer for javac internals, for when toString() just isn't enough. + * + *

+ * The printer provides an API to generate structured views of javac objects, + * such as AST nodes, symbol, types and annotations. Various aspects of the + * output can be configured, such as whether to show nulls, empty lists, or + * a compressed representation of the source code. Visitors are used to walk + * object hierarchies, and can be replaced with custom visitors if the default + * visitors are not flexible enough. + * + *

+ * In general, nodes are printed with an initial line identifying the node + * followed by indented lines for the child nodes. Currently, graphs are + * represented by printing a spanning subtree. + * + *

+ * The printer can be accessed via a simple command-line utility, + * which makes it easy to see the internal representation of source code, + * such as simple test programs, during the compilation pipeline. + * + *

This is NOT part of any supported API. + * If you write code that depends on this, you do so at your own risk. + * This code and its internal interfaces are subject to change or + * deletion without notice. + */ + +public class DPrinter { + protected final PrintWriter out; + protected final Trees trees; + protected Printer printer; + protected boolean showEmptyItems = true; + protected boolean showNulls = true; + protected boolean showPositions = false; + protected boolean showSrc; + protected boolean showTreeSymbols; + protected boolean showTreeTypes; + protected int maxSrcLength = 32; + protected Locale locale = Locale.getDefault(); + protected static final String NULL = "#null"; + + // + + public static DPrinter instance(Context context) { + DPrinter dp = context.get(DPrinter.class); + if (dp == null) { + dp = new DPrinter(context); + } + return dp; + + } + + protected DPrinter(Context context) { + context.put(DPrinter.class, this); + out = context.get(Log.outKey); + trees = JavacTrees.instance(context); + } + + public DPrinter(PrintWriter out, Trees trees) { + this.out = out; + this.trees = trees; + } + + public DPrinter emptyItems(boolean showEmptyItems) { + this.showEmptyItems = showEmptyItems; + return this; + } + + public DPrinter nulls(boolean showNulls) { + this.showNulls = showNulls; + return this; + } + + public DPrinter positions(boolean showPositions) { + this.showPositions = showPositions; + return this; + } + + public DPrinter source(boolean showSrc) { + this.showSrc = showSrc; + return this; + } + + public DPrinter source(int maxSrcLength) { + this.showSrc = true; + this.maxSrcLength = maxSrcLength; + return this; + } + + public DPrinter treeSymbols(boolean showTreeSymbols) { + this.showTreeSymbols = showTreeSymbols; + return this; + } + + public DPrinter treeTypes(boolean showTreeTypes) { + this.showTreeTypes = showTreeTypes; + return this; + } + + public DPrinter typeSymbolPrinter(Printer p) { + printer = p; + return this; + } + + // + + // + + protected enum Details { + /** A one-line non-recursive summary */ + SUMMARY, + /** Multi-line, possibly recursive. */ + FULL + }; + + public void printAnnotations(String label, Annotations annotations) { + printAnnotations(label, annotations, Details.FULL); + } + + protected void printAnnotations(String label, Annotations annotations, Details details) { + if (annotations == null) { + printNull(label); + } else { + // no SUMMARY format currently available to use + + // use reflection to get at private fields + Object DECL_NOT_STARTED = getField(null, Annotations.class, "DECL_NOT_STARTED"); + Object DECL_IN_PROGRESS = getField(null, Annotations.class, "DECL_IN_PROGRESS"); + Object attributes = getField(annotations, Annotations.class, "attributes"); + Object type_attributes = getField(annotations, Annotations.class, "type_attributes"); + + if (!showEmptyItems) { + if (attributes instanceof List && ((List) attributes).isEmpty() + && attributes != DECL_NOT_STARTED + && attributes != DECL_IN_PROGRESS + && type_attributes instanceof List && ((List) type_attributes).isEmpty()) + return; + } + + printString(label, hashString(annotations)); + + indent(+1); + if (attributes == DECL_NOT_STARTED) + printString("attributes", "DECL_NOT_STARTED"); + else if (attributes == DECL_IN_PROGRESS) + printString("attributes", "DECL_IN_PROGRESS"); + else if (attributes instanceof List) + printList("attributes", (List) attributes); + else + printObject("attributes", attributes, Details.SUMMARY); + + if (attributes instanceof List) + printList("type_attributes", (List) type_attributes); + else + printObject("type_attributes", type_attributes, Details.SUMMARY); + indent(-1); + } + } + + public void printAttribute(String label, Attribute attr) { + if (attr == null) { + printNull(label); + } else { + printString(label, attr.getClass().getSimpleName()); + + indent(+1); + attr.accept(attrVisitor); + indent(-1); + } + } + + public void printFileObject(String label, FileObject fo) { + if (fo == null) { + printNull(label); + } else { + printString(label, fo.getName()); + } + } + + protected void printImplClass(T item, Class stdImplClass) { + if (item.getClass() != stdImplClass) + printString("impl", item.getClass().getName()); + } + + public void printInt(String label, int i) { + printString(label, String.valueOf(i)); + } + + public void printList(String label, List list) { + if (list == null) { + printNull(label); + } else if (!list.isEmpty() || showEmptyItems) { + printString(label, "[" + list.size() + "]"); + + indent(+1); + int i = 0; + for (Object item: list) { + printObject(String.valueOf(i++), item, Details.FULL); + } + indent(-1); + } + } + + public void printName(String label, Name name) { + if (name == null) { + printNull(label); + } else { + printString(label, name.toString()); + } + } + + public void printNull(String label) { + if (showNulls) + printString(label, NULL); + } + + protected void printObject(String label, Object item, Details details) { + if (item == null) { + printNull(label); + } else if (item instanceof Attribute) { + printAttribute(label, (Attribute) item); + } else if (item instanceof Symbol) { + printSymbol(label, (Symbol) item, details); + } else if (item instanceof Type) { + printType(label, (Type) item, details); + } else if (item instanceof JCTree) { + printTree(label, (JCTree) item); + } else if (item instanceof List) { + printList(label, (List) item); + } else if (item instanceof Name) { + printName(label, (Name) item); + } else { + printString(label, String.valueOf(item)); + } + } + + public void printScope(String label, Scope scope) { + printScope(label, scope, Details.FULL); + } + + public void printScope(String label, Scope scope, Details details) { + if (scope == null) { + printNull(label); + } else { + switch (details) { + case SUMMARY: { + indent(); + out.print(label); + out.print(": ["); + String sep = ""; + for (Symbol sym: scope.getElements()) { + out.print(sep); + out.print(sym.name); + sep = ","; + } + out.println("]"); + break; + } + + case FULL: { + indent(); + out.println(label); + + indent(+1); + printImplClass(scope, Scope.class); + printSymbol("owner", scope.owner, Details.SUMMARY); + printScope("next", scope.next, Details.SUMMARY); + printObject("shared", getField(scope, Scope.class, "shared"), Details.SUMMARY); + if (scope instanceof CompoundScope) { + printObject("subScopes", + getField(scope, CompoundScope.class, "subScopes"), + Details.FULL); + } else { + for (Symbol sym : scope.getElements()) { + printSymbol(sym.name.toString(), sym, Details.SUMMARY); + } + } + indent(-1); + break; + } + } + } + } + + public void printSource(String label, JCTree tree) { + printString(label, Pretty.toSimpleString(tree, maxSrcLength)); + } + + public void printString(String label, String text) { + indent(); + out.print(label); + out.print(": "); + out.print(text); + out.println(); + } + + public void printSymbol(String label, Symbol symbol) { + printSymbol(label, symbol, Details.FULL); + } + + protected void printSymbol(String label, Symbol sym, Details details) { + if (sym == null) { + printNull(label); + } else { + switch (details) { + case SUMMARY: + printString(label, toString(sym)); + break; + + case FULL: + indent(); + out.print(label); + out.println(": " + + info(sym.getClass(), + String.format("0x%x--%s", sym.kind, Kinds.kindName(sym)), + sym.getKind()) + + " " + sym.name + + " " + hashString(sym)); + + indent(+1); + if (showSrc) { + JCTree tree = (JCTree) trees.getTree(sym); + if (tree != null) + printSource("src", tree); + } + printString("flags", String.format("0x%x--%s", + sym.flags_field, Flags.toString(sym.flags_field))); + printObject("completer", sym.completer, Details.SUMMARY); // what if too long? + printSymbol("owner", sym.owner, Details.SUMMARY); + printType("type", sym.type, Details.SUMMARY); + printType("erasure", sym.erasure_field, Details.SUMMARY); + sym.accept(symVisitor, null); + printAnnotations("annotations", sym.annotations, Details.SUMMARY); + indent(-1); + } + } + } + + protected String toString(Symbol sym) { + return (printer != null) ? printer.visit(sym, locale) : String.valueOf(sym); + } + + protected void printTree(String label, JCTree tree) { + if (tree == null) { + printNull(label); + } else { + indent(); + String ext; + try { + ext = tree.getKind().name(); + } catch (Throwable t) { + ext = "n/a"; + } + out.print(label + ": " + info(tree.getClass(), tree.getTag(), ext)); + if (showPositions) { + // We can always get start position, but to get end position + // and/or line+offset, we would need a JCCompilationUnit + out.print(" pos:" + tree.pos); + } + if (showTreeTypes && tree.type != null) + out.print(" type:" + toString(tree.type)); + Symbol sym; + if (showTreeSymbols && (sym = TreeInfo.symbolFor(tree)) != null) + out.print(" sym:" + toString(sym)); + out.println(); + + indent(+1); + if (showSrc) { + indent(); + out.println("src: " + Pretty.toSimpleString(tree, maxSrcLength)); + } + tree.accept(treeVisitor); + indent(-1); + } + } + + public void printType(String label, Type type) { + printType(label, type, Details.FULL); + } + + protected void printType(String label, Type type, Details details) { + if (type == null) + printNull(label); + else { + switch (details) { + case SUMMARY: + printString(label, toString(type)); + break; + + case FULL: + indent(); + out.print(label); + out.println(": " + info(type.getClass(), type.getTag(), type.getKind()) + + " " + hashString(type)); + + indent(+1); + printSymbol("tsym", type.tsym, Details.SUMMARY); + printObject("constValue", type.constValue(), Details.SUMMARY); + type.accept(typeVisitor, null); + indent(-1); + } + } + } + + protected String toString(Type type) { + return (printer != null) ? printer.visit(type, locale) : String.valueOf(type); + } + + protected String hashString(Object obj) { + return String.format("#%x", obj.hashCode()); + } + + protected String info(Class clazz, Object internal, Object external) { + return String.format("%s,%s,%s", clazz.getSimpleName(), internal, external); + } + + private int indent = 0; + + protected void indent() { + for (int i = 0; i < indent; i++) { + out.print(" "); + } + } + + protected void indent(int n) { + indent += n; + } + + protected Object getField(Object o, Class clazz, String name) { + try { + Field f = clazz.getDeclaredField(name); + boolean prev = f.isAccessible(); + f.setAccessible(true); + try { + return f.get(o); + } finally { + f.setAccessible(prev); + } + } catch (ReflectiveOperationException e) { + return e; + } catch (SecurityException e) { + return e; + } + } + + // + + // + + protected JCTree.Visitor treeVisitor = new TreeVisitor(); + + /** + * Default visitor class for JCTree (AST) objects. + */ + public class TreeVisitor extends JCTree.Visitor { + @Override + public void visitTopLevel(JCCompilationUnit tree) { + printList("packageAnnotations", tree.packageAnnotations); + printTree("pid", tree.pid); + printList("defs", tree.defs); + } + + @Override + public void visitImport(JCImport tree) { + printTree("qualid", tree.qualid); + } + + @Override + public void visitClassDef(JCClassDecl tree) { + printName("name", tree.name); + printTree("mods", tree.mods); + printList("typarams", tree.typarams); + printTree("extending", tree.extending); + printList("implementing", tree.implementing); + printList("defs", tree.defs); + } + + @Override + public void visitMethodDef(JCMethodDecl tree) { + printName("name", tree.name); + printTree("mods", tree.mods); + printTree("restype", tree.restype); + printList("typarams", tree.typarams); + printTree("recvparam", tree.recvparam); + printList("params", tree.params); + printList("thrown", tree.thrown); + printTree("defaultValue", tree.defaultValue); + printTree("body", tree.body); + } + + @Override + public void visitVarDef(JCVariableDecl tree) { + printName("name", tree.name); + printTree("mods", tree.mods); + printTree("vartype", tree.vartype); + printTree("init", tree.init); + } + + @Override + public void visitSkip(JCSkip tree) { + } + + @Override + public void visitBlock(JCBlock tree) { + printList("stats", tree.stats); + } + + @Override + public void visitDoLoop(JCDoWhileLoop tree) { + printTree("body", tree.body); + printTree("cond", tree.cond); + } + + @Override + public void visitWhileLoop(JCWhileLoop tree) { + printTree("cond", tree.cond); + printTree("body", tree.body); + } + + @Override + public void visitForLoop(JCForLoop tree) { + printList("init", tree.init); + printTree("cond", tree.cond); + printList("step", tree.step); + printTree("body", tree.body); + } + + @Override + public void visitForeachLoop(JCEnhancedForLoop tree) { + printTree("var", tree.var); + printTree("expr", tree.expr); + printTree("body", tree.body); + } + + @Override + public void visitLabelled(JCLabeledStatement tree) { + printTree("body", tree.body); + } + + @Override + public void visitSwitch(JCSwitch tree) { + printTree("selector", tree.selector); + printList("cases", tree.cases); + } + + @Override + public void visitCase(JCCase tree) { + printTree("pat", tree.pat); + printList("stats", tree.stats); + } + + @Override + public void visitSynchronized(JCSynchronized tree) { + printTree("lock", tree.lock); + printTree("body", tree.body); + } + + @Override + public void visitTry(JCTry tree) { + printList("resources", tree.resources); + printTree("body", tree.body); + printList("catchers", tree.catchers); + printTree("finalizer", tree.finalizer); + } + + @Override + public void visitCatch(JCCatch tree) { + printTree("param", tree.param); + printTree("body", tree.body); + } + + @Override + public void visitConditional(JCConditional tree) { + printTree("cond", tree.cond); + printTree("truepart", tree.truepart); + printTree("falsepart", tree.falsepart); + } + + @Override + public void visitIf(JCIf tree) { + printTree("cond", tree.cond); + printTree("thenpart", tree.thenpart); + printTree("elsepart", tree.elsepart); + } + + @Override + public void visitExec(JCExpressionStatement tree) { + printTree("expr", tree.expr); + } + + @Override + public void visitBreak(JCBreak tree) { + printName("label", tree.label); + } + + @Override + public void visitContinue(JCContinue tree) { + printName("label", tree.label); + } + + @Override + public void visitReturn(JCReturn tree) { + printTree("expr", tree.expr); + } + + @Override + public void visitThrow(JCThrow tree) { + printTree("expr", tree.expr); + } + + @Override + public void visitAssert(JCAssert tree) { + printTree("cond", tree.cond); + printTree("detail", tree.detail); + } + + @Override + public void visitApply(JCMethodInvocation tree) { + printList("typeargs", tree.typeargs); + printTree("meth", tree.meth); + printList("args", tree.args); + } + + @Override + public void visitNewClass(JCNewClass tree) { + printTree("encl", tree.encl); + printList("typeargs", tree.typeargs); + printTree("clazz", tree.clazz); + printList("args", tree.args); + printTree("def", tree.def); + } + + @Override + public void visitNewArray(JCNewArray tree) { + printList("annotations", tree.annotations); + printTree("elemtype", tree.elemtype); + printList("dims", tree.dims); + printList("dimAnnotations", tree.dimAnnotations); + printList("elems", tree.elems); + } + + @Override + public void visitLambda(JCLambda tree) { + printTree("body", tree.body); + printList("params", tree.params); + } + + @Override + public void visitParens(JCParens tree) { + printTree("expr", tree.expr); + } + + @Override + public void visitAssign(JCAssign tree) { + printTree("lhs", tree.lhs); + printTree("rhs", tree.rhs); + } + + @Override + public void visitAssignop(JCAssignOp tree) { + printTree("lhs", tree.lhs); + printTree("rhs", tree.rhs); + } + + @Override + public void visitUnary(JCUnary tree) { + printTree("arg", tree.arg); + } + + @Override + public void visitBinary(JCBinary tree) { + printTree("lhs", tree.lhs); + printTree("rhs", tree.rhs); + } + + @Override + public void visitTypeCast(JCTypeCast tree) { + printTree("clazz", tree.clazz); + printTree("expr", tree.expr); + } + + @Override + public void visitTypeTest(JCInstanceOf tree) { + printTree("expr", tree.expr); + printTree("clazz", tree.clazz); + } + + @Override + public void visitIndexed(JCArrayAccess tree) { + printTree("indexed", tree.indexed); + printTree("index", tree.index); + } + + @Override + public void visitSelect(JCFieldAccess tree) { + printTree("selected", tree.selected); + } + + @Override + public void visitReference(JCMemberReference tree) { + printTree("expr", tree.expr); + printList("typeargs", tree.typeargs); + } + + @Override + public void visitIdent(JCIdent tree) { + printName("name", tree.name); + } + + @Override + public void visitLiteral(JCLiteral tree) { + printString("value", Pretty.toSimpleString(tree, 32)); + } + + @Override + public void visitTypeIdent(JCPrimitiveTypeTree tree) { + printString("typetag", tree.typetag.name()); + } + + @Override + public void visitTypeArray(JCArrayTypeTree tree) { + printTree("elemtype", tree.elemtype); + } + + @Override + public void visitTypeApply(JCTypeApply tree) { + printTree("clazz", tree.clazz); + printList("arguments", tree.arguments); + } + + @Override + public void visitTypeUnion(JCTypeUnion tree) { + printList("alternatives", tree.alternatives); + } + + @Override + public void visitTypeIntersection(JCTypeIntersection tree) { + printList("bounds", tree.bounds); + } + + @Override + public void visitTypeParameter(JCTypeParameter tree) { + printName("name", tree.name); + printList("annotations", tree.annotations); + printList("bounds", tree.bounds); + } + + @Override + public void visitWildcard(JCWildcard tree) { + printTree("kind", tree.kind); + printTree("inner", tree.inner); + } + + @Override + public void visitTypeBoundKind(TypeBoundKind tree) { + printString("kind", tree.kind.name()); + } + + @Override + public void visitModifiers(JCModifiers tree) { + printList("annotations", tree.annotations); + printString("flags", String.valueOf(Flags.asFlagSet(tree.flags))); + } + + @Override + public void visitAnnotation(JCAnnotation tree) { + printTree("annotationType", tree.annotationType); + printList("args", tree.args); + } + + @Override + public void visitAnnotatedType(JCAnnotatedType tree) { + printList("annotations", tree.annotations); + printTree("underlyingType", tree.underlyingType); + } + + @Override + public void visitErroneous(JCErroneous tree) { + printList("errs", tree.errs); + } + + @Override + public void visitLetExpr(LetExpr tree) { + printList("defs", tree.defs); + printTree("expr", tree.expr); + } + + @Override + public void visitTree(JCTree tree) { + Assert.error(); + } + } + + // + + // + + protected Symbol.Visitor symVisitor = new SymbolVisitor(); + + /** + * Default visitor class for Symbol objects. + * Note: each visitXYZ method ends by calling the corresponding + * visit method for its superclass. + */ + class SymbolVisitor implements Symbol.Visitor { + @Override + public Void visitClassSymbol(ClassSymbol sym, Void ignore) { + printName("fullname", sym.fullname); + printName("flatname", sym.flatname); + printScope("members", sym.members_field); + printFileObject("sourcefile", sym.sourcefile); + printFileObject("classfile", sym.classfile); + // trans-local? + // pool? + return visitTypeSymbol(sym, null); + } + + @Override + public Void visitMethodSymbol(MethodSymbol sym, Void ignore) { + // code + printList("params", sym.params); + printList("savedParameterNames", sym.savedParameterNames); + return visitSymbol(sym, null); + } + + @Override + public Void visitPackageSymbol(PackageSymbol sym, Void ignore) { + printName("fullname", sym.fullname); + printScope("members", sym.members_field); + printSymbol("package-info", sym.package_info, Details.SUMMARY); + return visitTypeSymbol(sym, null); + } + + @Override + public Void visitOperatorSymbol(OperatorSymbol sym, Void ignore) { + printInt("opcode", sym.opcode); + return visitMethodSymbol(sym, null); + } + + @Override + public Void visitVarSymbol(VarSymbol sym, Void ignore) { + printInt("pos", sym.pos); + printInt("adm", sym.adr); + // data is a private field, and the standard accessors may + // mutate it as part of lazy evaluation. Therefore, use + // reflection to get the raw data. + printObject("data", getField(sym, VarSymbol.class, "data"), Details.SUMMARY); + return visitSymbol(sym, null); + } + + @Override + public Void visitTypeSymbol(TypeSymbol sym, Void ignore) { + return visitSymbol(sym, null); + } + + @Override + public Void visitSymbol(Symbol sym, Void ignore) { + return null; + } + } + + // + + // + + protected Type.Visitor typeVisitor = new TypeVisitor(); + + /** + * Default visitor class for Type objects. + * Note: each visitXYZ method ends by calling the corresponding + * visit method for its superclass. + */ + public class TypeVisitor implements Type.Visitor { + public Void visitAnnotatedType(AnnotatedType type, Void ignore) { + printList("typeAnnotations", type.typeAnnotations); + printType("underlyingType", type.underlyingType, Details.FULL); + return visitType(type, null); + } + + public Void visitArrayType(ArrayType type, Void ignore) { + printType("elemType", type.elemtype, Details.FULL); + return visitType(type, null); + } + + public Void visitCapturedType(CapturedType type, Void ignore) { + printType("wildcard", type.wildcard, Details.FULL); + return visitTypeVar(type, null); + } + + public Void visitClassType(ClassType type, Void ignore) { + printType("outer", type.getEnclosingType(), Details.SUMMARY); + printList("typarams", type.typarams_field); + printList("allparams", type.allparams_field); + printType("supertype", type.supertype_field, Details.SUMMARY); + printList("interfaces", type.interfaces_field); + printList("allinterfaces", type.all_interfaces_field); + return visitType(type, null); + } + + public Void visitErrorType(ErrorType type, Void ignore) { + printType("originalType", type.getOriginalType(), Details.FULL); + return visitClassType(type, null); + } + + public Void visitForAll(ForAll type, Void ignore) { + printList("tvars", type.tvars); + return visitDelegatedType(type); + } + + public Void visitMethodType(MethodType type, Void ignore) { + printList("argtypes", type.argtypes); + printType("restype", type.restype, Details.FULL); + printList("thrown", type.thrown); + return visitType(type, null); + } + + public Void visitPackageType(PackageType type, Void ignore) { + return visitType(type, null); + } + + public Void visitTypeVar(TypeVar type, Void ignore) { + // For TypeVars (and not subtypes), the bound should always be + // null or bot. So, only print the bound for subtypes of TypeVar, + // or if the bound is (erroneously) not null or bot. + if (!type.hasTag(TypeTag.TYPEVAR) + || !(type.bound == null || type.bound.hasTag(TypeTag.BOT))) { + printType("bound", type.bound, Details.FULL); + } + printType("lower", type.lower, Details.FULL); + return visitType(type, null); + } + + public Void visitUndetVar(UndetVar type, Void ignore) { + for (UndetVar.InferenceBound ib: UndetVar.InferenceBound.values()) + printList("bounds." + ib, type.getBounds(ib)); + printType("inst", type.inst, Details.SUMMARY); + return visitDelegatedType(type); + } + + public Void visitWildcardType(WildcardType type, Void ignore) { + printType("type", type.type, Details.SUMMARY); + printString("kind", type.kind.name()); + printType("bound", type.bound, Details.SUMMARY); + return visitType(type, null); + } + + protected Void visitDelegatedType(DelegatedType type) { + printType("qtype", type.qtype, Details.FULL); + return visitType(type, null); + } + + public Void visitType(Type type, Void ignore) { + return null; + } + } + + // + + // + + protected Attribute.Visitor attrVisitor = new AttributeVisitor(); + + /** + * Default visitor class for Attribute (annotation) objects. + */ + public class AttributeVisitor implements Attribute.Visitor { + + public void visitConstant(Attribute.Constant a) { + printObject("value", a.value, Details.SUMMARY); + visitAttribute(a); + } + + public void visitClass(Attribute.Class a) { + printObject("classType", a.classType, Details.SUMMARY); + visitAttribute(a); + } + + public void visitCompound(Attribute.Compound a) { + if (a instanceof Attribute.TypeCompound) { + Attribute.TypeCompound ta = (Attribute.TypeCompound) a; + // consider a custom printer? + printObject("position", ta.position, Details.SUMMARY); + } + printObject("synthesized", a.isSynthesized(), Details.SUMMARY); + printList("values", a.values); + visitAttribute(a); + } + + public void visitArray(Attribute.Array a) { + printList("values", Arrays.asList(a.values)); + visitAttribute(a); + } + + public void visitEnum(Attribute.Enum a) { + printSymbol("value", a.value, Details.SUMMARY); + visitAttribute(a); + } + + public void visitError(Attribute.Error a) { + visitAttribute(a); + } + + public void visitAttribute(Attribute a) { + printType("type", a.type, Details.SUMMARY); + } + + } + // + + // + + /** + * Utility class to invoke DPrinter from the command line. + */ + static class Main { + public static void main(String... args) throws IOException { + Main m = new Main(); + PrintWriter out = new PrintWriter(System.out); + try { + if (args.length == 0) + m.usage(out); + else + m.run(out, args); + } finally { + out.flush(); + } + } + + void usage(PrintWriter out) { + out.println("Usage:"); + out.println(" java " + Main.class.getName() + " mode [options] [javac-options]"); + out.print("where mode is one of: "); + String sep = ""; + for (Handler h: getHandlers().values()) { + out.print(sep); + out.print(h.name); + sep = ", "; + } + out.println(); + out.println("and where options include:"); + out.println(" -before PARSE|ENTER|ANALYZE|GENERATE|ANNOTATION_PROCESSING|ANNOTATION_PROCESSING_ROUND"); + out.println(" -after PARSE|ENTER|ANALYZE|GENERATE|ANNOTATION_PROCESSING|ANNOTATION_PROCESSING_ROUND"); + out.println(" -showPositions"); + out.println(" -showSource"); + out.println(" -showTreeSymbols"); + out.println(" -showTreeTypes"); + out.println(" -hideEmptyItems"); + out.println(" -hideNulls"); + } + + void run(PrintWriter out, String... args) throws IOException { + JavaCompiler c = ToolProvider.getSystemJavaCompiler(); + StandardJavaFileManager fm = c.getStandardFileManager(null, null, null); + + // DPrinter options + final Set before = EnumSet.noneOf(TaskEvent.Kind.class); + final Set after = EnumSet.noneOf(TaskEvent.Kind.class); + boolean showPositions = false; + boolean showSource = false; + boolean showTreeSymbols = false; + boolean showTreeTypes = false; + boolean showEmptyItems = true; + boolean showNulls = true; + + // javac options + Collection options = new ArrayList(); + Collection files = new ArrayList(); + String classpath = null; + String classoutdir = null; + + final Handler h = getHandlers().get(args[0]); + if (h == null) + throw new IllegalArgumentException(args[0]); + + for (int i = 1; i < args.length; i++) { + String arg = args[i]; + if (arg.equals("-before") && i + 1 < args.length) { + before.add(getKind(args[++i])); + } else if (arg.equals("-after") && i + 1 < args.length) { + after.add(getKind(args[++i])); + } else if (arg.equals("-showPositions")) { + showPositions = true; + } else if (arg.equals("-showSource")) { + showSource = true; + } else if (arg.equals("-showTreeSymbols")) { + showTreeSymbols = true; + } else if (arg.equals("-showTreeTypes")) { + showTreeTypes = true; + } else if (arg.equals("-hideEmptyLists")) { + showEmptyItems = false; + } else if (arg.equals("-hideNulls")) { + showNulls = false; + } else if (arg.equals("-classpath") && i + 1 < args.length) { + classpath = args[++i]; + } else if (arg.equals("-d") && i + 1 < args.length) { + classoutdir = args[++i]; + } else if (arg.startsWith("-")) { + int n = c.isSupportedOption(arg); + if (n < 0) throw new IllegalArgumentException(arg); + options.add(arg); + while (n > 0) options.add(args[++i]); + } else if (arg.endsWith(".java")) { + files.add(new File(arg)); + } + } + + if (classoutdir != null) { + fm.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(new File(classoutdir))); + } + + if (classpath != null) { + Collection path = new ArrayList(); + for (String p: classpath.split(File.pathSeparator)) { + if (p.isEmpty()) continue; + File f = new File(p); + if (f.exists()) path.add(f); + } + fm.setLocation(StandardLocation.CLASS_PATH, path); + } + Iterable fos = fm.getJavaFileObjectsFromFiles(files); + + JavacTask task = (JavacTask) c.getTask(out, fm, null, options, null, fos); + final Trees trees = Trees.instance(task); + + final DPrinter dprinter = new DPrinter(out, trees); + dprinter.source(showSource) + .emptyItems(showEmptyItems) + .nulls(showNulls) + .positions(showPositions) + .treeSymbols(showTreeSymbols) + .treeTypes(showTreeTypes); + + if (before.isEmpty() && after.isEmpty()) { + if (h.name.equals("trees") && !showTreeSymbols && !showTreeTypes) + after.add(TaskEvent.Kind.PARSE); + else + after.add(TaskEvent.Kind.ANALYZE); + } + + task.addTaskListener(new TaskListener() { + public void started(TaskEvent e) { + if (before.contains(e.getKind())) + handle(e); + } + + public void finished(TaskEvent e) { + if (after.contains(e.getKind())) + handle(e); + } + + private void handle(TaskEvent e) { + switch (e.getKind()) { + case PARSE: + case ENTER: + h.handle(e.getSourceFile().getName(), + (JCTree) e.getCompilationUnit(), + dprinter); + break; + + default: + TypeElement elem = e.getTypeElement(); + h.handle(elem.toString(), + (JCTree) trees.getTree(elem), + dprinter); + break; + } + } + }); + + task.call(); + } + + TaskEvent.Kind getKind(String s) { + return TaskEvent.Kind.valueOf(s.toUpperCase()); + } + + static protected abstract class Handler { + final String name; + Handler(String name) { + this.name = name; + } + abstract void handle(String label, JCTree tree, DPrinter dprinter); + } + + Map getHandlers() { + Map map = new HashMap(); + for (Handler h: defaultHandlers) { + map.put(h.name, h); + } + return map; + } + + protected final Handler[] defaultHandlers = { + new Handler("trees") { + @Override + void handle(String name, JCTree tree, DPrinter dprinter) { + dprinter.printTree(name, tree); + dprinter.out.println(); + } + }, + + new Handler("symbols") { + @Override + void handle(String name, JCTree tree, final DPrinter dprinter) { + TreeScanner ds = new TreeScanner() { + @Override + public void visitClassDef(JCClassDecl tree) { + visitDecl(tree, tree.sym); + super.visitClassDef(tree); + } + + @Override + public void visitMethodDef(JCMethodDecl tree) { + visitDecl(tree, tree.sym); + super.visitMethodDef(tree); + } + + @Override + public void visitVarDef(JCVariableDecl tree) { + visitDecl(tree, tree.sym); + super.visitVarDef(tree); + } + + void visitDecl(JCTree tree, Symbol sym) { + dprinter.printSymbol(sym.name.toString(), sym); + dprinter.out.println(); + } + }; + ds.scan(tree); + } + }, + + new Handler("types") { + @Override + void handle(String name, JCTree tree, final DPrinter dprinter) { + TreeScanner ts = new TreeScanner() { + @Override + public void scan(JCTree tree) { + if (tree == null) { + return; + } + if (tree.type != null) { + String label = Pretty.toSimpleString(tree); + dprinter.printType(label, tree.type); + dprinter.out.println(); + } + super.scan(tree); + } + }; + ts.scan(tree); + } + } + }; + } + + // + +} diff -r 6fde20398015 -r 89c664151689 test/tools/javac/lib/JavacTestingAbstractThreadedTest.java --- a/test/tools/javac/lib/JavacTestingAbstractThreadedTest.java Thu Feb 07 12:33:21 2013 -0800 +++ b/test/tools/javac/lib/JavacTestingAbstractThreadedTest.java Mon Feb 11 16:15:09 2013 -0800 @@ -41,14 +41,20 @@ * * If the property is not set the class will use a heuristic to determine the * maximum number of threads that can be fired to execute a given test. + * + * This code will have to be revisited if jprt starts using concurrency for + * for running jtreg tests. */ public abstract class JavacTestingAbstractThreadedTest { + protected static AtomicInteger numberOfThreads = new AtomicInteger(); + protected static int getThreadPoolSize() { Integer testConc = Integer.getInteger("test.concurrency"); if (testConc != null) return testConc; int cores = Runtime.getRuntime().availableProcessors(); - return Math.max(2, Math.min(8, cores / 2)); + numberOfThreads.set(Math.max(2, Math.min(8, cores / 2))); + return numberOfThreads.get(); } protected static void checkAfterExec() throws InterruptedException { @@ -82,11 +88,18 @@ } else if (printCheckCount) { outWriter.println("Total check executed: " + checkCount.get()); } + /* + * This output is for supporting debugging. It does not mean that a given + * test had executed that number of threads concurrently. The value printed + * here is the maximum possible amount. + */ closePrinters(); if (printAll) { System.out.println(errSWriter.toString()); System.out.println(outSWriter.toString()); } + System.out.println("Total number of threads in thread pool: " + + numberOfThreads.get()); } protected static void closePrinters() { diff -r 6fde20398015 -r 89c664151689 test/tools/javadoc/api/basic/RunTest.java --- a/test/tools/javadoc/api/basic/RunTest.java Thu Feb 07 12:33:21 2013 -0800 +++ b/test/tools/javadoc/api/basic/RunTest.java Mon Feb 11 16:15:09 2013 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2013, 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 @@ -23,7 +23,7 @@ /* * @test - * @bug 6493690 + * @bug 6493690 8007490 * @summary javadoc should have a javax.tools.Tool service provider * @build APITest * @run main RunTest @@ -31,6 +31,7 @@ import java.io.ByteArrayOutputStream; import java.io.File; +import java.io.PrintStream; import javax.tools.DocumentationTool; import javax.tools.ToolProvider; @@ -46,7 +47,7 @@ * Verify that run method can be invoked. */ @Test - public void testRun() throws Exception { + public void testRunOK() throws Exception { File testSrc = new File(System.getProperty("test.src")); File srcFile = new File(testSrc, "pkg/C.java"); File outDir = getOutDir(); @@ -77,7 +78,7 @@ * Verify that run method can be invoked. */ @Test - public void testRun2() throws Exception { + public void testRunFail() throws Exception { File outDir = getOutDir(); String badfile = "badfile.java"; String[] args = { "-d", outDir.getPath(), badfile }; @@ -100,5 +101,48 @@ } } + /** + * Verify that null args are accepted. + */ + @Test + public void testNullArgs() throws Exception { + File testSrc = new File(System.getProperty("test.src")); + File srcFile = new File(testSrc, "pkg/C.java"); + File outDir = getOutDir(); + String[] args = { "-d", outDir.getPath(), srcFile.getPath() }; + + ByteArrayOutputStream stdout = new ByteArrayOutputStream(); + PrintStream prevStdout = System.out; + System.setOut(new PrintStream(stdout)); + + ByteArrayOutputStream stderr = new ByteArrayOutputStream(); + PrintStream prevStderr = System.err; + System.setErr(new PrintStream(stderr)); + + int rc ; + try { + DocumentationTool tool = ToolProvider.getSystemDocumentationTool(); + rc = tool.run(null, null, null, args); + } finally { + System.setOut(prevStdout); + System.setErr(prevStderr); + } + + System.err.println("stdout >>" + stdout.toString() + "<<"); + System.err.println("stderr >>" + stderr.toString() + "<<"); + + if (rc == 0) { + System.err.println("call succeeded"); + checkFiles(outDir, standardExpectFiles); + String out = stdout.toString(); + for (String f: standardExpectFiles) { + String f1 = f.replace('/', File.separatorChar); + if (f1.endsWith(".html") && !out.contains(f1)) + error("expected string not found: " + f1); + } + } else { + error("call failed"); + } + } }