Support for new operator -

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 429 matching lines @@
     Clear();
   }
   void Clear() {
     has_abstract = false;
     has_external = false;
     has_final = false;
     has_const = false;
     has_static = false;
     has_var = false;
     has_factory = false;
+    has_operator = false;
     type = NULL;
     name_pos = 0;
     name = NULL;
     redirect_name = NULL;
     params.Clear();
     kind = RawFunction::kRegularFunction;
   }
   bool IsConstructor() const {
     return (kind == RawFunction::kConstructor) && !has_static;
   }
   bool IsFactory() const {
     return (kind == RawFunction::kConstructor) && has_static;
   }
   bool IsFactoryOrConstructor() const {
     return (kind == RawFunction::kConstructor);
   }
   bool IsGetter() const {
     return kind == RawFunction::kGetterFunction;
   }
   bool IsSetter() const {
     return kind == RawFunction::kSetterFunction;
   }
   bool has_abstract;
   bool has_external;
   bool has_final;
   bool has_const;
   bool has_static;
   bool has_var;
   bool has_factory;
+  bool has_operator;
   const AbstractType* type;
   intptr_t name_pos;
   String* name;
   String* redirect_name;  // For constructors: NULL or redirected constructor.
   ParamList params;
   RawFunction::Kind kind;
 };
 
 
 class ClassDesc : public ValueObject {
@@ skipping 1799 matching lines @@
   }
   if (method->has_abstract && members->is_interface()) {
     ErrorMsg(method->name_pos,
              "'abstract' method only allowed in class definition");
   }
   if (method->has_external && members->is_interface()) {
     ErrorMsg(method->name_pos,
              "'external' method only allowed in class definition");
   }
 
-  if (members->FunctionNameExists(*method->name, method->kind)) {
-    ErrorMsg(method->name_pos,
-             "field or method '%s' already defined", method->name->ToCString());
-  }
-
   // Parse the formal parameters.
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values = true;
   const intptr_t formal_param_pos = TokenPos();
   method->params.Clear();
   // Static functions do not have a receiver.
   // The first parameter of a factory is the AbstractTypeArguments vector of
   // the type of the instance to be allocated.
   if (!method->has_static || method->IsConstructor()) {
     method->params.AddReceiver(ReceiverType(formal_param_pos));
   } else if (method->has_factory) {
     method->params.AddFinalParameter(
         formal_param_pos,
         &String::ZoneHandle(Symbols::TypeArgumentsParameter()),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(
         TokenPos(),
         &String::ZoneHandle(Symbols::PhaseParameter()),
         &Type::ZoneHandle(Type::IntInterface()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &method->params);
+
+  // Now that we know the parameter list, we can distinguish between the
+  // unary and binary operator -.
+  if (method->has_operator &&
+      ((method->name->Equals(Token::Str(Token::kNEGATE))) ||
+      method->name->Equals("-")) &&
+      (method->params.num_fixed_parameters == 1)) {
+    // Patch up name for unary operator - so it does not clash with the
+    // name for binary operator -.
+    *method->name = Symbols::New("unary-");
+  }
+
+  if (members->FunctionNameExists(*method->name, method->kind)) {
+    ErrorMsg(method->name_pos,
+             "field or method '%s' already defined", method->name->ToCString());
+  }
+
+  // Mangle the name for getter and setter functions and check function
+  // arity.
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
     if (method->IsGetter()) {
       expected_num_parameters = (method->has_static) ? 0 : 1;
       method->name = &String::ZoneHandle(Field::GetterSymbol(*method->name));
     } else {
       ASSERT(method->IsSetter());
       expected_num_parameters = (method->has_static) ? 1 : 2;
       method->name = &String::ZoneHandle(Field::SetterSymbol(*method->name));
     }
@@ skipping 283 matching lines @@
       break;
     }
     ConsumeToken();
     field->name_pos = this->TokenPos();
     field->name = ExpectIdentifier("field name expected");
   }
   ExpectSemicolon();
 }
 
 
-void Parser::CheckOperatorArity(
-    const MemberDesc& member, Token::Kind operator_token) {
+void Parser::CheckOperatorArity(const MemberDesc& member,
+                                Token::Kind operator_token) {
   intptr_t expected_num_parameters;  // Includes receiver.
   if (operator_token == Token::kASSIGN_INDEX) {
     expected_num_parameters = 3;
+  } else if (operator_token == Token::kSUB) {
+    if (member.params.num_fixed_parameters == 1) {
+      // Unary operator minus (i.e. negate).
+      expected_num_parameters = 1;
+    } else {
+      expected_num_parameters = 2;
+    }
   } else if ((operator_token == Token::kNEGATE) ||
       (operator_token == Token::kBIT_NOT)) {
+    // TODO(hausner): Remove support for keyword 'negate'.
     expected_num_parameters = 1;
   } else {
     expected_num_parameters = 2;
   }
   if ((member.params.num_optional_parameters > 0) ||
       (member.params.has_named_optional_parameters) ||
       (member.params.num_fixed_parameters != expected_num_parameters)) {
     // Subtract receiver when reporting number of expected arguments.
     ErrorMsg(member.name_pos, "operator %s expects %d argument(s)",
         member.name->ToCString(), (expected_num_parameters - 1));
@@ skipping 167 matching lines @@
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
     ConsumeToken();
     if (!Token::CanBeOverloaded(CurrentToken())) {
       ErrorMsg("invalid operator overloading");
     }
     if (member.has_static) {
       ErrorMsg("operator overloading functions cannot be static");
     }
     operator_token = CurrentToken();
+    member.has_operator = true;
     member.kind = RawFunction::kRegularFunction;
     member.name_pos = this->TokenPos();
     member.name =
         &String::ZoneHandle(Symbols::New(Token::Str(operator_token)));
     ConsumeToken();
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
     member.name_pos = TokenPos();
     ConsumeToken();
   } else {
     ErrorMsg("identifier expected");
   }
 
   ASSERT(member.name != NULL);
   if (CurrentToken() == Token::kLPAREN) {
     if (members->is_interface() && member.has_static) {
       if (member.has_factory) {
         ErrorMsg("factory constructors are not allowed in interfaces");
       } else {
         ErrorMsg("static methods are not allowed in interfaces");
       }
     }
     // Constructor or method.
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(Type::DynamicType());
     }
     ParseMethodOrConstructor(members, &member);
-    if (operator_token != Token::kILLEGAL) {
+    if (member.has_operator) {
       CheckOperatorArity(member, operator_token);
     }
   } else if (CurrentToken() ==  Token::kSEMICOLON ||
              CurrentToken() == Token::kCOMMA ||
              CurrentToken() == Token::kASSIGN) {
     // Field definition.
     if (member.has_const) {
       // const fields are implicitly final.
       member.has_final = true;
     }
@@ skipping 6147 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart