Incoherent invocation type inference?

[B. Blaser]

Hi,

2017-01-16 19:33 GMT+01:00 B. Blaser <bsrbnd at gmail.com>:
> 2017-01-16 18:03 GMT+01:00 Maurizio Cimadamore <maurizio.cimadamore at oracle.com>:
>>
>> On 16/01/17 16:49, B. Blaser wrote:
>>>
>>> Intersections seem to be dangerous only in the case of a naked return
>>> type variable with no parameter provided ("get()" or "get(null)")
>>> because get() wouldn't know about the return type constraints. We
>>> could, for example, update the rule as follows: "emit a lint warning
>>> if the return type T is a naked type variable infered to an
>>> intersection type and no constraint is given by the actual arguments"?
>>>
>>> Or are you suggesting to modify the rules of intersection types on the
>>> language side?
>>
>> I think the Lint warning makes sense for naked return type regardless of
>> intersections - as in the example I wrote.
>
> Ok for this first rule.

What do you think of something like the draft below
(Infer.instantiateMethod() upon rev. b6960e2da008)?
Thanks,
Bernard

>> Maurizio

diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java
b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java
@@ -182,6 +182,26 @@
         final InferenceContext inferenceContext = new
InferenceContext(this, tvars);  //B0
         inferenceException.clear();
         try {
+            if (resultInfo != null && resultInfo.pt != Type.noType &&
mt.restype.hasTag(TYPEVAR)) {
+                int nbConstraints = 0;
+                if (mt.argtypes.length() == argtypes.length()) {
+                    for (int i=0; i<mt.argtypes.length(); i++) {
+                        Type pType = mt.argtypes.get(i);
+                        Type aType = argtypes.get(i);
+                        if (pType.contains(mt.restype) && aType !=
syms.botType)
+                            nbConstraints++;
+                    }
+                }
+                if (nbConstraints == 0) {
+                    chk.warnUnchecked(env.tree.pos(),
+                           "unchecked.invocation.type.inference",
+                           Kinds.kindName(msym),
+                           msym.name,
+                           Kinds.kindName(msym.location()),
+                           msym.location());
+                }
+            }
+
             DeferredAttr.DeferredAttrContext deferredAttrContext =
                         resolveContext.deferredAttrContext(msym,
inferenceContext, resultInfo, warn);

diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties
b/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties
@@ -1748,6 +1748,10 @@
     required: {2}\n\
     found: {3}

+# 0: symbol kind, 1: name, 2: symbol kind, 3: symbol
+compiler.warn.unchecked.invocation.type.inference=\
+    unchecked invocation type inference: {0} {1} in {2} {3} misses
constraints from actual arguments
+
 # 0: type
 compiler.warn.unchecked.generic.array.creation=\
     unchecked generic array creation for varargs parameter of type {0}