stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Lana Steuck 2011-04-10 10:25:12 -07:00
commit 992bfee42c
79 changed files with 3874 additions and 436 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
langtools/make/build.xml
View File

@ -806,6 +806,9 @@
<exclude name="**/*.java"/>
<exclude name="**/*.properties"/>
<exclude name="**/*-template"/>
<exclude name="**/*.rej"/>
<exclude name="**/*.orig"/>
<exclude name="**/overview.html"/>
<exclude name="**/package.html"/>
</fileset>
</copy>

14
langtools/src/share/classes/com/sun/tools/classfile/Type.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2008, 2011, 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
@ -41,6 +41,11 @@ import java.util.Set;
*/
public abstract class Type {
protected Type() { }
public boolean isObject() {
return false;
}
public abstract <R,D> R accept(Visitor<R,D> visitor, D data);
protected static void append(StringBuilder sb, String prefix, List<? extends Type> types, String suffix) {
@ -262,6 +267,13 @@ public abstract class Type {
return sb.toString();
}
@Override
public boolean isObject() {
return (outerType == null)
&& name.equals("java/lang/Object")
&& (typeArgs == null || typeArgs.isEmpty());
}
public final ClassType outerType;
public final String name;
public final List<Type> typeArgs;

17
langtools/src/share/classes/com/sun/tools/doclets/formats/html/AnnotationTypeWriterImpl.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2011, 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
@ -154,8 +154,8 @@ public class AnnotationTypeWriterImpl extends SubWriterHolderWriter
div.addStyle(HtmlStyle.header);
if (pkgname.length() > 0) {
Content pkgNameContent = new StringContent(pkgname);
Content pkgNamePara = HtmlTree.P(HtmlStyle.subTitle, pkgNameContent);
div.addContent(pkgNamePara);
Content pkgNameDiv = HtmlTree.DIV(HtmlStyle.subTitle, pkgNameContent);
div.addContent(pkgNameDiv);
}
LinkInfoImpl linkInfo = new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_HEADER, annotationType, false);
@ -216,12 +216,15 @@ public class AnnotationTypeWriterImpl extends SubWriterHolderWriter
pre.addContent(modifiers);
LinkInfoImpl linkInfo = new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_SIGNATURE, annotationType, false);
Content name = new RawHtml (annotationType.name() +
getTypeParameterLinks(linkInfo));
Content annotationName = new StringContent(annotationType.name());
Content parameterLinks = new RawHtml(getTypeParameterLinks(linkInfo));
if (configuration().linksource) {
addSrcLink(annotationType, name, pre);
addSrcLink(annotationType, annotationName, pre);
pre.addContent(parameterLinks);
} else {
pre.addContent(HtmlTree.STRONG(name));
Content span = HtmlTree.SPAN(HtmlStyle.strong, annotationName);
span.addContent(parameterLinks);
pre.addContent(span);
}
annotationInfoTree.addContent(pre);
}

