lambda: take into account substitution interface with method -> functional interface;

do not infer return type parameters when lambda parameter type was calculated, no substitution caching here (IDEA-90875)

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2000-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import java.util.*;
+
+class LambdaTest<TT> {
+  interface BinaryOperator<T> {
+
+    public T eval(T left, T right);
+  }
+
+  interface Mapper<T, U> {
+    U map(T t);
+  }
+
+  public static <T, U> LambdaTest<U> map(final Iterable<? extends T> iterable, final Mapper<? super T, ? extends U> mapper) {
+    return null;
+  }
+
+  TT reduce(TT base, BinaryOperator<TT> reducer) {
+    return null;
+  }
+
+  public void test() {
+    final List<String> aStrings = Arrays.asList("1", "2", "3");
+    map(aStrings, s -> s.length()).reduce(0, (l,  r) -> l + r);
+  }
+}
+
+class LambdaTest2<TypeParam> {
+  interface BinaryOperator<T> {
+    public T eval(T left, T right);
+  }
+
+  interface Mapper<T, U> {
+    U map(T t);
+  }
+
+  public <U> LambdaTest<U> map(final Mapper<? super TypeParam, ? extends U> mapper) {
+    return null;
+  }
+
+  TypeParam reduce(TypeParam base, BinaryOperator<TypeParam> reducer) {
+    return null;
+  }
+
+  public void test() {
+    final LambdaTest2<String> lt = new LambdaTest2<>();
+    lt.map(s -> s.length()).reduce(0, (l,  r) -> l + r);
+  }
+}

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

@@ -34,3 +34,27 @@ class Test3 {
     bar(<error descr="Cyclic inference">x->{}</error>, new ArrayList());
   }
 }
+
+
+class Test4 {
+  protected <T, U> U exerciseOps(TestData<T> data, TerminalOp1<T, U> terminal, IntermediateOp1... ops) {
+    return exerciseOps(data, (u, v) -> u.equals(v), terminal, ops);
+  }
+
+  protected static <T, U> U exerciseOps(TestData<T> data,
+                                        BiPredicate1<U, U> equalator,
+                                        TerminalOp1<T, U> terminalOp,
+                                        IntermediateOp1[] ops) {
+    return null;
+  }
+
+  public interface IntermediateOp1<T,U> {
+
+  }
+  public interface BiPredicate1<T, U> extends IntermediateOp1<T, U>{
+    boolean _(T t, U u);
+  }
+
+  public interface TerminalOp1<T, U> extends IntermediateOp1<T, U> {}
+
+}