From 3193b7d2c49939aeccbd3cee9b808d76cd8730f2 Mon Sep 17 00:00:00 2001
From: Stepan Koltsov <stepan.koltsov@jetbrains.com>
Date: Sat, 12 Nov 2011 16:54:33 +0400
Subject: [PATCH] fix incorrect overload error on regular function and
 extension function with same name

===
fun ff() = 1

fun Int.ff() = 1
===
---
 .../jet/lang/resolve/OverridingUtil.java      | 40 ++++++++++++++-----
 .../quick/ConflictingOverloads.jet            | 19 +++++++++
 .../jetbrains/jet/types/JetOverloadTest.java  |  4 ++
 3 files changed, 52 insertions(+), 11 deletions(-)

diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
index 6b26f59f733..2465e60292e 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
+++ b/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.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 /**
  * @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<ValueParameterDescriptor> subValueParameters = subDescriptor.getValueParameters();
+        List<JetType> superValueParameters = compiledValueParameters(superDescriptor);
+        List<JetType> subValueParameters = compiledValueParameters(subDescriptor);
         for (int i = 0, unsubstitutedValueParametersSize = superValueParameters.size(); i < unsubstitutedValueParametersSize; i++) {
-            ValueParameterDescriptor superValueParameter = superValueParameters.get(i);
-            ValueParameterDescriptor subValueParameter = subValueParameters.get(i);
+            JetType superValueParameter = superValueParameters.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
         }
 
diff --git a/compiler/testData/checkerWithErrorTypes/quick/ConflictingOverloads.jet b/compiler/testData/checkerWithErrorTypes/quick/ConflictingOverloads.jet
index 642fe8b6699..9871e2803cb 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/ConflictingOverloads.jet
+++ b/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
+}
diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java
index 30916fa528a..1aa3f4fbc90 100644
--- a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java
+++ b/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) {
-- 
GitLab