A warning added: parameter names disagree upon override

This should be an error, but there is an issue with Java interop: Java parameters may change names or not have them.

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java

@@ -383,6 +383,8 @@ public interface Errors {
     SimpleDiagnosticFactory<JetParameter> DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE = SimpleDiagnosticFactory.create(ERROR, PositioningStrategies.PARAMETER_DEFAULT_VALUE);
     DiagnosticFactory1<JetParameter, ValueParameterDescriptor> MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES = DiagnosticFactory1.create(ERROR, PositioningStrategies.POSITION_NAME_IDENTIFIER);
     DiagnosticFactory1<JetClassOrObject, ValueParameterDescriptor> MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE = DiagnosticFactory1.create(ERROR, PositioningStrategies.POSITION_NAME_IDENTIFIER);
+    DiagnosticFactory2<JetParameter, ClassDescriptor, ValueParameterDescriptor> PARAMETER_NAME_CHANGED_ON_OVERRIDE = DiagnosticFactory2.create(WARNING, PositioningStrategies.POSITION_NAME_IDENTIFIER);
+    DiagnosticFactory2<JetClassOrObject, Collection<? extends CallableMemberDescriptor>, Integer> DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES = DiagnosticFactory2.create(WARNING, PositioningStrategies.POSITION_NAME_IDENTIFIER);
 
     DiagnosticFactory2<JetDeclaration, CallableMemberDescriptor, String> CONFLICTING_OVERLOADS =
             DiagnosticFactory2.create(ERROR, new PositioningStrategy<JetDeclaration>() {

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java

@@ -386,11 +386,19 @@ public class DefaultErrorMessages {
         MAP.put(NOT_AN_ANNOTATION_CLASS, "''{0}'' is not an annotation class", TO_STRING);
 
         MAP.put(DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE, "An overriding function is not allowed to specify default values for its parameters");
-        MAP.put(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES, "More than one overridden descriptor declares a default value for ''{0}''. " +
-                                                             "As the compiler can not make sure these values agree, this is not allowed.", TO_STRING);
 
-        MAP.put(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE, "More than one overridden descriptor declares a default value for ''{0}''. " +
+
-                                                             "As the compiler can not make sure these values agree, this is not allowed.", TO_STRING);
+        String multipleDefaultsMessage = "More than one overridden descriptor declares a default value for ''{0}''. " +
+                                         "As the compiler can not make sure these values agree, this is not allowed.";
+        MAP.put(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES, multipleDefaultsMessage, TO_STRING);
+        MAP.put(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE, multipleDefaultsMessage, TO_STRING);
+
+        MAP.put(PARAMETER_NAME_CHANGED_ON_OVERRIDE, "The corresponding parameter in the supertype ''{0}'' is named ''{1}''. " +
+                                                    "This may cause problems when calling this function with named arguments.", NAME, NAME);
+
+        MAP.put(DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES,
+                    "Names of the parameter #{1} conflict in the following members of supertypes: ''{0}''" +
+                    "This may cause problems when calling this function with named arguments.", commaSeparated(TO_STRING), TO_STRING);
 
         MAP.setImmutable();
     }

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java

@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
 
 import java.util.Collection;
+import java.util.Iterator;
 
 /**
  * @author svtk
@@ -98,6 +99,24 @@ public class Renderers {
                 }
             };
 
+    public static <T> Renderer<Collection<? extends T>> commaSeparated(final Renderer<T> itemRenderer) {
+        return new Renderer<Collection<? extends T>>() {
+            @NotNull
+            @Override
+            public String render(@NotNull Collection<? extends T> object) {
+                StringBuilder result = new StringBuilder();
+                for (Iterator<? extends T> iterator = object.iterator(); iterator.hasNext(); ) {
+                    T next = iterator.next();
+                    result.append(itemRenderer.render(next));
+                    if (iterator.hasNext()) {
+                        result.append(", ");
+                    }
+                }
+                return result.toString();
+            }
+        };
+    }
+
     private Renderers() {
     }
 }

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

@@ -437,6 +437,9 @@ public class OverrideResolver {
                     fakeOverride ? null :
                             (JetParameter) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), parameterFromSubclass);
 
+            JetClassOrObject classElement = fakeOverride ? (JetClassOrObject) BindingContextUtils
+                    .descriptorToDeclaration(trace.getBindingContext(), declared.getContainingDeclaration()) : null;
+
             if (parameterFromSubclass.declaresDefaultValue() && !fakeOverride) {
                 trace.report(DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE.on(parameter));
             }
@@ -449,8 +452,6 @@ public class OverrideResolver {
                     }
                     else {
                         if (fakeOverride) {
-                            JetClassOrObject classElement = (JetClassOrObject) BindingContextUtils
-                                    .descriptorToDeclaration(trace.getBindingContext(), declared.getContainingDeclaration());
                             trace.report(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE.on(classElement, parameterFromSubclass));
                         }
                         else {
@@ -459,6 +460,15 @@ public class OverrideResolver {
                         break;
                     }
                 }
+
+                if (!parameterFromSuperclass.getName().equals(parameterFromSubclass.getName())) {
+                    if (fakeOverride) {
+                        trace.report(DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES.on(classElement, declared.getOverriddenDescriptors(), parameterFromSuperclass.getIndex() + 1));
+                    }
+                    else {
+                        trace.report(PARAMETER_NAME_CHANGED_ON_OVERRIDE.on(parameter, (ClassDescriptor) parameterFromSuperclass.getContainingDeclaration().getContainingDeclaration(), parameterFromSuperclass));
+                    }
+                }
             }
         }
     }

compiler/testData/diagnostics/tests/override/ConflictingParameterNames-MultipleSupertypes.jet

@@ -0,0 +1,15 @@
+trait C {
+    fun foo(a : Int)
+}
+
+trait D {
+    fun foo(b : Int)
+}
+
+trait <!DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES!>E<!> : C, D
+trait F : C, D {
+
+    override fun foo(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>a<!> : Int) {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/diagnostics/tests/override/ConflictingParameterNames.jet

@@ -0,0 +1,13 @@
+trait A {
+    fun b(a : Int)
+}
+
+trait B : A {}
+
+class C1 : A {
+    override fun b(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>b<!> : Int) {}
+}
+
+class C2 : B {
+    override fun b(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>b<!> : Int) {}
+}

compiler/testData/diagnostics/tests/override/DefaultParameterValueInOverride.jet

@@ -4,12 +4,10 @@ open class A {
 
 class C : A() {
     override fun foo(a : Int = <!DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE!>1<!>) {
-        super<A>.foo(a)
     }
 }
 
 class D : A() {
-    override fun foo(b : Int = <!DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE!>1<!>) {
+    override fun foo(a : Int = <!DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE!>1<!>) {
-        super<A>.foo(b)
     }
 }

compiler/testData/diagnostics/tests/override/Generics.jet

@@ -30,14 +30,14 @@ class MyChildClass2<T>(t : T) : MyGenericClass<T>(t) {
 }
 
 open class MyClass() : MyTrait<Int>, MyAbstractClass<String>() {
-    override fun foo(i: Int) = i
+    override fun foo(t: Int) = t
-    override fun bar(s: String) = s
+    override fun bar(t: String) = t
     override val pr : String = "1"
 }
 
 abstract class MyAbstractClass1 : MyTrait<Int>, MyAbstractClass<String>() {
-    override fun foo(i: Int) = i
+    override fun foo(t: Int) = t
-    override fun bar(s: String) = s
+    override fun bar(t: String) = t
 }
 
 class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T>() {}

idea/testData/checker/OverridesAndGenerics.jet

@@ -19,8 +19,8 @@
     }
 
     open class MyClass : MyTrait<Int>, MyAbstractClass<String>() {
-        override fun foo(i: Int) = i
+        override fun foo(t: Int) = t
-        override fun bar(s: String) = s
+        override fun bar(t: String) = t
     }
 
     class <error>MyIllegalGenericClass1</error><T> : MyTrait<T>, MyAbstractClass<T>() {}