fix incorrect overload error on regular function and extension function with same name

===
fun ff() = 1

fun Int.ff() = 1
===

compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java

@@ -7,12 +7,10 @@ import com.google.common.collect.Sets;
 import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 
-import java.util.Collection;
+import java.util.*;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 /**
  * @author abreslav
@@ -95,6 +93,26 @@ public class OverridingUtil {
     public static OverrideCompatibilityInfo isOverridableBy(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
         return isOverridableByImpl(superDescriptor, subDescriptor, true);
     }
+    
+    private static List<JetType> compiledValueParameters(CallableDescriptor callableDescriptor) {
+        ReceiverDescriptor receiverParameter = callableDescriptor.getReceiverParameter();
+        ArrayList<JetType> parameters = new ArrayList<JetType>();
+        if (receiverParameter.exists()) {
+            parameters.add(receiverParameter.getType());
+        }
+        for (ValueParameterDescriptor valueParameterDescriptor : callableDescriptor.getValueParameters()) {
+            parameters.add(valueParameterDescriptor.getOutType());
+        }
+        return parameters;
+    }
+    
+    private static int compiledValueParameterCount(CallableDescriptor callableDescriptor) {
+        if (callableDescriptor.getReceiverParameter().exists()) {
+            return 1 + callableDescriptor.getValueParameters().size();
+        } else {
+            return callableDescriptor.getValueParameters().size();
+        }
+    }
 
     /**
      * @param forOverride true for override, false for overload
@@ -116,7 +134,7 @@ public class OverridingUtil {
             return OverrideCompatibilityInfo.typeParameterNumberMismatch();
         }
 
-        if (superDescriptor.getValueParameters().size() != subDescriptor.getValueParameters().size()) {
+        if (compiledValueParameterCount(superDescriptor) != compiledValueParameterCount(subDescriptor)) {
             return OverrideCompatibilityInfo.valueParameterNumberMismatch();
         }
 
@@ -139,13 +157,13 @@ public class OverridingUtil {
             }
         }
 
-        List<ValueParameterDescriptor> superValueParameters = superDescriptor.getValueParameters();
+        List<JetType> superValueParameters = compiledValueParameters(superDescriptor);
-        List<ValueParameterDescriptor> subValueParameters = subDescriptor.getValueParameters();
+        List<JetType> subValueParameters = compiledValueParameters(subDescriptor);
         for (int i = 0, unsubstitutedValueParametersSize = superValueParameters.size(); i < unsubstitutedValueParametersSize; i++) {
-            ValueParameterDescriptor superValueParameter = superValueParameters.get(i);
+            JetType superValueParameter = superValueParameters.get(i);
-            ValueParameterDescriptor subValueParameter = subValueParameters.get(i);
+            JetType subValueParameter = subValueParameters.get(i);
 
-            if (!JetTypeImpl.equalTypes(superValueParameter.getOutType(), subValueParameter.getOutType(), axioms)) {
+            if (!JetTypeImpl.equalTypes(superValueParameter, subValueParameter, axioms)) {
                 return OverrideCompatibilityInfo.valueParameterTypeMismatch(superValueParameter, subValueParameter);
             }
         }
@@ -209,7 +227,7 @@ public class OverridingUtil {
         }
 
         @NotNull
-        public static OverrideCompatibilityInfo valueParameterTypeMismatch(ValueParameterDescriptor superValueParameter, ValueParameterDescriptor subValueParameter) {
+        public static OverrideCompatibilityInfo valueParameterTypeMismatch(JetType superValueParameter, JetType subValueParameter) {
             return new OverrideCompatibilityInfo(false, "valueParameterTypeMismatch"); // TODO
         }
 

compiler/testData/checkerWithErrorTypes/quick/ConflictingOverloads.jet

@@ -46,3 +46,22 @@ namespace ns3 {
     }
 }
 
+// check same rules apply for ext functions
+
+namespace extensionFunctions {
+    <!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float)<!> = 1
+    
+    <!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float)<!> = 2
+    
+    fun Int.rty() = 3
+    
+    fun String.rty() = 4
+}
+
+// check no error when regular function and extension function have same name
+
+namespace extensionAndRegular {
+    fun who() = 1
+    
+    fun Int.who() = 1
+}

compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java

@@ -127,6 +127,10 @@ public class JetOverloadTest extends JetLiteFixture {
                 "fun a<T1, X : Array<out T1>>(a : Array<*>) : T1",
                 "fun a<T, Y : Array<out T>>(a : Array<in T>) : T");
 
+        assertOverloadable(
+                "fun ff() : Int",
+                "fun Int.ff() : Int"
+        );
     }
 
     private void assertNotOverloadable(String funA, String funB) {