lambda: void return type compatibility (initial); functional interfaces without method params error messages

java/java-psi-api/src/com/intellij/psi/LambdaUtil.java

@@ -126,22 +126,29 @@ public class LambdaUtil {
     }
     LOG.assertTrue(psiClass != null);
     PsiType methodReturnType = getReturnType(psiClass, methodSignature);
-    if (methodReturnType != null && methodReturnType != PsiType.VOID) {
-      methodReturnType = resolveResult.getSubstitutor().substitute(methodSignature.getSubstitutor().substitute(methodReturnType));
-      final PsiElement body = lambdaExpression.getBody();
-      if (body instanceof PsiCodeBlock) {
-        final PsiCodeBlock block = (PsiCodeBlock)body;
-        for (PsiStatement statement : block.getStatements()) {
-          if (statement instanceof PsiReturnStatement) {
-            final PsiExpression returnValue = ((PsiReturnStatement)statement).getReturnValue();
-            if (returnValue != null) {
-              if (!checkReturnTypeAssignability(returnValue.getType(), parameterTypes, lambdaExpression, methodReturnType)) return false;
+    if (methodReturnType != null) {
+      if (methodReturnType != PsiType.VOID) {
+        methodReturnType = resolveResult.getSubstitutor().substitute(methodSignature.getSubstitutor().substitute(methodReturnType));
+        final PsiElement body = lambdaExpression.getBody();
+        if (body instanceof PsiCodeBlock) {
+          final PsiCodeBlock block = (PsiCodeBlock)body;
+          for (PsiStatement statement : block.getStatements()) {
+            if (statement instanceof PsiReturnStatement) {
+              final PsiExpression returnValue = ((PsiReturnStatement)statement).getReturnValue();
+              if (returnValue != null) {
+                if (!checkReturnTypeAssignability(returnValue.getType(), parameterTypes, lambdaExpression, methodReturnType)) return false;
+              }
             }
           }
         }
-      }
-      else if (body instanceof PsiExpression) {
-        return checkReturnTypeAssignability(((PsiExpression)body).getType(), parameterTypes, lambdaExpression, methodReturnType);
+        else if (body instanceof PsiExpression) {
+          return checkReturnTypeAssignability(((PsiExpression)body).getType(), parameterTypes, lambdaExpression, methodReturnType);
+        }
+      } else {
+        final List<PsiExpression> returnExpressions = lambdaExpression.getReturnExpressions();
+        for (PsiExpression returnValue : returnExpressions) {
+         if (returnValue.getType() != PsiType.VOID) return false;
+        }
       }
     }
     return true;

java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java

@@ -19,6 +19,7 @@ import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Pair;
 import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.*;
+import com.intellij.psi.impl.source.tree.java.PsiLambdaExpressionImpl;
 import com.intellij.psi.infos.CandidateInfo;
 import com.intellij.psi.infos.MethodCandidateInfo;
 import com.intellij.psi.scope.MethodProcessorSetupFailedException;
@@ -876,8 +877,14 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
       final PsiExpressionList argumentList = methodCall.getArgumentList();
       if (argumentList != null && PsiUtil.getLanguageLevel(argumentList).isAtLeast(LanguageLevel.JDK_1_8)) {
         for (PsiExpression expression : argumentList.getExpressions()) {
-          if (expression instanceof PsiLambdaExpression){
-            return getFailedInferenceConstraint(typeParameter);
+          if (expression instanceof PsiLambdaExpression) {
+            if (((PsiLambdaExpression)expression).getParameterList().getParametersCount() > 0){
+              return getFailedInferenceConstraint(typeParameter);
+            }
+            final PsiType functionalInterfaceType = PsiLambdaExpressionImpl.getFunctionalInterfaceType(((PsiLambdaExpression)expression), false);
+            if (functionalInterfaceType == null || PsiUtil.resolveClassInType(functionalInterfaceType) == typeParameter){
+              return getFailedInferenceConstraint(typeParameter);
+            }
           }
         }
       }

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility.java

@@ -57,7 +57,7 @@ class ReturnTypeCompatibility {
     }
 
     public static void main(String[] args) {
-        call(<error descr="Cyclic inference">i-> {return i;}</error>);
+        <error descr="Cannot resolve method 'call(<lambda expression>)'">call</error>(i-> {return i;});
     }
 }
 

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/TypeArgsConsistencyWithoutParams.java

@@ -0,0 +1,36 @@
+import java.util.*;
+class Test4 {
+   interface I<K> {
+       List<K> foo();
+   }
+    
+    static <T> void bar(I<T> i){}
+    
+    {
+        bar(() -> null);
+    }
+}
+
+class Test5 {
+    interface I<K> {
+        void foo(K k);
+    }
+
+    static <T> void bar(I<T> i){}
+
+    {
+        bar<error descr="'bar(Test5.I<T>)' in 'Test5' cannot be applied to '(<lambda expression>)'">(() -> null)</error>;
+    }
+}
+class Test6 {
+    interface I<K> {
+        void foo();
+    }
+
+    static <T> void bar(I<T> i){}
+
+    {
+        bar<error descr="'bar(Test6.I<java.lang.Object>)' in 'Test6' cannot be applied to '(<lambda expression>)'">(() -> null)</error>;
+        bar(() -> {});
+    }
+}

java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java

@@ -49,6 +49,10 @@ public class LambdaHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testTypeArgsConsistencyWithoutParams() throws Exception {
+    doTest();
+  }
+
   public void testWildcardBounds() throws Exception {
     doTest();
   }