17
langtools/src/share/classes/com/sun/tools/doclets/formats/html/ClassWriterImpl.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2011, 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
@ -161,8 +161,8 @@ public class ClassWriterImpl extends SubWriterHolderWriter
div.addStyle(HtmlStyle.header);
if (pkgname.length() > 0) {
Content pkgNameContent = new StringContent(pkgname);
Content pkgNamePara = HtmlTree.P(HtmlStyle.subTitle, pkgNameContent);
div.addContent(pkgNamePara);
Content pkgNameDiv = HtmlTree.DIV(HtmlStyle.subTitle, pkgNameContent);
div.addContent(pkgNameDiv);
}
LinkInfoImpl linkInfo = new LinkInfoImpl( LinkInfoImpl.CONTEXT_CLASS_HEADER,
classDoc, false);
@ -228,12 +228,15 @@ public class ClassWriterImpl extends SubWriterHolderWriter
LinkInfoImpl.CONTEXT_CLASS_SIGNATURE, classDoc, false);
//Let's not link to ourselves in the signature.
linkInfo.linkToSelf = false;
Content name = new RawHtml (classDoc.name() +
getTypeParameterLinks(linkInfo));
Content className = new StringContent(classDoc.name());
Content parameterLinks = new RawHtml(getTypeParameterLinks(linkInfo));
if (configuration().linksource) {
addSrcLink(classDoc, name, pre);
addSrcLink(classDoc, className, pre);
pre.addContent(parameterLinks);
} else {
pre.addContent(HtmlTree.STRONG(name));
Content span = HtmlTree.SPAN(HtmlStyle.strong, className);
span.addContent(parameterLinks);
pre.addContent(span);
}
if (!isInterface) {
Type superclass = Util.getFirstVisibleSuperClass(classDoc,

9
langtools/src/share/classes/com/sun/tools/doclets/formats/html/FrameOutputWriter.java
View File

@ -114,13 +114,10 @@ public class FrameOutputWriter extends HtmlDocletWriter {
Content noframesHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Frame_Alert"));
noframes.addContent(noframesHead);
Content p = HtmlTree.P(getResource("doclet.Frame_Warning_Message"));
Content p = HtmlTree.P(getResource("doclet.Frame_Warning_Message",
getHyperLinkString(configuration.topFile,
configuration.getText("doclet.Non_Frame_Version"))));
noframes.addContent(p);
noframes.addContent(new HtmlTree(HtmlTag.BR));
noframes.addContent(getResource("doclet.Link_To"));
Content link = getHyperLink(configuration.topFile,
getResource("doclet.Non_Frame_Version"));
noframes.addContent(link);
contentTree.addContent(noframes);
}

4
langtools/src/share/classes/com/sun/tools/doclets/formats/html/HelpWriter.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1998, 2011, 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
@ -96,7 +96,7 @@ public class HelpWriter extends HtmlDocletWriter {
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, false, HtmlStyle.title,
getResource("doclet.Help_line_1"));
Content div = HtmlTree.DIV(HtmlStyle.header, heading);
Content line2 = HtmlTree.P(HtmlStyle.subTitle,
Content line2 = HtmlTree.DIV(HtmlStyle.subTitle,
getResource("doclet.Help_line_2"));
div.addContent(line2);
contentTree.addContent(div);

5
langtools/src/share/classes/com/sun/tools/doclets/formats/html/LinkFactoryImpl.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2011, 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
@ -69,9 +69,6 @@ public class LinkFactoryImpl extends LinkFactory {
StringBuffer label = new StringBuffer(
classLinkInfo.getClassLinkLabel(m_writer.configuration));
classLinkInfo.displayLength += label.length();
if (noLabel && classLinkInfo.excludeTypeParameterLinks) {
label.append(getTypeParameterLinks(linkInfo).toString());
}
Configuration configuration = ConfigurationImpl.getInstance();
LinkOutputImpl linkOutput = new LinkOutputImpl();
if (classDoc.isIncluded()) {

6
langtools/src/share/classes/com/sun/tools/doclets/formats/html/LinkInfoImpl.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2011, 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
@ -408,10 +408,6 @@ public class LinkInfoImpl extends LinkInfo {
case CONTEXT_PACKAGE:
case CONTEXT_CLASS_USE:
excludeTypeBoundsLinks = true;
excludeTypeParameterLinks = true;
break;
case CONTEXT_CLASS_HEADER:
case CONTEXT_CLASS_SIGNATURE:
excludeTypeParameterLinks = true;

18
langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2011, 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
@ -163,10 +163,10 @@ public class PackageIndexWriter extends AbstractPackageIndexWriter {
*/
protected void addOverviewHeader(Content body) {
if (root.inlineTags().length > 0) {
HtmlTree p = new HtmlTree(HtmlTag.P);
p.addStyle(HtmlStyle.subTitle);
addSummaryComment(root, p);
Content div = HtmlTree.DIV(HtmlStyle.header, p);
HtmlTree subTitleDiv = new HtmlTree(HtmlTag.DIV);
subTitleDiv.addStyle(HtmlStyle.subTitle);
addSummaryComment(root, subTitleDiv);
Content div = HtmlTree.DIV(HtmlStyle.header, subTitleDiv);
Content see = seeLabel;
see.addContent(" ");
Content descPara = HtmlTree.P(see);
@ -188,10 +188,10 @@ public class PackageIndexWriter extends AbstractPackageIndexWriter {
protected void addOverviewComment(Content htmltree) {
if (root.inlineTags().length > 0) {
htmltree.addContent(getMarkerAnchor("overview_description"));
HtmlTree p = new HtmlTree(HtmlTag.P);
p.addStyle(HtmlStyle.subTitle);
addInlineComment(root, p);
htmltree.addContent(p);
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.subTitle);
addInlineComment(root, div);
htmltree.addContent(div);
}
}

10
langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageWriterImpl.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2011, 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
@ -115,10 +115,10 @@ public class PackageWriterImpl extends HtmlDocletWriter
tHeading.addContent(packageHead);
div.addContent(tHeading);
if (packageDoc.inlineTags().length > 0 && ! configuration.nocomment) {
HtmlTree p = new HtmlTree(HtmlTag.P);
p.addStyle(HtmlStyle.subTitle);
addSummaryComment(packageDoc, p);
div.addContent(p);
HtmlTree subTitleDiv = new HtmlTree(HtmlTag.DIV);
subTitleDiv.addStyle(HtmlStyle.subTitle);
addSummaryComment(packageDoc, subTitleDiv);
div.addContent(subTitleDiv);
Content space = getSpace();
Content descLink = getHyperLink("", "package_description",
descriptionLabel, "", "");

6
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlWriter.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2011, 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
@ -188,8 +188,8 @@ public class HtmlWriter extends PrintWriter {
nextclassLabel = getResource("doclet.Next_Class");
summaryLabel = getResource("doclet.Summary");
detailLabel = getResource("doclet.Detail");
framesLabel = getResource("doclet.FRAMES");
noframesLabel = getResource("doclet.NO_FRAMES");
framesLabel = getResource("doclet.Frames");
noframesLabel = getResource("doclet.No_Frames");
treeLabel = getResource("doclet.Tree");
classLabel = getResource("doclet.Class");
deprecatedLabel = getResource("doclet.navDeprecated");

77
langtools/src/share/classes/com/sun/tools/doclets/formats/html/resources/standard.properties
View File

@ -11,54 +11,30 @@ doclet.Window_Class_Hierarchy=Class Hierarchy
doclet.Interface_Hierarchy=Interface Hierarchy
doclet.Enum_Hierarchy=Enum Hierarchy
doclet.Annotation_Type_Hierarchy=Annotation Type Hierarchy
# The following ALL CAPS words should be translated. It is used as "Previous" link on javadoc.
doclet.Prev=PREV
# The following ALL CAPS words should be translated. It is used as "Next" link on javadoc.
doclet.Next=NEXT
# The following ALL CAPS words should be translated. It is used as "Previous Class" link on javadoc.
doclet.Prev_Class=PREV CLASS
# The following ALL CAPS words should be translated. It is used as "Next Class" link on javadoc.
doclet.Next_Class=NEXT CLASS
# The following ALL CAPS words should be translated. It is used as "Previous Package" link on javadoc.
doclet.Prev_Package=PREV PACKAGE
# The following ALL CAPS words should be translated. It is used as "Next Package" link on javadoc.
doclet.Next_Package=NEXT PACKAGE
# The following ALL CAPS words should be translated. It is used as "Previous Letter" link on javadoc alphabetical index.
doclet.Prev_Letter=PREV LETTER
# The following ALL CAPS words should be translated. It is used as "Next Letter" link on javadoc alphabetical index.
doclet.Next_Letter=NEXT LETTER
# The following ALL CAPS words should be translated. It is used as "Show List" link on javadoc.
doclet.Show_Lists=SHOW LISTS
# The following ALL CAPS words should be translated. It is used as "Hide List" link on javadoc.
doclet.Hide_Lists=HIDE LISTS
doclet.Prev=Prev
doclet.Next=Next
doclet.Prev_Class=Prev Class
doclet.Next_Class=Next Class
doclet.Prev_Package=Prev Package
doclet.Next_Package=Next Package
doclet.Prev_Letter=Prev Letter
doclet.Next_Letter=Next Letter
doclet.Href_Class_Title=class in {0}
doclet.Href_Interface_Title=interface in {0}
doclet.Href_Annotation_Title=annotation in {0}
doclet.Href_Enum_Title=enum in {0}
doclet.Href_Type_Param_Title=type parameter in {0}
doclet.Href_Class_Or_Interface_Title=class or interface in {0}
# The following ALL CAPS words should be translated. It's used as SUMMARY: NESTED | FIELD | CONSTR | METHOD, meaning Nested Class Summary, Field Summary, Constructor Summary, or Method Summary.
doclet.Summary=SUMMARY:
# The following ALL CAPS words should be translated. It is used as DETAIL: FIELD | CONSTR | METHOD, meaning Field Detail, Constructor Detail, or Method Detail.
doclet.Detail=DETAIL:
# The following ALL CAPS words should be translated. It is used as "Nested" (Nested Class Summary) link on javadoc.
doclet.navNested=NESTED
# The following ALL CAPS words should be translated. It is used as "Optional" (Optional Element Summary) link on javadoc.
doclet.navAnnotationTypeOptionalMember=OPTIONAL
# The following ALL CAPS words should be translated. It is used as "Required" (Required Element Summary) link on javadoc.
doclet.navAnnotationTypeRequiredMember=REQUIRED
# The following ALL CAPS words should be translated. It is used as "Element" (Required Element Summary) link on javadoc.
doclet.navAnnotationTypeMember=ELEMENT
# The following ALL CAPS words should be translated. It is used as "Field" (Field Detail) link on javadoc.
doclet.navField=FIELD
# The following ALL CAPS words should be translated. It is used as "Enum Constants" link on javadoc.
doclet.navEnum=ENUM CONSTANTS
# The following ALL CAPS words should be translated. It is used as "Constructor" (Constructor Detail) link on javadoc.
doclet.navConstructor=CONSTR
# The following ALL CAPS words should be translated. It is used as "Method" (Method Detail) link on javadoc.
doclet.navMethod=METHOD
# The following resource does not seem to be used anymore.
doclet.navFactoryMethod=FACTORY
doclet.Summary=Summary:
doclet.Detail=Detail:
doclet.navNested=Nested
doclet.navAnnotationTypeOptionalMember=Optional
doclet.navAnnotationTypeRequiredMember=Required
doclet.navAnnotationTypeMember=Element
doclet.navField=Field
doclet.navEnum=Enum Constants
doclet.navConstructor=Constr
doclet.navMethod=Method
doclet.Index=Index
doclet.Window_Single_Index=Index
doclet.Window_Split_Index={0}-Index
@ -66,12 +42,6 @@ doclet.Help=Help
doclet.Skip_navigation_links=Skip navigation links
doclet.New_Page=NewPage
doclet.None=None
# The following resource does not seem to be used anymore
doclet.CLASSES=CLASSES
# The following resource does not seem to be used anymore
doclet.MEMBERS=MEMBERS
# The following resource does not seem to be used anymore
doclet.NONE=NONE
doclet.Factory_Method_Detail=Static Factory Method Detail
doclet.navDeprecated=Deprecated
doclet.Deprecated_List=Deprecated List
@ -136,10 +106,7 @@ doclet.also=also
doclet.Option=Option
doclet.Or=Or
doclet.Frames=Frames
# The following ALL CAPS words should be translated. It is used as "FRAMES" javadoc navigation link to indicate displaying the page with HTML frames.
doclet.FRAMES=FRAMES
# The following ALL CAPS words should be translated. It is used as "NO FRAMES" javadoc navigation link to indicate displaying the page without HTML frames.
doclet.NO_FRAMES=NO FRAMES
doclet.No_Frames=No Frames
doclet.Package_Hierarchies=Package Hierarchies:
doclet.Hierarchy_For_Package=Hierarchy For Package {0}
doclet.Source_Code=Source Code:
@ -147,11 +114,10 @@ doclet.Hierarchy_For_All_Packages=Hierarchy For All Packages
doclet.Cannot_handle_no_packages=Cannot handle no packages.
doclet.Frame_Alert=Frame Alert
doclet.Overview-Member-Frame=Overview Member Frame
doclet.Frame_Warning_Message=This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client.
doclet.Frame_Warning_Message=This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client. Link to {0}.
doclet.No_Script_Message=JavaScript is disabled on your browser.
doclet.Non_Frame_Version=Non-frame version.
doclet.Non_Frame_Version=Non-frame version
doclet.Frame_Version=Frame version
doclet.Link_To=Link to
doclet.Following_From_Class=Following copied from class: {0}
doclet.Following_From_Interface=Following copied from interface: {0}
doclet.Description_From_Interface=Description copied from interface:
@ -200,7 +166,6 @@ doclet.Help_enum_line_3=Enum description
doclet.Help_annotation_type_line_1=Each annotation type has its own separate page with the following sections:
doclet.Help_annotation_type_line_2=Annotation Type declaration
doclet.Help_annotation_type_line_3=Annotation Type description
doclet.The=The
doclet.Style_line_1=Javadoc style sheet
doclet.Style_line_2=Define colors, fonts and other style attributes here to override the defaults
doclet.Style_line_3=Page background color

8
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/resources/stylesheet.css
View File

@ -142,19 +142,19 @@ ul.navList li.navBarCell1Rev {
.subNav ul.navList {
float:left;
margin:0;
font-size:0.7em;
font-size:0.8em;
width:350px;
}
ul.subNavList {
float:left;
margin:0;
font-size:0.7em;
font-size:0.8em;
width:350px;
}
ul.subNavList li{
list-style:none;
float:left;
font-size:90%;
font-size:98%;
}
/*
Page header and footer styles
@ -183,8 +183,6 @@ Page header and footer styles
.subTitle {
margin:0;
padding-top:10px;
font-size:0.75em;
font-weight:bold;
}
/*
Page layout container styles

593
langtools/src/share/classes/com/sun/tools/javac/api/ClientCodeWrapper.java Normal file
View File

@ -0,0 +1,593 @@
/*
* Copyright (c) 2011, 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 com.sun.tools.javac.api;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.lang.model.element.NestingKind;
import javax.tools.Diagnostic;
import javax.tools.FileObject;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileManager.Location;
import javax.tools.JavaFileObject;
import com.sun.source.util.TaskEvent;
import com.sun.source.util.TaskListener;
import com.sun.tools.javac.util.ClientCodeException;
import com.sun.tools.javac.util.Context;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import javax.lang.model.element.Modifier;
import javax.tools.DiagnosticListener;
import javax.tools.JavaFileObject.Kind;
/**
* Wrap objects to enable unchecked exceptions to be caught and handled.
*
* For each method, exceptions are handled as follows:
* <ul>
* <li>Checked exceptions are left alone and propogate upwards in the
* obvious way, since they are an expected aspect of the method's
* specification.
* <li>Unchecked exceptions which have already been caught and wrapped in
* ClientCodeException are left alone to continue propogating upwards.
* <li>All other unchecked exceptions (i.e. subtypes of RuntimeException
* and Error) and caught, and rethrown as a ClientCodeException with
* its cause set to the original exception.
* </ul>
*
* The intent is that ClientCodeException can be caught at an appropriate point
* in the program and can be distinguished from any unanticipated unchecked
* exceptions arising in the main body of the code (i.e. bugs.) When the
* ClientCodeException has been caught, either a suitable message can be
* generated, or if appropriate, the original cause can be rethrown.
*
* <p><b>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.</b>
*/
public class ClientCodeWrapper {
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Trusted { }
public static ClientCodeWrapper instance(Context context) {
ClientCodeWrapper instance = context.get(ClientCodeWrapper.class);
if (instance == null)
instance = new ClientCodeWrapper(context);
return instance;
}
/**
* A map to cache the results of whether or not a specific classes can
* be "trusted", and thus does not need to be wrapped.
*/
Map<Class<?>, Boolean> trustedClasses;
protected ClientCodeWrapper(Context context) {
trustedClasses = new HashMap<Class<?>, Boolean>();
}
public JavaFileManager wrap(JavaFileManager fm) {
if (isTrusted(fm))
return fm;
return new WrappedJavaFileManager(fm);
}
public FileObject wrap(FileObject fo) {
if (isTrusted(fo))
return fo;
return new WrappedFileObject(fo);
}
FileObject unwrap(FileObject fo) {
if (fo instanceof WrappedFileObject)
return ((WrappedFileObject) fo).clientFileObject;
else
return fo;
}
public JavaFileObject wrap(JavaFileObject fo) {
if (isTrusted(fo))
return fo;
return new WrappedJavaFileObject(fo);
}
public Iterable<JavaFileObject> wrapJavaFileObjects(Iterable<? extends JavaFileObject> list) {
List<JavaFileObject> wrapped = new ArrayList<JavaFileObject>();
for (JavaFileObject fo : list)
wrapped.add(wrap(fo));
return Collections.unmodifiableList(wrapped);
}
JavaFileObject unwrap(JavaFileObject fo) {
if (fo instanceof WrappedJavaFileObject)
return ((JavaFileObject) ((WrappedJavaFileObject) fo).clientFileObject);
else
return fo;
}
<T> DiagnosticListener<T> wrap(DiagnosticListener<T> dl) {
if (isTrusted(dl))
return dl;
return new WrappedDiagnosticListener<T>(dl);
}
TaskListener wrap(TaskListener tl) {
if (isTrusted(tl))
return tl;
return new WrappedTaskListener(tl);
}
protected boolean isTrusted(Object o) {
Class<?> c = o.getClass();
Boolean trusted = trustedClasses.get(c);
if (trusted == null) {
trusted = c.getName().startsWith("com.sun.tools.javac.")
|| c.isAnnotationPresent(Trusted.class);
trustedClasses.put(c, trusted);
}
return trusted;
}
// <editor-fold defaultstate="collapsed" desc="Wrapper classes">
// FIXME: all these classes should be converted to use multi-catch when
// that is available in the bootstrap compiler.
protected class WrappedJavaFileManager implements JavaFileManager {
protected JavaFileManager clientJavaFileManager;
WrappedJavaFileManager(JavaFileManager clientJavaFileManager) {
clientJavaFileManager.getClass(); // null check
this.clientJavaFileManager = clientJavaFileManager;
}
@Override
public ClassLoader getClassLoader(Location location) {
try {
return clientJavaFileManager.getClassLoader(location);
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public Iterable<JavaFileObject> list(Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException {
try {
return wrapJavaFileObjects(clientJavaFileManager.list(location, packageName, kinds, recurse));
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public String inferBinaryName(Location location, JavaFileObject file) {
try {
return clientJavaFileManager.inferBinaryName(location, unwrap(file));
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public boolean isSameFile(FileObject a, FileObject b) {
try {
return clientJavaFileManager.isSameFile(unwrap(a), unwrap(b));
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public boolean handleOption(String current, Iterator<String> remaining) {
try {
return clientJavaFileManager.handleOption(current, remaining);
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public boolean hasLocation(Location location) {
try {
return clientJavaFileManager.hasLocation(location);
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public JavaFileObject getJavaFileForInput(Location location, String className, Kind kind) throws IOException {
try {
return wrap(clientJavaFileManager.getJavaFileForInput(location, className, kind));
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling) throws IOException {
try {
return wrap(clientJavaFileManager.getJavaFileForOutput(location, className, kind, unwrap(sibling)));
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {
try {
return wrap(clientJavaFileManager.getFileForInput(location, packageName, relativeName));
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException {
try {
return wrap(clientJavaFileManager.getFileForOutput(location, packageName, relativeName, unwrap(sibling)));
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public void flush() throws IOException {
try {
clientJavaFileManager.flush();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public void close() throws IOException {
try {
clientJavaFileManager.close();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public int isSupportedOption(String option) {
try {
return clientJavaFileManager.isSupportedOption(option);
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
}
protected class WrappedFileObject implements FileObject {
protected FileObject clientFileObject;
WrappedFileObject(FileObject clientFileObject) {
clientFileObject.getClass(); // null check
this.clientFileObject = clientFileObject;
}
@Override
public URI toUri() {
try {
return clientFileObject.toUri();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public String getName() {
try {
return clientFileObject.getName();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public InputStream openInputStream() throws IOException {
try {
return clientFileObject.openInputStream();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public OutputStream openOutputStream() throws IOException {
try {
return clientFileObject.openOutputStream();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
try {
return clientFileObject.openReader(ignoreEncodingErrors);
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
try {
return clientFileObject.getCharContent(ignoreEncodingErrors);
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public Writer openWriter() throws IOException {
try {
return clientFileObject.openWriter();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public long getLastModified() {
try {
return clientFileObject.getLastModified();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public boolean delete() {
try {
return clientFileObject.delete();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
}
protected class WrappedJavaFileObject extends WrappedFileObject implements JavaFileObject {
WrappedJavaFileObject(JavaFileObject clientJavaFileObject) {
super(clientJavaFileObject);
}
@Override
public Kind getKind() {
try {
return ((JavaFileObject)clientFileObject).getKind();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public boolean isNameCompatible(String simpleName, Kind kind) {
try {
return ((JavaFileObject)clientFileObject).isNameCompatible(simpleName, kind);
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public NestingKind getNestingKind() {
try {
return ((JavaFileObject)clientFileObject).getNestingKind();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public Modifier getAccessLevel() {
try {
return ((JavaFileObject)clientFileObject).getAccessLevel();
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
}
protected class WrappedDiagnosticListener<T> implements DiagnosticListener<T> {
protected DiagnosticListener<T> clientDiagnosticListener;
WrappedDiagnosticListener(DiagnosticListener<T> clientDiagnosticListener) {
clientDiagnosticListener.getClass(); // null check
this.clientDiagnosticListener = clientDiagnosticListener;
}
@Override
public void report(Diagnostic<? extends T> diagnostic) {
try {
clientDiagnosticListener.report(diagnostic);
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
}
protected class WrappedTaskListener implements TaskListener {
protected TaskListener clientTaskListener;
WrappedTaskListener(TaskListener clientTaskListener) {
clientTaskListener.getClass(); // null check
this.clientTaskListener = clientTaskListener;
}
@Override
public void started(TaskEvent ev) {
try {
clientTaskListener.started(ev);
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
@Override
public void finished(TaskEvent ev) {
try {
clientTaskListener.finished(ev);
} catch (ClientCodeException e) {
throw e;
} catch (RuntimeException e) {
throw new ClientCodeException(e);
} catch (Error e) {
throw new ClientCodeException(e);
}
}
}
// </editor-fold>
}

41
langtools/src/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java
View File

@ -65,7 +65,7 @@ import com.sun.tools.javac.main.JavaCompiler;
* @author Jonathan Gibbons
*/
public class JavacTaskImpl extends JavacTask {
private JavacTool tool;
private ClientCodeWrapper ccw;
private Main compilerMain;
private JavaCompiler compiler;
private Locale locale;
@ -80,12 +80,11 @@ public class JavacTaskImpl extends JavacTask {
private Integer result = null;
JavacTaskImpl(JavacTool tool,
Main compilerMain,
JavacTaskImpl(Main compilerMain,
String[] args,
Context context,
List<JavaFileObject> fileObjects) {
this.tool = tool;
this.ccw = ClientCodeWrapper.instance(context);
this.compilerMain = compilerMain;
this.args = args;
this.context = context;
@ -94,17 +93,15 @@ public class JavacTaskImpl extends JavacTask {
// null checks
compilerMain.getClass();
args.getClass();
context.getClass();
fileObjects.getClass();
}
JavacTaskImpl(JavacTool tool,
Main compilerMain,
JavacTaskImpl(Main compilerMain,
Iterable<String> flags,
Context context,
Iterable<String> classes,
Iterable<? extends JavaFileObject> fileObjects) {
this(tool, compilerMain, toArray(flags, classes), context, toList(fileObjects));
this(compilerMain, toArray(flags, classes), context, toList(fileObjects));
}
static private String[] toArray(Iterable<String> flags, Iterable<String> classes) {
@ -131,7 +128,7 @@ public class JavacTaskImpl extends JavacTask {
if (!used.getAndSet(true)) {
initContext();
notYetEntered = new HashMap<JavaFileObject, JCCompilationUnit>();
compilerMain.setFatalErrors(true);
compilerMain.setAPIMode(true);
result = compilerMain.compile(args, context, fileObjects, processors);
cleanup();
return result == 0;
@ -185,31 +182,9 @@ public class JavacTaskImpl extends JavacTask {
if (context.get(TaskListener.class) != null)
context.put(TaskListener.class, (TaskListener)null);
if (taskListener != null)
context.put(TaskListener.class, wrap(taskListener));
context.put(TaskListener.class, ccw.wrap(taskListener));
//initialize compiler's default locale
JavacMessages.instance(context).setCurrentLocale(locale);
}
// where
private TaskListener wrap(final TaskListener tl) {
tl.getClass(); // null check
return new TaskListener() {
public void started(TaskEvent e) {
try {
tl.started(e);
} catch (Throwable t) {
throw new ClientCodeException(t);
}
}
public void finished(TaskEvent e) {
try {
tl.finished(e);
} catch (Throwable t) {
throw new ClientCodeException(t);
}
}
};
context.put(Locale.class, locale);
}
void cleanup() {

79
langtools/src/share/classes/com/sun/tools/javac/api/JavacTool.java
View File

@ -28,8 +28,10 @@ package com.sun.tools.javac.api;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumSet;
@ -47,12 +49,11 @@ import com.sun.tools.javac.main.JavacOption;
import com.sun.tools.javac.main.Main;
import com.sun.tools.javac.main.RecognizedOptions.GrumpyHelper;
import com.sun.tools.javac.main.RecognizedOptions;
import com.sun.tools.javac.util.ClientCodeException;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Log;
import com.sun.tools.javac.util.JavacMessages;
import com.sun.tools.javac.util.Options;
import com.sun.tools.javac.util.Pair;
import java.nio.charset.Charset;
/**
* TODO: describe com.sun.tools.javac.api.Tool
@ -145,10 +146,13 @@ public final class JavacTool implements JavaCompiler {
Locale locale,
Charset charset) {
Context context = new Context();
JavacMessages.instance(context).setCurrentLocale(locale);
context.put(Locale.class, locale);
if (diagnosticListener != null)
context.put(DiagnosticListener.class, diagnosticListener);
context.put(Log.outKey, new PrintWriter(System.err, true)); // FIXME
PrintWriter pw = (charset == null)
? new PrintWriter(System.err, true)
: new PrintWriter(new OutputStreamWriter(System.err, charset), true);
context.put(Log.outKey, pw);
return new JavacFileManager(context, true, charset);
}
@ -159,38 +163,45 @@ public final class JavacTool implements JavaCompiler {
Iterable<String> classes,
Iterable<? extends JavaFileObject> compilationUnits)
{
final String kindMsg = "All compilation units must be of SOURCE kind";
if (options != null)
for (String option : options)
option.getClass(); // null check
if (classes != null) {
for (String cls : classes)
if (!SourceVersion.isName(cls)) // implicit null check
throw new IllegalArgumentException("Not a valid class name: " + cls);
}
if (compilationUnits != null) {
for (JavaFileObject cu : compilationUnits) {
if (cu.getKind() != JavaFileObject.Kind.SOURCE) // implicit null check
throw new IllegalArgumentException(kindMsg);
try {
Context context = new Context();
ClientCodeWrapper ccw = ClientCodeWrapper.instance(context);
final String kindMsg = "All compilation units must be of SOURCE kind";
if (options != null)
for (String option : options)
option.getClass(); // null check
if (classes != null) {
for (String cls : classes)
if (!SourceVersion.isName(cls)) // implicit null check
throw new IllegalArgumentException("Not a valid class name: " + cls);
}
if (compilationUnits != null) {
compilationUnits = ccw.wrapJavaFileObjects(compilationUnits); // implicit null check
for (JavaFileObject cu : compilationUnits) {
if (cu.getKind() != JavaFileObject.Kind.SOURCE)
throw new IllegalArgumentException(kindMsg);
}
}
if (diagnosticListener != null)
context.put(DiagnosticListener.class, ccw.wrap(diagnosticListener));
if (out == null)
context.put(Log.outKey, new PrintWriter(System.err, true));
else
context.put(Log.outKey, new PrintWriter(out, true));
if (fileManager == null)
fileManager = getStandardFileManager(diagnosticListener, null, null);
fileManager = ccw.wrap(fileManager);
context.put(JavaFileManager.class, fileManager);
processOptions(context, fileManager, options);
Main compiler = new Main("javacTask", context.get(Log.outKey));
return new JavacTaskImpl(compiler, options, context, classes, compilationUnits);
} catch (ClientCodeException ex) {
throw new RuntimeException(ex.getCause());
}
Context context = new Context();
if (diagnosticListener != null)
context.put(DiagnosticListener.class, diagnosticListener);
if (out == null)
context.put(Log.outKey, new PrintWriter(System.err, true));
else
context.put(Log.outKey, new PrintWriter(out, true));
if (fileManager == null)
fileManager = getStandardFileManager(diagnosticListener, null, null);
context.put(JavaFileManager.class, fileManager);
processOptions(context, fileManager, options);
Main compiler = new Main("javacTask", context.get(Log.outKey));
return new JavacTaskImpl(this, compiler, options, context, classes, compilationUnits);
}
private static void processOptions(Context context,

8
langtools/src/share/classes/com/sun/tools/javac/code/Symtab.java
View File

@ -125,12 +125,11 @@ public class Symtab {
public final Type stringBuilderType;
public final Type cloneableType;
public final Type serializableType;
public final Type transientMethodHandleType; // transient - 292
public final Type methodHandleType;
public final Type transientPolymorphicSignatureType; // transient - 292
public final Type polymorphicSignatureType;
public final Type throwableType;
public final Type errorType;
public final Type interruptedExceptionType;
public final Type illegalArgumentExceptionType;
public final Type exceptionType;
public final Type runtimeExceptionType;
@ -435,12 +434,11 @@ public class Symtab {
cloneableType = enterClass("java.lang.Cloneable");
throwableType = enterClass("java.lang.Throwable");
serializableType = enterClass("java.io.Serializable");
transientMethodHandleType = enterClass("java.dyn.MethodHandle"); // transient - 292
methodHandleType = enterClass("java.lang.invoke.MethodHandle");
transientPolymorphicSignatureType = enterClass("java.dyn.MethodHandle$PolymorphicSignature"); // transient - 292
polymorphicSignatureType = enterClass("java.lang.invoke.MethodHandle$PolymorphicSignature");
errorType = enterClass("java.lang.Error");
illegalArgumentExceptionType = enterClass("java.lang.IllegalArgumentException");
interruptedExceptionType = enterClass("java.lang.InterruptedException");
exceptionType = enterClass("java.lang.Exception");
runtimeExceptionType = enterClass("java.lang.RuntimeException");
classNotFoundExceptionType = enterClass("java.lang.ClassNotFoundException");
@ -480,9 +478,9 @@ public class Symtab {
autoCloseableType.tsym);
trustMeType = enterClass("java.lang.SafeVarargs");
synthesizeEmptyInterfaceIfMissing(autoCloseableType);
synthesizeEmptyInterfaceIfMissing(cloneableType);
synthesizeEmptyInterfaceIfMissing(serializableType);
synthesizeEmptyInterfaceIfMissing(transientPolymorphicSignatureType); // transient - 292
synthesizeEmptyInterfaceIfMissing(polymorphicSignatureType);
synthesizeBoxTypeIfMissing(doubleType);
synthesizeBoxTypeIfMissing(floatType);

16
langtools/src/share/classes/com/sun/tools/javac/code/Types.java
View File

@ -2461,6 +2461,22 @@ public class Types {
}
};
public Type createMethodTypeWithReturn(Type original, Type newReturn) {
return original.accept(methodWithReturn, newReturn);
}
// where
private final MapVisitor<Type> methodWithReturn = new MapVisitor<Type>() {
public Type visitType(Type t, Type newReturn) {
throw new IllegalArgumentException("Not a method type: " + t);
}
public Type visitMethodType(MethodType t, Type newReturn) {
return new MethodType(t.argtypes, newReturn, t.thrown, t.tsym);
}
public Type visitForAll(ForAll t, Type newReturn) {
return new ForAll(t.tvars, t.qtype.accept(this, newReturn));
}
};
// <editor-fold defaultstate="collapsed" desc="createErrorType">
public Type createErrorType(Type originalType) {
return new ErrorType(originalType, syms.errSymbol);

181
langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java
View File

@ -1089,6 +1089,10 @@ public class Attr extends JCTree.Visitor {
if (resource.getTag() == JCTree.VARDEF) {
attribStat(resource, tryEnv);
chk.checkType(resource, resource.type, syms.autoCloseableType, "try.not.applicable.to.type");
//check that resource type cannot throw InterruptedException
checkAutoCloseable(resource.pos(), localEnv, resource.type);
VarSymbol var = (VarSymbol)TreeInfo.symbolFor(resource);
var.setData(ElementKind.RESOURCE_VARIABLE);
} else {
@ -1127,6 +1131,35 @@ public class Attr extends JCTree.Visitor {
result = null;
}
void checkAutoCloseable(DiagnosticPosition pos, Env<AttrContext> env, Type resource) {
if (!resource.isErroneous() &&
types.asSuper(resource, syms.autoCloseableType.tsym) != null) {
Symbol close = syms.noSymbol;
boolean prevDeferDiags = log.deferDiagnostics;
Queue<JCDiagnostic> prevDeferredDiags = log.deferredDiagnostics;
try {
log.deferDiagnostics = true;
log.deferredDiagnostics = ListBuffer.lb();
close = rs.resolveQualifiedMethod(pos,
env,
resource,
names.close,
List.<Type>nil(),
List.<Type>nil());
}
finally {
log.deferDiagnostics = prevDeferDiags;
log.deferredDiagnostics = prevDeferredDiags;
}
if (close.kind == MTH &&
close.overrides(syms.autoCloseableClose, resource.tsym, types, true) &&
chk.isHandled(syms.interruptedExceptionType, types.memberType(resource, close).getThrownTypes()) &&
env.info.lint.isEnabled(LintCategory.TRY)) {
log.warning(LintCategory.TRY, pos, "try.resource.throws.interrupted.exc", resource);
}
}
}
public void visitConditional(JCConditional tree) {
attribExpr(tree.cond, env, syms.booleanType);
attribExpr(tree.truepart, env);
@ -1580,7 +1613,7 @@ public class Attr extends JCTree.Visitor {
// Attribute clazz expression and store
// symbol + type back into the attributed tree.
Type clazztype = attribType(clazz, env);
Pair<Scope,Scope> mapping = getSyntheticScopeMapping(clazztype, cdef != null);
Pair<Scope,Scope> mapping = getSyntheticScopeMapping(clazztype);
clazztype = chk.checkDiamond(tree, clazztype);
chk.validate(clazz, localEnv);
if (tree.encl != null) {
@ -1778,62 +1811,48 @@ public class Attr extends JCTree.Visitor {
Pair<Scope, Scope> mapping,
List<Type> argtypes,
List<Type> typeargtypes) {
if (clazztype.isErroneous() || mapping == erroneousMapping) {
if (clazztype.isErroneous() ||
clazztype.isInterface() ||
mapping == erroneousMapping) {
//if the type of the instance creation expression is erroneous,
//or something prevented us to form a valid mapping, return the
//(possibly erroneous) type unchanged
//or if it's an interface, or if something prevented us to form a valid
//mapping, return the (possibly erroneous) type unchanged
return clazztype;
}
else if (clazztype.isInterface()) {
//if the type of the instance creation expression is an interface
//skip the method resolution step (JLS 15.12.2.7). The type to be
//inferred is of the kind <X1,X2, ... Xn>C<X1,X2, ... Xn>
clazztype = new ForAll(clazztype.tsym.type.allparams(), clazztype.tsym.type) {
@Override
public List<Type> getConstraints(TypeVar tv, ConstraintKind ck) {
switch (ck) {
case EXTENDS: return types.getBounds(tv);
default: return List.nil();
}
}
@Override
public Type inst(List<Type> inferred, Types types) throws Infer.NoInstanceException {
// check that inferred bounds conform to their bounds
infer.checkWithinBounds(tvars,
types.subst(tvars, tvars, inferred), Warner.noWarnings);
return super.inst(inferred, types);
}
};
} else {
//if the type of the instance creation expression is a class type
//apply method resolution inference (JLS 15.12.2.7). The return type
//of the resolved constructor will be a partially instantiated type
((ClassSymbol) clazztype.tsym).members_field = mapping.snd;
Symbol constructor;
try {
constructor = rs.resolveDiamond(tree.pos(),
env,
clazztype.tsym.type,
argtypes,
typeargtypes);
} finally {
((ClassSymbol) clazztype.tsym).members_field = mapping.fst;
}
if (constructor.kind == MTH) {
ClassType ct = new ClassType(clazztype.getEnclosingType(),
clazztype.tsym.type.getTypeArguments(),
clazztype.tsym);
clazztype = checkMethod(ct,
constructor,
env,
tree.args,
argtypes,
typeargtypes,
env.info.varArgs).getReturnType();
} else {
clazztype = syms.errType;
}
//dup attribution environment and augment the set of inference variables
Env<AttrContext> localEnv = env.dup(tree);
localEnv.info.tvars = clazztype.tsym.type.getTypeArguments();
//if the type of the instance creation expression is a class type
//apply method resolution inference (JLS 15.12.2.7). The return type
//of the resolved constructor will be a partially instantiated type
((ClassSymbol) clazztype.tsym).members_field = mapping.snd;
Symbol constructor;
try {
constructor = rs.resolveDiamond(tree.pos(),
localEnv,
clazztype.tsym.type,
argtypes,
typeargtypes);
} finally {
((ClassSymbol) clazztype.tsym).members_field = mapping.fst;
}
if (constructor.kind == MTH) {
ClassType ct = new ClassType(clazztype.getEnclosingType(),
clazztype.tsym.type.getTypeArguments(),
clazztype.tsym);
clazztype = checkMethod(ct,
constructor,
localEnv,
tree.args,
argtypes,
typeargtypes,
localEnv.info.varArgs).getReturnType();
} else {
clazztype = syms.errType;
}
if (clazztype.tag == FORALL && !pt.isErroneous()) {
//if the resolved constructor's return type has some uninferred
//type-variables, infer them using the expected type and declared
@ -1863,34 +1882,28 @@ public class Attr extends JCTree.Visitor {
* inference. The inferred return type of the synthetic constructor IS
* the inferred type for the diamond operator.
*/
private Pair<Scope, Scope> getSyntheticScopeMapping(Type ctype, boolean overrideProtectedAccess) {
private Pair<Scope, Scope> getSyntheticScopeMapping(Type ctype) {
if (ctype.tag != CLASS) {
return erroneousMapping;
}
Pair<Scope, Scope> mapping =
new Pair<Scope, Scope>(ctype.tsym.members(), new Scope(ctype.tsym));
List<Type> typevars = ctype.tsym.type.getTypeArguments();
//for each constructor in the original scope, create a synthetic constructor
//whose return type is the type of the class in which the constructor is
//declared, and insert it into the new scope.
for (Scope.Entry e = mapping.fst.lookup(names.init);
e.scope != null;
e = e.next()) {
MethodSymbol newConstr = (MethodSymbol) e.sym.clone(ctype.tsym);
if (overrideProtectedAccess && (newConstr.flags() & PROTECTED) != 0) {
//make protected constructor public (this is required for
//anonymous inner class creation expressions using diamond)
newConstr.flags_field |= PUBLIC;
newConstr.flags_field &= ~PROTECTED;
}
newConstr.name = names.init;
List<Type> oldTypeargs = List.nil();
if (newConstr.type.tag == FORALL) {
oldTypeargs = ((ForAll) newConstr.type).tvars;
}
newConstr.type = new MethodType(newConstr.type.getParameterTypes(),
new ClassType(ctype.getEnclosingType(), ctype.tsym.type.getTypeArguments(), ctype.tsym),
newConstr.type.getThrownTypes(),
syms.methodClass);
newConstr.type = new ForAll(typevars.prependList(oldTypeargs), newConstr.type);
mapping.snd.enter(newConstr);
Type synthRestype = new ClassType(ctype.getEnclosingType(),
ctype.tsym.type.getTypeArguments(),
ctype.tsym);
MethodSymbol synhConstr = new MethodSymbol(e.sym.flags(),
names.init,
types.createMethodTypeWithReturn(e.sym.type, synthRestype),
e.sym.owner);
mapping.snd.enter(synhConstr);
}
return mapping;
}
@ -2276,6 +2289,7 @@ public class Attr extends JCTree.Visitor {
sitesym.kind == VAR &&
((VarSymbol)sitesym).isResourceVariable() &&
sym.kind == MTH &&
sym.name.equals(names.close) &&
sym.overrides(syms.autoCloseableClose, sitesym.type.tsym, types, true) &&
env.info.lint.isEnabled(LintCategory.TRY)) {
log.warning(LintCategory.TRY, tree, "try.explicit.close.call");
@ -2901,7 +2915,23 @@ public class Attr extends JCTree.Visitor {
ctype = chk.checkType(typeTree.pos(),
chk.checkClassType(typeTree.pos(), ctype),
syms.throwableType);
multicatchTypes.append(ctype);
if (!ctype.isErroneous()) {
//check that alternatives of a disjunctive type are pairwise
//unrelated w.r.t. subtyping
if (chk.intersects(ctype, multicatchTypes.toList())) {
for (Type t : multicatchTypes) {
boolean sub = types.isSubtype(ctype, t);
boolean sup = types.isSubtype(t, ctype);
if (sub || sup) {
//assume 'a' <: 'b'
Type a = sub ? ctype : t;
Type b = sub ? t : ctype;
log.error(typeTree.pos(), "multicatch.types.must.be.disjoint", a, b);
}
}
}
multicatchTypes.append(ctype);
}
}
tree.type = result = check(tree, types.lub(multicatchTypes.toList()), TYP, pkind, pt);
}
@ -3173,6 +3203,9 @@ public class Attr extends JCTree.Visitor {
// method conform to the method they implement.
chk.checkImplementations(tree);
//check that a resource implementing AutoCloseable cannot throw InterruptedException
checkAutoCloseable(tree.pos(), env, c.type);
for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
// Attribute declaration
attribStat(l.head, env);

2
langtools/src/share/classes/com/sun/tools/javac/comp/Check.java
View File

@ -676,7 +676,7 @@ public class Check {
"cant.apply.diamond.1",
t, diags.fragment("diamond.and.anon.class", t));
return types.createErrorType(t);
} else if (!t.tsym.type.isParameterized()) {
} else if (t.tsym.type.getTypeArguments().isEmpty()) {
log.error(tree.clazz.pos(),
"cant.apply.diamond.1",
t, diags.fragment("diamond.non.generic", t));

3
langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java
View File

@ -788,8 +788,7 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
// Internally to java.lang.invoke, a @PolymorphicSignature annotation
// acts like a classfile attribute.
if (!c.type.isErroneous() &&
(types.isSameType(c.type, syms.polymorphicSignatureType) ||
types.isSameType(c.type, syms.transientPolymorphicSignatureType))) {
types.isSameType(c.type, syms.polymorphicSignatureType)) {
if (!target.hasMethodHandles()) {
// Somebody is compiling JDK7 source code to a JDK6 target.
// Make it an error, since it is unlikely but important.

6
langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java
View File

@ -338,7 +338,11 @@ public class Resolve {
// tvars is the list of formal type variables for which type arguments
// need to inferred.
List<Type> tvars = env.info.tvars;
List<Type> tvars = null;
if (env.info.tvars != null) {
tvars = types.newInstances(env.info.tvars);
mt = types.subst(mt, env.info.tvars, tvars);
}
if (typeargtypes == null) typeargtypes = List.nil();
if (mt.tag != FORALL && typeargtypes.nonEmpty()) {
// This is not a polymorphic method, but typeargs are supplied

6
langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java
View File

@ -1162,6 +1162,9 @@ public class ClassReader implements Completer {
ClassSymbol c = readClassSymbol(nextChar());
NameAndType nt = (NameAndType)readPool(nextChar());
if (c.members_field == null)
throw badClassFile("bad.enclosing.class", self, c);
MethodSymbol m = findMethod(nt, c.members_field, self.flags());
if (nt != null && m == null)
throw badClassFile("bad.enclosing.method", self);
@ -1318,8 +1321,7 @@ public class ClassReader implements Completer {
else
proxies.append(proxy);
if (majorVersion >= V51.major &&
(proxy.type.tsym == syms.polymorphicSignatureType.tsym ||
proxy.type.tsym == syms.transientPolymorphicSignatureType.tsym)) {
proxy.type.tsym == syms.polymorphicSignatureType.tsym) {
sym.flags_field |= POLYMORPHIC_SIGNATURE;
}
}

24
langtools/src/share/classes/com/sun/tools/javac/main/Main.java
View File

@ -65,9 +65,11 @@ public class Main {
PrintWriter out;
/**
* If true, any command line arg errors will cause an exception.
* If true, certain errors will cause an exception, such as command line
* arg errors, or exceptions in user provided code.
*/
boolean fatalErrors;
boolean apiMode;
/** Result codes.
*/
@ -163,7 +165,7 @@ public class Main {
/** Report a usage error.
*/
void error(String key, Object... args) {
if (fatalErrors) {
if (apiMode) {
String msg = getLocalizedString(key, args);
throw new PropagatedException(new IllegalStateException(msg));
}
@ -192,8 +194,8 @@ public class Main {
this.options = options;
}
public void setFatalErrors(boolean fatalErrors) {
this.fatalErrors = fatalErrors;
public void setAPIMode(boolean apiMode) {
this.apiMode = apiMode;
}
/** Process command line arguments: store all command line options
@ -440,7 +442,9 @@ public class Main {
} catch (FatalError ex) {
feMessage(ex);
return EXIT_SYSERR;
} catch(AnnotationProcessingError ex) {
} catch (AnnotationProcessingError ex) {
if (apiMode)
throw new RuntimeException(ex.getCause());
apMessage(ex);
return EXIT_SYSERR;
} catch (ClientCodeException ex) {
@ -458,7 +462,13 @@ public class Main {
bugMessage(ex);
return EXIT_ABNORMAL;
} finally {
if (comp != null) comp.close();
if (comp != null) {
try {
comp.close();
} catch (ClientCodeException ex) {
throw new RuntimeException(ex.getCause());
}
}
filenames = null;
options = null;
}

3
langtools/src/share/classes/com/sun/tools/javac/nio/PathFileObject.java
View File

@ -37,6 +37,7 @@ import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharsetDecoder;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import javax.lang.model.element.Modifier;
@ -170,7 +171,7 @@ abstract class PathFileObject implements JavaFileObject {
if (pn.equalsIgnoreCase(sn)) {
try {
// allow for Windows
return path.toRealPath(false).getFileName().toString().equals(sn);
return path.toRealPath(LinkOption.NOFOLLOW_LINKS).getFileName().toString().equals(sn);
} catch (IOException e) {
}
}

91
langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java
View File

@ -971,7 +971,7 @@ public class JavacParser implements Parser {
if ((mode & EXPR) != 0) {
mode = EXPR;
S.nextToken();
if (S.token() == LT) typeArgs = typeArguments();
if (S.token() == LT) typeArgs = typeArguments(false);
t = creator(pos, typeArgs);
typeArgs = null;
} else return illegal();
@ -1036,7 +1036,7 @@ public class JavacParser implements Parser {
mode = EXPR;
int pos1 = S.pos();
S.nextToken();
if (S.token() == LT) typeArgs = typeArguments();
if (S.token() == LT) typeArgs = typeArguments(false);
t = innerCreator(pos1, typeArgs, t);
typeArgs = null;
break loop;
@ -1116,7 +1116,7 @@ public class JavacParser implements Parser {
mode = EXPR;
int pos2 = S.pos();
S.nextToken();
if (S.token() == LT) typeArgs = typeArguments();
if (S.token() == LT) typeArgs = typeArguments(false);
t = innerCreator(pos2, typeArgs, t);
typeArgs = null;
} else {
@ -1146,7 +1146,7 @@ public class JavacParser implements Parser {
} else {
int pos = S.pos();
accept(DOT);
typeArgs = (S.token() == LT) ? typeArguments() : null;
typeArgs = (S.token() == LT) ? typeArguments(false) : null;
t = toP(F.at(pos).Select(t, ident()));
t = argumentsOpt(typeArgs, t);
}
@ -1206,7 +1206,7 @@ public class JavacParser implements Parser {
(mode & NOPARAMS) == 0) {
mode = TYPE;
checkGenerics();
return typeArguments(t);
return typeArguments(t, false);
} else {
return t;
}
@ -1223,51 +1223,54 @@ public class JavacParser implements Parser {
illegal();
}
mode = useMode;
return typeArguments();
return typeArguments(false);
}
return null;
}
/** TypeArguments = "<" TypeArgument {"," TypeArgument} ">"
*/
List<JCExpression> typeArguments() {
ListBuffer<JCExpression> args = lb();
List<JCExpression> typeArguments(boolean diamondAllowed) {
if (S.token() == LT) {
S.nextToken();
if (S.token() == GT && (mode & DIAMOND) != 0) {
if (S.token() == GT && diamondAllowed) {
checkDiamond();
mode |= DIAMOND;
S.nextToken();
return List.nil();
}
args.append(((mode & EXPR) == 0) ? typeArgument() : parseType());
while (S.token() == COMMA) {
S.nextToken();
} else {
ListBuffer<JCExpression> args = ListBuffer.lb();
args.append(((mode & EXPR) == 0) ? typeArgument() : parseType());
}
switch (S.token()) {
case GTGTGTEQ:
S.token(GTGTEQ);
break;
case GTGTEQ:
S.token(GTEQ);
break;
case GTEQ:
S.token(EQ);
break;
case GTGTGT:
S.token(GTGT);
break;
case GTGT:
S.token(GT);
break;
default:
accept(GT);
break;
while (S.token() == COMMA) {
S.nextToken();
args.append(((mode & EXPR) == 0) ? typeArgument() : parseType());
}
switch (S.token()) {
case GTGTGTEQ:
S.token(GTGTEQ);
break;
case GTGTEQ:
S.token(GTEQ);
break;
case GTEQ:
S.token(EQ);
break;
case GTGTGT:
S.token(GTGT);
break;
case GTGT:
S.token(GT);
break;
default:
accept(GT);
break;
}
return args.toList();
}
} else {
syntaxError(S.pos(), "expected", LT);
return List.nil();
}
return args.toList();
}
/** TypeArgument = Type
@ -1303,9 +1306,9 @@ public class JavacParser implements Parser {
}
}
JCTypeApply typeArguments(JCExpression t) {
JCTypeApply typeArguments(JCExpression t, boolean diamondAllowed) {
int pos = S.pos();
List<JCExpression> args = typeArguments();
List<JCExpression> args = typeArguments(diamondAllowed);
return toP(F.at(pos).TypeApply(t, args));
}
@ -1370,18 +1373,25 @@ public class JavacParser implements Parser {
}
JCExpression t = qualident();
int oldmode = mode;
mode = TYPE | DIAMOND;
mode = TYPE;
boolean diamondFound = false;
if (S.token() == LT) {
checkGenerics();
t = typeArguments(t);
t = typeArguments(t, true);
diamondFound = (mode & DIAMOND) != 0;
}
while (S.token() == DOT) {
if (diamondFound) {
//cannot select after a diamond
illegal(S.pos());
}
int pos = S.pos();
S.nextToken();
t = toP(F.at(pos).Select(t, ident()));
if (S.token() == LT) {
checkGenerics();
t = typeArguments(t);
t = typeArguments(t, true);
diamondFound = (mode & DIAMOND) != 0;
}
}
mode = oldmode;
@ -1416,9 +1426,8 @@ public class JavacParser implements Parser {
JCExpression t = toP(F.at(S.pos()).Ident(ident()));
if (S.token() == LT) {
int oldmode = mode;
mode |= DIAMOND;
checkGenerics();
t = typeArguments(t);
t = typeArguments(t, true);
mode = oldmode;
}
return classCreatorRest(newpos, encl, typeArgs, t);

18
langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java
View File

@ -34,8 +34,8 @@ import java.io.Closeable;
import java.io.File;
import java.io.PrintWriter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.io.StringWriter;
import java.net.MalformedURLException;
import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
@ -58,6 +58,7 @@ import com.sun.tools.javac.code.Symbol.*;
import com.sun.tools.javac.file.FSInfo;
import com.sun.tools.javac.file.JavacFileManager;
import com.sun.tools.javac.jvm.*;
import com.sun.tools.javac.jvm.ClassReader.BadClassFile;
import com.sun.tools.javac.main.JavaCompiler;
import com.sun.tools.javac.main.JavaCompiler.CompileState;
import com.sun.tools.javac.model.JavacElements;
@ -67,6 +68,7 @@ import com.sun.tools.javac.tree.*;
import com.sun.tools.javac.tree.JCTree.*;
import com.sun.tools.javac.util.Abort;
import com.sun.tools.javac.util.Assert;
import com.sun.tools.javac.util.ClientCodeException;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Convert;
import com.sun.tools.javac.util.FatalError;
@ -432,6 +434,8 @@ public class JavacProcessingEnvironment implements ProcessingEnvironment, Closea
log.error("proc.processor.cant.instantiate", processorName);
return false;
}
} catch(ClientCodeException e) {
throw e;
} catch(Throwable t) {
throw new AnnotationProcessingError(t);
}
@ -527,6 +531,8 @@ public class JavacProcessingEnvironment implements ProcessingEnvironment, Closea
supportedOptionNames.add(optionName);
}
} catch (ClientCodeException e) {
throw e;
} catch (Throwable t) {
throw new AnnotationProcessingError(t);
}
@ -785,11 +791,16 @@ public class JavacProcessingEnvironment implements ProcessingEnvironment, Closea
RoundEnvironment renv) {
try {
return proc.process(tes, renv);
} catch (BadClassFile ex) {
log.error("proc.cant.access.1", ex.sym, ex.getDetailValue());
return false;
} catch (CompletionFailure ex) {
StringWriter out = new StringWriter();
ex.printStackTrace(new PrintWriter(out));
log.error("proc.cant.access", ex.sym, ex.getDetailValue(), out.toString());
return false;
} catch (ClientCodeException e) {
throw e;
} catch (Throwable t) {
throw new AnnotationProcessingError(t);
}
@ -1061,6 +1072,11 @@ public class JavacProcessingEnvironment implements ProcessingEnvironment, Closea
PrintWriter out = context.get(Log.outKey);
Assert.checkNonNull(out);
next.put(Log.outKey, out);
Locale locale = context.get(Locale.class);
if (locale != null)
next.put(Locale.class, locale);
Assert.checkNonNull(messages);
next.put(JavacMessages.messagesKey, messages);
final boolean shareNames = true;
if (shareNames) {

22
langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties
View File

@ -302,6 +302,11 @@ compiler.err.try.resource.may.not.be.assigned=\
compiler.err.multicatch.parameter.may.not.be.assigned=\
multi-catch parameter {0} may not be assigned
# 0: type, 1: type
compiler.err.multicatch.types.must.be.disjoint=\
Alternatives in a multi-catch statement cannot be related by subclassing\n\
Alternative {0} is a subclass of alternative {1}
compiler.err.finally.without.try=\
''finally'' without ''try''
@ -606,12 +611,18 @@ compiler.err.warnings.and.werror=\
# Errors related to annotation processing
# 0: symbol, 1: string, 2: stack-trace
compiler.err.proc.cant.access=\
cannot access {0}\n\
{1}\n\
Consult the following stack trace for details.\n\
{2}
# 0: symbol, 1: string
compiler.err.proc.cant.access.1=\
cannot access {0}\n\
{1}
# 0: string
compiler.err.proc.cant.find.class=\
Could not find class file for ''{0}''.
@ -1239,6 +1250,10 @@ compiler.warn.try.explicit.close.call=\
compiler.warn.try.resource.not.referenced=\
auto-closeable resource {0} is never referenced in body of corresponding try statement
# 0: type
compiler.warn.try.resource.throws.interrupted.exc=\
auto-closeable resource {0} has a member method close() that could throw InterruptedException
compiler.warn.unchecked.assign=\
unchecked assignment: {0} to {1}
@ -1415,8 +1430,13 @@ compiler.misc.bad.source.file.header=\
compiler.misc.bad.class.signature=\
bad class signature: {0}
#0: symbol, 1: symbol
compiler.misc.bad.enclosing.class=\
bad enclosing class for {0}: {1}
# 0: symbol
compiler.misc.bad.enclosing.method=\
bad enclosing method attribute: {0}
bad enclosing method attribute for class {0}
compiler.misc.bad.runtime.invisible.param.annotations=\
bad RuntimeInvisibleParameterAnnotations attribute: {0}

15
langtools/src/share/classes/com/sun/tools/javac/util/JavacMessages.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2011, 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
@ -44,7 +44,7 @@ import java.util.Map;
*/
public class JavacMessages implements Messages {
/** The context key for the JavacMessages object. */
protected static final Context.Key<JavacMessages> messagesKey =
public static final Context.Key<JavacMessages> messagesKey =
new Context.Key<JavacMessages>();
/** Get the JavacMessages instance for this context. */
@ -77,7 +77,7 @@ public class JavacMessages implements Messages {
/** Creates a JavacMessages object.
*/
public JavacMessages(Context context) {
this(defaultBundleName);
this(defaultBundleName, context.get(Locale.class));
context.put(messagesKey, this);
}
@ -85,10 +85,17 @@ public class JavacMessages implements Messages {
* @param bundleName the name to identify the resource buundle of localized messages.
*/
public JavacMessages(String bundleName) throws MissingResourceException {
this(bundleName, null);
}
/** Creates a JavacMessages object.
* @param bundleName the name to identify the resource buundle of localized messages.
*/
public JavacMessages(String bundleName, Locale locale) throws MissingResourceException {
bundleNames = List.nil();
bundleCache = new HashMap<Locale, SoftReference<List<ResourceBundle>>>();
add(bundleName);
setCurrentLocale(Locale.getDefault());
setCurrentLocale(locale);
}
public JavacMessages() throws MissingResourceException {

9
langtools/src/share/classes/com/sun/tools/javac/util/Log.java
View File

@ -425,13 +425,8 @@ public class Log extends AbstractLog {
*/
protected void writeDiagnostic(JCDiagnostic diag) {
if (diagListener != null) {
try {
diagListener.report(diag);
return;
}
catch (Throwable t) {
throw new ClientCodeException(t);
}
diagListener.report(diag);
return;
}
PrintWriter writer = getWriterForDiagnosticType(diag.getType());

2
langtools/src/share/classes/com/sun/tools/javac/util/Names.java
View File

@ -73,7 +73,6 @@ public class Names {
public final Name java_io_Serializable;
public final Name serialVersionUID;
public final Name java_lang_Enum;
public final Name transient_java_dyn_MethodHandle; // transient - 292
public final Name java_lang_invoke_MethodHandle;
public final Name package_info;
public final Name ConstantValue;
@ -184,7 +183,6 @@ public class Names {
java_lang_Cloneable = fromString("java.lang.Cloneable");
java_io_Serializable = fromString("java.io.Serializable");
java_lang_Enum = fromString("java.lang.Enum");
transient_java_dyn_MethodHandle = fromString("java.dyn.MethodHandle"); //transient - 292
java_lang_invoke_MethodHandle = fromString("java.lang.invoke.MethodHandle");
package_info = fromString("package-info");
serialVersionUID = fromString("serialVersionUID");

144
langtools/src/share/classes/com/sun/tools/javap/ClassWriter.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2007, 2011, 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
@ -48,6 +48,13 @@ import com.sun.tools.classfile.Signature;
import com.sun.tools.classfile.Signature_attribute;
import com.sun.tools.classfile.SourceFile_attribute;
import com.sun.tools.classfile.Type;
import com.sun.tools.classfile.Type.ArrayType;
import com.sun.tools.classfile.Type.ClassSigType;
import com.sun.tools.classfile.Type.ClassType;
import com.sun.tools.classfile.Type.MethodType;
import com.sun.tools.classfile.Type.SimpleType;
import com.sun.tools.classfile.Type.TypeParamType;
import com.sun.tools.classfile.Type.WildcardType;
import static com.sun.tools.classfile.AccessFlags.*;
@ -166,8 +173,10 @@ public class ClassWriter extends BasicWriter {
// use info from class file header
if (classFile.isClass() && classFile.super_class != 0 ) {
String sn = getJavaSuperclassName(cf);
print(" extends ");
print(sn);
if (!sn.equals("java.lang.Object")) {
print(" extends ");
print(sn);
}
}
for (int i = 0; i < classFile.interfaces.length; i++) {
print(i == 0 ? (classFile.isClass() ? " implements " : " extends ") : ",");
@ -176,13 +185,14 @@ public class ClassWriter extends BasicWriter {
} else {
try {
Type t = sigAttr.getParsedSignature().getType(constant_pool);
JavaTypePrinter p = new JavaTypePrinter(classFile.isInterface());
// The signature parser cannot disambiguate between a
// FieldType and a ClassSignatureType that only contains a superclass type.
if (t instanceof Type.ClassSigType)
print(getJavaName(t.toString()));
else {
if (t instanceof Type.ClassSigType) {
print(p.print(t));
} else if (options.verbose || !t.isObject()) {
print(" extends ");
print(getJavaName(t.toString()));
print(p.print(t));
}
} catch (ConstantPoolException e) {
print(report(e));
@ -210,6 +220,124 @@ public class ClassWriter extends BasicWriter {
indent(-1);
println("}");
}
// where
class JavaTypePrinter implements Type.Visitor<StringBuilder,StringBuilder> {
boolean isInterface;
JavaTypePrinter(boolean isInterface) {
this.isInterface = isInterface;
}
String print(Type t) {
return t.accept(this, new StringBuilder()).toString();
}
public StringBuilder visitSimpleType(SimpleType type, StringBuilder sb) {
sb.append(getJavaName(type.name));
return sb;
}
public StringBuilder visitArrayType(ArrayType type, StringBuilder sb) {
append(sb, type.elemType);
sb.append("[]");
return sb;
}
public StringBuilder visitMethodType(MethodType type, StringBuilder sb) {
appendIfNotEmpty(sb, "<", type.typeParamTypes, "> ");
append(sb, type.returnType);
append(sb, " (", type.paramTypes, ")");
appendIfNotEmpty(sb, " throws ", type.throwsTypes, "");
return sb;
}
public StringBuilder visitClassSigType(ClassSigType type, StringBuilder sb) {
appendIfNotEmpty(sb, "<", type.typeParamTypes, ">");
if (isInterface) {
appendIfNotEmpty(sb, " extends ", type.superinterfaceTypes, "");
} else {
if (type.superclassType != null
&& (options.verbose || !type.superclassType.isObject())) {
sb.append(" extends ");
append(sb, type.superclassType);
}
appendIfNotEmpty(sb, " implements ", type.superinterfaceTypes, "");
}
return sb;
}
public StringBuilder visitClassType(ClassType type, StringBuilder sb) {
if (type.outerType != null) {
append(sb, type.outerType);
sb.append(".");
}
sb.append(getJavaName(type.name));
appendIfNotEmpty(sb, "<", type.typeArgs, ">");
return sb;
}
public StringBuilder visitTypeParamType(TypeParamType type, StringBuilder sb) {
sb.append(type.name);
String sep = " extends ";
if (type.classBound != null
&& (options.verbose || !type.classBound.isObject())) {
sb.append(sep);
append(sb, type.classBound);
sep = " & ";
}
if (type.interfaceBounds != null) {
for (Type bound: type.interfaceBounds) {
sb.append(sep);
append(sb, bound);
sep = " & ";
}
}
return sb;
}
public StringBuilder visitWildcardType(WildcardType type, StringBuilder sb) {
switch (type.kind) {
case UNBOUNDED:
sb.append("?");
break;
case EXTENDS:
sb.append("? extends ");
append(sb, type.boundType);
break;
case SUPER:
sb.append("? super ");
append(sb, type.boundType);
break;
default:
throw new AssertionError();
}
return sb;
}
private void append(StringBuilder sb, Type t) {
t.accept(this, sb);
}
private void append(StringBuilder sb, String prefix, List<? extends Type> list, String suffix) {
sb.append(prefix);
String sep = "";
for (Type t: list) {
sb.append(sep);
append(sb, t);
sep = ", ";
}
sb.append(suffix);
}
private void appendIfNotEmpty(StringBuilder sb, String prefix, List<? extends Type> list, String suffix) {
if (!isEmpty(list))
append(sb, prefix, list, suffix);
}
private boolean isEmpty(List<? extends Type> list) {
return (list == null || list.isEmpty());
}
}
protected void writeFields() {
for (Field f: classFile.fields) {
@ -298,7 +426,7 @@ public class ClassWriter extends BasicWriter {
try {
methodType = (Type.MethodType) methodSig.getType(constant_pool);
methodExceptions = methodType.throwsTypes;
if (methodExceptions != null && methodExceptions.size() == 0)
if (methodExceptions != null && methodExceptions.isEmpty())
methodExceptions = null;
} catch (ConstantPoolException e) {
// report error?

7
langtools/test/com/sun/javadoc/testDeprecatedDocs/TestDeprecatedDocs.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2011, 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
@ -27,8 +27,7 @@
* @summary <DESC>
* @author jamieh
* @library ../lib/
* @build JavadocTester
* @build TestDeprecatedDocs
* @build JavadocTester TestDeprecatedDocs
* @run main TestDeprecatedDocs
*/
@ -77,7 +76,7 @@ public class TestDeprecatedDocs extends JavadocTester {
{TARGET_FILE, "pkg.DeprecatedClassByAnnotation.field"},
{TARGET_FILE2, "<pre>@Deprecated" + NL +
"public class <strong>DeprecatedClassByAnnotation</strong>" + NL +
"public class <span class=\"strong\">DeprecatedClassByAnnotation</span>" + NL +
"extends java.lang.Object</pre>"},
{TARGET_FILE2, "<pre>@Deprecated" + NL +

7
langtools/test/com/sun/javadoc/testHref/TestHref.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2011, 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
@ -27,8 +27,7 @@
* @summary Verify that spaces do not appear in hrefs and anchors.
* @author jamieh
* @library ../lib/
* @build JavadocTester
* @build TestHref
* @build JavadocTester TestHref
* @run main TestHref
*/
@ -81,7 +80,7 @@ public class TestHref extends JavadocTester {
//Signature does not link to the page itself.
{BUG_ID + FS + "pkg" + FS + "C4.html",
"public abstract class <strong>C4&lt;E extends C4&lt;E&gt;&gt;</strong>"
"public abstract class <span class=\"strong\">C4&lt;E extends C4&lt;E&gt;&gt;</span>"
},
};
private static final String[][] NEGATED_TEST =

8
langtools/test/com/sun/javadoc/testHtmlDefinitionListTag/TestHtmlDefinitionListTag.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2009, 2011, 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
@ -29,8 +29,7 @@
* @summary This test verifies the nesting of definition list tags.
* @author Bhavesh Patel
* @library ../lib/
* @build JavadocTester
* @build TestHtmlDefinitionListTag
* @build JavadocTester TestHtmlDefinitionListTag
* @run main TestHtmlDefinitionListTag
*/
@ -43,7 +42,8 @@ public class TestHtmlDefinitionListTag extends JavadocTester {
// Optional Element should print properly nested definition list tags
// for default value.
private static final String[][] TEST_ALL = {
{BUG_ID + FS + "pkg1" + FS + "C1.html", "<pre>public class <strong>C1</strong>" + NL +
{BUG_ID + FS + "pkg1" + FS + "C1.html", "<pre>public class " +
"<span class=\"strong\">C1</span>" + NL +
"extends java.lang.Object" + NL + "implements java.io.Serializable</pre>"},
{BUG_ID + FS + "pkg1" + FS + "C4.html", "<dl>" + NL +
"<dt>Default:</dt>" + NL + "<dd>true</dd>" + NL +

8
langtools/test/com/sun/javadoc/testJavascript/TestJavascript.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2004, 2011, 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 4665566 4855876
* @bug 4665566 4855876 7025314
* @summary Verify that the output has the right javascript.
* @author jamieh
* @library ../lib/
@ -45,9 +45,9 @@ public class TestJavascript extends JavadocTester {
//Input for string search tests.
private static final String[][] TEST = {
{BUG_ID + FS + "pkg" + FS + "C.html",
"<a href=\"../index.html?pkg/C.html\" target=\"_top\">FRAMES</a>"},
"<a href=\"../index.html?pkg/C.html\" target=\"_top\">Frames</a>"},
{BUG_ID + FS + "TestJavascript.html",
"<a href=\"index.html?TestJavascript.html\" target=\"_top\">FRAMES</a>"},
"<a href=\"index.html?TestJavascript.html\" target=\"_top\">Frames</a>"},
{BUG_ID + FS + "index.html",
"<script type=\"text/javascript\">" + NL +
" targetPage = \"\" + window.location.search;" + NL +

7
langtools/test/com/sun/javadoc/testLinkOption/TestLinkOption.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2011, 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
@ -28,8 +28,7 @@
* right files.
* @author jamieh
* @library ../lib/
* @build JavadocTester
* @build TestLinkOption
* @build JavadocTester TestLinkOption
* @run main TestLinkOption
*/
@ -62,7 +61,7 @@ public class TestLinkOption extends JavadocTester {
"Object</a>&nbsp;p3)"
},
{BUG_ID + "-1" + FS + "java" + FS + "lang" + FS + "StringBuilderChild.html",
"<pre>public abstract class <strong>StringBuilderChild</strong>" + NL +
"<pre>public abstract class <span class=\"strong\">StringBuilderChild</span>" + NL +
"extends <a href=\"http://java.sun.com/j2se/1.4/docs/api/java/lang/Object.html?is-external=true\" " +
"title=\"class or interface in java.lang\">Object</a></pre>"
},

20
langtools/test/com/sun/javadoc/testNavagation/TestNavagation.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2011, 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 4131628 4664607
* @bug 4131628 4664607 7025314
* @summary Make sure the Next/Prev Class links iterate through all types.
* Make sure the navagation is 2 columns, not 3.
* @author jamieh
@ -45,20 +45,20 @@ public class TestNavagation extends JavadocTester {
//Input for string search tests.
private static final String[][] TEST = {
{BUG_ID + FS + "pkg" + FS + "A.html", "<li>PREV CLASS</li>"},
{BUG_ID + FS + "pkg" + FS + "A.html", "<li>Prev Class</li>"},
{BUG_ID + FS + "pkg" + FS + "A.html",
"<a href=\"../pkg/C.html\" title=\"class in pkg\"><span class=\"strong\">NEXT CLASS</span></a>"},
"<a href=\"../pkg/C.html\" title=\"class in pkg\"><span class=\"strong\">Next Class</span></a>"},
{BUG_ID + FS + "pkg" + FS + "C.html",
"<a href=\"../pkg/A.html\" title=\"annotation in pkg\"><span class=\"strong\">PREV CLASS</span></a>"},
"<a href=\"../pkg/A.html\" title=\"annotation in pkg\"><span class=\"strong\">Prev Class</span></a>"},
{BUG_ID + FS + "pkg" + FS + "C.html",
"<a href=\"../pkg/E.html\" title=\"enum in pkg\"><span class=\"strong\">NEXT CLASS</span></a>"},
"<a href=\"../pkg/E.html\" title=\"enum in pkg\"><span class=\"strong\">Next Class</span></a>"},
{BUG_ID + FS + "pkg" + FS + "E.html",
"<a href=\"../pkg/C.html\" title=\"class in pkg\"><span class=\"strong\">PREV CLASS</span></a>"},
"<a href=\"../pkg/C.html\" title=\"class in pkg\"><span class=\"strong\">Prev Class</span></a>"},
{BUG_ID + FS + "pkg" + FS + "E.html",
"<a href=\"../pkg/I.html\" title=\"interface in pkg\"><span class=\"strong\">NEXT CLASS</span></a>"},
"<a href=\"../pkg/I.html\" title=\"interface in pkg\"><span class=\"strong\">Next Class</span></a>"},
{BUG_ID + FS + "pkg" + FS + "I.html",
"<a href=\"../pkg/E.html\" title=\"enum in pkg\"><span class=\"strong\">PREV CLASS</span></a>"},
{BUG_ID + FS + "pkg" + FS + "I.html", "<li>NEXT CLASS</li>"},
"<a href=\"../pkg/E.html\" title=\"enum in pkg\"><span class=\"strong\">Prev Class</span></a>"},
{BUG_ID + FS + "pkg" + FS + "I.html", "<li>Next Class</li>"},
// Test for 4664607
{BUG_ID + FS + "pkg" + FS + "I.html",
"<a href=\"#skip-navbar_top\" title=\"Skip navigation links\"></a><a name=\"navbar_top_firstrow\">" + NL +

92
langtools/test/com/sun/javadoc/testNewLanguageFeatures/TestNewLanguageFeatures.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2011, 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,14 +23,13 @@
/*
* @test
* @bug 4789689 4905985 4927164 4827184 4993906 5004549
* @bug 4789689 4905985 4927164 4827184 4993906 5004549 7025314 7010344
* @summary Run Javadoc on a set of source files that demonstrate new
* language features. Check the output to ensure that the new
* language features are properly documented.
* @author jamieh
* @library ../lib/
* @build JavadocTester
* @build TestNewLanguageFeatures
* @build JavadocTester TestNewLanguageFeatures
* @run main TestNewLanguageFeatures
*/
@ -53,9 +52,10 @@ public class TestNewLanguageFeatures extends JavadocTester {
//Make sure enum header is correct.
{BUG_ID + FS + "pkg" + FS + "Coin.html", "Enum Coin</h2>"},
//Make sure enum signature is correct.
{BUG_ID + FS + "pkg" + FS + "Coin.html", "<pre>public enum <strong>Coin</strong>" + NL +
"extends java.lang.Enum&lt;<a href=\"../pkg/Coin.html\" " +
"title=\"enum in pkg\">Coin</a>&gt;</pre>"
{BUG_ID + FS + "pkg" + FS + "Coin.html", "<pre>public enum " +
"<span class=\"strong\">Coin</span>" + NL +
"extends java.lang.Enum&lt;<a href=\"../pkg/Coin.html\" " +
"title=\"enum in pkg\">Coin</a>&gt;</pre>"
},
//Check for enum constant section
{BUG_ID + FS + "pkg" + FS + "Coin.html", "<caption><span>Enum Constants" +
@ -118,8 +118,8 @@ public class TestNewLanguageFeatures extends JavadocTester {
//Signature of subclass that has type parameters.
{BUG_ID + FS + "pkg" + FS + "TypeParameterSubClass.html",
"<pre>public class <strong>TypeParameterSubClass&lt;T extends " +
"java.lang.String&gt;</strong>" + NL + "extends " +
"<pre>public class <span class=\"strong\">TypeParameterSubClass&lt;T extends " +
"java.lang.String&gt;</span>" + NL + "extends " +
"<a href=\"../pkg/TypeParameterSuperClass.html\" title=\"class in pkg\">" +
"TypeParameterSuperClass</a>&lt;T&gt;</pre>"},
@ -155,20 +155,20 @@ public class TestNewLanguageFeatures extends JavadocTester {
//=================================
//Make sure the summary links are correct.
{BUG_ID + FS + "pkg" + FS + "AnnotationType.html",
"<li>SUMMARY:&nbsp;</li>" + NL +
"<li>Summary:&nbsp;</li>" + NL +
"<li><a href=\"#annotation_type_required_element_summary\">" +
"REQUIRED</a>&nbsp;|&nbsp;</li>" + NL + "<li>" +
"<a href=\"#annotation_type_optional_element_summary\">OPTIONAL</a></li>"},
"Required</a>&nbsp;|&nbsp;</li>" + NL + "<li>" +
"<a href=\"#annotation_type_optional_element_summary\">Optional</a></li>"},
//Make sure the detail links are correct.
{BUG_ID + FS + "pkg" + FS + "AnnotationType.html",
"<li>DETAIL:&nbsp;</li>" + NL +
"<li><a href=\"#annotation_type_element_detail\">ELEMENT</a></li>"},
"<li>Detail:&nbsp;</li>" + NL +
"<li><a href=\"#annotation_type_element_detail\">Element</a></li>"},
//Make sure the heading is correct.
{BUG_ID + FS + "pkg" + FS + "AnnotationType.html",
"Annotation Type AnnotationType</h2>"},
//Make sure the signature is correct.
{BUG_ID + FS + "pkg" + FS + "AnnotationType.html",
"public @interface <strong>AnnotationType</strong>"},
"public @interface <span class=\"strong\">AnnotationType</span>"},
//Make sure member summary headings are correct.
{BUG_ID + FS + "pkg" + FS + "AnnotationType.html",
"<h3>Required Element Summary</h3>"},
@ -198,8 +198,8 @@ public class TestNewLanguageFeatures extends JavadocTester {
"<a href=\"../pkg/AnnotationType.html#optional()\">optional</a>" +
"=\"Class Annotation\"," + NL +
" <a href=\"../pkg/AnnotationType.html#required()\">" +
"required</a>=1994)" + NL + "public class <strong>" +
"AnnotationTypeUsage</strong>" + NL + "extends java.lang.Object</pre>"},
"required</a>=1994)" + NL + "public class <span class=\"strong\">" +
"AnnotationTypeUsage</span>" + NL + "extends java.lang.Object</pre>"},
//FIELD
{BUG_ID + FS + "pkg" + FS + "AnnotationTypeUsage.html",
@ -299,7 +299,7 @@ public class TestNewLanguageFeatures extends JavadocTester {
{BUG_ID + FS + "pkg1" + FS + "B.html",
"<pre><a href=\"../pkg1/A.html\" title=\"annotation in pkg1\">@A</a>"},
{BUG_ID + FS + "pkg1" + FS + "B.html",
"public interface <strong>B</strong></pre>"},
"public interface <span class=\"strong\">B</span></pre>"},
//==============================================================
@ -320,9 +320,11 @@ public class TestNewLanguageFeatures extends JavadocTester {
"Foo</a></span><span class=\"tabEnd\">&nbsp;</span></caption>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "Foo.html",
"<td class=\"colLast\"><code><strong><a href=\"../../pkg2/" +
"ClassUseTest1.html\" title=\"class in pkg2\">ClassUseTest1" +
"&lt;T extends Foo & Foo2&gt;</a></strong></code>&nbsp;</td>"
"<td class=\"colLast\"><code><strong><a href=\"../../pkg2/ClassUseTest1.html\" " +
"title=\"class in pkg2\">ClassUseTest1</a>&lt;T extends " +
"<a href=\"../../pkg2/Foo.html\" title=\"class in pkg2\">Foo" +
"</a> & <a href=\"../../pkg2/Foo2.html\" title=\"interface in pkg2\">" +
"Foo2</a>&gt;</strong></code>&nbsp;</td>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "Foo.html",
"<caption><span>Methods in <a href=\"../../pkg2/" +
@ -370,10 +372,11 @@ public class TestNewLanguageFeatures extends JavadocTester {
"</span></caption>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "Foo2.html",
"<td class=\"colLast\"><code><strong><a href=\"../../pkg2/" +
"ClassUseTest1.html\" title=\"class in pkg2\">" +
"ClassUseTest1&lt;T extends Foo & Foo2&gt;</a></strong>" +
"</code>&nbsp;</td>"
"<td class=\"colLast\"><code><strong><a href=\"../../pkg2/ClassUseTest1.html\" " +
"title=\"class in pkg2\">ClassUseTest1</a>&lt;T extends " +
"<a href=\"../../pkg2/Foo.html\" title=\"class in pkg2\">Foo" +
"</a> & <a href=\"../../pkg2/Foo2.html\" title=\"interface in pkg2\">" +
"Foo2</a>&gt;</strong></code>&nbsp;</td>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "Foo2.html",
"<caption><span>Methods in <a href=\"../../pkg2/" +
@ -398,10 +401,11 @@ public class TestNewLanguageFeatures extends JavadocTester {
"&nbsp;</span></caption>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "ParamTest.html",
"<td class=\"colLast\"><code><strong><a href=\"../../pkg2/" +
"ClassUseTest2.html\" title=\"class in pkg2\">ClassUseTest2&lt;T " +
"extends ParamTest&lt;<a href=\"../../pkg2/Foo3.html\" title=\"class " +
"in pkg2\">Foo3</a>&gt;&gt;</a></strong></code>&nbsp;</td>"
"<td class=\"colLast\"><code><strong><a href=\"../../pkg2/ClassUseTest2.html\" " +
"title=\"class in pkg2\">ClassUseTest2</a>&lt;T extends " +
"<a href=\"../../pkg2/ParamTest.html\" title=\"class in pkg2\">" +
"ParamTest</a>&lt;<a href=\"../../pkg2/Foo3.html\" title=\"class in pkg2\">" +
"Foo3</a>&gt;&gt;</strong></code>&nbsp;</td>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "ParamTest.html",
"<caption><span>Methods in <a href=\"../../pkg2/" +
@ -452,11 +456,11 @@ public class TestNewLanguageFeatures extends JavadocTester {
"Foo3</a></span><span class=\"tabEnd\">&nbsp;</span></caption>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "Foo3.html",
"<td class=\"colLast\"><code><strong><a href=\"../../" +
"pkg2/ClassUseTest2.html\" title=\"class in pkg2\">" +
"ClassUseTest2&lt;T extends ParamTest&lt;<a href=\"../../" +
"pkg2/Foo3.html\" title=\"class in pkg2\">Foo3</a>&gt;&gt;" +
"</a></strong></code>&nbsp;</td>"
"<td class=\"colLast\"><code><strong><a href=\"../../pkg2/ClassUseTest2.html\" " +
"title=\"class in pkg2\">ClassUseTest2</a>&lt;T extends " +
"<a href=\"../../pkg2/ParamTest.html\" title=\"class in pkg2\">" +
"ParamTest</a>&lt;<a href=\"../../pkg2/Foo3.html\" title=\"class in pkg2\">" +
"Foo3</a>&gt;&gt;</strong></code>&nbsp;</td>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "Foo3.html",
"<caption><span>Methods in <a href=\"../../pkg2/" +
@ -496,10 +500,12 @@ public class TestNewLanguageFeatures extends JavadocTester {
"&nbsp;</span></caption>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "ParamTest2.html",
"<td class=\"colLast\"><code><strong><a href=\"../../pkg2/" +
"ClassUseTest3.html\" title=\"class in pkg2\">" +
"ClassUseTest3&lt;T extends ParamTest2&lt;java.util.List" +
"&lt;? extends Foo4&gt;&gt;&gt;</a></strong></code>&nbsp;</td>"
"<td class=\"colLast\"><code><strong><a href=\"../../pkg2/ClassUseTest3.html\" " +
"title=\"class in pkg2\">ClassUseTest3</a>&lt;T extends " +
"<a href=\"../../pkg2/ParamTest2.html\" title=\"class in pkg2\">" +
"ParamTest2</a>&lt;java.util.List&lt;? extends " +
"<a href=\"../../pkg2/Foo4.html\" title=\"class in pkg2\">" +
"Foo4</a>&gt;&gt;&gt;</strong></code>&nbsp;</td>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "ParamTest2.html",
"<caption><span>Methods in <a href=\"../../pkg2/" +
@ -532,10 +538,12 @@ public class TestNewLanguageFeatures extends JavadocTester {
"</span></caption>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "Foo4.html",
"<td class=\"colLast\"><code><strong><a href=\"../../" +
"pkg2/ClassUseTest3.html\" title=\"class in pkg2\">" +
"ClassUseTest3&lt;T extends ParamTest2&lt;java.util.List" +
"&lt;? extends Foo4&gt;&gt;&gt;</a></strong></code>&nbsp;</td>"
"<td class=\"colLast\"><code><strong><a href=\"../../pkg2/ClassUseTest3.html\" " +
"title=\"class in pkg2\">ClassUseTest3</a>&lt;T extends " +
"<a href=\"../../pkg2/ParamTest2.html\" title=\"class in pkg2\">" +
"ParamTest2</a>&lt;java.util.List&lt;? extends " +
"<a href=\"../../pkg2/Foo4.html\" title=\"class in pkg2\">" +
"Foo4</a>&gt;&gt;&gt;</strong></code>&nbsp;</td>"
},
{BUG_ID + FS + "pkg2" + FS + "class-use" + FS + "Foo4.html",
"<caption><span>Methods in <a href=\"../../pkg2/" +

71
langtools/test/com/sun/javadoc/testNonFrameWarning/TestNonFrameWarning.java Normal file
View File

@ -0,0 +1,71 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7001086
* @summary Test Non-frame warning.
* @author Bhavesh Patel
* @library ../lib/
* @build JavadocTester TestNonFrameWarning
* @run main TestNonFrameWarning
*/
public class TestNonFrameWarning extends JavadocTester {
private static final String BUG_ID = "7001086";
private static final String[][] TEST = {
{BUG_ID + FS + "index.html",
"<p>This document is designed to be viewed using the frames feature. " +
"If you see this message, you are using a non-frame-capable web client. " +
"Link to <a href=\"pkg/package-summary.html\">Non-frame version</a>.</p>"
}
};
private static final String[] ARGS = new String[]{
"-d", BUG_ID, "-sourcepath", SRC_DIR, "pkg"
};
/**
* The entry point of the test.
* @param args the array of command line arguments.
*/
public static void main(String[] args) {
TestNonFrameWarning tester = new TestNonFrameWarning();
run(tester, ARGS, TEST, NO_TEST);
tester.printSummary();
}
/**
* {@inheritDoc}
*/
public String getBugId() {
return BUG_ID;
}
/**
* {@inheritDoc}
*/
public String getBugName() {
return getClass().getName();
}
}

30
langtools/test/com/sun/javadoc/testNonFrameWarning/pkg/C.java Normal file
View File

@ -0,0 +1,30 @@
/*
* Copyright (c) 2011, 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.
*/
package pkg;
/**
* Source file for C
*/
public class C {
}

83
langtools/test/com/sun/javadoc/testSubTitle/TestSubTitle.java Normal file
View File

@ -0,0 +1,83 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7010342
* @summary Test for correct sub title generation.
* @author Bhavesh Patel
* @library ../lib/
* @build JavadocTester
* @build TestSubTitle
* @run main TestSubTitle
*/
public class TestSubTitle extends JavadocTester {
private static final String BUG_ID = "7010342";
private static final String[][] TEST = {
{BUG_ID + FS + "pkg" + FS + "package-summary.html",
"<div class=\"subTitle\">" + NL + "<div class=\"block\">This is the " +
"description of package pkg.</div>" + NL + "</div>"
},
{BUG_ID + FS + "pkg" + FS + "C.html",
"<div class=\"subTitle\">pkg</div>"
}
};
private static final String[][] NEG_TEST = {
{BUG_ID + FS + "pkg" + FS + "package-summary.html",
"<p class=\"subTitle\">" + NL + "<div class=\"block\">This is the " +
"description of package pkg.</div>" + NL + "</p>"
},
{BUG_ID + FS + "pkg" + FS + "C.html",
"<p class=\"subTitle\">pkg</p>"
}
};
private static final String[] ARGS = new String[]{
"-d", BUG_ID, "-sourcepath", SRC_DIR, "pkg"
};
/**
* The entry point of the test.
* @param args the array of command line arguments.
*/
public static void main(String[] args) {
TestSubTitle tester = new TestSubTitle();
run(tester, ARGS, TEST, NEG_TEST);
tester.printSummary();
}
/**
* {@inheritDoc}
*/
public String getBugId() {
return BUG_ID;
}
/**
* {@inheritDoc}
*/
public String getBugName() {
return getClass().getName();
}
}

30
langtools/test/com/sun/javadoc/testSubTitle/pkg/C.java Normal file
View File

@ -0,0 +1,30 @@
/*
* Copyright (c) 2011, 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.
*/
package pkg;
/**
* Source file for C
*/
public class C {
}

8
langtools/test/com/sun/javadoc/testSubTitle/pkg/package.html Normal file
View File

@ -0,0 +1,8 @@
<html lang="en">
<head>
<title>Package Summary</title>
</head>
<body>
This is the description of package pkg.
</body>
</html>

58
langtools/test/com/sun/javadoc/testTypeParams/TestTypeParameters.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2011, 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,55 +23,77 @@
/*
* @test
* @bug 4927167 4974929
* @bug 4927167 4974929 7010344
* @summary When the type parameters are more than 10 characters in length,
* make sure there is a line break between type params and return type
* in member summary.
* in member summary. Also, test for type parameter links in package-summary and
* class-use pages. The class/annotation pages should check for type
* parameter links in the class/annotation signature section when -linksource is set.
* @author jamieh
* @library ../lib/
* @build JavadocTester
* @build TestTypeParameters
* @build JavadocTester TestTypeParameters
* @run main TestTypeParameters
*/
public class TestTypeParameters extends JavadocTester {
//Test information.
private static final String BUG_ID = "4927167-4974929";
private static final String BUG_ID = "4927167-4974929-7010344";
//Javadoc arguments.
private static final String[] ARGS = new String[] {
"-d", BUG_ID, "-source", "1.5", "-sourcepath", SRC_DIR,
"pkg"
private static final String[] ARGS1 = new String[]{
"-d", BUG_ID, "-use", "-source", "1.5", "-sourcepath", SRC_DIR,
"pkg"
};
private static final String[] ARGS2 = new String[]{
"-d", BUG_ID, "-linksource", "-source", "1.5", "-sourcepath", SRC_DIR,
"pkg"
};
//Input for string search tests.
private static final String[][] TEST =
{
private static final String[][] TEST1 = {
{BUG_ID + FS + "pkg" + FS + "C.html",
"<td class=\"colFirst\"><code>&lt;W extends java.lang.String,V extends " +
"java.util.List&gt;&nbsp;<br>java.lang.Object</code></td>"},
"java.util.List&gt;&nbsp;<br>java.lang.Object</code></td>"
},
{BUG_ID + FS + "pkg" + FS + "C.html",
"<code>&lt;T&gt;&nbsp;java.lang.Object</code>"},
"<code>&lt;T&gt;&nbsp;java.lang.Object</code>"
},
{BUG_ID + FS + "pkg" + FS + "package-summary.html",
"C&lt;E extends Parent&gt;"},
"C</a>&lt;E extends <a href=\"../pkg/Parent.html\" " +
"title=\"class in pkg\">Parent</a>&gt;"
},
{BUG_ID + FS + "pkg" + FS + "class-use" + FS + "Foo4.html",
"<a href=\"../../pkg/ClassUseTest3.html\" title=\"class in pkg\">" +
"ClassUseTest3</a>&lt;T extends <a href=\"../../pkg/ParamTest2.html\" " +
"title=\"class in pkg\">ParamTest2</a>&lt;java.util.List&lt;? extends " +
"<a href=\"../../pkg/Foo4.html\" title=\"class in pkg\">Foo4</a>&gt;&gt;&gt;"
},
//Nested type parameters
{BUG_ID + FS + "pkg" + FS + "C.html",
"<a name=\"formatDetails(java.util.Collection, java.util.Collection)\">" + NL +
"<!-- -->" + NL +
"</a>"},
"</a>"
},
};
private static final String[][] TEST2 = {
{BUG_ID + FS + "pkg" + FS + "ClassUseTest3.html",
"public class <a href=\"../src-html/pkg/ClassUseTest3.html#line.28\">" +
"ClassUseTest3</a>&lt;T extends <a href=\"../pkg/ParamTest2.html\" " +
"title=\"class in pkg\">ParamTest2</a>&lt;java.util.List&lt;? extends " +
"<a href=\"../pkg/Foo4.html\" title=\"class in pkg\">Foo4</a>&gt;&gt;&gt;"
}
};
private static final String[][] NEGATED_TEST = NO_TEST;
/**
* The entry point of the test.
* @param args the array of command line arguments.
*/
public static void main(String[] args) {
TestTypeParameters tester = new TestTypeParameters();
run(tester, ARGS, TEST, NEGATED_TEST);
run(tester, ARGS1, TEST1, NEGATED_TEST);
run(tester, ARGS2, TEST2, NEGATED_TEST);
tester.printSummary();
}

37
langtools/test/com/sun/javadoc/testTypeParams/pkg/ClassUseTest3.java Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (c) 2011, 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.
*/
package pkg;
import java.util.*;
public class ClassUseTest3 <T extends ParamTest2<List<? extends Foo4>>> {
public ClassUseTest3(Set<Foo4> p) {}
public <T extends ParamTest2<List<? extends Foo4>>> ParamTest2<List<? extends Foo4>> method(T t) {
return null;
}
public void method(Set<Foo4> p) {}
}

26
langtools/test/com/sun/javadoc/testTypeParams/pkg/Foo4.java Normal file
View File

@ -0,0 +1,26 @@
/*
* Copyright (c) 2011, 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.
*/
package pkg;
public class Foo4 {}

27
langtools/test/com/sun/javadoc/testTypeParams/pkg/ParamTest2.java Normal file
View File

@ -0,0 +1,27 @@
/*
* Copyright (c) 2011, 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.
*/
package pkg;
public class ParamTest2<E> {
}

234
langtools/test/tools/javac/TryWithResources/InterruptedExceptionTest.java Normal file
View File

@ -0,0 +1,234 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7027157
* @summary Project Coin: javac warnings for AutoCloseable.close throwing InterruptedException
*/
import com.sun.source.util.JavacTask;
import java.net.URI;
import java.util.Arrays;
import javax.tools.Diagnostic;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
public class InterruptedExceptionTest {
enum XlintOption {
NONE("none"),
TRY("try");
String opt;
XlintOption(String opt) {
this.opt = opt;
}
String getXlintOption() {
return "-Xlint:" + opt;
}
}
enum SuppressLevel {
NONE,
SUPPRESS;
String getSuppressAnno() {
return this == SUPPRESS ?
"@SuppressWarnings(\"try\")" :
"";
}
}
enum ClassKind {
ABSTRACT_CLASS("abstract class", "implements", false),
CLASS("class", "implements", true),
INTERFACE("interface", "extends", false);
String kindName;
String extendsClause;
boolean hasBody;
private ClassKind(String kindName, String extendsClause, boolean hasBody) {
this.kindName = kindName;
this.extendsClause = extendsClause;
this.hasBody = hasBody;
}
String getBody() {
return hasBody ? "{}" : ";";
}
}
enum ExceptionKind {
NONE("", false),
EXCEPTION("Exception", true),
INTERRUPTED_EXCEPTION("InterruptedException", true),
ILLEGAL_ARGUMENT_EXCEPTION("IllegalArgumentException", false),
X("X", false);
String exName;
boolean shouldWarn;
private ExceptionKind(String exName, boolean shouldWarn) {
this.exName = exName;
this.shouldWarn = shouldWarn;
}
String getThrowsClause() {
return this == NONE ? "" : "throws " + exName;
}
String getTypeArguments(ExceptionKind decl) {
return (decl != X || this == NONE) ? "" : "<" + exName + ">";
}
String getTypeParameter() {
return this == X ? "<X extends Exception>" : "";
}
}
public static void main(String... args) throws Exception {
//create default shared JavaCompiler - reused across multiple compilations
JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
for (XlintOption xlint : XlintOption.values()) {
for (SuppressLevel suppress_decl : SuppressLevel.values()) {
for (SuppressLevel suppress_use : SuppressLevel.values()) {
for (ClassKind ck : ClassKind.values()) {
for (ExceptionKind ek_decl : ExceptionKind.values()) {
for (ExceptionKind ek_use : ExceptionKind.values()) {
new InterruptedExceptionTest(xlint, suppress_decl,
suppress_use, ck, ek_decl, ek_use).run(comp, fm);
}
}
}
}
}
}
}
XlintOption xlint;
SuppressLevel suppress_decl;
SuppressLevel suppress_use;
ClassKind ck;
ExceptionKind ek_decl;
ExceptionKind ek_use;
JavaSource source;
DiagnosticChecker diagChecker;
InterruptedExceptionTest(XlintOption xlint, SuppressLevel suppress_decl, SuppressLevel suppress_use,
ClassKind ck, ExceptionKind ek_decl, ExceptionKind ek_use) {
this.xlint = xlint;
this.suppress_decl = suppress_decl;
this.suppress_use = suppress_use;
this.ck = ck;
this.ek_decl = ek_decl;
this.ek_use = ek_use;
this.source = new JavaSource();
this.diagChecker = new DiagnosticChecker();
}
class JavaSource extends SimpleJavaFileObject {
String template = "#S1 #CK Resource#G #EC AutoCloseable {\n" +
"public void close() #TK #BK\n" +
"}\n" +
"class Test {\n" +
"#S2 <X> void test() {\n" +
"try (Resource#PK r = null) { }\n" +
"}\n" +
"}\n";
String source;
public JavaSource() {
super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
source = template.replace("#S1", suppress_decl.getSuppressAnno())
.replace("#S2", suppress_use.getSuppressAnno())
.replace("#CK", ck.kindName)
.replace("#EC", ck.extendsClause)
.replace("#G", ek_decl.getTypeParameter())
.replace("#TK", ek_decl.getThrowsClause())
.replace("#BK", ck.getBody())
.replace("#PK", ek_use.getTypeArguments(ek_decl));
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return source;
}
}
void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
Arrays.asList(xlint.getXlintOption()), null, Arrays.asList(source));
ct.analyze();
check();
}
void check() {
boolean shouldWarnDecl = ek_decl.shouldWarn &&
xlint == XlintOption.TRY &&
suppress_decl != SuppressLevel.SUPPRESS;
boolean shouldWarnUse = (ek_decl.shouldWarn ||
((ek_use.shouldWarn || ek_use == ExceptionKind.NONE) && ek_decl == ExceptionKind.X)) &&
xlint == XlintOption.TRY &&
suppress_use != SuppressLevel.SUPPRESS;
int foundWarnings = 0;
if (shouldWarnDecl) foundWarnings++;
if (shouldWarnUse) foundWarnings++;
if (foundWarnings != diagChecker.tryWarnFound) {
throw new Error("invalid diagnostics for source:\n" +
source.getCharContent(true) +
"\nOptions: " + xlint.getXlintOption() +
"\nFound warnings: " + diagChecker.tryWarnFound +
"\nExpected decl warning: " + shouldWarnDecl +
"\nExpected use warning: " + shouldWarnUse);
}
}
static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
int tryWarnFound;
public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
if (diagnostic.getKind() == Diagnostic.Kind.WARNING &&
diagnostic.getCode().contains("try.resource.throws.interrupted.exc")) {
tryWarnFound++;
}
}
}
}

40
langtools/test/tools/javac/TryWithResources/T7032633.java Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7032633
* @summary javac -Xlint:all warns about flush() within try on an auto-closeable resource
* @compile -Xlint:try -Werror T7032633.java
*/
import java.io.IOException;
import java.io.OutputStream;
public class T7032633 {
void test() throws IOException {
try (OutputStream out = System.out) {
out.flush();
}
}
}

61
langtools/test/tools/javac/api/T6437138.java Normal file
View File

@ -0,0 +1,61 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 6437138
* @summary JSR 199: Compiler doesn't diagnose crash in user code
*/
import java.net.URI;
import java.util.Arrays;
import javax.tools.*;
import static javax.tools.JavaFileObject.Kind.*;
public class T6437138 {
static class JFO extends SimpleJavaFileObject {
public JFO(URI uri, JavaFileObject.Kind kind) {
super(uri, kind);
}
// getCharContent not impl, will throw UnsupportedOperationException
}
public static void main(String... arg) throws Exception {
try {
JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
JavaFileObject jfo = new JFO(new URI("JFOTest04.java"),SOURCE);
JavaCompiler.CompilationTask ct = javac.getTask(null,null,null,null,
null, Arrays.asList(jfo));
ct.call();
throw new Exception("no exception thrown by JavaCompiler.CompilationTask");
} catch (RuntimeException e) {
if (e.getCause() instanceof UnsupportedOperationException) {
System.err.println("RuntimeException(UnsupportedOperationException) caught as expected");
return;
}
throw new Exception("unexpected exception caught", e);
}
}
}

604
langtools/test/tools/javac/api/TestClientCodeWrapper.java Normal file
View File

@ -0,0 +1,604 @@
/*
* Copyright (c) 2011 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.
*/
/*
* @test
* @bug 6437138 6482554
* @summary JSR 199: Compiler doesn't diagnose crash in user code
* @library ../lib
* @build JavacTestingAbstractProcessor TestClientCodeWrapper
* @run main TestClientCodeWrapper
*/
import java.io.*;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.*;
import javax.annotation.processing.*;
import javax.lang.model.*;
import javax.lang.model.element.*;
import javax.tools.*;
import com.sun.source.util.*;
import com.sun.tools.javac.api.*;
import javax.tools.JavaFileObject.Kind;
public class TestClientCodeWrapper extends JavacTestingAbstractProcessor {
public static void main(String... args) throws Exception {
new TestClientCodeWrapper().run();
}
/**
* Run a series of compilations, each with a different user-provided object
* configured to throw an exception when a specific method is invoked.
* Then, verify the exception is thrown as expected.
*
* Some methods are not invoked from the compiler, and are excluded from the test.
*/
void run() throws Exception {
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
defaultFileManager = compiler.getStandardFileManager(null, null, null);
for (Method m: getMethodsExcept(JavaFileManager.class, "close", "getJavaFileForInput")) {
test(m);
}
for (Method m: getMethodsExcept(FileObject.class, "delete")) {
test(m);
}
for (Method m: getMethods(JavaFileObject.class)) {
test(m);
}
for (Method m: getMethodsExcept(Processor.class, "getCompletions")) {
test(m);
}
for (Method m: DiagnosticListener.class.getDeclaredMethods()) {
test(m);
}
for (Method m: TaskListener.class.getDeclaredMethods()) {
test(m);
}
if (errors > 0)
throw new Exception(errors + " errors occurred");
}
/** Get a sorted set of the methods declared on a class. */
Set<Method> getMethods(Class<?> clazz) {
return getMethodsExcept(clazz, new String[0]);
}
/** Get a sorted set of the methods declared on a class, excluding
* specified methods by name. */
Set<Method> getMethodsExcept(Class<?> clazz, String... exclude) {
Set<Method> methods = new TreeSet<Method>(new Comparator<Method>() {
public int compare(Method m1, Method m2) {
return m1.toString().compareTo(m2.toString());
}
});
Set<String> e = new HashSet<String>(Arrays.asList(exclude));
for (Method m: clazz.getDeclaredMethods()) {
if (!e.contains(m.getName()))
methods.add(m);
}
return methods;
}
/**
* Test a method in a user supplied component, to verify javac's handling
* of any exceptions thrown by that method.
*/
void test(Method m) throws Exception {
testNum++;
File extDirs = new File("empty-extdirs");
extDirs.mkdirs();
File testClasses = new File("test" + testNum);
testClasses.mkdirs();
defaultFileManager.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(testClasses));
System.err.println("test " + testNum + ": "
+ m.getDeclaringClass().getSimpleName() + "." + m.getName());
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
List<String> javacOptions = Arrays.asList(
"-extdirs", extDirs.getPath(), // for use by filemanager handleOption
"-processor", TestClientCodeWrapper.class.getName()
);
List<String> classes = Collections.emptyList();
JavacTool tool = JavacTool.create();
try {
JavacTask task = tool.getTask(pw,
getFileManager(m, defaultFileManager),
getDiagnosticListener(m, pw),
javacOptions,
classes,
getCompilationUnits(m));
if (isDeclaredIn(m, Processor.class))
task.setProcessors(getProcessors(m));
if (isDeclaredIn(m, TaskListener.class))
task.setTaskListener(getTaskListener(m, pw));
boolean ok = task.call();
error("compilation " + (ok ? "succeeded" : "failed") + " unexpectedly");
} catch (RuntimeException e) {
System.err.println("caught " + e);
if (e.getClass() == RuntimeException.class) {
Throwable cause = e.getCause();
if (cause instanceof UserError) {
String expect = m.getName();
String found = cause.getMessage();
checkEqual("exception messaqe", expect, found);
} else {
cause.printStackTrace(System.err);
error("Unexpected exception: " + cause);
}
} else {
e.printStackTrace(System.err);
error("Unexpected exception: " + e);
}
}
pw.close();
String out = sw.toString();
System.err.println(out);
}
/** Get a file manager to use for the test compilation. */
JavaFileManager getFileManager(Method m, JavaFileManager defaultFileManager) {
return isDeclaredIn(m, JavaFileManager.class, FileObject.class, JavaFileObject.class)
? new UserFileManager(m, defaultFileManager)
: defaultFileManager;
}
/** Get a diagnostic listener to use for the test compilation. */
DiagnosticListener<JavaFileObject> getDiagnosticListener(Method m, PrintWriter out) {
return isDeclaredIn(m, DiagnosticListener.class)
? new UserDiagnosticListener(m, out)
: null;
}
/** Get a set of file objects to use for the test compilation. */
Iterable<? extends JavaFileObject> getCompilationUnits(Method m) {
File testSrc = new File(System.getProperty("test.src"));
File thisSrc = new File(testSrc, TestClientCodeWrapper.class.getName() + ".java");
Iterable<? extends JavaFileObject> files = defaultFileManager.getJavaFileObjects(thisSrc);
if (isDeclaredIn(m, FileObject.class, JavaFileObject.class))
return Arrays.asList(new UserFileObject(m, files.iterator().next()));
else
return files;
}
/** Get a set of annotation processors to use for the test compilation. */
Iterable<? extends Processor> getProcessors(Method m) {
return Arrays.asList(new UserProcessor(m));
}
/** Get a task listener to use for the test compilation. */
TaskListener getTaskListener(Method m, PrintWriter out) {
return new UserTaskListener(m, out);
}
/** Check if two values are .equal, and report an error if not. */
<T> void checkEqual(String label, T expect, T found) {
if (!expect.equals(found))
error("Unexpected value for " + label + ": " + found + "; expected: " + expect);
}
/** Report an error. */
void error(String msg) {
System.err.println("Error: " + msg);
errors++;
}
/** Check if a method is declared in any of a set of classes */
static boolean isDeclaredIn(Method m, Class<?>... classes) {
Class<?> dc = m.getDeclaringClass();
for (Class<?> c: classes) {
if (c == dc) return true;
}
return false;
}
/** Throw an intentional error if the method has a given name. */
static void throwUserExceptionIfNeeded(Method m, String name) {
if (m != null && m.getName().equals(name))
throw new UserError(name);
}
StandardJavaFileManager defaultFileManager;
int testNum;
int errors;
//--------------------------------------------------------------------------
/**
* Processor used to trigger use of methods not normally used by javac.
*/
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
boolean firstRound = false;
for (Element e: roundEnv.getRootElements()) {
if (e.getSimpleName().contentEquals(TestClientCodeWrapper.class.getSimpleName()))
firstRound = true;
}
if (firstRound) {
try {
FileObject f1 = filer.getResource(StandardLocation.CLASS_PATH, "",
TestClientCodeWrapper.class.getName() + ".java");
f1.openInputStream().close();
f1.openReader(false).close();
FileObject f2 = filer.createResource(
StandardLocation.CLASS_OUTPUT, "", "f2.txt", (Element[]) null);
f2.openOutputStream().close();
FileObject f3 = filer.createResource(
StandardLocation.CLASS_OUTPUT, "", "f3.txt", (Element[]) null);
f3.openWriter().close();
JavaFileObject f4 = filer.createSourceFile("f4", (Element[]) null);
f4.openWriter().close();
f4.getNestingKind();
f4.getAccessLevel();
messager.printMessage(Diagnostic.Kind.NOTE, "informational note",
roundEnv.getRootElements().iterator().next());
} catch (IOException e) {
throw new UserError(e);
}
}
return true;
}
//--------------------------------------------------------------------------
// <editor-fold defaultstate="collapsed" desc="User classes">
static class UserError extends Error {
private static final long serialVersionUID = 1L;
UserError(String msg) {
super(msg);
}
UserError(Throwable t) {
super(t);
}
}
static class UserFileManager extends ForwardingJavaFileManager<JavaFileManager> {
Method fileManagerMethod;
Method fileObjectMethod;
UserFileManager(Method m, JavaFileManager delegate) {
super(delegate);
if (isDeclaredIn(m, JavaFileManager.class)) {
fileManagerMethod = m;
} else if (isDeclaredIn(m, FileObject.class, JavaFileObject.class)) {
fileObjectMethod = m;
} else
assert false;
}
@Override
public ClassLoader getClassLoader(Location location) {
throwUserExceptionIfNeeded(fileManagerMethod, "getClassLoader");
return super.getClassLoader(location);
}
@Override
public Iterable<JavaFileObject> list(Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException {
throwUserExceptionIfNeeded(fileManagerMethod, "list");
return wrap(super.list(location, packageName, kinds, recurse));
}
@Override
public String inferBinaryName(Location location, JavaFileObject file) {
throwUserExceptionIfNeeded(fileManagerMethod, "inferBinaryName");
return super.inferBinaryName(location, unwrap(file));
}
@Override
public boolean isSameFile(FileObject a, FileObject b) {
throwUserExceptionIfNeeded(fileManagerMethod, "isSameFile");
return super.isSameFile(unwrap(a), unwrap(b));
}
@Override
public boolean handleOption(String current, Iterator<String> remaining) {
throwUserExceptionIfNeeded(fileManagerMethod, "handleOption");
return super.handleOption(current, remaining);
}
@Override
public boolean hasLocation(Location location) {
throwUserExceptionIfNeeded(fileManagerMethod, "hasLocation");
return super.hasLocation(location);
}
@Override
public JavaFileObject getJavaFileForInput(Location location, String className, Kind kind) throws IOException {
throwUserExceptionIfNeeded(fileManagerMethod, "getJavaFileForInput");
return wrap(super.getJavaFileForInput(location, className, kind));
}
@Override
public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling) throws IOException {
throwUserExceptionIfNeeded(fileManagerMethod, "getJavaFileForOutput");
return wrap(super.getJavaFileForOutput(location, className, kind, sibling));
}
@Override
public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {
throwUserExceptionIfNeeded(fileManagerMethod, "getFileForInput");
return wrap(super.getFileForInput(location, packageName, relativeName));
}
@Override
public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException {
throwUserExceptionIfNeeded(fileManagerMethod, "getFileForOutput");
return wrap(super.getFileForOutput(location, packageName, relativeName, sibling));
}
@Override
public void flush() throws IOException {
throwUserExceptionIfNeeded(fileManagerMethod, "flush");
super.flush();
}
@Override
public void close() throws IOException {
throwUserExceptionIfNeeded(fileManagerMethod, "close");
super.close();
}
@Override
public int isSupportedOption(String option) {
throwUserExceptionIfNeeded(fileManagerMethod, "isSupportedOption");
return super.isSupportedOption(option);
}
public FileObject wrap(FileObject fo) {
if (fileObjectMethod == null)
return fo;
return new UserFileObject(fileObjectMethod, (JavaFileObject)fo);
}
FileObject unwrap(FileObject fo) {
if (fo instanceof UserFileObject)
return ((UserFileObject) fo).unwrap();
else
return fo;
}
public JavaFileObject wrap(JavaFileObject fo) {
if (fileObjectMethod == null)
return fo;
return new UserFileObject(fileObjectMethod, fo);
}
public Iterable<JavaFileObject> wrap(Iterable<? extends JavaFileObject> list) {
List<JavaFileObject> wrapped = new ArrayList<JavaFileObject>();
for (JavaFileObject fo : list)
wrapped.add(wrap(fo));
return Collections.unmodifiableList(wrapped);
}
JavaFileObject unwrap(JavaFileObject fo) {
if (fo instanceof UserFileObject)
return ((UserFileObject) fo).unwrap();
else
return fo;
}
}
static class UserFileObject extends ForwardingJavaFileObject<JavaFileObject> {
Method method;
UserFileObject(Method m, JavaFileObject delegate) {
super(delegate);
assert isDeclaredIn(m, FileObject.class, JavaFileObject.class);
this.method = m;
}
JavaFileObject unwrap() {
return fileObject;
}
@Override
public Kind getKind() {
throwUserExceptionIfNeeded(method, "getKind");
return super.getKind();
}
@Override
public boolean isNameCompatible(String simpleName, Kind kind) {
throwUserExceptionIfNeeded(method, "isNameCompatible");
return super.isNameCompatible(simpleName, kind);
}
@Override
public NestingKind getNestingKind() {
throwUserExceptionIfNeeded(method, "getNestingKind");
return super.getNestingKind();
}
@Override
public Modifier getAccessLevel() {
throwUserExceptionIfNeeded(method, "getAccessLevel");
return super.getAccessLevel();
}
@Override
public URI toUri() {
throwUserExceptionIfNeeded(method, "toUri");
return super.toUri();
}
@Override
public String getName() {
throwUserExceptionIfNeeded(method, "getName");
return super.getName();
}
@Override
public InputStream openInputStream() throws IOException {
throwUserExceptionIfNeeded(method, "openInputStream");
return super.openInputStream();
}
@Override
public OutputStream openOutputStream() throws IOException {
throwUserExceptionIfNeeded(method, "openOutputStream");
return super.openOutputStream();
}
@Override
public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
throwUserExceptionIfNeeded(method, "openReader");
return super.openReader(ignoreEncodingErrors);
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
throwUserExceptionIfNeeded(method, "getCharContent");
return super.getCharContent(ignoreEncodingErrors);
}
@Override
public Writer openWriter() throws IOException {
throwUserExceptionIfNeeded(method, "openWriter");
return super.openWriter();
}
@Override
public long getLastModified() {
throwUserExceptionIfNeeded(method, "getLastModified");
return super.getLastModified();
}
@Override
public boolean delete() {
throwUserExceptionIfNeeded(method, "delete");
return super.delete();
}
}
static class UserProcessor extends JavacTestingAbstractProcessor {
Method method;
UserProcessor(Method m) {
assert isDeclaredIn(m, Processor.class);
method = m;
}
@Override
public Set<String> getSupportedOptions() {
throwUserExceptionIfNeeded(method, "getSupportedOptions");
return super.getSupportedOptions();
}
@Override
public Set<String> getSupportedAnnotationTypes() {
throwUserExceptionIfNeeded(method, "getSupportedAnnotationTypes");
return super.getSupportedAnnotationTypes();
}
@Override
public SourceVersion getSupportedSourceVersion() {
throwUserExceptionIfNeeded(method, "getSupportedSourceVersion");
return super.getSupportedSourceVersion();
}
@Override
public void init(ProcessingEnvironment processingEnv) {
throwUserExceptionIfNeeded(method, "init");
super.init(processingEnv);
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
throwUserExceptionIfNeeded(method, "process");
return true;
}
@Override
public Iterable<? extends Completion> getCompletions(Element element, AnnotationMirror annotation, ExecutableElement member, String userText) {
throwUserExceptionIfNeeded(method, "getCompletions");
return super.getCompletions(element, annotation, member, userText);
}
}
static class UserDiagnosticListener implements DiagnosticListener<JavaFileObject> {
Method method;
PrintWriter out;
UserDiagnosticListener(Method m, PrintWriter out) {
assert isDeclaredIn(m, DiagnosticListener.class);
this.method = m;
this.out = out;
}
@Override
public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
throwUserExceptionIfNeeded(method, "report");
out.println("report: " + diagnostic);
}
}
static class UserTaskListener implements TaskListener {
Method method;
PrintWriter out;
UserTaskListener(Method m, PrintWriter out) {
assert isDeclaredIn(m, TaskListener.class);
this.method = m;
this.out = out;
}
@Override
public void started(TaskEvent e) {
throwUserExceptionIfNeeded(method, "started");
out.println("started: " + e);
}
@Override
public void finished(TaskEvent e) {
throwUserExceptionIfNeeded(method, "finished");
out.println("finished: " + e);
}
}
// </editor-fold>
}

149
langtools/test/tools/javac/classreader/T7031108.java Normal file
View File

@ -0,0 +1,149 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7031108
* @summary NPE in javac.jvm.ClassReader.findMethod in PackageElement.enclosedElements from AP in incr build
* @library ../lib
* @build JavacTestingAbstractProcessor T7031108
* @run main T7031108
*/
import java.io.*;
import java.net.*;
import java.util.*;
import javax.annotation.processing.*;
import javax.lang.model.element.*;
import javax.tools.*;
import javax.tools.JavaCompiler.CompilationTask;
public class T7031108 extends JavacTestingAbstractProcessor {
public static void main(String... args) throws Exception {
new T7031108().run();
}
/* Class containing a local class definition;
* compiled class file will have an EnclosedMethod attribute.
*/
static final JavaSource pC =
new JavaSource("p/C.java",
"package p;\n"
+ "class C {\n"
+ " void m() {\n"
+ " new Runnable() {\n"
+ " public void run() {\n"
+ " new Runnable() {\n"
+ " public void run() { }\n"
+ " };\n"
+ " }\n"
+ " };\n"
+ " }\n"
+ "}");
/* Dummy source file to compile while running anno processor. */
static final JavaSource dummy =
new JavaSource("Dummy.java",
"class Dummy { }");
void run() throws Exception {
JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
// step 1: compile test classes
File cwd = new File(".");
fm.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(cwd));
compile(comp, fm, null, null, pC);
// step 2: verify functioning of processor
fm.setLocation(StandardLocation.ANNOTATION_PROCESSOR_PATH,
fm.getLocation(StandardLocation.CLASS_PATH));
fm.setLocation(StandardLocation.CLASS_PATH, Arrays.asList(cwd));
compile(comp, fm, null, getClass().getName(), dummy);
File pC_class = new File(new File("p"), "C.class");
pC_class.delete();
DiagnosticCollector<JavaFileObject> dc = new DiagnosticCollector<JavaFileObject>();
compile(comp, fm, dc, getClass().getName(), dummy);
List<Diagnostic<? extends JavaFileObject>> diags =dc.getDiagnostics();
System.err.println(diags);
switch (diags.size()) {
case 0:
throw new Exception("no diagnostics received");
case 1:
String code = diags.get(0).getCode();
String expect = "compiler.err.proc.cant.access.1";
if (!expect.equals(code))
throw new Exception("unexpected diag code: " + code
+ ", expected: " + expect);
break;
default:
throw new Exception("unexpected diags received");
}
}
void compile(JavaCompiler comp, JavaFileManager fm,
DiagnosticListener<JavaFileObject> dl,
String processor, JavaFileObject... files) throws Exception {
System.err.println("compile processor:" + processor + ", files:" + Arrays.asList(files));
List<String> opts = new ArrayList<String>();
if (processor != null) {
// opts.add("-verbose");
opts.addAll(Arrays.asList("-processor", processor));
}
CompilationTask task = comp.getTask(null, fm, dl, opts, null, Arrays.asList(files));
boolean ok = task.call();
if (dl == null && !ok)
throw new Exception("compilation failed");
}
static class JavaSource extends SimpleJavaFileObject {
JavaSource(String name, String text) {
super(URI.create("js://" + name), JavaFileObject.Kind.SOURCE);
this.text = text;
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return text;
}
final String text;
}
// annotation processor method
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (!roundEnv.processingOver()) {
PackageElement p = elements.getPackageElement("p");
List<? extends Element> elems = p.getEnclosedElements();
System.err.println("contents of package p: " + elems);
if (elems.size() != 1 || !elems.get(0).getSimpleName().contentEquals("C")) {
messager.printMessage(Diagnostic.Kind.ERROR, "unexpected package contents");
}
}
return true;
}
}

2
langtools/test/tools/javac/diags/examples.not-yet.txt
View File

@ -27,6 +27,7 @@ compiler.err.not.annotation.type # cannot occur given pre
compiler.err.prob.found.req.1 # Check: DEAD, in unused method
compiler.err.proc.bad.config.file # JavacProcessingEnvironment
compiler.err.proc.cant.access # completion failure
compiler.err.proc.cant.access.1 # completion failure, no stack trace
compiler.err.proc.cant.create.loader # security exception from service loader
compiler.err.proc.no.service # JavacProcessingEnvironment: no service loader available
compiler.err.proc.processor.bad.option.name # cannot happen? masked by javac.err.invalid.A.key
@ -49,6 +50,7 @@ compiler.misc.bad.class.file.header # bad class file
compiler.misc.bad.class.signature # bad class file
compiler.misc.bad.const.pool.tag # bad class file
compiler.misc.bad.const.pool.tag.at # bad class file
compiler.misc.bad.enclosing.class # bad class file
compiler.misc.bad.enclosing.method # bad class file
compiler.misc.bad.runtime.invisible.param.annotations # bad class file
compiler.misc.bad.signature # bad class file

39
langtools/test/tools/javac/diags/examples/MulticatchTypesMustBeDisjoint.java Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 2011, 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.
*/
// key: compiler.err.multicatch.types.must.be.disjoint
class MulticatchTypesMustBeDisjoint {
class E1 extends Exception { }
class E2 extends E1 { }
void e1() throws E1 { }
void e2() throws E2 { }
void m() {
try {
e1();
e2();
} catch (E1 | E2 e) { }
}
}

29
langtools/test/tools/javac/diags/examples/TryResourceThrowsInterruptedExc.java Normal file
View File

@ -0,0 +1,29 @@
/*
* Copyright (c) 2011, 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.
*/
// key: compiler.warn.try.resource.throws.interrupted.exc
// options: -Xlint:try
class TryResourceThrowsInterruptedException implements AutoCloseable {
public void close() throws InterruptedException {}
}

252
langtools/test/tools/javac/generics/diamond/7030150/GenericConstructorAndDiamondTest.java Normal file
View File

@ -0,0 +1,252 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7030150
* @summary Type inference for generic instance creation failed for formal type parameter
*/
import com.sun.source.util.JavacTask;
import java.net.URI;
import java.util.Arrays;
import javax.tools.Diagnostic;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
public class GenericConstructorAndDiamondTest {
enum BoundKind {
NO_BOUND(""),
STRING_BOUND("extends String"),
INTEGER_BOUND("extends Integer");
String boundStr;
private BoundKind(String boundStr) {
this.boundStr = boundStr;
}
boolean matches(TypeArgumentKind tak) {
switch (tak) {
case NONE: return true;
case STRING: return this != INTEGER_BOUND;
case INTEGER: return this != STRING_BOUND;
default: return false;
}
}
}
enum ConstructorKind {
NON_GENERIC("Foo(Object o) {}"),
GENERIC_NO_BOUND("<T> Foo(T t) {}"),
GENERIC_STRING_BOUND("<T extends String> Foo(T t) {}"),
GENERIC_INTEGER_BOUND("<T extends Integer> Foo(T t) {}");
String constrStr;
private ConstructorKind(String constrStr) {
this.constrStr = constrStr;
}
boolean matches(ArgumentKind ak) {
switch (ak) {
case STRING: return this != GENERIC_INTEGER_BOUND;
case INTEGER: return this != GENERIC_STRING_BOUND;
default: return false;
}
}
}
enum TypeArgArity {
ONE(1),
TWO(2),
THREE(3);
int n;
private TypeArgArity(int n) {
this.n = n;
}
}
enum TypeArgumentKind {
NONE(""),
STRING("String"),
INTEGER("Integer");
String typeargStr;
private TypeArgumentKind(String typeargStr) {
this.typeargStr = typeargStr;
}
String getArgs(TypeArgArity arity) {
if (this == NONE) return "";
else {
StringBuilder buf = new StringBuilder();
String sep = "";
for (int i = 0 ; i < arity.n ; i++) {
buf.append(sep);
buf.append(typeargStr);
sep = ",";
}
return "<" + buf.toString() + ">";
}
}
boolean matches(ArgumentKind ak) {
switch (ak) {
case STRING: return this != INTEGER;
case INTEGER: return this != STRING;
default: return false;
}
}
}
enum ArgumentKind {
STRING("\"\""),
INTEGER("1");
String argStr;
private ArgumentKind(String argStr) {
this.argStr = argStr;
}
}
public static void main(String... args) throws Exception {
//create default shared JavaCompiler - reused across multiple compilations
JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
for (BoundKind boundKind : BoundKind.values()) {
for (ConstructorKind constructorKind : ConstructorKind.values()) {
for (TypeArgumentKind declArgKind : TypeArgumentKind.values()) {
for (TypeArgArity arity : TypeArgArity.values()) {
for (TypeArgumentKind useArgKind : TypeArgumentKind.values()) {
for (ArgumentKind argKind : ArgumentKind.values()) {
new GenericConstructorAndDiamondTest(boundKind, constructorKind,
declArgKind, arity, useArgKind, argKind).run(comp, fm);
}
}
}
}
}
}
}
BoundKind boundKind;
ConstructorKind constructorKind;
TypeArgumentKind declTypeArgumentKind;
TypeArgArity useTypeArgArity;
TypeArgumentKind useTypeArgumentKind;
ArgumentKind argumentKind;
JavaSource source;
DiagnosticChecker diagChecker;
GenericConstructorAndDiamondTest(BoundKind boundKind, ConstructorKind constructorKind,
TypeArgumentKind declTypeArgumentKind, TypeArgArity useTypeArgArity,
TypeArgumentKind useTypeArgumentKind, ArgumentKind argumentKind) {
this.boundKind = boundKind;
this.constructorKind = constructorKind;
this.declTypeArgumentKind = declTypeArgumentKind;
this.useTypeArgArity = useTypeArgArity;
this.useTypeArgumentKind = useTypeArgumentKind;
this.argumentKind = argumentKind;
this.source = new JavaSource();
this.diagChecker = new DiagnosticChecker();
}
class JavaSource extends SimpleJavaFileObject {
String template = "class Foo<X #BK> {\n" +
"#CK\n" +
"}\n" +
"class Test {\n" +
"void test() {\n" +
"Foo#TA1 f = new #TA2 Foo<>(#A);\n" +
"}\n" +
"}\n";
String source;
public JavaSource() {
super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
source = template.replace("#BK", boundKind.boundStr).
replace("#CK", constructorKind.constrStr)
.replace("#TA1", declTypeArgumentKind.getArgs(TypeArgArity.ONE))
.replace("#TA2", useTypeArgumentKind.getArgs(useTypeArgArity))
.replace("#A", argumentKind.argStr);
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return source;
}
}
void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
null, null, Arrays.asList(source));
ct.analyze();
check();
}
void check() {
boolean badActual = !constructorKind.matches(argumentKind);
boolean badArity = constructorKind != ConstructorKind.NON_GENERIC &&
useTypeArgumentKind != TypeArgumentKind.NONE &&
useTypeArgArity != TypeArgArity.ONE;
boolean badMethodTypeArg = constructorKind != ConstructorKind.NON_GENERIC &&
!useTypeArgumentKind.matches(argumentKind);
boolean badGenericType = !boundKind.matches(declTypeArgumentKind);
boolean shouldFail = badActual || badArity || badMethodTypeArg || badGenericType;
if (shouldFail != diagChecker.errorFound) {
throw new Error("invalid diagnostics for source:\n" +
source.getCharContent(true) +
"\nFound error: " + diagChecker.errorFound +
"\nExpected error: " + shouldFail);
}
}
static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
boolean errorFound;
public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
errorFound = true;
}
}
}
}

17
langtools/test/tools/javac/generics/diamond/7030150/Neg01.java Normal file
View File

@ -0,0 +1,17 @@
/*
* @test /nodynamiccopyright/
* @bug 7030150
* @summary Type inference for generic instance creation failed for formal type parameter
* check that explicit type-argument that causes resolution failure is rejected
* @compile/fail/ref=Neg01.out -XDrawDiagnostics Neg01.java
*/
class Neg01 {
static class Foo<X> {
<T> Foo(T t) {}
}
Foo<Integer> fi1 = new <String> Foo<>(1);
Foo<Integer> fi2 = new <String> Foo<Integer>(1);
}

3
langtools/test/tools/javac/generics/diamond/7030150/Neg01.out Normal file
View File

@ -0,0 +1,3 @@
Neg01.java:15:24: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg01.Foo), (compiler.misc.infer.no.conforming.assignment.exists: X, int, java.lang.String)
Neg01.java:16:24: compiler.err.cant.apply.symbol.1: kindname.constructor, Foo, T, int, kindname.class, Neg01.Foo<X>, (compiler.misc.no.conforming.assignment.exists: int, java.lang.String)
2 errors

17
langtools/test/tools/javac/generics/diamond/7030150/Neg02.java Normal file
View File

@ -0,0 +1,17 @@
/*
* @test /nodynamiccopyright/
* @bug 7030150
* @summary Type inference for generic instance creation failed for formal type parameter
* check that compiler rejects bad number of explicit type-arguments
* @compile/fail/ref=Neg02.out -XDrawDiagnostics Neg02.java
*/
class Neg02 {
static class Foo<X> {
<T> Foo(T t) {}
}
Foo<Integer> fi1 = new <String, Integer> Foo<>("");
Foo<Integer> fi2 = new <String, Integer> Foo<Integer>("");
}

3
langtools/test/tools/javac/generics/diamond/7030150/Neg02.out Normal file
View File

@ -0,0 +1,3 @@
Neg02.java:15:24: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg02.Foo), (compiler.misc.arg.length.mismatch)
Neg02.java:16:24: compiler.err.cant.apply.symbol.1: kindname.constructor, Foo, T, java.lang.String, kindname.class, Neg02.Foo<X>, (compiler.misc.arg.length.mismatch)
2 errors

17
langtools/test/tools/javac/generics/diamond/7030150/Neg03.java Normal file
View File

@ -0,0 +1,17 @@
/*
* @test /nodynamiccopyright/
* @bug 7030150
* @summary Type inference for generic instance creation failed for formal type parameter
* check that explicit type-argument that does not conform to bound is rejected
* @compile/fail/ref=Neg03.out -XDrawDiagnostics Neg03.java
*/
class Neg03 {
static class Foo<X> {
<T extends Integer> Foo(T t) {}
}
Foo<Integer> fi1 = new <String> Foo<>(1);
Foo<Integer> fi2 = new <String> Foo<Integer>(1);
}

3
langtools/test/tools/javac/generics/diamond/7030150/Neg03.out Normal file
View File

@ -0,0 +1,3 @@
Neg03.java:15:24: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg03.Foo), (compiler.misc.explicit.param.do.not.conform.to.bounds: java.lang.String, java.lang.Integer)
Neg03.java:16:24: compiler.err.cant.apply.symbol.1: kindname.constructor, Foo, T, int, kindname.class, Neg03.Foo<X>, (compiler.misc.explicit.param.do.not.conform.to.bounds: java.lang.String, java.lang.Integer)
2 errors

44
langtools/test/tools/javac/generics/diamond/7030150/Pos01.java Normal file
View File

@ -0,0 +1,44 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7030150
* @summary Type inference for generic instance creation failed for formal type parameter
* check that redundant type-arguments on non-generic constructor are accepted
* @compile Pos01.java
*/
class Pos01 {
static class Foo<X> {
Foo(X t) {}
}
Foo<Integer> fi1 = new Foo<>(1);
Foo<Integer> fi2 = new Foo<Integer>(1);
Foo<Integer> fi3 = new <String> Foo<>(1);
Foo<Integer> fi4 = new <String> Foo<Integer>(1);
Foo<Integer> fi5 = new <String, String> Foo<>(1);
Foo<Integer> fi6 = new <String, String> Foo<Integer>(1);
}

40
langtools/test/tools/javac/generics/diamond/7030150/Pos02.java Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7030150
* @summary Type inference for generic instance creation failed for formal type parameter
* check that diamond in return context works w/o problems
* @compile Pos02.java
*/
class Pos02<X> {
Pos02(X x) {}
Pos02<X> test(X x) {
return new Pos02<>(x);
}
}

175
langtools/test/tools/javac/generics/diamond/7030687/ParserTest.java Normal file
View File

@ -0,0 +1,175 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7030687
* @summary Diamond: compiler accepts erroneous code where diamond is used with non-generic inner class
*/
import com.sun.source.util.JavacTask;
import java.net.URI;
import java.util.Arrays;
import javax.tools.Diagnostic;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
public class ParserTest {
enum TypeArgumentKind {
NONE(""),
EXPLICIT("<String>"),
DIAMOND("<>");
String typeargStr;
private TypeArgumentKind(String typeargStr) {
this.typeargStr = typeargStr;
}
}
enum TypeQualifierArity {
ONE(1, "A1#TA1"),
TWO(2, "A1#TA1.A2#TA2"),
THREE(3, "A1#TA1.A2#TA2.A3#TA3"),
FOUR(4, "A1#TA1.A2#TA2.A3#TA3.A4#TA4");
int n;
String qualifierStr;
private TypeQualifierArity(int n, String qualifierStr) {
this.n = n;
this.qualifierStr = qualifierStr;
}
String getType(TypeArgumentKind... typeArgumentKinds) {
String res = qualifierStr;
for (int i = 1 ; i <= typeArgumentKinds.length ; i++) {
res = res.replace("#TA" + i, typeArgumentKinds[i-1].typeargStr);
}
return res;
}
}
public static void main(String... args) throws Exception {
//create default shared JavaCompiler - reused across multiple compilations
JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
for (TypeQualifierArity arity : TypeQualifierArity.values()) {
for (TypeArgumentKind tak1 : TypeArgumentKind.values()) {
if (arity == TypeQualifierArity.ONE) {
new ParserTest(arity, tak1).run(comp, fm);
continue;
}
for (TypeArgumentKind tak2 : TypeArgumentKind.values()) {
if (arity == TypeQualifierArity.TWO) {
new ParserTest(arity, tak1, tak2).run(comp, fm);
continue;
}
for (TypeArgumentKind tak3 : TypeArgumentKind.values()) {
if (arity == TypeQualifierArity.THREE) {
new ParserTest(arity, tak1, tak2, tak3).run(comp, fm);
continue;
}
for (TypeArgumentKind tak4 : TypeArgumentKind.values()) {
new ParserTest(arity, tak1, tak2, tak3, tak4).run(comp, fm);
}
}
}
}
}
}
TypeQualifierArity qualifierArity;
TypeArgumentKind[] typeArgumentKinds;
JavaSource source;
DiagnosticChecker diagChecker;
ParserTest(TypeQualifierArity qualifierArity, TypeArgumentKind... typeArgumentKinds) {
this.qualifierArity = qualifierArity;
this.typeArgumentKinds = typeArgumentKinds;
this.source = new JavaSource();
this.diagChecker = new DiagnosticChecker();
}
class JavaSource extends SimpleJavaFileObject {
String template = "class Test {\n" +
"R res = new #T();\n" +
"}\n";
String source;
public JavaSource() {
super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
source = template.replace("#T", qualifierArity.getType(typeArgumentKinds));
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return source;
}
}
void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
null, null, Arrays.asList(source));
ct.parse();
check();
}
void check() {
boolean errorExpected = false;
for (int i = 0 ; i < qualifierArity.n - 1 ; i++) {
if (typeArgumentKinds[i] == TypeArgumentKind.DIAMOND) {
errorExpected = true;
break;
}
}
if (errorExpected != diagChecker.errorFound) {
throw new Error("invalid diagnostics for source:\n" +
source.getCharContent(true) +
"\nFound error: " + diagChecker.errorFound +
"\nExpected error: " + errorExpected);
}
}
static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
boolean errorFound;
public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
errorFound = true;
}
}
}
}

19
langtools/test/tools/javac/generics/diamond/7030687/T7030687.java Normal file
View File

@ -0,0 +1,19 @@
/*
* @test /nodynamiccopyright/
* @bug 7030687
* @summary Diamond: compiler accepts erroneous code where diamond is used with non-generic inner class
* @compile/fail/ref=T7030687.out -XDrawDiagnostics T7030687.java
*/
class T7030687<X> {
class Member { }
static class Nested {}
void test() {
class Local {}
Member m = new Member<>();
Nested n = new Nested<>();
Local l = new Local<>();
}
}

4
langtools/test/tools/javac/generics/diamond/7030687/T7030687.out Normal file
View File

@ -0,0 +1,4 @@
T7030687.java:15:30: compiler.err.cant.apply.diamond.1: T7030687<X>.Member, (compiler.misc.diamond.non.generic: T7030687<X>.Member)
T7030687.java:16:30: compiler.err.cant.apply.diamond.1: T7030687.Nested, (compiler.misc.diamond.non.generic: T7030687.Nested)
T7030687.java:17:28: compiler.err.cant.apply.diamond.1: Local, (compiler.misc.diamond.non.generic: Local)
3 errors

2
langtools/test/tools/javac/meth/InvokeMH.java
View File

@ -42,7 +42,7 @@
package meth;
import java.dyn.MethodHandle;
import java.lang.invoke.MethodHandle;
public class InvokeMH {
void test(MethodHandle mh_SiO,

2
langtools/test/tools/javac/meth/TestCP.java
View File

@ -35,7 +35,7 @@ import com.sun.tools.classfile.Code_attribute;
import com.sun.tools.classfile.ConstantPool.*;
import com.sun.tools.classfile.Method;
import java.dyn.*;
import java.lang.invoke.*;
import java.io.*;
public class TestCP {

2
langtools/test/tools/javac/meth/XlintWarn.java
View File

@ -30,7 +30,7 @@
* @compile -Werror -Xlint:cast XlintWarn.java
*/
import java.dyn.*;
import java.lang.invoke.*;
class XlintWarn {
void test(MethodHandle mh) throws Throwable {

205
langtools/test/tools/javac/multicatch/7030606/DisjunctiveTypeWellFormednessTest.java Normal file
View File

@ -0,0 +1,205 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7030606
* @summary Project-coin: multi-catch types should be pairwise disjoint
*/
import com.sun.source.util.JavacTask;
import java.net.URI;
import java.util.Arrays;
import javax.tools.Diagnostic;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
public class DisjunctiveTypeWellFormednessTest {
enum Alternative {
EXCEPTION("Exception"),
RUNTIME_EXCEPTION("RuntimeException"),
IO_EXCEPTION("java.io.IOException"),
FILE_NOT_FOUND_EXCEPTION("java.io.FileNotFoundException"),
ILLEGAL_ARGUMENT_EXCEPTION("IllegalArgumentException");
String exceptionStr;
private Alternative(String exceptionStr) {
this.exceptionStr = exceptionStr;
}
static String makeDisjunctiveType(Alternative... alternatives) {
StringBuilder buf = new StringBuilder();
String sep = "";
for (Alternative alternative : alternatives) {
buf.append(sep);
buf.append(alternative.exceptionStr);
sep = "|";
}
return buf.toString();
}
boolean disjoint(Alternative that) {
return disjoint[this.ordinal()][that.ordinal()];
}
static boolean[][] disjoint = {
// Exception RuntimeException IOException FileNotFoundException IllegalArgumentException
/*Exception*/ { false, false, false, false, false },
/*RuntimeException*/ { false, false, true, true, false },
/*IOException*/ { false, true, false, false, true },
/*FileNotFoundException*/ { false, true, false, false, true },
/*IllegalArgumentException*/ { false, false, true, true, false }
};
}
enum Arity {
ONE(1),
TWO(2),
THREE(3),
FOUR(4),
FIVE(5);
int n;
private Arity(int n) {
this.n = n;
}
}
public static void main(String... args) throws Exception {
//create default shared JavaCompiler - reused across multiple compilations
JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
for (Arity arity : Arity.values()) {
for (Alternative a1 : Alternative.values()) {
if (arity == Arity.ONE) {
new DisjunctiveTypeWellFormednessTest(a1).run(comp, fm);
continue;
}
for (Alternative a2 : Alternative.values()) {
if (arity == Arity.TWO) {
new DisjunctiveTypeWellFormednessTest(a1, a2).run(comp, fm);
continue;
}
for (Alternative a3 : Alternative.values()) {
if (arity == Arity.THREE) {
new DisjunctiveTypeWellFormednessTest(a1, a2, a3).run(comp, fm);
continue;
}
for (Alternative a4 : Alternative.values()) {
if (arity == Arity.FOUR) {
new DisjunctiveTypeWellFormednessTest(a1, a2, a3, a4).run(comp, fm);
continue;
}
for (Alternative a5 : Alternative.values()) {
new DisjunctiveTypeWellFormednessTest(a1, a2, a3, a4, a5).run(comp, fm);
}
}
}
}
}
}
}
Alternative[] alternatives;
JavaSource source;
DiagnosticChecker diagChecker;
DisjunctiveTypeWellFormednessTest(Alternative... alternatives) {
this.alternatives = alternatives;
this.source = new JavaSource();
this.diagChecker = new DiagnosticChecker();
}
class JavaSource extends SimpleJavaFileObject {
String template = "class Test {\n" +
"void test() {\n" +
"try {} catch (#T e) {}\n" +
"}\n" +
"}\n";
String source;
public JavaSource() {
super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
source = template.replace("#T", Alternative.makeDisjunctiveType(alternatives));
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return source;
}
}
void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
null, null, Arrays.asList(source));
ct.analyze();
check();
}
void check() {
int non_disjoint = 0;
int i = 0;
for (Alternative a1 : alternatives) {
int j = 0;
for (Alternative a2 : alternatives) {
if (i == j) continue;
if (!a1.disjoint(a2)) {
non_disjoint++;
break;
}
j++;
}
i++;
}
if (non_disjoint != diagChecker.errorsFound) {
throw new Error("invalid diagnostics for source:\n" +
source.getCharContent(true) +
"\nFound errors: " + diagChecker.errorsFound +
"\nExpected errors: " + non_disjoint);
}
}
static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
int errorsFound;
public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
if (diagnostic.getKind() == Diagnostic.Kind.ERROR &&
diagnostic.getCode().startsWith("compiler.err.multicatch.types.must.be.disjoint")) {
errorsFound++;
}
}
}
}

57
langtools/test/tools/javac/multicatch/7030606/T7030606.java Normal file
View File

@ -0,0 +1,57 @@
/*
* @test /nodynamiccopyright/
* @bug 7030606
*
* @summary Project-coin: multi-catch types should be pairwise disjoint
* @compile/fail/ref=T7030606.out -XDrawDiagnostics T7030606.java
*/
class T7030606 {
class E1 extends Exception { }
class E2 extends E1 { }
void e1() throws E1 { }
void e2() throws E2 { }
void m1() {
try {
e1();
e2();
} catch (NonExistentType | E2 | E1 e) { }
}
void m2() {
try {
e1();
e2();
} catch (NonExistentType | E1 | E2 e) { }
}
void m3() {
try {
e1();
e2();
} catch (E2 | NonExistentType | E1 e) { }
}
void m4() {
try {
e1();
e2();
} catch (E1 | NonExistentType | E2 e) { }
}
void m5() {
try {
e1();
e2();
} catch (E2 | E1 | NonExistentType e) { }
}
void m6() {
try {
e1();
e2();
} catch (E1 | E2 | NonExistentType e) { }
}
}

13
langtools/test/tools/javac/multicatch/7030606/T7030606.out Normal file
View File

@ -0,0 +1,13 @@
T7030606.java:20:18: compiler.err.cant.resolve.location: kindname.class, NonExistentType, , , (compiler.misc.location: kindname.class, T7030606, null)
T7030606.java:20:41: compiler.err.multicatch.types.must.be.disjoint: T7030606.E2, T7030606.E1
T7030606.java:27:18: compiler.err.cant.resolve.location: kindname.class, NonExistentType, , , (compiler.misc.location: kindname.class, T7030606, null)
T7030606.java:27:41: compiler.err.multicatch.types.must.be.disjoint: T7030606.E2, T7030606.E1
T7030606.java:34:23: compiler.err.cant.resolve.location: kindname.class, NonExistentType, , , (compiler.misc.location: kindname.class, T7030606, null)
T7030606.java:34:41: compiler.err.multicatch.types.must.be.disjoint: T7030606.E2, T7030606.E1
T7030606.java:41:23: compiler.err.cant.resolve.location: kindname.class, NonExistentType, , , (compiler.misc.location: kindname.class, T7030606, null)
T7030606.java:41:41: compiler.err.multicatch.types.must.be.disjoint: T7030606.E2, T7030606.E1
T7030606.java:48:23: compiler.err.multicatch.types.must.be.disjoint: T7030606.E2, T7030606.E1
T7030606.java:48:28: compiler.err.cant.resolve.location: kindname.class, NonExistentType, , , (compiler.misc.location: kindname.class, T7030606, null)
T7030606.java:55:23: compiler.err.multicatch.types.must.be.disjoint: T7030606.E2, T7030606.E1
T7030606.java:55:28: compiler.err.cant.resolve.location: kindname.class, NonExistentType, , , (compiler.misc.location: kindname.class, T7030606, null)
12 errors

105
langtools/test/tools/javac/util/T6597678.java Normal file
View File

@ -0,0 +1,105 @@
/*
* Copyright (c) 2011, 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.
*/
/**
* @test
* @bug 6597678
* @summary Ensure Messages propogated between rounds
* @library ../lib
* @build JavacTestingAbstractProcessor T6597678
* @run main T6597678
*/
import java.io.*;
import java.util.*;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedOptions;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.JavacMessages;
public class T6597678 extends JavacTestingAbstractProcessor {
public static void main(String... args) throws Exception {
new T6597678().run();
}
void run() throws Exception {
String myName = T6597678.class.getSimpleName();
File testSrc = new File(System.getProperty("test.src"));
File file = new File(testSrc, myName + ".java");
compile(
"-proc:only",
"-processor", myName,
file.getPath());
}
void compile(String... args) throws Exception {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
int rc = com.sun.tools.javac.Main.compile(args, pw);
pw.close();
String out = sw.toString();
if (!out.isEmpty())
System.err.println(out);
if (rc != 0)
throw new Exception("compilation failed unexpectedly: rc=" + rc);
}
//---------------
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
Locale locale = context.get(Locale.class);
JavacMessages messages = context.get(JavacMessages.messagesKey);
round++;
if (round == 1) {
initialLocale = locale;
initialMessages = messages;
} else {
checkEqual("locale", locale, initialLocale);
checkEqual("messages", messages, initialMessages);
}
return true;
}
<T> void checkEqual(String label, T actual, T expected) {
if (actual != expected)
messager.printMessage(Diagnostic.Kind.ERROR,
"Unexpected value for " + label
+ "; expected: " + expected
+ "; found: " + actual);
}
int round = 0;
Locale initialLocale;
JavacMessages initialMessages;
}

6
langtools/test/tools/javap/6937244/T6937244A.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2010, 2011, 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
@ -49,8 +49,8 @@ public class T6937244A {
int count = 0;
for (String line: out.split("[\r\n]+")) {
if (line.contains("extends")) {
verify(line, "extends java.lang.Object implements java.util.List<java.lang.String>");
if (line.contains("implements")) {
verify(line, "implements java.util.List<java.lang.String>");
count++;
}

6
langtools/test/tools/javap/T4880663.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2008, 2011, 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 4880663 6715757
* @bug 4880663 6715757 7031005
* @summary javap could output whitespace between class name and opening brace
* javap prints "extends java.lang.Object"
*/
@ -39,7 +39,7 @@ public class T4880663 {
public void run() throws IOException {
File javaFile = writeTestFile();
File classFile = compileTestFile(javaFile);
verify(classFile, "class Test extends java.lang.Object {");
verify(classFile, "class Test {");
if (errors > 0)
throw new Error(errors + " found.");

6
langtools/test/tools/javap/T4880672.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2009, 2011, 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
@ -24,7 +24,7 @@
/*
* @test
* @bug 4880672
* @bug 4880672 7031005
* @summary javap does not output inner interfaces of an interface
*/
@ -39,7 +39,7 @@ public class T4880672
void run() {
verify("java.util.Map", "public interface java.util.Map$Entry");
verify("T4880672", "class T4880672$A$B extends java.lang.Object");
verify("T4880672", "class T4880672$A$B");
verify("C", ""); // must not give error if no InnerClasses attribute
if (errors > 0)
throw new Error(errors + " found.");

178
langtools/test/tools/javap/TestSuperclass.java Normal file
View File

@ -0,0 +1,178 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 7031005
* @summary javap prints "extends java.lang.Object"
*/
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.URI;
import java.util.Arrays;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;
import javax.tools.ToolProvider;
public class TestSuperclass {
enum ClassKind {
CLASS("class"),
INTERFACE("interface");
ClassKind(String keyword) {
this.keyword = keyword;
}
final String keyword;
}
enum GenericKind {
NO(""),
YES("<T>");
GenericKind(String typarams) {
this.typarams = typarams;
}
final String typarams;
}
enum SuperKind {
NONE(null),
SUPER("Super");
SuperKind(String name) {
this.name = name;
}
String extend() {
return (name == null) ? "" : "extends " + name;
}
String decl(ClassKind ck) {
return (name == null) ? "" : ck.keyword + " " + name + " { }";
}
final String name;
}
public static void main(String... args) throws Exception {
JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
int errors = 0;
for (ClassKind ck: ClassKind.values()) {
for (GenericKind gk: GenericKind.values()) {
for (SuperKind sk: SuperKind.values()) {
errors += new TestSuperclass(ck, gk, sk).run(comp, fm);
}
}
}
if (errors > 0)
throw new Exception(errors + " errors found");
}
final ClassKind ck;
final GenericKind gk;
final SuperKind sk;
TestSuperclass(ClassKind ck, GenericKind gk, SuperKind sk) {
this.ck = ck;
this.gk = gk;
this.sk = sk;
}
int run(JavaCompiler comp, StandardJavaFileManager fm) throws IOException {
System.err.println("test: ck:" + ck + " gk:" + gk + " sk:" + sk);
File testDir = new File(ck + "-" + gk + "-" + sk);
testDir.mkdirs();
fm.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(testDir));
JavaSource js = new JavaSource();
System.err.println(js.getCharContent(false));
CompilationTask t = comp.getTask(null, fm, null, null, null, Arrays.asList(js));
if (!t.call())
throw new Error("compilation failed");
File testClass = new File(testDir, "Test.class");
String out = javap(testClass);
// Extract class sig from first line of Java source
String expect = js.source.replaceAll("(?s)^(.* Test[^{]+?) *\\{.*", "$1");
// Extract class sig from line from javap output
String found = out.replaceAll("(?s).*\n(.* Test[^{]+?) *\\{.*", "$1");
checkEqual("class signature", expect, found);
return errors;
}
String javap(File file) {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
String[] args = { file.getPath() };
int rc = com.sun.tools.javap.Main.run(args, pw);
pw.close();
String out = sw.toString();
if (!out.isEmpty())
System.err.println(out);
if (rc != 0)
throw new Error("javap failed: rc=" + rc);
return out;
}
void checkEqual(String label, String expect, String found) {
if (!expect.equals(found))
error("Unexpected " + label + " found: '" + found + "', expected: '" + expect + "'");
}
void error(String msg) {
System.err.println("Error: " + msg);
errors++;
}
int errors;
class JavaSource extends SimpleJavaFileObject {
static final String template =
"#CK Test#GK #EK { }\n"
+ "#SK\n";
final String source;
public JavaSource() {
super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
source = template
.replace("#CK", ck.keyword)
.replace("#GK", gk.typarams)
.replace("#EK", sk.extend())
.replace("#SK", sk.decl(ck));
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return source;
}
}
}