Report arity errors on user definable operators.

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 503 matching lines @@
             new Modifiers.withFlags(null, mismatchedFlagsBits);
           compiler.reportMessage(
             compiler.spanFromElement(member),
             MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS.error([mismatchedFlags]),
             Diagnostic.ERROR);
         }
         checkConstructorNameHack(holder, member);
       }
       checkAbstractField(member);
       checkValidOverride(member, cls.lookupSuperMember(member.name));
+      checkUserDefinableOperator(member);
     });
   }
 
   // TODO(ahe): Remove this method.  It is only needed while we store
   // constructor names as ClassName$id.  Once we start storing
   // constructors as just id, this will be caught by the general
   // mechanism for duplicate members.
   /// Check that a constructor name does not conflict with a member.
   void checkConstructorNameHack(ClassElement holder, FunctionElement member) {
     // If the name of the constructor is the same as the name of the
@@ skipping 48 matching lines @@
           compiler.spanFromElement(field.getter),
           MessageKind.GETTER_MISMATCH.error([mismatchedFlags]),
           Diagnostic.ERROR);
       compiler.reportMessage(
           compiler.spanFromElement(field.setter),
           MessageKind.SETTER_MISMATCH.error([mismatchedFlags]),
           Diagnostic.ERROR);
     }
   }
 
+  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;
+
+    FunctionSignature signature = function.computeSignature(compiler);
+    if (identical(value, 'unary-')) {

[ahe, 2013/01/09 10:17:52]

Consider this approach:

int requiredParameterCount;
if (identical(value, 'unary-')) {
  requiredParameterCount = 0;
} else if (isMinusOperator(value) {
  requiredParameterCount = 1;
} ... {
  internalErrorOnElement(function);
}
checkArity(function, requiredParameterCount, 0, 0);

We should be able to reuse the checkArity method with other code and generate
really nice messages, such as:

Error: extra parameter "y". "+" must have exactly 1 parameter.
operator+(x, y) { ... }
             ^

Error: missing parameter. "+" must have exactly 1 parameter.
operator+() { ... }
         ^^

[Johnni Winther, 2013/01/09 13:00:47]

Done.

+      if (signature.requiredParameterCount != 0) {

[ahe, 2013/01/09 10:17:52]

You should be able to assert this.

+        compiler.reportMessage(
+            compiler.spanFromElement(function),
+            MessageKind.MINUS_OPERATOR_BAD_ARITY.error(),
+            Diagnostic.ERROR);
+      }
+    } else if (isMinusOperator(value)) {
+      if (signature.requiredParameterCount != 1) {
+        compiler.reportMessage(
+            compiler.spanFromElement(function),
+            MessageKind.MINUS_OPERATOR_BAD_ARITY.error(),
+            Diagnostic.ERROR);
+      }
+    } else if (isUnaryOperator(value)) {
+      if (signature.requiredParameterCount != 0) {
+        compiler.reportMessage(
+            compiler.spanFromElement(function),
+            MessageKind.UNARY_OPERATOR_BAD_ARITY.error([function.name]),
+            Diagnostic.ERROR);
+      }
+    } else if (isBinaryOperator(value)) {
+      if (signature.requiredParameterCount != 1) {
+        compiler.reportMessage(
+            compiler.spanFromElement(function),
+            MessageKind.BINARY_OPERATOR_BAD_ARITY.error([function.name]),
+            Diagnostic.ERROR);
+      }
+    } else if (isTernaryOperator(value)) {
+      if (signature.requiredParameterCount != 2) {
+        compiler.reportMessage(
+            compiler.spanFromElement(function),
+            MessageKind.TERNARY_OPERATOR_BAD_ARITY.error([function.name]),
+            Diagnostic.ERROR);
+      }
+    }

[ahe, 2013/01/09 10:17:52]

else {
  // Internal error.
}

[Johnni Winther, 2013/01/09 13:00:47]

Done.

+    if (signature.optionalParameterCount != 0) {
+      if (signature.optionalParametersAreNamed) {
+        compiler.reportMessage(
+            compiler.spanFromElement(function),

[ahe, 2013/01/09 10:17:52]

There is a more accurate position for the optional parameters.

[Johnni Winther, 2013/01/09 13:00:47]

Done.

+            MessageKind.OPERATOR_NAMED_ARGUMENTS.error([function.name]),
+            Diagnostic.ERROR);
+      } else {
+        compiler.reportMessage(
+            compiler.spanFromElement(function),

[ahe, 2013/01/09 10:17:52]

Ditto.

[Johnni Winther, 2013/01/09 13:00:47]

Done.

+            MessageKind.OPERATOR_OPTIONAL_ARGUMENTS.error([function.name]),
+            Diagnostic.ERROR);
+      }
+    }
+  }
+
   reportErrorWithContext(Element errorneousElement,
                          MessageKind errorMessage,
                          Element contextElement,
                          MessageKind contextMessage) {
     compiler.reportMessage(
         compiler.spanFromElement(errorneousElement),
         errorMessage.error([contextElement.name,
                             contextElement.getEnclosingClass().name]),
         Diagnostic.ERROR);
     compiler.reportMessage(
@@ skipping 2716 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }