method refs: testdata; varargs

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefMisc1.java

@@ -1,3 +1,4 @@
+import java.util.*;
 class MyTest {
 
    static void m(int i) {//here 
@@ -56,3 +57,141 @@ class MyTest2 {
         call<error descr="Cannot resolve method 'call(int, <method reference>)'">(1, MyTest2::m)</error>; //ambiguous
     }
 }
+
+class MyTest3 {
+    interface I {
+       void m();
+    }
+
+    MyTest3() {}
+
+   static void m() { }
+
+   public static void main(String[] args) {
+      I s = new MyTest3()::m;
+   }
+}
+
+class MyTest4 {
+
+    interface I {
+        MyTest4 m(List<Integer> l1, List<Integer> l2);
+    }
+
+    MyTest4 meth(List<Integer>... lli) { return null; }
+    MyTest4(List<Integer>... lli) { }
+
+    I s1 = this::meth;
+    I s2 = MyTest4::new;
+}
+
+class MyTest5 {
+    interface I_void<X> {
+        void m();
+    }
+    
+    interface I_Void<X> {
+        void m();
+    }
+    
+    static void m_void() {}
+    
+    static Void _Void() {return null; }
+    
+    public static void main(String[] args) {
+        I_void s1 = MyTest5::m_void;
+        s1.m();
+        I_Void s2 = MyTest5::m_void;
+        s2.m();
+        I_void s3 = MyTest5::_Void;
+        s3.m();
+        I_Void s4 = MyTest5::_Void;
+        s4.m();
+    }
+}
+class MyTest6 {
+    interface I {
+        MyTest6 invoke();
+    }
+    
+    MyTest6() {
+    }
+    
+    static MyTest6 m() {
+        return null;
+    }
+
+    public static void main(String[] args) {
+        I I1 = ((I)() -> {return null; })::invoke;
+        I1.invoke();
+        I I2 = ((I)MyTest6::new)::invoke;
+        I1.invoke();
+        I I3 = ((I)MyTest6::m)::invoke;
+        I1.invoke();
+    }
+}
+
+class MyTest7{
+    
+    interface I<R> {
+        R invoke();
+    }
+    
+    @interface A { }
+
+    static abstract class AC { }
+    
+    enum E { }
+    
+    void test() {
+        <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest7.I'">I s1 = A::new;</error>
+        <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest7.I'">I s2 = I::new;</error>
+        <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest7.I'">I s3 = AC::new;</error>
+        <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest7.I'">I s4 = E::new;</error>
+    }
+}
+
+class MyTest8{
+
+    static class Sup {} 
+
+
+    static class Sub extends Sup {
+
+        interface I { Sup m(Sup x, String str); }
+
+        class Inner extends Sup {
+            Inner(String val) { }
+        }
+
+        void test() {
+            <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest8.Sub.I'">I var = Sub.Inner::new;</error>;
+        }
+    }
+}
+
+class MyTest9 {
+    
+    static class SuperFoo<X> { }
+
+    static class Foo<X extends Number> extends SuperFoo<X> { }
+    
+    interface I1 {
+        void m();
+    }
+
+    interface I2 {
+        void m();
+    }
+    
+    static <X extends Number> Foo<X> m() { return null; }
+    
+    static void g1(I1 s) { }
+    static void g2(I1 s) { }
+    static void g2(I2 s) { }
+
+    void test() {
+        g1(MyTest9::m);
+        g2<error descr="Ambiguous method call: both 'MyTest9.g2(I1)' and 'MyTest9.g2(I2)' match">(MyTest9::m)</error>;
+    }
+}