KT-1781 Can't distinguish between two constructors

#KT-1781 Fixed

 Now, if foo() and foo(vararg bar) both match the call site, the first one is preferred

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java

@@ -94,10 +94,24 @@ public class OverloadingConflictResolver {
         List<ValueParameterDescriptor> gParams = g.getValueParameters();
 
         int fSize = fParams.size();
-        if (fSize != gParams.size()) return false;
-        for (int i = 0; i < fSize; i++) {
+        int gSize = gParams.size();
+        if (fSize > gSize) return false;
+        for (int i = 0; i < gSize; i++) {
+            ValueParameterDescriptor gParam = gParams.get(i);
+            JetType gParamType = gParam.getType();
+
+            if (i >= fSize) {
+                // f() has fewer parameters than g()
+                // The point is: g() may have a last vararg that doesn't get any arguments
+                // In this case f() is more specific, because one can explicitly pass
+                // an empty array to g() and make it preferred
+                if (i != gSize - 1 || gParam.getVarargElementType() == null) {
+                    return false;
+                }
+                return true;
+            }
+
             JetType fParamType = fParams.get(i).getType();
-            JetType gParamType = gParams.get(i).getType();
 
             if (!typeMoreSpecific(fParamType, gParamType)) {
                 return false;

compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.jet

@@ -0,0 +1,6 @@
+fun foo(vararg <!UNUSED_PARAMETER!>t<!> : String) = ""
+fun foo(vararg <!UNUSED_PARAMETER!>t<!> : Int) = ""
+
+fun test() {
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo()<!>
+}

compiler/testData/diagnostics/tests/varargs/NilaryVsVararg.jet

@@ -0,0 +1,10 @@
+fun foo0() : String = "noarg"
+
+fun foo0(vararg <!UNUSED_PARAMETER!>t<!> : Int) : String = "vararg"
+
+fun test0() {
+    foo0()
+    foo0(1)
+    val a = IntArray(0)
+    foo0(*a)
+}

compiler/testData/diagnostics/tests/varargs/UnaryVsVararg.jet

@@ -0,0 +1,9 @@
+fun foo1(<!UNUSED_PARAMETER!>a<!> : Int) : String = "noarg"
+
+fun foo1(<!UNUSED_PARAMETER!>a<!> : Int, vararg <!UNUSED_PARAMETER!>t<!> : Int) : String = "vararg"
+
+fun test1() {
+    foo1(1)
+    val a = IntArray(0)
+    foo1(1, *a)
+}

compiler/testData/diagnostics/tests/varargs/kt1781.jet

@@ -0,0 +1,13 @@
+// FILE: kotlin.kt
+fun foo() {
+  JavaClass()
+  JavaClass("")
+}
+
+// FILE: JavaClass.java
+
+public class JavaClass {
+    public JavaClass() {  }
+
+    public JavaClass(String... ss) {  }
+}

compiler/testData/resolve/varargs/NilaryVsVararg.jet

@@ -0,0 +1,10 @@
+~nilary~fun foo0() : String = "noarg"
+
+~vararg~fun foo0(vararg t : Int) : String = "vararg"
+
+fun test0() {
+    `nilary`foo0()
+    `vararg`foo0(1)
+    val a = intArray()
+    `vararg`foo0(*a)
+}

compiler/testData/resolve/varargs/UnaryVsVararg.jet

@@ -0,0 +1,10 @@
+~unary~fun foo1(a : Int) : String = "noarg"
+
+~vararg~fun foo1(a : Int, vararg t : Int) : String = "vararg"
+
+fun test1() {
+    `unary`foo1(1)
+    `vararg`foo1(1, 1)
+    val a = intArray()
+    `vararg`foo1(1, *a)
+}