Mercurial > hg > openjdk > jdk8 > langtools
changeset 2156:963c57175e40
8025290: javac implicit versus explicit lambda compilation error
Reviewed-by: jjg, dlsmith
author | vromero |
---|---|
date | Tue, 22 Oct 2013 13:54:49 +0100 |
parents | f003f09144ff |
children | 6cd16d8ed2b9 351d6808c1a5 |
files | src/share/classes/com/sun/tools/javac/comp/Attr.java src/share/classes/com/sun/tools/javac/comp/Check.java src/share/classes/com/sun/tools/javac/comp/Infer.java src/share/classes/com/sun/tools/javac/util/JavacMessages.java test/tools/javac/lambda/T8025290/ExplicitVSImplicitLambdaTest.java |
diffstat | 5 files changed, 111 insertions(+), 19 deletions(-) [+] |
line wrap: on
line diff
--- a/src/share/classes/com/sun/tools/javac/comp/Attr.java Tue Oct 22 10:08:49 2013 +0200 +++ b/src/share/classes/com/sun/tools/javac/comp/Attr.java Tue Oct 22 13:54:49 2013 +0100 @@ -250,6 +250,14 @@ Type owntype = found; if (!owntype.hasTag(ERROR) && !resultInfo.pt.hasTag(METHOD) && !resultInfo.pt.hasTag(FORALL)) { if (allowPoly && inferenceContext.free(found)) { + if ((ownkind & ~resultInfo.pkind) == 0) { + owntype = resultInfo.check(tree, inferenceContext.asFree(owntype)); + } else { + log.error(tree.pos(), "unexpected.type", + kindNames(resultInfo.pkind), + kindName(ownkind)); + owntype = types.createErrorType(owntype); + } inferenceContext.addFreeTypeListener(List.of(found, resultInfo.pt), new FreeTypeListener() { @Override public void typesInferred(InferenceContext inferenceContext) { @@ -511,6 +519,15 @@ protected ResultInfo dup(CheckContext newContext) { return new ResultInfo(pkind, pt, newContext); } + + @Override + public String toString() { + if (pt != null) { + return pt.toString(); + } else { + return ""; + } + } } class RecoveryInfo extends ResultInfo {
--- a/src/share/classes/com/sun/tools/javac/comp/Check.java Tue Oct 22 10:08:49 2013 +0200 +++ b/src/share/classes/com/sun/tools/javac/comp/Check.java Tue Oct 22 13:54:49 2013 +0100 @@ -528,7 +528,7 @@ inferenceContext.addFreeTypeListener(List.of(req), new FreeTypeListener() { @Override public void typesInferred(InferenceContext inferenceContext) { - checkType(pos, found, inferenceContext.asInstType(req), checkContext); + checkType(pos, inferenceContext.asInstType(found), inferenceContext.asInstType(req), checkContext); } }); }
--- a/src/share/classes/com/sun/tools/javac/comp/Infer.java Tue Oct 22 10:08:49 2013 +0200 +++ b/src/share/classes/com/sun/tools/javac/comp/Infer.java Tue Oct 22 13:54:49 2013 +0100 @@ -1768,9 +1768,11 @@ public Type apply(Type t) { if (t.hasTag(TYPEVAR)) { TypeVar tv = (TypeVar)t; - return tv.isCaptured() ? - new CapturedUndetVar((CapturedType)tv, types) : - new UndetVar(tv, types); + if (tv.isCaptured()) { + return new CapturedUndetVar((CapturedType)tv, types); + } else { + return new UndetVar(tv, types); + } } else { return t.map(this); }
--- a/src/share/classes/com/sun/tools/javac/util/JavacMessages.java Tue Oct 22 10:08:49 2013 +0200 +++ b/src/share/classes/com/sun/tools/javac/util/JavacMessages.java Tue Oct 22 13:54:49 2013 +0100 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 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 @@ -184,19 +184,19 @@ String key, Object... args) { String msg = null; - for (List<ResourceBundle> l = bundles; l.nonEmpty() && msg == null; l = l.tail) { - ResourceBundle rb = l.head; - try { - msg = rb.getString(key); - } - catch (MissingResourceException e) { - // ignore, try other bundles in list - } - } - if (msg == null) { - msg = "compiler message file broken: key=" + key + - " arguments={0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}"; - } - return MessageFormat.format(msg, args); + for (List<ResourceBundle> l = bundles; l.nonEmpty() && msg == null; l = l.tail) { + ResourceBundle rb = l.head; + try { + msg = rb.getString(key); + } + catch (MissingResourceException e) { + // ignore, try other bundles in list + } + } + if (msg == null) { + msg = "compiler message file broken: key=" + key + + " arguments={0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}"; + } + return MessageFormat.format(msg, args); } }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/javac/lambda/T8025290/ExplicitVSImplicitLambdaTest.java Tue Oct 22 13:54:49 2013 +0100 @@ -0,0 +1,73 @@ +/* + * 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 8025290 + * @summary javac implicit versus explicit lambda compilation error + * @compile ExplicitVSImplicitLambdaTest.java + */ + +import java.util.function.*; + +public class ExplicitVSImplicitLambdaTest { + private void test() + { + /* in the explicit case "e" is inferred to String so we can use a String + * only method. + */ + MyComparator.mycomparing1((String e) -> e.concat("")); + MyComparator.mycomparing2((String e) -> e.concat("")); + MyComparator.mycomparing3((String e) -> e.concat("")); + MyComparator.mycomparing4((String e) -> e.concat("")); + + /* in the implicit case "e" is inferred to Object so toString() is OK. + */ + MyComparator.mycomparing1((e) -> e.toString()); + MyComparator.mycomparing2((e) -> e.toString()); + MyComparator.mycomparing3((e) -> e.toString()); + MyComparator.mycomparing4((e) -> e.toString()); + } +} + +interface MyComparator<T> { + public static <T, U extends Comparable<? super U>> MyComparator<T> mycomparing1( + Function<? super T, ? extends U> keyExtractor) { + return null; + } + + public static <T, U extends Comparable<? super U>> MyComparator<T> mycomparing2( + Function<? super T, ? super U> keyExtractor) { + return null; + } + + public static <T, U extends Comparable<? super U>> MyComparator<T> mycomparing3( + Function<? extends T, ? extends U> keyExtractor) { + return null; + } + + public static <T, U extends Comparable<? super U>> MyComparator<T> mycomparing4( + Function<? extends T, ? super U> keyExtractor) { + return null; + } +}