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 477 matching lines @@
       metadata.ensureResolved(compiler);
     }
   }
 
   void checkMembers(ClassElement cls) {
     assert(invariant(cls, cls.isDeclaration));
     if (cls.isObject(compiler)) return;
     // TODO(johnniwinther): Should this be done on the implementation element as
     // well?
     cls.forEachMember((holder, member) {
-      // Perform various checks as side effect of "computing" the type.
-      member.computeType(compiler);
+      compiler.withCurrentElement(member, () {
+        // Perform various checks as side effect of "computing" the type.
+        member.computeType(compiler);
 
-      // Check modifiers.
-      if (member.isFunction() && member.modifiers.isFinal()) {
-        compiler.reportMessage(
-          compiler.spanFromElement(member),
-          MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER.error(),
-          Diagnostic.ERROR);
-      }
-      if (member.isConstructor()) {
-        final mismatchedFlagsBits =
-          member.modifiers.flags &
-          (Modifiers.FLAG_STATIC | Modifiers.FLAG_ABSTRACT);
-        if (mismatchedFlagsBits != 0) {
-          final mismatchedFlags =
-            new Modifiers.withFlags(null, mismatchedFlagsBits);
+        // Check modifiers.
+        if (member.isFunction() && member.modifiers.isFinal()) {
           compiler.reportMessage(
-            compiler.spanFromElement(member),
-            MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS.error([mismatchedFlags]),
-            Diagnostic.ERROR);
+              compiler.spanFromElement(member),
+              MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER.error(),
+              Diagnostic.ERROR);
         }
-        checkConstructorNameHack(holder, member);
-      }
-      checkAbstractField(member);
-      checkValidOverride(member, cls.lookupSuperMember(member.name));
+        if (member.isConstructor()) {
+          final mismatchedFlagsBits =
+              member.modifiers.flags &
+              (Modifiers.FLAG_STATIC | Modifiers.FLAG_ABSTRACT);
+          if (mismatchedFlagsBits != 0) {
+            final mismatchedFlags =
+                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;
+
+    int requiredParameterCount;
+    MessageKind messageKind;
+    FunctionSignature signature = function.computeSignature(compiler);
+    if (identical(value, 'unary-')) {
+      messageKind = MessageKind.MINUS_OPERATOR_BAD_ARITY;
+      requiredParameterCount = 0;
+    } else if (isMinusOperator(value)) {
+      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);
+  }
+
+  void checkArity(FunctionElement function,
+                  int requiredParameterCount, MessageKind messageKind) {
+    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) {
+          errorNode = node.parameters;
+        } else {
+          errorNode = node.parameters.nodes.skip(requiredParameterCount).head;
+        }
+      }
+      compiler.reportMessage(
+          compiler.spanFromNode(errorNode),
+          messageKind.error([function.name]),
+          Diagnostic.ERROR);
+    }
+    if (signature.optionalParameterCount != 0) {
+      Node errorNode =
+          node.parameters.nodes.skip(signature.requiredParameterCount).head;
+      if (signature.optionalParametersAreNamed) {
+        compiler.reportMessage(
+            compiler.spanFromNode(errorNode),
+            MessageKind.OPERATOR_NAMED_PARAMETERS.error([function.name]),
+            Diagnostic.ERROR);
+      } else {
+        compiler.reportMessage(
+            compiler.spanFromNode(errorNode),
+            MessageKind.OPERATOR_OPTIONAL_PARAMETERS.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);
   }
 }