Tue, 14 May 2013 11:11:09 -0700
8012556: Implement lambda methods on interfaces as static
8006140: Javac NPE compiling Lambda expression on initialization expression of static field in interface
Summary: Lambdas occurring in static contexts or those not needing instance information should be generated into static methods. This has long been the case for classes. However, as a work-around to the lack of support for statics on interfaces, interface lambda methods have been generated into default methods. For lambdas in interface static contexts (fields and static methods) this causes an NPE in javac because there is no 'this'. MethodHandles now support static methods on interfaces. This changeset allows lambda methods to be generated as static interface methods. An existing bug in Hotspot (8013875) is exposed in a test when the "-esa" flag is used. This test and another test that already exposed this bug have been marked with @ignore.
Reviewed-by: mcimadamore
1 /*
2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
24 /*
25 * @test
26 * @bug 8003280
27 * @summary Add lambda tests
28 * compile crashes on partial lambda expressions
29 */
31 import com.sun.source.util.JavacTask;
32 import java.net.URI;
33 import java.util.Arrays;
34 import javax.tools.Diagnostic;
35 import javax.tools.JavaCompiler;
36 import javax.tools.JavaFileObject;
37 import javax.tools.SimpleJavaFileObject;
38 import javax.tools.StandardJavaFileManager;
39 import javax.tools.ToolProvider;
42 public class BadLambdaExpr {
44 static int checkCount = 0;
46 enum ParameterListKind {
47 ZERO_ARY("()"),
48 UNARY("(#P)"),
49 TWO_ARY("(#P, #P)"),
50 THREE_ARY("(#P, #P, #P)");
52 String parametersTemplateStr;
54 ParameterListKind(String parametersTemplateStr) {
55 this.parametersTemplateStr = parametersTemplateStr;
56 }
58 String getParameterString(ParameterKind pk) {
59 return parametersTemplateStr.replaceAll("#P", pk.parameterStr);
60 }
61 }
63 enum ParameterKind {
64 IMPLICIT("a"),
65 EXPLIICT("A a");
67 String parameterStr;
69 ParameterKind(String parameterStr) {
70 this.parameterStr = parameterStr;
71 }
72 }
74 enum ArrowKind {
75 NONE(""),
76 SEMI("-"),
77 FULL("->");
79 String arrowStr;
81 ArrowKind(String arrowStr) {
82 this.arrowStr = arrowStr;
83 }
84 }
86 enum ExprKind {
87 NONE("#P#A"),
88 METHOD_CALL("m(#P#A)"),
89 CONSTR_CALL("new Foo(#P#A)");
91 String expressionTemplate;
93 ExprKind(String expressionTemplate) {
94 this.expressionTemplate = expressionTemplate;
95 }
97 String expressionString(ParameterListKind plk, ParameterKind pk,
98 ArrowKind ak) {
99 return expressionTemplate.replaceAll("#P", plk.getParameterString(pk))
100 .replaceAll("#A", ak.arrowStr);
101 }
102 }
104 public static void main(String... args) throws Exception {
106 //create default shared JavaCompiler - reused across multiple compilations
107 JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
108 StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
110 for (ParameterListKind plk : ParameterListKind.values()) {
111 for (ParameterKind pk : ParameterKind.values()) {
112 for (ArrowKind ak : ArrowKind.values()) {
113 for (ExprKind ek : ExprKind.values()) {
114 new BadLambdaExpr(plk, pk, ak, ek).run(comp, fm);
115 }
116 }
117 }
118 }
119 System.out.println("Total check executed: " + checkCount);
120 }
122 ParameterListKind plk;
123 ParameterKind pk;
124 ArrowKind ak;
125 ExprKind ek;
126 JavaSource source;
127 DiagnosticChecker diagChecker;
129 BadLambdaExpr(ParameterListKind plk, ParameterKind pk, ArrowKind ak, ExprKind ek) {
130 this.plk = plk;
131 this.pk = pk;
132 this.ak = ak;
133 this.ek = ek;
134 this.source = new JavaSource();
135 this.diagChecker = new DiagnosticChecker();
136 }
138 class JavaSource extends SimpleJavaFileObject {
140 String template = "class Test {\n" +
141 " SAM s = #E;\n" +
142 "}";
144 String source;
146 public JavaSource() {
147 super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
148 source = template.replaceAll("#E", ek.expressionString(plk, pk, ak));
149 }
151 @Override
152 public CharSequence getCharContent(boolean ignoreEncodingErrors) {
153 return source;
154 }
155 }
157 void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
158 JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
159 null, null, Arrays.asList(source));
160 try {
161 ct.parse();
162 } catch (Throwable ex) {
163 throw new AssertionError("Error thron when parsing the following source:\n" + source.getCharContent(true));
164 }
165 check();
166 }
168 void check() {
169 boolean errorExpected =
170 ak != ArrowKind.NONE ||
171 plk != ParameterListKind.UNARY ||
172 pk != ParameterKind.IMPLICIT;
173 if (errorExpected != diagChecker.errorFound) {
174 throw new Error("bad diag for source:\n" +
175 source.getCharContent(true));
176 }
177 checkCount++;
178 }
180 static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
182 boolean errorFound;
184 @Override
185 public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
186 if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
187 errorFound = true;
188 }
189 }
190 }
191 }