Paul King created GROOVY-12783:
----------------------------------
Summary: SC: a lambda or method reference returning to a
functional interface that declares a String does not convert the value
Key: GROOVY-12783
URL: https://issues.apache.org/jira/browse/GROOVY-12783
Project: Groovy
Issue Type: Bug
Reporter: Paul King
The type checker accepts a value of another type where a lambda, closure,
method reference or method pointer returns to a functional interface that
declares a {{String}}, as it does for an assignment to a {{String}} or the
{{return}} of a method declared to return one. For an assignment or a
{{return}} the value is then converted. For a lambda or a method reference
under {{@CompileStatic}} it is not, so the functional interface gives a value
that is not a {{String}}.
{code:groovy}
import java.util.function.Supplier
@groovy.transform.CompileStatic
class C {
// reads the value with no static type for it
static String given(Supplier s) { Object o = s.get();
o.getClass().simpleName }
static main(args) {
def n = 1
Supplier<String> v = () -> "a$n"
println given(v)
}
}
{code}
*Actual*, with 6.0.0 and master: {{GStringImpl}}.
*Expected*: {{String}}, as for {{String s = "a$n"}} and for {{String m() {
"a$n" } }}.
The same holds for a value that is not a {{GString}}:
{code:groovy}
static <T extends Number> T zero() { (T) Integer.valueOf(0) }
...
Supplier<String> v = () -> C.zero() // gives an Integer
Supplier<String> w = C::zero // gives an Integer
{code}
What a caller then sees depends on how it reads the value:
||Read||6.0.0||master||
|{{given(v)}}, no static type|{{GStringImpl}}|{{GStringImpl}}|
|{{Object o = v.get()}}|{{String}}|{{GStringImpl}}|
|{{String s = v.get()}}|{{String}}|{{String}}|
|{{v.get().length()}}|{{ClassCastException}}|2|
The two rows that differ follow from GROOVY-12469, which no longer converts a
value on assignment to a wider variable and converts a {{GString}} where a
method of {{String}} is called. That change is to how such a value is read.
This issue is that the value is produced with the wrong type. For a value that
is not a {{GString}}, {{v.get().length()}} is a {{ClassCastException}} in both.
By form, under {{@CompileStatic}} / {{@TypeChecked}}, for {{Supplier<String> v
= ...}} giving a {{Number}}:
||Form||@CompileStatic||@TypeChecked||
|closure, {{ { -> C.zero() } }}|{{String}}|{{String}}|
|lambda, {{() -> C.zero()}}|{{Integer}}|{{String}}|
|method reference, {{C::zero}}|{{Integer}}|{{Integer}}|
|method pointer, {{C.&zero}}|{{Integer}}|{{Integer}}|
h3. Proposal
Treat the return to a functional interface as the conversion that the type
checker already takes it to be: the value is converted as by a method declared
to return the type that the functional interface declares. GROOVY-12616,
GROOVY-12617 and GROOVY-12623 did this for a functional interface whose method
returns a primitive type.
A prototype for lambdas declares the generated {{doCall}} method to return
{{String}} where the functional interface type that the lambda is compiled for
declares one, so the existing conversion of a returned value applies. With it:
* each lambda above gives a {{String}}, as do {{Function<Integer, String>}},
{{UnaryOperator<String>}}, {{Callable<String>}}, a lambda passed as an
argument, a block body with several {{return}} statements and a serializable
lambda;
* a {{String}} and {{null}} are returned as they are;
* {{Supplier<CharSequence>}} and {{Supplier<Object>}} still give the
{{GString}};
* {{Supplier<List<String>> v = () -> ["a$n"]}} is still a compile error: a type
argument within the returned type is not converted.
Of 9,324 tests in the type checking, static compilation, lambda and method
reference suites, the 21 that fail assert the descriptor of the generated
method, {{doCall()Ljava/lang/Object;}}.
h3. To decide
* *Method references and pointers.* Either convert, with the adapter that
GROOVY-12617 uses for a primitive return type, or reject them, as the method
does not return what the functional interface declares. A lambda has a body in
which to convert; a reference does not.
* *{{Boolean}}.* {{Supplier<Boolean> v = () -> 'x'}} is a compile error, while
{{Predicate<String> p = s -> s}} and {{boolean b = 'x'}} convert by Groovy
truth, and {{Supplier<Boolean> v = 'x'::toString}} compiles and gives a
{{String}}. The same rule would cover these.
* *Through a generic call.* {{Supplier<String> v = toSupplier(() -> C.zero())}}
is a compile error in 6.0.0 and master, as the target gives the type parameter
of {{toSupplier}} a {{String}} and the result of the lambda is then checked
against it as a type argument. If the return is a conversion, this would
compile as the direct assignment does.
* *GROOVY-12469.* For a lambda, {{Object o = v.get()}} would be a {{String}}
again, as the value would be one.
--
This message was sent by Atlassian Jira
(v10.3.26#10030026)