new inference: ignore return dependencies of a variable when proper bound is present (IDEA-119535)

java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceVariable.java

@@ -74,8 +74,15 @@ public class InferenceVariable {
     next:
     for (InferenceVariable variable : session.getInferenceVariables()) {
       if (!dependencies.contains(variable) && variable != this) {
+        nextBound:
         for (InferenceBound inferenceBound : InferenceBound.values()) {
-          for (PsiType bound : getBounds(inferenceBound)) {
+          final List<PsiType> bounds = getBounds(inferenceBound); //todo
+          for (PsiType bound : bounds) {
+            if (session.isProperType(bound)) {
+              continue nextBound;
+            }
+          }
+          for (PsiType bound : bounds) {
             Set<InferenceVariable> deps = new HashSet<InferenceVariable>();
             session.collectDependencies(bound, deps);
             if (deps.contains(this)) {

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/IDEA119003.java

@@ -0,0 +1,84 @@
+package problems;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static java.util.stream.Collectors.*;
+
+class Test {
+
+  enum CaloricLevel { DIET, NORMAL, FAT }
+
+  public static void main(String[] args) {
+    List<Dish> menu = Arrays.asList(
+      new Dish("pork", false, 800, Dish.Type.MEAT),
+      new Dish("beef", false, 700, Dish.Type.MEAT),
+      new Dish("chicken", false, 400, Dish.Type.MEAT),
+      new Dish("french fries", true, 530, Dish.Type.OTHER),
+      new Dish("rice", true, 350, Dish.Type.OTHER),
+      new Dish("season fruit", true, 120, Dish.Type.OTHER),
+      new Dish("pizza", true, 550, Dish.Type.OTHER),
+      new Dish("prawns", false, 400, Dish.Type.FISH),
+      new Dish("salmon", false, 450, Dish.Type.FISH)
+    );
+
+    System.out.println(
+      menu.stream().collect(reducing(0, Dish::getCalories, (Integer i, Integer j) -> i + j))
+    );
+
+    System.out.println(
+      menu.stream().collect(
+        groupingBy(Dish::getType, mapping(
+          dish -> { if (dish.getCalories() <= 400) return CaloricLevel.DIET;
+          else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
+          else return CaloricLevel.FAT; },
+          toSet())))
+    );
+
+    System.out.println(
+      menu.stream().collect(
+        groupingBy(Dish::getType,
+                   collectingAndThen(
+                     reducing((d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2),
+                     Optional::get)))
+    );
+  }
+}
+
+class Dish {
+  private final String name;
+  private final boolean vegetarian;
+  private final int calories;
+  private final Type type;
+
+  public Dish(String name, boolean vegetarian, int calories, Type type) {
+    this.name = name;
+    this.vegetarian = vegetarian;
+    this.calories = calories;
+    this.type = type;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public boolean isVegetarian() {
+    return vegetarian;
+  }
+
+  public int getCalories() {
+    return calories;
+  }
+
+  public Type getType() {
+    return type;
+  }
+
+  public enum Type { MEAT, FISH, OTHER }
+
+  @Override
+  public String toString() {
+    return name;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/IDEA119535.java

@@ -1,3 +1,4 @@
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -5,6 +6,8 @@ import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.stream.Collector;
 
+import static java.util.stream.Collectors.*;
+
 class Stuff {
   public enum Type { A }
   private final int value;
@@ -41,4 +44,31 @@ class FakeErrors {
                                         Collector<? super T, A, D> downstream) {
     return null;
   }
+}
+
+class FakeErrorsComplete {
+  public static List<Stuff> elems(){
+    return Arrays.asList(
+      new Stuff(800, Stuff.Type.A));
+  }
+
+  public static void main(String ... args){
+
+    Map<Stuff.Type, Optional<Stuff>> bar =
+      elems()
+        .stream()
+        .collect(groupingBy(Stuff::getType,
+                            reducing((d1, d2) -> d1.getValue() > d2.getValue() ? d1 : d2)));
+
+    System.out.println(bar);
+
+    Map<Stuff.Type, Stuff> baz =
+      elems()
+        .stream()
+        .collect(groupingBy(Stuff::getType,
+                            collectingAndThen(reducing((Stuff d1, Stuff d2) -> d1.getValue() > d2.getValue() ? d1 : d2),
+                                              Optional::get)));
+
+    System.out.println(baz);
+  }
 }

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

@@ -130,6 +130,10 @@ public class NewLambdaHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testIDEA119003() throws Exception {
+    doTest();
+  }
+
   public void testIDEA117124() throws Exception {
     doTest();
   }