# HG changeset patch # User mcimadamore # Date 1249949671 -3600 # Node ID bbfccbd92afe44c3f9d32d9907f3f209761e42fd # Parent 58cfcc0f1aa9b759e162e29d670a5b430508d9da 6199153: Generic throws and overriding Summary: javac incorrectly rejects an uchecked overriding Reviewed-by: jjg diff -r 58cfcc0f1aa9 -r bbfccbd92afe langtools/src/share/classes/com/sun/tools/javac/comp/Check.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java Tue Aug 11 01:14:06 2009 +0100 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java Tue Aug 11 01:14:31 2009 +0100 @@ -1043,7 +1043,7 @@ * @param thrown The list of thrown exceptions. * @param handled The list of handled exceptions. */ - List unHandled(List thrown, List handled) { + List unhandled(List thrown, List handled) { List unhandled = List.nil(); for (List l = thrown; l.nonEmpty(); l = l.tail) if (!isHandled(l.head, handled)) unhandled = unhandled.prepend(l.head); @@ -1200,29 +1200,36 @@ m.owner.isSubClass(other.owner, types)) { // allow limited interoperability with covariant returns } else { - typeError(TreeInfo.diagnosticPositionFor(m, tree), - diags.fragment("override.incompatible.ret", - cannotOverride(m, other)), + log.error(TreeInfo.diagnosticPositionFor(m, tree), + "override.incompatible.ret", + cannotOverride(m, other), mtres, otres); return; } } else if (overrideWarner.warned) { warnUnchecked(TreeInfo.diagnosticPositionFor(m, tree), - "prob.found.req", - diags.fragment("override.unchecked.ret", - uncheckedOverrides(m, other)), - mtres, otres); + "override.unchecked.ret", + uncheckedOverrides(m, other), + mtres, otres); } // Error if overriding method throws an exception not reported // by overridden method. List otthrown = types.subst(ot.getThrownTypes(), otvars, mtvars); - List unhandled = unHandled(mt.getThrownTypes(), otthrown); - if (unhandled.nonEmpty()) { + List unhandledErased = unhandled(mt.getThrownTypes(), types.erasure(otthrown)); + List unhandledUnerased = unhandled(mt.getThrownTypes(), otthrown); + if (unhandledErased.nonEmpty()) { log.error(TreeInfo.diagnosticPositionFor(m, tree), "override.meth.doesnt.throw", cannotOverride(m, other), - unhandled.head); + unhandledUnerased.head); + return; + } + else if (unhandledUnerased.nonEmpty()) { + warnUnchecked(TreeInfo.diagnosticPositionFor(m, tree), + "override.unchecked.thrown", + cannotOverride(m, other), + unhandledUnerased.head); return; } diff -r 58cfcc0f1aa9 -r bbfccbd92afe langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties --- a/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties Tue Aug 11 01:14:06 2009 +0100 +++ b/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties Tue Aug 11 01:14:31 2009 +0100 @@ -1093,23 +1093,33 @@ no arguments compiler.err.override.static=\ - {0}; overriding method is static + {0}\n\ + overriding method is static compiler.err.override.meth=\ - {0}; overridden method is {1} + {0}\n\ + overridden method is {1} compiler.err.override.meth.doesnt.throw=\ - {0}; overridden method does not throw {1} + {0}\n\ + overridden method does not throw {1} # In the following string {1} is a space separated list of Java Keywords, as # they would have been declared in the source code compiler.err.override.weaker.access=\ - {0}; attempting to assign weaker access privileges; was {1} + {0}\n\ + attempting to assign weaker access privileges; was {1} + +compiler.err.override.incompatible.ret=\ + {0}\n\ + return type {1} is not compatible with {2} -compiler.misc.override.incompatible.ret=\ - {0}; attempting to use incompatible return type +compiler.warn.override.unchecked.ret=\ + [unchecked] {0}\n\ + return type requires unchecked conversion from {1} to {2} -compiler.misc.override.unchecked.ret=\ - {0}; return type requires unchecked conversion +compiler.warn.override.unchecked.thrown=\ + [unchecked] {0}\n\ + overridden method does not throw {1} ## The following are all possible strings for the first argument ({0}) of the ## above strings. diff -r 58cfcc0f1aa9 -r bbfccbd92afe langtools/test/tools/javac/OverrideChecks/6199153/T6199153.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/OverrideChecks/6199153/T6199153.java Tue Aug 11 01:14:31 2009 +0100 @@ -0,0 +1,44 @@ +/* + * Copyright 2009 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 6199153 + * @summary Generic throws and overriding + * @author mcimadamore + * @compile/fail/ref=T6199153.out -Xlint -Werror -XDrawDiagnostics T6199153.java + */ + +import java.io.IOException; + +class T6199153 { + + static class A { + public void m() throws T {} + } + + static class B extends A { + public void m() throws IOException {} + } +} + diff -r 58cfcc0f1aa9 -r bbfccbd92afe langtools/test/tools/javac/OverrideChecks/6199153/T6199153.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/OverrideChecks/6199153/T6199153.out Tue Aug 11 01:14:31 2009 +0100 @@ -0,0 +1,4 @@ +T6199153.java:41:21: compiler.warn.override.unchecked.thrown: (compiler.misc.cant.override: m(), T6199153.B, m(), T6199153.A), java.io.IOException +- compiler.err.warnings.and.werror +1 error +1 warning