Fix VariableDefinitions.endToken for formal parameters.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of resolution;
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 582 matching lines @@
     }
   }
 
   void checkUserDefinableOperator(Element member) {
     FunctionElement function = member.asFunctionElement();
     if (function == null) return;
     String value = member.name.stringValue;
     if (value == null) return;
     if (!(isUserDefinableOperator(value) || identical(value, 'unary-'))) return;
 
+    bool isMinus = false;
     int requiredParameterCount;
     MessageKind messageKind;
     FunctionSignature signature = function.computeSignature(compiler);
     if (identical(value, 'unary-')) {
+      isMinus = true;
       messageKind = MessageKind.MINUS_OPERATOR_BAD_ARITY;
       requiredParameterCount = 0;
     } else if (isMinusOperator(value)) {
+      isMinus = true;
       messageKind = MessageKind.MINUS_OPERATOR_BAD_ARITY;
       requiredParameterCount = 1;
     } else if (isUnaryOperator(value)) {
       messageKind = MessageKind.UNARY_OPERATOR_BAD_ARITY;
       requiredParameterCount = 0;
     } else if (isBinaryOperator(value)) {
       messageKind = MessageKind.BINARY_OPERATOR_BAD_ARITY;
       requiredParameterCount = 1;
     } else if (isTernaryOperator(value)) {
       messageKind = MessageKind.TERNARY_OPERATOR_BAD_ARITY;
       requiredParameterCount = 2;
     } else {
       compiler.internalErrorOnElement(function,
           'Unexpected user defined operator $value');
     }
-    checkArity(function, requiredParameterCount, messageKind);
+    checkArity(function, requiredParameterCount, messageKind, isMinus);
   }
 
   void checkArity(FunctionElement function,
-                  int requiredParameterCount, MessageKind messageKind) {
+                  int requiredParameterCount, MessageKind messageKind,
+                  bool isMinus) {
     FunctionExpression node = function.parseNode(compiler);
     FunctionSignature signature = function.computeSignature(compiler);
     if (signature.requiredParameterCount != requiredParameterCount) {
       Node errorNode = node;
       if (node.parameters != null) {
-        if (signature.requiredParameterCount < requiredParameterCount) {
+        if (isMinus || // Point to the parameter list is case of operator -.

[ahe, 2013/01/21 11:14:08]

is -> in

[ahe, 2013/01/21 11:14:08]

I don't understand the purpose of this. Could you give some examples?

[Johnni Winther, 2013/01/22 15:57:30]

For operator -, always point the whole parameter list, like

     int operator -(a, b) {}
                   ^^^^^^
 
instead of

     int operator -(a, b) {}
                       ^

since the correction might not be to remove 'b' but instead to remove 'a, b'.

[Johnni Winther, 2013/01/22 15:57:30]

Done.

[ahe, 2013/01/23 11:26:35]

Thanks for the explanation and adding a comment.

+            signature.requiredParameterCount < requiredParameterCount) {
           errorNode = node.parameters;
         } else {
           errorNode = node.parameters.nodes.skip(requiredParameterCount).head;
         }
       }
       compiler.reportMessage(
           compiler.spanFromSpannable(errorNode),
           messageKind.error([function.name]),
           Diagnostic.ERROR);
     }
@@ skipping 2751 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }