# HG changeset patch # User vromero # Date 1387491867 0 # Node ID e0ba35f27975466325c1c8b454a9994cc44b97d9 # Parent adc980c0dbcc43b27d0cee899762c213f09c88a7 8029240: Default methods not always visible under -source 7 Reviewed-by: jjg diff -r adc980c0dbcc -r e0ba35f27975 langtools/src/share/classes/com/sun/tools/javac/code/Source.java --- a/langtools/src/share/classes/com/sun/tools/javac/code/Source.java Thu Dec 19 21:58:50 2013 +0000 +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Source.java Thu Dec 19 22:24:27 2013 +0000 @@ -207,6 +207,9 @@ public boolean allowDefaultMethods() { return compareTo(JDK1_8) >= 0; } + public boolean allowDefaultMethodsResolution() { + return compareTo(JDK1_7) >= 0; + } public boolean allowStaticInterfaceMethods() { return compareTo(JDK1_8) >= 0; } diff -r adc980c0dbcc -r e0ba35f27975 langtools/src/share/classes/com/sun/tools/javac/code/Types.java --- a/langtools/src/share/classes/com/sun/tools/javac/code/Types.java Thu Dec 19 21:58:50 2013 +0000 +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Types.java Thu Dec 19 22:24:27 2013 +0000 @@ -83,7 +83,6 @@ final boolean allowBoxing; final boolean allowCovariantReturns; final boolean allowObjectToPrimitiveCast; - final boolean allowDefaultMethods; final ClassReader reader; final Check chk; final Enter enter; @@ -110,7 +109,6 @@ allowBoxing = source.allowBoxing(); allowCovariantReturns = source.allowCovariantReturns(); allowObjectToPrimitiveCast = source.allowObjectToPrimitiveCast(); - allowDefaultMethods = source.allowDefaultMethods(); reader = ClassReader.instance(context); chk = Check.instance(context); enter = Enter.instance(context); diff -r adc980c0dbcc -r e0ba35f27975 langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java Thu Dec 19 21:58:50 2013 +0000 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java Thu Dec 19 22:24:27 2013 +0000 @@ -94,7 +94,7 @@ public final boolean boxingEnabled; // = source.allowBoxing(); public final boolean varargsEnabled; // = source.allowVarargs(); public final boolean allowMethodHandles; - public final boolean allowDefaultMethods; + public final boolean allowDefaultMethodsResolution; public final boolean allowStructuralMostSpecific; private final boolean debugResolve; private final boolean compactMethodDiags; @@ -136,7 +136,7 @@ verboseResolutionMode = VerboseResolutionMode.getVerboseResolutionMode(options); Target target = Target.instance(context); allowMethodHandles = target.hasMethodHandles(); - allowDefaultMethods = source.allowDefaultMethods(); + allowDefaultMethodsResolution = source.allowDefaultMethodsResolution(); allowStructuralMostSpecific = source.allowStructuralMostSpecific(); polymorphicSignatureScope = new Scope(syms.noSymbol); @@ -1680,7 +1680,7 @@ bestSoFar : methodNotFound; for (InterfaceLookupPhase iphase2 : InterfaceLookupPhase.values()) { - if (iphase2 == InterfaceLookupPhase.DEFAULT_OK && !allowDefaultMethods) break; + if (iphase2 == InterfaceLookupPhase.DEFAULT_OK && !allowDefaultMethodsResolution) break; //keep searching for abstract methods for (Type itype : itypes[iphase2.ordinal()]) { if (!itype.isInterface()) continue; //skip j.l.Object (included by Types.closure()) @@ -1713,7 +1713,7 @@ //from superinterfaces) if ((s.flags() & (ABSTRACT | INTERFACE | ENUM)) != 0) { return this; - } else if (rs.allowDefaultMethods) { + } else if (rs.allowDefaultMethodsResolution) { return DEFAULT_OK; } else { return null; @@ -3340,7 +3340,7 @@ if ((env1.enclClass.sym.flags() & STATIC) != 0) staticOnly = true; env1 = env1.outer; } - if (allowDefaultMethods && c.isInterface() && + if (allowDefaultMethodsResolution && c.isInterface() && name == names._super && !isStatic(env) && types.isDirectSuperInterface(c, env.enclClass.sym)) { //this might be a default super call if one of the superinterfaces is 'c' diff -r adc980c0dbcc -r e0ba35f27975 langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java --- a/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java Thu Dec 19 21:58:50 2013 +0000 +++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java Thu Dec 19 22:24:27 2013 +0000 @@ -115,10 +115,6 @@ */ boolean lintClassfile; - /** Switch: allow default methods - */ - boolean allowDefaultMethods; - /** Switch: preserve parameter names from the variable table. */ public boolean saveParameterNames; @@ -306,7 +302,6 @@ allowVarargs = source.allowVarargs(); allowAnnotations = source.allowAnnotations(); allowSimplifiedVarargs = source.allowSimplifiedVarargs(); - allowDefaultMethods = source.allowDefaultMethods(); saveParameterNames = options.isSet("save-parameter-names"); cacheCompletionFailure = options.isUnset("dev"); diff -r adc980c0dbcc -r e0ba35f27975 langtools/test/tools/javac/T8029240/DefaultMethodsNotVisibileForSource7Test.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/T8029240/DefaultMethodsNotVisibileForSource7Test.java Thu Dec 19 22:24:27 2013 +0000 @@ -0,0 +1,164 @@ +/* + * Copyright (c) 2013, 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 8029240 + * @summary Default methods not always visible under -source 7 + * @library /tools/javac/lib + * @build ToolBox + * @run main DefaultMethodsNotVisibileForSource7Test + */ + +import java.nio.file.Files; +import java.nio.file.Paths; + +public class DefaultMethodsNotVisibileForSource7Test { + // common definitions + + // this one should be compiled with source 8, the rest with source 7 + static final String ISrc = + "interface I {\n" + + " default void m() {}\n" + + "}"; + + static final String JSrc = + "interface J extends I {}"; + + static final String ASrc = + "abstract class A implements I {}"; + + static final String BSrc = + "class B implements I {}"; + + // test legacy implementations + static final String C1Src = + "class C1 implements I {\n" + + " @Override public void m() {}\n" + + "}"; + + static final String C2Src = + "class C2 implements J {\n" + + " @Override public void m() {}\n" + + "}"; + + static final String C3Src = + "class C3 extends A {\n" + + " @Override public void m() {}\n" + + "}"; + + static final String C4Src = + "class C4 extends B {\n" + + " @Override public void m() {}\n" + + "}"; + + //test legacy invocations + static final String LegacyInvocationSrc = + "class LegacyInvocation {\n" + + " public static void test(I i, J j, A a, B b) {\n" + + " i.m();\n" + + " j.m();\n" + + " a.m();\n" + + " b.m();\n" + + " }\n" + + "}"; + + //test case super invocations + static final String SubASrc = + "class SubA extends A {\n" + + " public void test() {\n" + + " super.m();\n" + + " }\n" + + "}"; + + static final String SubBSrc = + "class SubB extends B {\n" + + " public void test() {\n" + + " super.m();\n" + + " }\n" + + "}"; + + public static void main(String[] args) throws Exception { + new DefaultMethodsNotVisibileForSource7Test().run(); + } + + void run() throws Exception { + testsPreparation(); + testLegacyImplementations(); + testLegacyInvocations(); + testSuperInvocations(); + } + + void testsPreparation() throws Exception { + Files.createDirectory(Paths.get("out")); + + /* as an extra check let's make sure that interface 'I' can't be compiled + * with source 7 + */ + ToolBox.JavaToolArgs javacArgs = + new ToolBox.JavaToolArgs(ToolBox.Expect.FAIL) + .setOptions("-d", "out", "-source", "7") + .setSources(ISrc); + ToolBox.javac(javacArgs); + + //but it should compile with source >= 8 + javacArgs = + new ToolBox.JavaToolArgs() + .setOptions("-d", "out") + .setSources(ISrc); + ToolBox.javac(javacArgs); + + javacArgs = + new ToolBox.JavaToolArgs() + .setOptions("-cp", "out", "-d", "out", "-source", "7") + .setSources(JSrc, ASrc, BSrc); + ToolBox.javac(javacArgs); + } + + void testLegacyImplementations() throws Exception { + //compile C1-4 + ToolBox.JavaToolArgs javacArgs = + new ToolBox.JavaToolArgs() + .setOptions("-cp", "out", "-d", "out", "-source", "7") + .setSources(C1Src, C2Src, C3Src, C4Src); + ToolBox.javac(javacArgs); + } + + void testLegacyInvocations() throws Exception { + //compile LegacyInvocation + ToolBox.JavaToolArgs javacArgs = + new ToolBox.JavaToolArgs() + .setOptions("-cp", "out", "-d", "out", "-source", "7") + .setSources(LegacyInvocationSrc); + ToolBox.javac(javacArgs); + } + + void testSuperInvocations() throws Exception { + //compile SubA, SubB + ToolBox.JavaToolArgs javacArgs = + new ToolBox.JavaToolArgs() + .setOptions("-cp", "out", "-d", "out", "-source", "7") + .setSources(SubASrc, SubBSrc); + ToolBox.javac(javacArgs); + } +} diff -r adc980c0dbcc -r e0ba35f27975 langtools/test/tools/javac/scope/7046348/EagerInterfaceCompletionTest.java --- a/langtools/test/tools/javac/scope/7046348/EagerInterfaceCompletionTest.java Thu Dec 19 21:58:50 2013 +0000 +++ b/langtools/test/tools/javac/scope/7046348/EagerInterfaceCompletionTest.java Thu Dec 19 22:24:27 2013 +0000 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2013, 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 @@ -181,7 +181,7 @@ case FIELD: case SUPER: return true; case METHOD: return hk != HierarchyKind.INTERFACE || ak == ActionKind.REMOVE_B || - (hk == HierarchyKind.INTERFACE && ak == ActionKind.REMOVE_A && vk == VersionKind.LAMBDA); + (hk == HierarchyKind.INTERFACE && ak == ActionKind.REMOVE_A); default: throw new AssertionError("Unexpected test kind " + this); } }