switch tests on new inference

(cherry picked from commit d2cbf3f2833104c3a0381059b0d6ef8ac0b3c94c)

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

@@ -0,0 +1,20 @@
+abstract class AbstractPip {
+
+    interface Getter<T> {
+        T get();
+    }
+
+    interface Unbounded<K> {}
+
+
+    abstract <P_IN> void wrap(Getter<Unbounded<P_IN>> getter);
+
+
+    public void spliterator() {
+       wrap(()   -> getUnbound());
+    }
+
+    private Unbounded<? extends String> getUnbound() {
+        return null;
+    }
+}

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

@@ -0,0 +1,31 @@
+class CyclicInference {
+
+    interface Execute {
+        void execute();
+    }
+
+    /**
+     * Lambda wrapper for expression-like lambdas
+     *
+     * @param lambda
+     * @param <I> interface which lambda class implements (derived by compiler via type inference)
+     * @param <T> lambda class having function code to be executed
+     * @return I interface implemented by lambda
+     */
+    private static <I, T extends I> I lambdaWrapper(final T lambda) {
+        return (I)lambda;
+    }
+
+    /**
+     * How expression-like lambdas returning void can be wrapped
+     */
+    public void lambdaWithOneExpressionReturningVoid() {
+        Execute sayHello = lambdaWrapper(() -> System.out.println("Hello"));
+        sayHello.execute();
+    }
+
+    public static void main(String[] args) {
+        CyclicInference lam = new CyclicInference();
+        lam.lambdaWithOneExpressionReturningVoid();
+    }
+}

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

@@ -0,0 +1,86 @@
+class BugExample {
+
+    public static void main(String... args) {
+        Observable<String> obs = create((Observer<? super String> o) -> {
+            o.onNext("one");
+            o.onNext("two");
+            o.onCompleted();
+        });
+
+        obs.subscribe(new Observer<String>() {
+            @Override
+            public void onCompleted() {
+                System.out.println("Completed");
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                System.out.println("Error");
+            }
+
+            @Override
+            public void onNext(String v) {
+                System.out.println("Value: " + v);
+            }
+        });
+
+        Observable<String> obs2 = create(new OnSubscribeFunc<String>() {
+            @Override
+            public void onSubscribe(Observer<? super String> o) {
+                o.onNext("one");
+                o.onNext("two");
+                o.onCompleted();
+            }
+        });
+
+        obs2.subscribe(new Observer<String>() {
+            @Override
+            public void onCompleted() {
+                System.out.println("Completed");
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                System.out.println("Error");
+            }
+
+            @Override
+            public void onNext(String v) {
+                System.out.println("Value: " + v);
+            }
+        });
+
+    }
+
+    public static class Observable<T> {
+        private final OnSubscribeFunc<T> f;
+
+        public Observable(OnSubscribeFunc<T> f) {
+            this.f = f;
+        }
+
+        public void subscribe(Observer<T> o) {
+            f.onSubscribe(o);
+        }
+    }
+
+    public static <T> Observable<T> create(OnSubscribeFunc<T> func) {
+        return new Observable<T>(func);
+    }
+
+    public static interface OnSubscribeFunc<T> {
+
+        public void onSubscribe(Observer<? super T> t1);
+
+    }
+
+    public interface Observer<T> {
+
+        public void onCompleted();
+
+        public void onError(Throwable e);
+
+        public void onNext(T args);
+    }
+
+}

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

@@ -0,0 +1,21 @@
+public class Tmp {
+  Integer toInt(Number num) {
+    return null;
+  }
+
+  Stream<Number> test() {
+    Stream<Number> numberStream = null;
+    Stream<Number> integerStream1 = numberStream.map(this::toInt);
+    Stream<Number> integerStream2 = numberStream.map(num -> toInt(num));
+
+    return numberStream.map(this::toInt);
+  }
+}
+
+interface Stream<T> {
+  <R> Stream<R> map(Function<? super T, ? extends R> mapper);
+}
+
+interface Function<I, R> {
+  R fun(I t);
+}

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

@@ -0,0 +1,17 @@
+interface Eff<A, B> {
+  B f(A a);
+}
+
+class Disfunction {
+  public static <A, B, C> Eff<C, B> apply(final Eff<C, Eff<A, B>> cab, final Eff<C, A> ca) {
+    return bind(cab, f -> compose(a -> f.f(a), ca));
+  }
+
+  public static <A, B, C> Eff<C, B> bind(final Eff<C, A> ma, final Eff<A, Eff<C, B>> f) {
+    return m -> f.f(ma.f(m)).f(m);
+  }
+
+  public static <A, B, C> Eff<A, C> compose(final Eff<B, C> f, final Eff<A, B> g) {
+    return a -> f.f(g.f(a));
+  }
+}