# HG changeset patch # User lana # Date 1328639966 28800 # Node ID 5f9506e97a4533799e53f666b7367c8da1b88f07 # Parent 921a6b64cea249bae538cc086d45469991162569# Parent 3a9d57fab406086e1915043c000aa71251667900 Merge diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/src/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java --- a/langtools/src/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java Thu Feb 02 09:39:44 2012 -0800 +++ b/langtools/src/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java Tue Feb 07 10:39:26 2012 -0800 @@ -70,6 +70,7 @@ private JavaCompiler compiler; private Locale locale; private String[] args; + private String[] classNames; private Context context; private List fileObjects; private Map notYetEntered; @@ -82,11 +83,13 @@ JavacTaskImpl(Main compilerMain, String[] args, + String[] classNames, Context context, List fileObjects) { this.ccw = ClientCodeWrapper.instance(context); this.compilerMain = compilerMain; this.args = args; + this.classNames = classNames; this.context = context; this.fileObjects = fileObjects; setLocale(Locale.getDefault()); @@ -101,17 +104,14 @@ Context context, Iterable classes, Iterable fileObjects) { - this(compilerMain, toArray(flags, classes), context, toList(fileObjects)); + this(compilerMain, toArray(flags), toArray(classes), context, toList(fileObjects)); } - static private String[] toArray(Iterable flags, Iterable classes) { + static private String[] toArray(Iterable iter) { ListBuffer result = new ListBuffer(); - if (flags != null) - for (String flag : flags) - result.append(flag); - if (classes != null) - for (String cls : classes) - result.append(cls); + if (iter != null) + for (String s : iter) + result.append(s); return result.toArray(new String[result.length()]); } @@ -129,7 +129,7 @@ initContext(); notYetEntered = new HashMap(); compilerMain.setAPIMode(true); - result = compilerMain.compile(args, context, fileObjects, processors); + result = compilerMain.compile(args, classNames, context, fileObjects, processors); cleanup(); return result.isOK(); } else { @@ -159,7 +159,7 @@ initContext(); compilerMain.setOptions(Options.instance(context)); compilerMain.filenames = new LinkedHashSet(); - Collection filenames = compilerMain.processArgs(CommandLine.parse(args)); + Collection filenames = compilerMain.processArgs(CommandLine.parse(args), classNames); if (!filenames.isEmpty()) throw new IllegalArgumentException("Malformed arguments " + toString(filenames, " ")); compiler = JavaCompiler.instance(context); @@ -174,6 +174,7 @@ // endContext will be called when all classes have been generated // TODO: should handle the case after each phase if errors have occurred args = null; + classNames = null; } } @@ -204,6 +205,7 @@ compiler = null; compilerMain = null; args = null; + classNames = null; context = null; fileObjects = null; notYetEntered = null; diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java Thu Feb 02 09:39:44 2012 -0800 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java Tue Feb 07 10:39:26 2012 -0800 @@ -34,6 +34,7 @@ import com.sun.tools.javac.code.Type.*; import com.sun.tools.javac.code.Type.ForAll.ConstraintKind; import com.sun.tools.javac.code.Symbol.*; +import com.sun.tools.javac.comp.Resolve.InapplicableMethodException; import com.sun.tools.javac.comp.Resolve.VerboseResolutionMode; import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition; @@ -84,7 +85,7 @@ } - public static class InferenceException extends Resolve.InapplicableMethodException { + public static class InferenceException extends InapplicableMethodException { private static final long serialVersionUID = 0; InferenceException(JCDiagnostic.Factory diags) { @@ -287,6 +288,18 @@ } } + Type asUndetType(Type t, List undetvars) { + return types.subst(t, inferenceVars(undetvars), undetvars); + } + + List inferenceVars(List undetvars) { + ListBuffer tvars = ListBuffer.lb(); + for (Type uv : undetvars) { + tvars.append(((UndetVar)uv).qtype); + } + return tvars.toList(); + } + /*************************************************************************** * Exported Methods ***************************************************************************/ @@ -372,62 +385,11 @@ final Warner warn) throws InferenceException { //-System.err.println("instantiateMethod(" + tvars + ", " + mt + ", " + argtypes + ")"); //DEBUG List undetvars = Type.map(tvars, fromTypeVarFun); - List formals = mt.argtypes; - //need to capture exactly once - otherwise subsequent - //applicability checks might fail - final List capturedArgs = types.capture(argtypes); - List actuals = capturedArgs; - List actualsNoCapture = argtypes; - // instantiate all polymorphic argument types and - // set up lower bounds constraints for undetvars - Type varargsFormal = useVarargs ? formals.last() : null; - if (varargsFormal == null && - actuals.size() != formals.size()) { - throw unambiguousNoInstanceException - .setMessage("infer.arg.length.mismatch"); - } - while (actuals.nonEmpty() && formals.head != varargsFormal) { - Type formal = formals.head; - Type actual = actuals.head.baseType(); - Type actualNoCapture = actualsNoCapture.head.baseType(); - if (actual.tag == FORALL) - actual = instantiateArg((ForAll)actual, formal, tvars, warn); - Type undetFormal = types.subst(formal, tvars, undetvars); - boolean works = allowBoxing - ? types.isConvertible(actual, undetFormal, warn) - : types.isSubtypeUnchecked(actual, undetFormal, warn); - if (!works) { - throw unambiguousNoInstanceException - .setMessage("infer.no.conforming.assignment.exists", - tvars, actualNoCapture, formal); - } - formals = formals.tail; - actuals = actuals.tail; - actualsNoCapture = actualsNoCapture.tail; - } + //final List capturedArgs = types.capture(argtypes); - if (formals.head != varargsFormal) // not enough args - throw unambiguousNoInstanceException.setMessage("infer.arg.length.mismatch"); - - // for varargs arguments as well - if (useVarargs) { - Type elemType = types.elemtype(varargsFormal); - Type elemUndet = types.subst(elemType, tvars, undetvars); - while (actuals.nonEmpty()) { - Type actual = actuals.head.baseType(); - Type actualNoCapture = actualsNoCapture.head.baseType(); - if (actual.tag == FORALL) - actual = instantiateArg((ForAll)actual, elemType, tvars, warn); - boolean works = types.isConvertible(actual, elemUndet, warn); - if (!works) { - throw unambiguousNoInstanceException - .setMessage("infer.no.conforming.assignment.exists", - tvars, actualNoCapture, elemType); - } - actuals = actuals.tail; - actualsNoCapture = actualsNoCapture.tail; - } - } + final List capturedArgs = + rs.checkRawArgumentsAcceptable(env, undetvars, argtypes, mt.getParameterTypes(), + allowBoxing, useVarargs, warn, new InferenceCheckHandler(undetvars)); // minimize as yet undetermined type variables for (Type t : undetvars) @@ -503,6 +465,31 @@ } //where + /** inference check handler **/ + class InferenceCheckHandler implements Resolve.MethodCheckHandler { + + List undetvars; + + public InferenceCheckHandler(List undetvars) { + this.undetvars = undetvars; + } + + public InapplicableMethodException arityMismatch() { + return unambiguousNoInstanceException.setMessage("infer.arg.length.mismatch"); + } + public InapplicableMethodException argumentMismatch(boolean varargs, Type found, Type expected) { + String key = varargs ? + "infer.varargs.argument.mismatch" : + "infer.no.conforming.assignment.exists"; + return unambiguousNoInstanceException.setMessage(key, + inferenceVars(undetvars), found, expected); + } + public InapplicableMethodException inaccessibleVarargs(Symbol location, Type expected) { + return unambiguousNoInstanceException.setMessage("inaccessible.varargs.type", + expected, Kinds.kindName(location), location); + } + } + /** * A delegated type representing a partially uninferred method type. * The return type of a partially uninferred method type is a ForAll @@ -572,7 +559,7 @@ rs.checkRawArgumentsAcceptable(env, actuals, formals, allowBoxing, useVarargs, warn); } - catch (Resolve.InapplicableMethodException ex) { + catch (InapplicableMethodException ex) { // inferred method is not applicable throw invalidInstanceException.setMessage(ex.getDiagnostic()); } diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java Thu Feb 02 09:39:44 2012 -0800 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java Tue Feb 07 10:39:26 2012 -0800 @@ -44,6 +44,7 @@ import static com.sun.tools.javac.code.Kinds.*; import static com.sun.tools.javac.code.TypeTags.*; import static com.sun.tools.javac.tree.JCTree.Tag.*; +import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag; import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition; /** This is the second phase of Enter, in which classes are completed @@ -142,7 +143,7 @@ JCDiagnostic msg = diags.fragment("fatal.err.no.java.lang"); throw new FatalError(msg); } else { - log.error(pos, "doesnt.exist", tsym); + log.error(DiagnosticFlag.RESOLVE_ERROR, pos, "doesnt.exist", tsym); } } env.toplevel.starImportScope.importAll(tsym.members()); diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java Thu Feb 02 09:39:44 2012 -0800 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java Tue Feb 07 10:39:26 2012 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2012, 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 @@ -474,52 +474,126 @@ return false; } } + /** + * A check handler is used by the main method applicability routine in order + * to handle specific method applicability failures. It is assumed that a class + * implementing this interface should throw exceptions that are a subtype of + * InapplicableMethodException (see below). Such exception will terminate the + * method applicability check and propagate important info outwards (for the + * purpose of generating better diagnostics). + */ + interface MethodCheckHandler { + /* The number of actuals and formals differ */ + InapplicableMethodException arityMismatch(); + /* An actual argument type does not conform to the corresponding formal type */ + InapplicableMethodException argumentMismatch(boolean varargs, Type found, Type expected); + /* The element type of a varargs is not accessible in the current context */ + InapplicableMethodException inaccessibleVarargs(Symbol location, Type expected); + } + + /** + * Basic method check handler used within Resolve - all methods end up + * throwing InapplicableMethodException; a diagnostic fragment that describes + * the cause as to why the method is not applicable is set on the exception + * before it is thrown. + */ + MethodCheckHandler resolveHandler = new MethodCheckHandler() { + public InapplicableMethodException arityMismatch() { + return inapplicableMethodException.setMessage("arg.length.mismatch"); + } + public InapplicableMethodException argumentMismatch(boolean varargs, Type found, Type expected) { + String key = varargs ? + "varargs.argument.mismatch" : + "no.conforming.assignment.exists"; + return inapplicableMethodException.setMessage(key, + found, expected); + } + public InapplicableMethodException inaccessibleVarargs(Symbol location, Type expected) { + return inapplicableMethodException.setMessage("inaccessible.varargs.type", + expected, Kinds.kindName(location), location); + } + }; + void checkRawArgumentsAcceptable(Env env, List argtypes, List formals, boolean allowBoxing, boolean useVarargs, Warner warn) { + checkRawArgumentsAcceptable(env, List.nil(), argtypes, formals, + allowBoxing, useVarargs, warn, resolveHandler); + } + + /** + * Main method applicability routine. Given a list of actual types A, + * a list of formal types F, determines whether the types in A are + * compatible (by method invocation conversion) with the types in F. + * + * Since this routine is shared between overload resolution and method + * type-inference, it is crucial that actual types are converted to the + * corresponding 'undet' form (i.e. where inference variables are replaced + * with undetvars) so that constraints can be propagated and collected. + * + * Moreover, if one or more types in A is a poly type, this routine calls + * Infer.instantiateArg in order to complete the poly type (this might involve + * deferred attribution). + * + * A method check handler (see above) is used in order to report errors. + */ + List checkRawArgumentsAcceptable(Env env, + List undetvars, + List argtypes, + List formals, + boolean allowBoxing, + boolean useVarargs, + Warner warn, + MethodCheckHandler handler) { Type varargsFormal = useVarargs ? formals.last() : null; + ListBuffer checkedArgs = ListBuffer.lb(); + if (varargsFormal == null && argtypes.size() != formals.size()) { - throw inapplicableMethodException.setMessage("arg.length.mismatch"); // not enough args + throw handler.arityMismatch(); // not enough args } while (argtypes.nonEmpty() && formals.head != varargsFormal) { - boolean works = allowBoxing - ? types.isConvertible(argtypes.head, formals.head, warn) - : types.isSubtypeUnchecked(argtypes.head, formals.head, warn); - if (!works) - throw inapplicableMethodException.setMessage("no.conforming.assignment.exists", - argtypes.head, - formals.head); + Type undetFormal = infer.asUndetType(formals.head, undetvars); + Type capturedActual = types.capture(argtypes.head); + boolean works = allowBoxing ? + types.isConvertible(capturedActual, undetFormal, warn) : + types.isSubtypeUnchecked(capturedActual, undetFormal, warn); + if (!works) { + throw handler.argumentMismatch(false, argtypes.head, formals.head); + } + checkedArgs.append(capturedActual); argtypes = argtypes.tail; formals = formals.tail; } - if (formals.head != varargsFormal) - throw inapplicableMethodException.setMessage("arg.length.mismatch"); // not enough args + if (formals.head != varargsFormal) { + throw handler.arityMismatch(); // not enough args + } if (useVarargs) { + //note: if applicability check is triggered by most specific test, + //the last argument of a varargs is _not_ an array type (see JLS 15.12.2.5) Type elt = types.elemtype(varargsFormal); + Type eltUndet = infer.asUndetType(elt, undetvars); while (argtypes.nonEmpty()) { - if (!types.isConvertible(argtypes.head, elt, warn)) - throw inapplicableMethodException.setMessage("varargs.argument.mismatch", - argtypes.head, - elt); + Type capturedActual = types.capture(argtypes.head); + if (!types.isConvertible(capturedActual, eltUndet, warn)) { + throw handler.argumentMismatch(true, argtypes.head, elt); + } + checkedArgs.append(capturedActual); argtypes = argtypes.tail; } //check varargs element type accessibility - if (!isAccessible(env, elt)) { + if (undetvars.isEmpty() && !isAccessible(env, elt)) { Symbol location = env.enclClass.sym; - throw inapplicableMethodException.setMessage("inaccessible.varargs.type", - elt, - Kinds.kindName(location), - location); + throw handler.inaccessibleVarargs(location, elt); } } - return; + return checkedArgs.toList(); } // where public static class InapplicableMethodException extends RuntimeException { diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/src/share/classes/com/sun/tools/javac/main/Main.java --- a/langtools/src/share/classes/com/sun/tools/javac/main/Main.java Thu Feb 02 09:39:44 2012 -0800 +++ b/langtools/src/share/classes/com/sun/tools/javac/main/Main.java Tue Feb 07 10:39:26 2012 -0800 @@ -31,6 +31,7 @@ import java.net.URL; import java.security.DigestInputStream; import java.security.MessageDigest; +import java.util.Arrays; import java.util.Collection; import java.util.LinkedHashSet; import java.util.Set; @@ -208,6 +209,10 @@ * @param flags The array of command line arguments. */ public Collection processArgs(String[] flags) { // XXX sb protected + return processArgs(flags, null); + } + + public Collection processArgs(String[] flags, String[] classNames) { // XXX sb protected int ac = 0; while (ac < flags.length) { String flag = flags[ac]; @@ -248,6 +253,10 @@ } } + if (this.classnames != null && classNames != null) { + this.classnames.addAll(Arrays.asList(classNames)); + } + if (!checkDirectory(D)) return null; if (!checkDirectory(S)) @@ -346,6 +355,15 @@ List fileObjects, Iterable processors) { + return compile(args, null, context, fileObjects, processors); + } + + public Result compile(String[] args, + String[] classNames, + Context context, + List fileObjects, + Iterable processors) + { context.put(Log.outKey, out); log = Log.instance(context); @@ -361,14 +379,16 @@ * into account. */ try { - if (args.length == 0 && fileObjects.isEmpty()) { + if (args.length == 0 + && (classNames == null || classNames.length == 0) + && fileObjects.isEmpty()) { Option.HELP.process(optionHelper, "-help"); return Result.CMDERR; } Collection files; try { - files = processArgs(CommandLine.parse(args)); + files = processArgs(CommandLine.parse(args), classNames); if (files == null) { // null signals an error in options, abort return Result.CMDERR; diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties --- a/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties Thu Feb 02 09:39:44 2012 -0800 +++ b/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties Tue Feb 07 10:39:26 2012 -0800 @@ -1,5 +1,5 @@ # -# Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1999, 2012, 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 @@ -1620,6 +1620,10 @@ compiler.misc.infer.arg.length.mismatch=\ cannot instantiate from arguments because actual and formal argument lists differ in length +# 0: list of type, 1: type, 2: type +compiler.misc.infer.varargs.argument.mismatch=\ + no instance(s) of type variable(s) {0} exist so that argument type {1} conforms to vararg element type {2} + # 0: type, 1: list of type compiler.misc.inferred.do.not.conform.to.bounds=\ inferred type does not conform to declared bound(s)\n\ diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/test/tools/javac/7129225/Anno.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/7129225/Anno.java Tue Feb 07 10:39:26 2012 -0800 @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2012, 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. + */ + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +@Target(ElementType.TYPE) +public @interface Anno { +} diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/test/tools/javac/7129225/AnnoProcessor.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/7129225/AnnoProcessor.java Tue Feb 07 10:39:26 2012 -0800 @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2012, 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. + */ + +import java.util.Set; +import javax.annotation.processing.*; +import javax.lang.model.SourceVersion; +import javax.lang.model.element.TypeElement; +import javax.tools.Diagnostic.Kind; + +@SupportedAnnotationTypes("Anno") +public class AnnoProcessor extends JavacTestingAbstractProcessor { + @Override + public SourceVersion getSupportedSourceVersion() { + return SourceVersion.latest(); + } + + @Override + public boolean process(Set set, RoundEnvironment re) { + messager.printMessage(Kind.NOTE, "RUNNING - lastRound = " + re.processingOver()); + return true; + } +} + diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/test/tools/javac/7129225/NegTest.ref --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/7129225/NegTest.ref Tue Feb 07 10:39:26 2012 -0800 @@ -0,0 +1,2 @@ +TestImportStar.java:39:1: compiler.err.doesnt.exist: xxx +1 error diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/test/tools/javac/7129225/TestImportStar.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/7129225/TestImportStar.java Tue Feb 07 10:39:26 2012 -0800 @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2012, 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. + */ + +/* @test + * @bug 7129225 + * @summary import xxx.* isn't handled correctly by annotation processing + * @library ../lib + * @build JavacTestingAbstractProcessor + * @compile/fail/ref=NegTest.ref -XDrawDiagnostics TestImportStar.java + * @compile Anno.java AnnoProcessor.java + * @compile/ref=TestImportStar.ref -XDrawDiagnostics -processor AnnoProcessor -proc:only TestImportStar.java + */ + + //The @compile/fail... verifies that the fix doesn't break the normal compilation of import xxx.* + //The @comple/ref... verifies the fix fixes the bug + +import xxx.*; + +@Anno +public class TestImportStar { +} diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/test/tools/javac/7129225/TestImportStar.ref --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/7129225/TestImportStar.ref Tue Feb 07 10:39:26 2012 -0800 @@ -0,0 +1,3 @@ +- compiler.note.proc.messager: RUNNING - lastRound = false +TestImportStar.java:39:1: compiler.err.doesnt.exist: xxx +- compiler.note.proc.messager: RUNNING - lastRound = true diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/test/tools/javac/diags/examples/InferVarargsArgumentMismatch.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/diags/examples/InferVarargsArgumentMismatch.java Tue Feb 07 10:39:26 2012 -0800 @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2012, 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.cant.apply.symbol.1 +// key: compiler.misc.infer.varargs.argument.mismatch + +class InferVarargsArgumentMismatch { + void m(X x1, String... xs) {} + { this.m("", 1); } +} diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/test/tools/javah/T7126832/T7126832.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javah/T7126832/T7126832.java Tue Feb 07 10:39:26 2012 -0800 @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2012, 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 7126832 + * @compile java.java + * @summary com.sun.tools.javac.api.ClientCodeWrapper$WrappedJavaFileManager cannot be cast + * @run main T7126832 + */ + +import java.io.*; +import java.util.*; + +public class T7126832 { + public static void main(String... args) throws Exception { + new T7126832().run(); + } + + void run() throws Exception { + Locale prev = Locale.getDefault(); + Locale.setDefault(Locale.ENGLISH); + try { + // Verify that a .java file is correctly diagnosed + File ff = writeFile(new File("JavahTest.java"), "class JavahTest {}"); + test(Arrays.asList(ff.getPath()), 1, "Could not find class file for 'JavahTest.java'."); + + // Verify that a class named 'xx.java' is accepted. + // Note that ./xx/java.class exists, so this should work ok + test(Arrays.asList("xx.java"), 0, null); + + if (errors > 0) { + throw new Exception(errors + " errors occurred"); + } + } finally { + Locale.setDefault(prev); + } + } + + void test(List args, int expectRC, String expectOut) { + System.err.println("Test: " + args + + " rc:" + expectRC + + ((expectOut != null) ? " out:" + expectOut : "")); + + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + int rc = 0; + String out = null; + try { + rc = com.sun.tools.javah.Main.run(args.toArray(new String[args.size()]), pw); + out = sw.toString(); + } catch(Exception ee) { + rc = 1; + out = ee.toString();; + } + pw.close(); + if (!out.isEmpty()) { + System.err.println(out); + } + if (rc != expectRC) { + error("Unexpected exit code: " + rc + "; expected: " + expectRC); + } + if (expectOut != null && !out.contains(expectOut)) { + error("Expected string not found: " + expectOut); + } + + System.err.println(); + } + + File writeFile(File ff, String ss) throws IOException { + if (ff.getParentFile() != null) + ff.getParentFile().mkdirs(); + + try (FileWriter out = new FileWriter(ff)) { + out.write(ss); + } + return ff; + } + + void error(String msg) { + System.err.println(msg); + errors++; + } + + int errors; +} + diff -r 921a6b64cea2 -r 5f9506e97a45 langtools/test/tools/javah/T7126832/java.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javah/T7126832/java.java Tue Feb 07 10:39:26 2012 -0800 @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2012, 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 xx; +class java { + int fred; +}