inference: skip lambda content and all its dependants when lambda type parameter type is calculated

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/expressions/CacheUnresolvedMethods4.java

@@ -0,0 +1,14 @@
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+class Test {
+  <K> void foo(Function<String, K> f1) {}
+
+  <T> Stream<T> bar(T ts) {
+    return null;
+  }
+
+  void f(){
+    foo(y -> bar(y.to<caret>String()).map(a -> a.length()));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/expressions/CacheUnresolvedMethods5.java

@@ -0,0 +1,10 @@
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+
+class StreamMainSimplified {
+  public static void main(Optional<Map.Entry<Integer, String>> first) {
+    String s1 = first.map((e) -> e.getV<caret>alue()).orElse("").substring(9);
+  }
+
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ChainedInference.java

@@ -3,8 +3,8 @@ import java.util.*;
 class Main {
 
     void foo(List<Integer> list) {
-        bar(list, i -> i.intValue(), i -> i.<error descr="Cannot resolve method 'unknown()'">unknown</error>());
-        bar1(list, i -> i.intValue(), i -> i.<error descr="Cannot resolve method 'unknown()'">unknown</error>());
+        bar(list, i -> <error descr="Bad return type in lambda expression: int cannot be converted to S_OUT">i.intValue()</error>, i -> i.<error descr="Cannot resolve method 'unknown()'">unknown</error>());
+        bar1(list, i -> <error descr="Bad return type in lambda expression: int cannot be converted to S_OUT">i.intValue()</error>, i -> i.<error descr="Cannot resolve method 'unknown()'">unknown</error>());
     }
 
     <U, S_IN, S_OUT, R> R bar(List<S_IN> list,

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/IDEA148841.java

@@ -36,3 +36,12 @@ final class Collectors {
                         downstream.characteristics().toArray(new Collector.Characteristics[downstream.characteristics().size()]));
   }
 }
+
+class SimplifiedTest {
+
+  public static void a(Stream<Integer> classifier) {
+    flatMapping(classifier.map(k -> new AbstractMap.SimpleEntry<Integer, String>(k,k.toString())), Map.Entry::getKey);
+  }
+
+  public static <U, R> void flatMapping(Stream<U> stream, Function<U, R> downstream) {}
+}