6199153: Generic throws and overriding

Summary: javac incorrectly rejects an uchecked overriding
Reviewed-by: jjg

src/share/classes/com/sun/tools/javac/comp/Check.java

@@ -1043,7 +1043,7 @@ public class Check {
      *  @param thrown     The list of thrown exceptions.
      *  @param handled    The list of handled exceptions.
      */
-    List<Type> unHandled(List<Type> thrown, List<Type> handled) {
+    List<Type> unhandled(List<Type> thrown, List<Type> handled) {
         List<Type> unhandled = List.nil();
         for (List<Type> l = thrown; l.nonEmpty(); l = l.tail)
             if (!isHandled(l.head, handled)) unhandled = unhandled.prepend(l.head);
@@ -1200,29 +1200,36 @@ public class Check {
                 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<Type> otthrown = types.subst(ot.getThrownTypes(), otvars, mtvars);
-        List<Type> unhandled = unHandled(mt.getThrownTypes(), otthrown);
-        if (unhandled.nonEmpty()) {
+        List<Type> unhandledErased = unhandled(mt.getThrownTypes(), types.erasure(otthrown));
+        List<Type> 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;
         }
 

src/share/classes/com/sun/tools/javac/resources/compiler.properties

@@ -1093,23 +1093,33 @@ compiler.misc.no.args=\
     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.misc.override.incompatible.ret=\
-    {0}; attempting to use incompatible return type
+compiler.err.override.incompatible.ret=\
+    {0}\n\
+    return type {1} is not compatible with {2}
 
-compiler.misc.override.unchecked.ret=\
-    {0}; return type requires unchecked conversion
+compiler.warn.override.unchecked.ret=\
+    [unchecked] {0}\n\
+    return type requires unchecked conversion from {1} to {2}
+
+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.

test/tools/javac/OverrideChecks/6199153/T6199153.java

+/*
+ * 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 <T extends IOException> void m() throws T {}
+    }
+
+    static class B extends A {
+        public void m() throws IOException {}
+    }
+}
+

test/tools/javac/OverrideChecks/6199153/T6199153.out

+T6199153.java:41:21: compiler.warn.override.unchecked.thrown: (compiler.misc.cant.override: m(), T6199153.B, <T>m(), T6199153.A), java.io.IOException
+- compiler.err.warnings.and.werror
+1 error
+1 warning