From 2a3879180e63aa0a7a19479f061fe78d7885da7b Mon Sep 17 00:00:00 2001 From: Jan Lahoda Date: Wed, 14 Sep 2022 08:51:03 +0000 Subject: [PATCH] 8292755: Non-default method in interface leads to a stack overflow in JShell Reviewed-by: vromero --- .../com/sun/tools/javac/comp/Attr.java | 17 +- test/langtools/jdk/jshell/ClassesTest.java | 16 +- .../tools/javac/recovery/MethodModifiers.java | 162 ++++++++++++++++++ 3 files changed, 186 insertions(+), 9 deletions(-) create mode 100644 test/langtools/tools/javac/recovery/MethodModifiers.java diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java index ef80bbb85f8..0ff738e210d 100644 --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java @@ -1173,15 +1173,16 @@ public class Attr extends JCTree.Visitor { } if (isDefaultMethod || (tree.sym.flags() & (ABSTRACT | NATIVE)) == 0) log.error(tree.pos(), Errors.MissingMethBodyOrDeclAbstract); - } else if ((tree.sym.flags() & (ABSTRACT|DEFAULT|PRIVATE)) == ABSTRACT) { - if ((owner.flags() & INTERFACE) != 0) { - log.error(tree.body.pos(), Errors.IntfMethCantHaveBody); - } else { - log.error(tree.pos(), Errors.AbstractMethCantHaveBody); - } - } else if ((tree.mods.flags & NATIVE) != 0) { - log.error(tree.pos(), Errors.NativeMethCantHaveBody); } else { + if ((tree.sym.flags() & (ABSTRACT|DEFAULT|PRIVATE)) == ABSTRACT) { + if ((owner.flags() & INTERFACE) != 0) { + log.error(tree.body.pos(), Errors.IntfMethCantHaveBody); + } else { + log.error(tree.pos(), Errors.AbstractMethCantHaveBody); + } + } else if ((tree.mods.flags & NATIVE) != 0) { + log.error(tree.pos(), Errors.NativeMethCantHaveBody); + } // Add an implicit super() call unless an explicit call to // super(...) or this(...) is given // or we are compiling class java.lang.Object. diff --git a/test/langtools/jdk/jshell/ClassesTest.java b/test/langtools/jdk/jshell/ClassesTest.java index 6c01a4ad8d5..eafd2320db0 100644 --- a/test/langtools/jdk/jshell/ClassesTest.java +++ b/test/langtools/jdk/jshell/ClassesTest.java @@ -23,7 +23,7 @@ /* * @test - * @bug 8145239 8129559 8080354 8189248 8010319 8246353 8247456 8282160 + * @bug 8145239 8129559 8080354 8189248 8010319 8246353 8247456 8282160 8292755 * @summary Tests for EvaluationState.classes * @build KullaTesting TestingInputStream ExpectedDiagnostic * @run testng ClassesTest @@ -360,4 +360,18 @@ public class ClassesTest extends KullaTesting { ste(classKey, Status.RECOVERABLE_NOT_DEFINED, Status.VALID, true, null)); } + public void testDefaultMethodInInterface() { + assertEvalFail(""" + interface C { + public void run() { + try { + throw IllegalStateException(); + } catch (Throwable t) { + throw new RuntimeException(t); + } + } + } + """); + } + } diff --git a/test/langtools/tools/javac/recovery/MethodModifiers.java b/test/langtools/tools/javac/recovery/MethodModifiers.java new file mode 100644 index 00000000000..3212d20f47c --- /dev/null +++ b/test/langtools/tools/javac/recovery/MethodModifiers.java @@ -0,0 +1,162 @@ +/* + * Copyright (c) 2022, 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 8292755 + * @summary Verify error recovery related to method modifiers. + * @library /tools/lib + * @modules jdk.compiler/com.sun.tools.javac.api + * jdk.compiler/com.sun.tools.javac.main + * jdk.jdeps/com.sun.tools.classfile + * @build toolbox.ToolBox toolbox.JavacTask + * @run main MethodModifiers + */ + +import java.nio.file.Path; +import java.util.List; +import java.util.Objects; + +import toolbox.JavacTask; +import toolbox.Task.Expect; +import toolbox.Task.OutputKind; +import toolbox.TestRunner; +import toolbox.ToolBox; + +public class MethodModifiers extends TestRunner { + + ToolBox tb; + + public MethodModifiers() { + super(System.err); + tb = new ToolBox(); + } + + public static void main(String[] args) throws Exception { + MethodModifiers t = new MethodModifiers(); + t.runTests(); + } + + @Test + public void testNonDefaultMethodInterface() throws Exception { + String code = """ + interface Test { + void test() { + try { + unresolvable(); + } catch (Throwable t) { + throw new RuntimeException(t); + } + } + } + """; + Path curPath = Path.of("."); + List actual = new JavacTask(tb) + .options("-XDrawDiagnostics", + "-XDshould-stop.at=FLOW", + "-XDdev") + .sources(code) + .outdir(curPath) + .run(Expect.FAIL) + .getOutputLines(OutputKind.DIRECT); + + List expected = List.of( + "Test.java:2:17: compiler.err.intf.meth.cant.have.body", + "Test.java:4:13: compiler.err.cant.resolve.location.args: kindname.method, unresolvable, , , (compiler.misc.location: kindname.interface, Test, null)", + "2 errors" + ); + + if (!Objects.equals(actual, expected)) { + error("Expected: " + expected + ", but got: " + actual); + } + } + + @Test + public void testAbstractMethodWithBody() throws Exception { + String code = """ + abstract class Test { + abstract void test() { + try { + unresolvable(); + } catch (Throwable t) { + throw new RuntimeException(t); + } + } + } + """; + Path curPath = Path.of("."); + List actual = new JavacTask(tb) + .options("-XDrawDiagnostics", + "-XDshould-stop.at=FLOW", + "-XDdev") + .sources(code) + .outdir(curPath) + .run(Expect.FAIL) + .getOutputLines(OutputKind.DIRECT); + + List expected = List.of( + "Test.java:2:19: compiler.err.abstract.meth.cant.have.body", + "Test.java:4:13: compiler.err.cant.resolve.location.args: kindname.method, unresolvable, , , (compiler.misc.location: kindname.class, Test, null)", + "2 errors" + ); + + if (!Objects.equals(actual, expected)) { + error("Expected: " + expected + ", but got: " + actual); + } + } + + @Test + public void testNativeMethodWithBody() throws Exception { + String code = """ + class Test { + native void test() { + try { + unresolvable(); + } catch (Throwable t) { + throw new RuntimeException(t); + } + } + } + """; + Path curPath = Path.of("."); + List actual = new JavacTask(tb) + .options("-XDrawDiagnostics", + "-XDshould-stop.at=FLOW", + "-XDdev") + .sources(code) + .outdir(curPath) + .run(Expect.FAIL) + .getOutputLines(OutputKind.DIRECT); + + List expected = List.of( + "Test.java:2:17: compiler.err.native.meth.cant.have.body", + "Test.java:4:13: compiler.err.cant.resolve.location.args: kindname.method, unresolvable, , , (compiler.misc.location: kindname.class, Test, null)", + "2 errors" + ); + + if (!Objects.equals(actual, expected)) { + error("Expected: " + expected + ", but got: " + actual); + } + } + +}