# HG changeset patch # User lana # Date 1273620973 25200 # Node ID d9799ef9198d604561dac31817d888e1a076130c # Parent b5dab6a313fdff4c043250e4d9c8f66fd624d27e# Parent 515e4b33b335d4a4f416252e36975b639fa1ebfd Merge diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/bin/launcher.sh-template --- a/langtools/src/share/bin/launcher.sh-template Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/bin/launcher.sh-template Tue May 11 16:36:13 2010 -0700 @@ -66,4 +66,5 @@ done unset DUALCASE -eval "#TARGET_JAVA#" "${bcp:+-Xbootclasspath/p:"$bcp"}" ${ea} ${javaOpts} -jar "${mydir}"/../lib/#PROGRAM#.jar ${toolOpts} +IFS=$nl +"#TARGET_JAVA#" "${bcp:+-Xbootclasspath/p:"$bcp"}" ${ea} ${javaOpts} -jar "${mydir}"/../lib/#PROGRAM#.jar ${toolOpts} diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/source/tree/DisjointTypeTree.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/src/share/classes/com/sun/source/tree/DisjointTypeTree.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,40 @@ +/* + * Copyright 2010 Sun Microsystems, Inc. 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. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +package com.sun.source.tree; + +import java.util.List; + +/** + * A tree node for a disjoint type expression in a multicatch var declaration. + * + * + * @author Maurizio Cimadamore + * + * @since 1.7 + */ +public interface DisjointTypeTree extends Tree { + List getTypeComponents(); +} \ No newline at end of file diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/source/tree/Tree.java --- a/langtools/src/share/classes/com/sun/source/tree/Tree.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/source/tree/Tree.java Tue May 11 16:36:13 2010 -0700 @@ -234,6 +234,11 @@ PARAMETERIZED_TYPE(ParameterizedTypeTree.class), /** + * Used for instances of {@link DisjointTypeTree}. + */ + DISJOINT_TYPE(DisjointTypeTree.class), + + /** * Used for instances of {@link TypeCastTree}. */ TYPE_CAST(TypeCastTree.class), diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/source/tree/TreeVisitor.java --- a/langtools/src/share/classes/com/sun/source/tree/TreeVisitor.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/source/tree/TreeVisitor.java Tue May 11 16:36:13 2010 -0700 @@ -96,6 +96,7 @@ R visitCompilationUnit(CompilationUnitTree node, P p); R visitTry(TryTree node, P p); R visitParameterizedType(ParameterizedTypeTree node, P p); + R visitDisjointType(DisjointTypeTree node, P p); R visitArrayType(ArrayTypeTree node, P p); R visitTypeCast(TypeCastTree node, P p); R visitPrimitiveType(PrimitiveTypeTree node, P p); diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/source/util/SimpleTreeVisitor.java --- a/langtools/src/share/classes/com/sun/source/util/SimpleTreeVisitor.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/source/util/SimpleTreeVisitor.java Tue May 11 16:36:13 2010 -0700 @@ -228,6 +228,10 @@ return defaultAction(node, p); } + public R visitDisjointType(DisjointTypeTree node, P p) { + return defaultAction(node, p); + } + public R visitTypeParameter(TypeParameterTree node, P p) { return defaultAction(node, p); } diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/source/util/TreeScanner.java --- a/langtools/src/share/classes/com/sun/source/util/TreeScanner.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/source/util/TreeScanner.java Tue May 11 16:36:13 2010 -0700 @@ -354,6 +354,10 @@ return r; } + public R visitDisjointType(DisjointTypeTree node, P p) { + return scan(node.getTypeComponents(), p); + } + public R visitTypeParameter(TypeParameterTree node, P p) { R r = scan(node.getAnnotations(), p); r = scanAndReduce(node.getBounds(), p, r); diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/code/Flags.java --- a/langtools/src/share/classes/com/sun/tools/javac/code/Flags.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Flags.java Tue May 11 16:36:13 2010 -0700 @@ -230,6 +230,11 @@ */ public static final long PROPRIETARY = 1L<<38; + /** + * Flag that marks a disjoint var in a multi-catch clause + */ + public static final long DISJOINT = 1L<<39; + /** Modifier masks. */ public static final int diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/code/Source.java --- a/langtools/src/share/classes/com/sun/tools/javac/code/Source.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Source.java Tue May 11 16:36:13 2010 -0700 @@ -125,6 +125,9 @@ public boolean allowDiamond() { return compareTo(JDK1_7) >= 0; } + public boolean allowMulticatch() { + return compareTo(JDK1_7) >= 0; + } public boolean allowEnums() { return compareTo(JDK1_5) >= 0; } diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java Tue May 11 16:36:13 2010 -0700 @@ -988,6 +988,13 @@ Env catchEnv = env.dup(c, env.info.dup(env.info.scope.dup())); Type ctype = attribStat(c.param, catchEnv); + if (TreeInfo.isMultiCatch(c)) { + //check that multi-catch parameter is marked as final + if ((c.param.sym.flags() & FINAL) == 0) { + log.error(c.param.pos(), "multicatch.param.must.be.final", c.param.sym); + } + c.param.sym.flags_field = c.param.sym.flags() | DISJOINT; + } if (c.param.type.tsym.kind == Kinds.VAR) { c.param.sym.setData(ElementKind.EXCEPTION_PARAMETER); } @@ -2621,12 +2628,10 @@ } if (useVarargs) { JCTree tree = env.tree; - Type argtype = owntype.getParameterTypes().last(); - if (!types.isReifiable(argtype)) - chk.warnUnchecked(env.tree.pos(), - "unchecked.generic.array.creation", - argtype); - Type elemtype = types.elemtype(argtype); + if (owntype.getReturnType().tag != FORALL || warned) { + chk.checkVararg(env.tree.pos(), owntype.getParameterTypes()); + } + Type elemtype = types.elemtype(owntype.getParameterTypes().last()); switch (tree.getTag()) { case JCTree.APPLY: ((JCMethodInvocation) tree).varargsElement = elemtype; @@ -2737,6 +2742,11 @@ result = check(tree, owntype, TYP, pkind, pt); } + public void visitTypeDisjoint(JCTypeDisjoint tree) { + List componentTypes = attribTypes(tree.components, env); + tree.type = result = check(tree, types.lub(componentTypes), TYP, pkind, pt); + } + public void visitTypeParameter(JCTypeParameter tree) { TypeVar a = (TypeVar)tree.type; Set boundSet = new HashSet(); diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/comp/Check.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java Tue May 11 16:36:13 2010 -0700 @@ -677,6 +677,19 @@ } } + /** + * Check that vararg method call is sound + * @param pos Position to be used for error reporting. + * @param argtypes Actual arguments supplied to vararg method. + */ + void checkVararg(DiagnosticPosition pos, List argtypes) { + Type argtype = argtypes.last(); + if (!types.isReifiable(argtype)) + warnUnchecked(pos, + "unchecked.generic.array.creation", + argtype); + } + /** Check that given modifiers are legal for given symbol and * return modifiers together with any implicit modififiers for that symbol. * Warning: we can't use flags() here since this method diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java Tue May 11 16:36:13 2010 -0700 @@ -27,6 +27,8 @@ package com.sun.tools.javac.comp; +import java.util.HashMap; + import com.sun.tools.javac.code.*; import com.sun.tools.javac.tree.*; import com.sun.tools.javac.util.*; @@ -184,6 +186,7 @@ private final Check chk; private TreeMaker make; private Lint lint; + private final boolean allowRethrowAnalysis; public static Flow instance(Context context) { Flow instance = context.get(flowKey); @@ -194,13 +197,14 @@ protected Flow(Context context) { context.put(flowKey, this); - names = Names.instance(context); log = Log.instance(context); syms = Symtab.instance(context); types = Types.instance(context); chk = Check.instance(context); lint = Lint.instance(context); + Source source = Source.instance(context); + allowRethrowAnalysis = source.allowMulticatch(); } /** A flag that indicates whether the last statement could @@ -216,6 +220,8 @@ */ Bits uninits; + HashMap> multicatchTypes; + /** The set of variables that are definitely unassigned everywhere * in current try block. This variable is maintained lazily; it is * updated only when something gets removed from uninits, @@ -355,8 +361,14 @@ if (sym.adr >= firstadr && trackable(sym)) { if ((sym.flags() & FINAL) != 0) { if ((sym.flags() & PARAMETER) != 0) { - log.error(pos, "final.parameter.may.not.be.assigned", + if ((sym.flags() & DISJOINT) != 0) { //multi-catch parameter + log.error(pos, "multicatch.parameter.may.not.be.assigned", + sym); + } + else { + log.error(pos, "final.parameter.may.not.be.assigned", sym); + } } else if (!uninits.isMember(sym.adr)) { log.error(pos, loopPassTwo @@ -952,8 +964,14 @@ List caughtPrev = caught; List thrownPrev = thrown; thrown = List.nil(); - for (List l = tree.catchers; l.nonEmpty(); l = l.tail) - caught = chk.incl(l.head.param.type, caught); + for (List l = tree.catchers; l.nonEmpty(); l = l.tail) { + List subClauses = TreeInfo.isMultiCatch(l.head) ? + ((JCTypeDisjoint)l.head.param.vartype).components : + List.of(l.head.param.vartype); + for (JCExpression ct : subClauses) { + caught = chk.incl(ct.type, caught); + } + } Bits uninitsTryPrev = uninitsTry; ListBuffer prevPendingExits = pendingExits; pendingExits = new ListBuffer(); @@ -973,27 +991,39 @@ for (List l = tree.catchers; l.nonEmpty(); l = l.tail) { alive = true; JCVariableDecl param = l.head.param; - Type exc = param.type; - if (chk.subset(exc, caughtInTry)) { - log.error(l.head.pos(), - "except.already.caught", exc); - } else if (!chk.isUnchecked(l.head.pos(), exc) && - exc.tsym != syms.throwableType.tsym && - exc.tsym != syms.exceptionType.tsym && - !chk.intersects(exc, thrownInTry)) { - log.error(l.head.pos(), - "except.never.thrown.in.try", exc); + List subClauses = TreeInfo.isMultiCatch(l.head) ? + ((JCTypeDisjoint)l.head.param.vartype).components : + List.of(l.head.param.vartype); + List ctypes = List.nil(); + List rethrownTypes = chk.diff(thrownInTry, caughtInTry); + for (JCExpression ct : subClauses) { + Type exc = ct.type; + ctypes = ctypes.append(exc); + if (types.isSameType(exc, syms.objectType)) + continue; + if (chk.subset(exc, caughtInTry)) { + log.error(l.head.pos(), + "except.already.caught", exc); + } else if (!chk.isUnchecked(l.head.pos(), exc) && + exc.tsym != syms.throwableType.tsym && + exc.tsym != syms.exceptionType.tsym && + !chk.intersects(exc, thrownInTry)) { + log.error(l.head.pos(), + "except.never.thrown.in.try", exc); + } + caughtInTry = chk.incl(exc, caughtInTry); } - caughtInTry = chk.incl(exc, caughtInTry); inits = initsTry.dup(); uninits = uninitsTry.dup(); scan(param); inits.incl(param.sym.adr); uninits.excl(param.sym.adr); + multicatchTypes.put(param.sym, chk.intersect(ctypes, rethrownTypes)); scanStat(l.head.body); initsEnd.andSet(inits); uninitsEnd.andSet(uninits); nextadr = nextadrCatch; + multicatchTypes.remove(param.sym); aliveEnd |= alive; } if (tree.finalizer != null) { @@ -1121,7 +1151,19 @@ public void visitThrow(JCThrow tree) { scanExpr(tree.expr); - markThrown(tree, tree.expr.type); + Symbol sym = TreeInfo.symbol(tree.expr); + if (sym != null && + sym.kind == VAR && + (sym.flags() & FINAL) != 0 && + multicatchTypes.get(sym) != null && + allowRethrowAnalysis) { + for (Type t : multicatchTypes.get(sym)) { + markThrown(tree, t); + } + } + else { + markThrown(tree, tree.expr.type); + } markDead(); } @@ -1308,6 +1350,7 @@ firstadr = 0; nextadr = 0; pendingExits = new ListBuffer(); + multicatchTypes = new HashMap>(); alive = true; this.thrown = this.caught = null; this.classDef = null; diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java Tue May 11 16:36:13 2010 -0700 @@ -287,7 +287,8 @@ /** Instantiate method type `mt' by finding instantiations of * `tvars' so that method can be applied to `argtypes'. */ - public Type instantiateMethod(List tvars, + public Type instantiateMethod(final Env env, + List tvars, MethodType mt, final List argtypes, final boolean allowBoxing, @@ -416,6 +417,9 @@ // check that inferred bounds conform to their bounds checkWithinBounds(all_tvars, types.subst(inferredTypes, tvars, inferred), warn); + if (useVarargs) { + chk.checkVararg(env.tree.pos(), formals); + } return super.inst(inferred, types); }}; return mt2; diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java Tue May 11 16:36:13 2010 -0700 @@ -345,7 +345,8 @@ if (instNeeded) return - infer.instantiateMethod(tvars, + infer.instantiateMethod(env, + tvars, (MethodType)mt, argtypes, allowBoxing, diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/jvm/Gen.java --- a/langtools/src/share/classes/com/sun/tools/javac/jvm/Gen.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/Gen.java Tue May 11 16:36:13 2010 -0700 @@ -1454,20 +1454,26 @@ int startpc, int endpc, List gaps) { if (startpc != endpc) { - int catchType = makeRef(tree.pos(), tree.param.type); - while (gaps.nonEmpty()) { - int end = gaps.head.intValue(); - registerCatch(tree.pos(), - startpc, end, code.curPc(), - catchType); - gaps = gaps.tail; - startpc = gaps.head.intValue(); - gaps = gaps.tail; + List subClauses = TreeInfo.isMultiCatch(tree) ? + ((JCTypeDisjoint)tree.param.vartype).components : + List.of(tree.param.vartype); + for (JCExpression subCatch : subClauses) { + int catchType = makeRef(tree.pos(), subCatch.type); + List lGaps = gaps; + while (lGaps.nonEmpty()) { + int end = lGaps.head.intValue(); + registerCatch(tree.pos(), + startpc, end, code.curPc(), + catchType); + lGaps = lGaps.tail; + startpc = lGaps.head.intValue(); + lGaps = lGaps.tail; + } + if (startpc < endpc) + registerCatch(tree.pos(), + startpc, endpc, code.curPc(), + catchType); } - if (startpc < endpc) - registerCatch(tree.pos(), - startpc, endpc, code.curPc(), - catchType); VarSymbol exparam = tree.param.sym; code.statBegin(tree.pos); code.markStatBegin(); diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java --- a/langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java Tue May 11 16:36:13 2010 -0700 @@ -132,6 +132,7 @@ this.allowStaticImport = source.allowStaticImport(); this.allowAnnotations = source.allowAnnotations(); this.allowDiamond = source.allowDiamond(); + this.allowMulticatch = source.allowMulticatch(); this.allowTypeAnnotations = source.allowTypeAnnotations(); this.keepDocComments = keepDocComments; if (keepDocComments) @@ -153,6 +154,10 @@ */ boolean allowDiamond; + /** Switch: Should multicatch clause be accepted? + */ + boolean allowMulticatch; + /** Switch: Should varargs be recognized? */ boolean allowVarargs; @@ -2011,14 +2016,28 @@ int pos = S.pos(); accept(CATCH); accept(LPAREN); - JCVariableDecl formal = - variableDeclaratorId(optFinal(Flags.PARAMETER), - qualident()); + JCModifiers mods = optFinal(Flags.PARAMETER); + List catchTypes = catchTypes(); + JCExpression paramType = catchTypes.size() > 1 ? + toP(F.at(catchTypes.head.getStartPosition()).TypeDisjoint(catchTypes)) : + catchTypes.head; + JCVariableDecl formal = variableDeclaratorId(mods, paramType); accept(RPAREN); JCBlock body = block(); return F.at(pos).Catch(formal, body); } + List catchTypes() { + ListBuffer catchTypes = ListBuffer.lb(); + catchTypes.add(parseType()); + while (S.token() == BAR) { + checkMulticatch(); + S.nextToken(); + catchTypes.add(qualident()); + } + return catchTypes.toList(); + } + /** SwitchBlockStatementGroups = { SwitchBlockStatementGroup } * SwitchBlockStatementGroup = SwitchLabel BlockStatements * SwitchLabel = CASE ConstantExpression ":" | DEFAULT ":" @@ -3193,4 +3212,10 @@ allowDiamond = true; } } + void checkMulticatch() { + if (!allowMulticatch) { + log.error(S.pos(), "multicatch.not.supported.in.source", source.name); + allowMulticatch = true; + } + } } diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties --- a/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties Tue May 11 16:36:13 2010 -0700 @@ -172,6 +172,10 @@ compiler.err.final.parameter.may.not.be.assigned=\ final parameter {0} may not be assigned +compiler.err.multicatch.parameter.may.not.be.assigned=\ + multi-catch parameter {0} may not be assigned +compiler.err.multicatch.param.must.be.final=\ + multi-catch parameter {0} must be final compiler.err.finally.without.try=\ ''finally'' without ''try'' compiler.err.foreach.not.applicable.to.type=\ @@ -1235,6 +1239,10 @@ enums are not supported in -source {0}\n\ (use -source 5 or higher to enable enums) +compiler.err.multicatch.not.supported.in.source=\ + multi-catch statement is not supported in -source {0}\n\ +(use -source 7 or higher to enable multi-catch statement) + compiler.err.string.switch.not.supported.in.source=\ strings in switch are not supported in -source {0}\n\ (use -source 7 or higher to enable strings in switch) diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java --- a/langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java Tue May 11 16:36:13 2010 -0700 @@ -236,9 +236,13 @@ */ public static final int TYPEAPPLY = TYPEARRAY + 1; + /** Disjunctive types, of type TypeDisjoint. + */ + public static final int TYPEDISJOINT = TYPEAPPLY + 1; + /** Formal type parameters, of type TypeParameter. */ - public static final int TYPEPARAMETER = TYPEAPPLY + 1; + public static final int TYPEPARAMETER = TYPEDISJOINT + 1; /** Type argument. */ @@ -1863,6 +1867,34 @@ } /** + * A disjoint type, T1 | T2 | ... Tn (used in multicatch statements) + */ + public static class JCTypeDisjoint extends JCExpression implements DisjointTypeTree { + + public List components; + + protected JCTypeDisjoint(List components) { + this.components = components; + } + @Override + public void accept(Visitor v) { v.visitTypeDisjoint(this); } + + public Kind getKind() { return Kind.DISJOINT_TYPE; } + + public List getTypeComponents() { + return components; + } + @Override + public R accept(TreeVisitor v, D d) { + return v.visitDisjointType(this, d); + } + @Override + public int getTag() { + return TYPEDISJOINT; + } + } + + /** * A formal class parameter. * @param name name * @param bounds bounds @@ -2220,6 +2252,7 @@ public void visitTypeIdent(JCPrimitiveTypeTree that) { visitTree(that); } public void visitTypeArray(JCArrayTypeTree that) { visitTree(that); } public void visitTypeApply(JCTypeApply that) { visitTree(that); } + public void visitTypeDisjoint(JCTypeDisjoint that) { visitTree(that); } public void visitTypeParameter(JCTypeParameter that) { visitTree(that); } public void visitWildcard(JCWildcard that) { visitTree(that); } public void visitTypeBoundKind(TypeBoundKind that) { visitTree(that); } diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/tree/Pretty.java --- a/langtools/src/share/classes/com/sun/tools/javac/tree/Pretty.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/tree/Pretty.java Tue May 11 16:36:13 2010 -0700 @@ -1182,6 +1182,14 @@ } } + public void visitTypeDisjoint(JCTypeDisjoint tree) { + try { + printExprs(tree.components, " | "); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + } + public void visitTypeParameter(JCTypeParameter tree) { try { print(tree.name); diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/tree/TreeCopier.java --- a/langtools/src/share/classes/com/sun/tools/javac/tree/TreeCopier.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/tree/TreeCopier.java Tue May 11 16:36:13 2010 -0700 @@ -345,6 +345,12 @@ return M.at(t.pos).TypeApply(clazz, arguments); } + public JCTree visitDisjointType(DisjointTypeTree node, P p) { + JCTypeDisjoint t = (JCTypeDisjoint) node; + List components = copy(t.components, p); + return M.at(t.pos).TypeDisjoint(components); + } + public JCTree visitArrayType(ArrayTypeTree node, P p) { JCArrayTypeTree t = (JCArrayTypeTree) node; JCExpression elemtype = copy(t.elemtype, p); diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java --- a/langtools/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java Tue May 11 16:36:13 2010 -0700 @@ -118,6 +118,10 @@ return false; } + public static boolean isMultiCatch(JCCatch catchClause) { + return catchClause.param.vartype.getTag() == JCTree.TYPEDISJOINT; + } + /** Is statement an initializer for a synthetic field? */ public static boolean isSyntheticInit(JCTree stat) { diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/tree/TreeMaker.java --- a/langtools/src/share/classes/com/sun/tools/javac/tree/TreeMaker.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/tree/TreeMaker.java Tue May 11 16:36:13 2010 -0700 @@ -444,6 +444,12 @@ return tree; } + public JCTypeDisjoint TypeDisjoint(List components) { + JCTypeDisjoint tree = new JCTypeDisjoint(components); + tree.pos = pos; + return tree; + } + public JCTypeParameter TypeParameter(Name name, List bounds) { return TypeParameter(name, bounds, List.nil()); } diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/tree/TreeScanner.java --- a/langtools/src/share/classes/com/sun/tools/javac/tree/TreeScanner.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/tree/TreeScanner.java Tue May 11 16:36:13 2010 -0700 @@ -275,6 +275,10 @@ scan(tree.arguments); } + public void visitTypeDisjoint(JCTypeDisjoint tree) { + scan(tree.components); + } + public void visitTypeParameter(JCTypeParameter tree) { scan(tree.annotations); scan(tree.bounds); diff -r b5dab6a313fd -r d9799ef9198d langtools/src/share/classes/com/sun/tools/javac/tree/TreeTranslator.java --- a/langtools/src/share/classes/com/sun/tools/javac/tree/TreeTranslator.java Wed Jul 05 17:11:37 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/tree/TreeTranslator.java Tue May 11 16:36:13 2010 -0700 @@ -367,6 +367,11 @@ result = tree; } + public void visitTypeDisjoint(JCTypeDisjoint tree) { + tree.components = translate(tree.components); + result = tree; + } + public void visitTypeParameter(JCTypeParameter tree) { tree.annotations = translate(tree.annotations); tree.bounds = translate(tree.bounds); diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Neg01.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Neg01.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,28 @@ +/* + * @test /nodynamiccopyright/ + * @bug 6943289 + * + * @summary Project Coin: Improved Exception Handling for Java (aka 'multicatch') + * @author darcy + * @compile/fail/ref=Neg01.out -XDrawDiagnostics Neg01.java + * @compile -source 6 -XDrawDiagnostics Neg01.java + * + */ + +class Neg01 { + static class A extends Exception {} + static class B1 extends A {} + static class B2 extends A {} + + class Test { + void m() throws A { + try { + throw new B1(); + } catch (final A ex1) { + try { + throw ex1; // used to throw A, now throws B1! + } catch (B2 ex2) { }//unreachable + } + } + } +} diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Neg01.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Neg01.out Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,2 @@ +Neg01.java:24:19: compiler.err.except.never.thrown.in.try: Neg01.B2 +1 error diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Neg02.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Neg02.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,25 @@ +/* + * @test /nodynamiccopyright/ + * @bug 6943289 + * + * @summary Project Coin: Improved Exception Handling for Java (aka 'multicatch') + * @author mcimadamore + * @compile/fail/ref=Neg02.out -XDrawDiagnostics Neg02.java + * + */ + +class Neg02 { + static class A extends Exception {} + static class B extends Exception {} + + void m() { + try { + if (true) { + throw new A(); + } + else { + throw new B(); + } + } catch (A | B ex) { } + } +} diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Neg02.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Neg02.out Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,2 @@ +Neg02.java:23:24: compiler.err.multicatch.param.must.be.final: ex +1 error diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Neg03.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Neg03.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,27 @@ +/* + * @test /nodynamiccopyright/ + * @bug 6943289 + * + * @summary Project Coin: Improved Exception Handling for Java (aka 'multicatch') + * @author mcimadamore + * @compile/fail/ref=Neg03.out -XDrawDiagnostics Neg03.java + * + */ + +class Neg03 { + static class A extends Exception {} + static class B extends Exception {} + + void m() { + try { + if (true) { + throw new A(); + } + else { + throw new B(); + } + } catch (final A | B ex) { + ex = new B(); + } + } +} diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Neg03.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Neg03.out Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,2 @@ +Neg03.java:24:13: compiler.err.multicatch.parameter.may.not.be.assigned: ex +1 error diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Neg04.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Neg04.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,31 @@ +/* + * @test /nodynamiccopyright/ + * @bug 6943289 + * + * @summary Project Coin: Improved Exception Handling for Java (aka 'multicatch') + * @author mcimadamore + * @compile/fail/ref=Neg04.out -XDrawDiagnostics Neg04.java + * + */ + +class Neg04 { + static class A extends Exception {} + static class B extends Exception {} + + void test() throws B { + try { + if (true) { + throw new A(); + } else if (false) { + throw new B(); + } else { + throw (Throwable)new Exception(); + } + } + catch (A e) {} + catch (final Exception e) { + throw e; + } + catch (Throwable t) {} + } +} diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Neg04.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Neg04.out Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,2 @@ +Neg04.java:27:13: compiler.err.unreported.exception.need.to.catch.or.throw: java.lang.Exception +1 error diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Pos01.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Pos01.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,59 @@ +/* + * Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 6943289 + * @summary Project Coin: Improved Exception Handling for Java (aka 'multicatch') + * + */ + +public class Pos01 { + + static class A extends Exception {} + static class B extends Exception {} + + static int caughtExceptions = 0; + + static void test(boolean b) { + try { + if (b) { + throw new A(); + } + else { + throw new B(); + } + } + catch (final A | B ex) { + caughtExceptions++; + } + } + + public static void main(String[] args) { + test(true); + test(false); + if (caughtExceptions != 2) { + throw new AssertionError("Exception handler called " + caughtExceptions + "times"); + } + } +} diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Pos02.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Pos02.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,81 @@ +/* + * Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 6943289 + * @summary Project Coin: Improved Exception Handling for Java (aka 'multicatch') + * + */ + +public class Pos02 { + + static class A extends Exception {} + static class B extends Exception {} + static class C extends Exception {} + static class C1 extends C {} + static class C2 extends C {} + + enum ExceptionKind { + A, + B, + C1, + C2 + } + + static int caughtExceptions = 0; + static int caughtRethrownExceptions = 0; + + static void test(ExceptionKind ekind) throws A, C1 { + try { + switch (ekind) { + case A : throw new A(); + case B : throw new B(); + case C1: throw new C1(); + case C2 : throw new C2(); + } + } + catch (final C2 | B ex) { + caughtExceptions++; + } + catch (final C | A ex) { + caughtExceptions++; + throw ex; + } + } + + public static void main(String[] args) { + for (ExceptionKind ekind : ExceptionKind.values()) { + try { + test(ekind); + } + catch (final C1 | A ex) { + caughtRethrownExceptions++; + } + } + if (caughtExceptions != 4 && caughtRethrownExceptions == 2) { + throw new AssertionError("Exception handler called " + caughtExceptions + "times" + + " rethrown handler called " + caughtRethrownExceptions + "times"); + } + } +} diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Pos03.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Pos03.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,50 @@ +/* + * Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 6943289 + * @summary Project Coin: Improved Exception Handling for Java (aka 'multicatch') + * @compile Pos03.java + */ + +class Pos03 { + + static class A extends Exception { public void m() {}; public Object f;} + static class B1 extends A {} + static class B2 extends A {} + + void m() { + try { + if (true) { + throw new B1(); + } + else { + throw new B2(); + } + } catch (final B1 | B2 ex) { + ex.m(); + System.out.println(ex.f); + } + } +} diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Pos04.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Pos04.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,92 @@ +/* + * Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 6943289 + * @summary Project Coin: Improved Exception Handling for Java (aka 'multicatch') + */ + +import java.lang.annotation.*; + +public class Pos04 { + + enum ExceptionKind { + A(1), + B(2), + C(1); + + int expectedValue; + + ExceptionKind(int expectedValue) { + this.expectedValue = expectedValue; + } + } + + @Retention(RetentionPolicy.RUNTIME) + @interface CatchNumber { + int value(); + } + + @CatchNumber(1) + static class A extends Exception { } + + @CatchNumber(2) + static class B extends Exception { } + + @CatchNumber(1) + static class C extends Exception { } + + static int sum = 0; + + public static void main(String[] args) { + for (ExceptionKind ekind : ExceptionKind.values()) { + test(ekind); + } + if (sum != 4) { + throw new Error("bad checksum - expected:4, found:" + sum); + } + } + + public static void test(ExceptionKind ekind) { + try { + switch(ekind) { + case A: throw new A(); + case B: throw new B(); + case C: throw new C(); + } + } catch(final A | C ex) {// Catch number 1 + CatchNumber catchNumber = ex.getClass().getAnnotation(CatchNumber.class); + if (catchNumber == null || catchNumber.value() != ekind.expectedValue) { + throw new Error("was expecting 1 - got " + catchNumber); + } + sum += catchNumber.value(); + } catch (final B ex) { // Catch number 2 + CatchNumber catchNumber = ex.getClass().getAnnotation(CatchNumber.class); + if (catchNumber == null || catchNumber.value() != ekind.expectedValue) { + throw new Error("was expecting 2 - got " + catchNumber); + } + sum += catchNumber.value(); + } + } +} diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/multicatch/Pos05.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/multicatch/Pos05.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,117 @@ +/* + * Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 6943289 + * @summary Project Coin: Improved Exception Handling for Java (aka 'multicatch') + * @run main Pos05 + */ + +import com.sun.tools.classfile.Attribute; +import com.sun.tools.classfile.ClassFile; +import com.sun.tools.classfile.Code_attribute; +import com.sun.tools.classfile.Code_attribute.Exception_data; +import com.sun.tools.classfile.Method; +import java.io.*; + +public class Pos05 { + + static class Pos05sub { + + class A extends Exception {} + class B extends Exception {} + class C extends Exception {} + + void test(boolean b1, boolean b2) { + try { + if (b1) { + throw new A(); + } + else if (b2) { + throw new B(); + } + else { + throw new C(); + } + } + catch (final A | B | C ex) { + System.out.println("Exception caught"); + } + } + } + + static final int TYPES_IN_MULTICATCH = 3; + static final String SUBTEST_NAME = Pos05sub.class.getName() + ".class"; + static final String TEST_METHOD_NAME = "test"; + + public static void main(String... args) throws Exception { + new Pos05().run(); + } + + public void run() throws Exception { + String workDir = System.getProperty("test.classes"); + File compiledTest = new File(workDir, SUBTEST_NAME); + verifyMulticatchExceptionRanges(compiledTest); + } + + void verifyMulticatchExceptionRanges(File f) { + System.err.println("verify: " + f); + try { + int count = 0; + ClassFile cf = ClassFile.read(f); + Method testMethod = null; + for (Method m : cf.methods) { + if (m.getName(cf.constant_pool).equals(TEST_METHOD_NAME)) { + testMethod = m; + break; + } + } + if (testMethod == null) { + throw new Error("Test method not found"); + } + Code_attribute ea = (Code_attribute)testMethod.attributes.get(Attribute.Code); + if (testMethod == null) { + throw new Error("Code attribute for test() method not found"); + } + Exception_data firstExceptionTable = null; + for (int i = 0 ; i < ea.exception_table_langth; i++) { + if (firstExceptionTable == null) { + firstExceptionTable = ea.exception_table[i]; + } + if (ea.exception_table[i].handler_pc != firstExceptionTable.handler_pc || + ea.exception_table[i].start_pc != firstExceptionTable.start_pc || + ea.exception_table[i].end_pc != firstExceptionTable.end_pc) { + throw new Error("Multiple overlapping catch clause found in generated code"); + } + count++; + } + if (count != TYPES_IN_MULTICATCH) { + throw new Error("Wrong number of exception data found: " + count); + } + } catch (Exception e) { + e.printStackTrace(); + throw new Error("error reading " + f +": " + e); + } + } +} diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/varargs/6730476/T6730476a.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/varargs/6730476/T6730476a.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,39 @@ +/* + * Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 6730476 + * + * @summary invalid "unchecked generic array" warning + * @author mcimadamore + * @compile T6730476a.java -Xlint -Werror + * + */ + +class T6730476a { + void f(int i, T ... x) {} + void g() { + f(1); + } +} diff -r b5dab6a313fd -r d9799ef9198d langtools/test/tools/javac/varargs/6730476/T6730476b.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/varargs/6730476/T6730476b.java Tue May 11 16:36:13 2010 -0700 @@ -0,0 +1,36 @@ +/* + * Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 6730476 + * + * @summary invalid "unchecked generic array" warning + * @author mcimadamore + * @compile T6730476b.java -Xlint -Werror + * + */ + +class T6730476b { + java.util.List ints = java.util.Arrays.asList(); +}