Support static method references

#KT-5123 Fixed

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java

@@ -591,14 +591,24 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             return null;
         }
 
-        JetScope staticScope = getStaticNestedClassesScope((ClassDescriptor) classifier);
+        JetScope staticScope = ((ClassDescriptor) classifier).getStaticScope();
         TemporaryTraceAndCache temporaryForStatic = TemporaryTraceAndCache.create(
                 context, "trace to resolve callable reference in static scope", reference);
-        CallableDescriptor possibleStaticNestedClassConstructor = resolveCallableNotCheckingArguments(reference, NO_RECEIVER,
+        CallableDescriptor possibleStatic = resolveCallableNotCheckingArguments(
-                context.replaceTraceAndCache(temporaryForStatic).replaceScope(staticScope), result);
+                reference, NO_RECEIVER, context.replaceTraceAndCache(temporaryForStatic).replaceScope(staticScope), result);
         if (result[0]) {
             temporaryForStatic.commit();
-            return possibleStaticNestedClassConstructor;
+            return possibleStatic;
+        }
+
+        JetScope staticNestedClasses = getStaticNestedClassesScope((ClassDescriptor) classifier);
+        TemporaryTraceAndCache temporaryForNested = TemporaryTraceAndCache.create(
+                context, "trace to resolve callable reference in static nested classes scope", reference);
+        CallableDescriptor possibleNestedClassConstructor = resolveCallableNotCheckingArguments(reference, NO_RECEIVER,
+                context.replaceTraceAndCache(temporaryForNested).replaceScope(staticNestedClasses), result);
+        if (result[0]) {
+            temporaryForNested.commit();
+            return possibleNestedClassConstructor;
         }
 
         ReceiverValue receiver = new TransientReceiver(lhsType);

compiler/testData/codegen/boxAgainstJava/callableReference/staticMethod.java

@@ -0,0 +1,5 @@
+class A {
+    public static void main(String[] args) {
+        args[0] = "OK";
+    }
+}

compiler/testData/codegen/boxAgainstJava/callableReference/staticMethod.kt

@@ -0,0 +1,5 @@
+fun box(): String {
+    val args = array("Fail")
+    (A::main)(args)
+    return args[0]
+}

compiler/testData/codegen/boxWithStdlib/callableReference/function/enumValueOfMethod.kt

@@ -0,0 +1,9 @@
+enum class E {
+    ENTRY
+}
+
+fun box(): String {
+    val f = E::valueOf
+    val result = f("ENTRY")
+    return if (result == E.ENTRY) "OK" else "Fail $result"
+}

compiler/testData/codegen/boxWithStdlib/callableReference/function/javaCollectionsStaticMethod.kt

@@ -0,0 +1,13 @@
+// KT-5123
+
+import java.util.Collections
+import java.util.ArrayList
+
+fun box(): String {
+    val numbers = ArrayList<Int>()
+    numbers.add(1)
+    numbers.add(2)
+    numbers.add(3)
+    (Collections::rotate)(numbers, 1)
+    return if ("$numbers" == "[3, 1, 2]") "OK" else "Fail $numbers"
+}

compiler/testData/diagnostics/testsWithStdLib/callableReference/function/javaStaticMethod.kt

@@ -0,0 +1,23 @@
+// FILE: test/A.java
+
+package test
+
+import java.util.Arrays;
+
+public class A {
+    public static void main(String[] args) {
+        System.out.println(Arrays.asList(args));
+    }
+}
+
+// FILE: 1.kt
+
+import kotlin.reflect.*
+import test.A
+
+fun foo(args: Array<String>) {
+    val main2 = A::main
+    main2 : KFunction1<Array<String>, Unit>
+    main2(args)
+    (A::main)(args)
+}

compiler/testData/diagnostics/testsWithStdLib/callableReference/function/javaStaticMethod.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun foo(/*0*/ args: kotlin.Array<kotlin.String>): kotlin.Unit

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java

@@ -289,6 +289,12 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic
                 doTest(fileName);
             }
             
+            @TestMetadata("javaStaticMethod.kt")
+            public void testJavaStaticMethod() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/callableReference/function/javaStaticMethod.kt");
+                doTest(fileName);
+            }
+            
             @TestMetadata("lhsNotAClass.kt")
             public void testLhsNotAClass() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/callableReference/function/lhsNotAClass.kt");

compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxAgainstJavaCodegenTestGenerated.java

@@ -111,6 +111,12 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxCod
             doTestAgainstJava(fileName);
         }
         
+        @TestMetadata("staticMethod.kt")
+        public void testStaticMethod() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/callableReference/staticMethod.kt");
+            doTestAgainstJava(fileName);
+        }
+        
     }
     
     @TestMetadata("compiler/testData/codegen/boxAgainstJava/constructor")

compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java

@@ -297,6 +297,12 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
                 doTestWithStdlib(fileName);
             }
             
+            @TestMetadata("enumValueOfMethod.kt")
+            public void testEnumValueOfMethod() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/callableReference/function/enumValueOfMethod.kt");
+                doTestWithStdlib(fileName);
+            }
+            
             @TestMetadata("equalsIntrinsic.kt")
             public void testEqualsIntrinsic() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/callableReference/function/equalsIntrinsic.kt");
@@ -369,6 +375,12 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
                 doTestWithStdlib(fileName);
             }
             
+            @TestMetadata("javaCollectionsStaticMethod.kt")
+            public void testJavaCollectionsStaticMethod() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/callableReference/function/javaCollectionsStaticMethod.kt");
+                doTestWithStdlib(fileName);
+            }
+            
             @TestMetadata("nestedConstructorFromClass.kt")
             public void testNestedConstructorFromClass() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/callableReference/function/nestedConstructorFromClass.kt");