better diagnostics for KT-424

highlight full function definition, not only function name

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

@@ -375,17 +375,7 @@ public interface Errors {
         }
     };
 
-    ParameterizedDiagnosticFactory2<JetClassOrObject, CallableMemberDescriptor> CONFLICTING_OVERLOADS = new ParameterizedDiagnosticFactory2<JetClassOrObject, CallableMemberDescriptor>(ERROR, "{1} is already defined in ''{0}''") {
-        @Override
-        protected String makeMessageForA(@NotNull JetClassOrObject jetClassOrObject) {
-            return jetClassOrObject.getName();
-        }
-
-        @Override
-        protected String makeMessageForB(@NotNull CallableMemberDescriptor memberDescriptor) {
-            return DescriptorRenderer.TEXT.render(memberDescriptor);
-        }
-    };
+    FunctionSignatureDiagnosticFactory CONFLICTING_OVERLOADS = new FunctionSignatureDiagnosticFactory(ERROR, "{1} is already defined in ''{0}''");
 
 
     ParameterizedDiagnosticFactory3<String, JetType, JetType> RESULT_TYPE_MISMATCH = ParameterizedDiagnosticFactory3.create(ERROR, "{0} must return {1} but returns {2}");

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

@@ -0,0 +1,33 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.openapi.util.TextRange;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.psi.JetClassOrObject;
+import org.jetbrains.jet.lang.psi.JetNamedFunction;
+import org.jetbrains.jet.resolve.DescriptorRenderer;
+
+/**
+ * @author Stepan Koltsov
+ */
+public class FunctionSignatureDiagnosticFactory extends DiagnosticFactoryWithMessageFormat {
+
+    public FunctionSignatureDiagnosticFactory(Severity severity, String messageTemplate) {
+        super(severity, messageTemplate);
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull JetNamedFunction functionElement, @NotNull FunctionDescriptor functionDescriptor,
+                         @NotNull JetClassOrObject jetClassOrObject)
+    {
+        TextRange rangeToMark = new TextRange(
+                functionElement.getStartOfSignatureElement().getTextRange().getStartOffset(),
+                functionElement.getEndOfSignatureElement().getTextRange().getEndOffset()
+            );
+        String message = messageFormat.format(new Object[]{
+                jetClassOrObject.getName(),
+                DescriptorRenderer.TEXT.render(functionDescriptor)});
+        return new GenericDiagnostic(this, severity, message, functionElement.getContainingFile(), rangeToMark);
+    }
+
+} //~

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedFunction.java

@@ -40,4 +40,26 @@ public class JetNamedFunction extends JetFunction {
         return findChildByType(JetTokens.EQ) == null;
     }
 
+    @NotNull
+    public JetElement getStartOfSignatureElement() {
+        return this;
+    }
+
+    @NotNull
+    public JetElement getEndOfSignatureElement() {
+        JetElement r = getReturnTypeRef();
+        if (r != null) {
+            return r;
+        }
+        
+        r = getValueParameterList();
+        if (r != null) {
+            return r;
+        }
+
+        // otherwise it is an error
+
+        return this;
+    }
+
 }

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

@@ -75,9 +75,7 @@ public class OverloadResolver {
                         return;
                     }
 
-                    // XXX: mark "fun" keyword and parameters as in Java IDE // stepan.koltsov@
-                    PsiElement mark = member.getNameIdentifier();
-                    context.getTrace().report(Errors.CONFLICTING_OVERLOADS.on(mark, klass, function));
+                    context.getTrace().report(Errors.CONFLICTING_OVERLOADS.on(member, function, klass));
                 }
             }
         }

compiler/testData/checkerWithErrorTypes/quick/ConflictingOverloads.jet

@@ -1,12 +1,14 @@
 // http://youtrack.jetbrains.net/issue/KT-424
 
 class A {
-    // XXX: error should be reported on the whole method signature
-    // not only on method name
-    fun <!CONFLICTING_OVERLOADS!>a<!>() {
+    <!CONFLICTING_OVERLOADS!>fun a(a: Int): Int<!> = 0
+
+    <!CONFLICTING_OVERLOADS!>fun a(a: Int)<!> {
     }
 
-    fun <!CONFLICTING_OVERLOADS!>a<!>() {
+    <!CONFLICTING_OVERLOADS!>fun b()<!> {
+    }
+
+    <!CONFLICTING_OVERLOADS!>fun b()<!> {
     }
 }
-