Remove built-in identifier 'negate' from VM

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 469 matching lines @@
   }
   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;
+    operator_token = Token::kILLEGAL;
     type = NULL;
     name_pos = 0;
     name = NULL;
     redirect_name = NULL;
     constructor_name = NULL;
     params.Clear();
     kind = RawFunction::kRegularFunction;
   }
   bool IsConstructor() const {
     return (kind == RawFunction::kConstructor) && !has_static;
@@ skipping 11 matching lines @@
     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;
+  Token::Kind operator_token;
   const AbstractType* type;
   intptr_t name_pos;
   String* name;
   // For constructors: NULL or name of redirected to constructor.
   String* redirect_name;
   // For constructors: NULL for unnamed constructor,
   // identifier after classname for named constructors.
   String* constructor_name;
   ParamList params;
   RawFunction::Kind kind;
@@ skipping 1907 matching lines @@
     // TODO(hausner): Remove this once the old getter syntax with
     // empty parameter list is no longer supported.
     if (CurrentToken() == Token::kLPAREN) {
       ConsumeToken();
       ExpectToken(Token::kRPAREN);
     }
   }
 
   // Now that we know the parameter list, we can distinguish between the
   // unary and binary operator -.
-  if (method->has_operator &&
-      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 (method->has_operator) {
+    if ((method->operator_token == Token::kSUB) &&
+       (method->params.num_fixed_parameters == 1)) {
+      // Patch up name for unary operator - so it does not clash with the
+      // name for binary operator -.
+      method->operator_token = Token::kNEGATE;
+      *method->name = Symbols::New(Token::Str(Token::kNEGATE));
+    }
+    CheckOperatorArity(*method);
   }
 
   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()) {
@@ skipping 340 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) {
   intptr_t expected_num_parameters;  // Includes receiver.
-  if (operator_token == Token::kASSIGN_INDEX) {
+  Token::Kind op = member.operator_token;
+  if (op == 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::kBIT_NOT) {
+  } else if ((op == Token::kBIT_NOT) || (op == Token::kNEGATE)) {
     expected_num_parameters = 1;
   } else {
     expected_num_parameters = 2;
   }
   if ((member.params.num_optional_parameters > 0) ||
       member.params.has_optional_positional_parameters ||
       member.params.has_optional_named_parameters ||
       (member.params.num_fixed_parameters != expected_num_parameters)) {
     // Subtract receiver when reporting number of expected arguments.
     ErrorMsg(member.name_pos, "operator %s expects %"Pd" argument(s)",
@@ skipping 73 matching lines @@
            (LookaheadToken(3) != Token::kLPAREN))) {  // but not a named constr.
         ASSERT(is_top_level_);
         // The declared type of fields is never ignored, even in unchecked mode,
         // because getters and setters could be closurized at some time (not
         // supported yet).
         member.type = &AbstractType::ZoneHandle(
             ParseType(ClassFinalizer::kTryResolve));
       }
     }
   }
-  Token::Kind operator_token = Token::kILLEGAL;
+
   // Optionally parse a (possibly named) constructor name or factory.
   if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     if (member.has_factory) {
       // The factory name may be qualified.
       QualIdent factory_name;
       ParseQualIdent(&factory_name);
       member.name_pos = factory_name.ident_pos;
       member.name = factory_name.ident;  // Unqualified identifier.
       // The class of the factory result type is specified by the factory name.
@@ skipping 76 matching lines @@
              (LookaheadToken(1) != Token::kASSIGN) &&
              (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.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)));
+        &String::ZoneHandle(Symbols::New(Token::Str(member.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 || member.IsGetter()) {
     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());
     }
     ASSERT(member.IsFactory() == member.has_factory);
     ParseMethodOrConstructor(members, &member);
-    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;
     }
     if (member.type == NULL) {
       if (member.has_final) {
@@ skipping 3550 matching lines @@
 }
 
 
 bool Parser::IsLiteral(const char* literal) {
   const uint8_t* characters = reinterpret_cast<const uint8_t*>(literal);
   intptr_t len = strlen(literal);
   return IsIdentifier() && CurrentLiteral()->Equals(characters, len);
 }
 
 
-bool Parser::IsIncrementOperator(Token::Kind token) {
+static bool IsIncrementOperator(Token::Kind token) {
   return token == Token::kINCR || token == Token::kDECR;

[srdjan, 2012/10/16 19:43:41]

Does this belong into class Token with all the other IsXXX?

[hausner, 2012/10/16 20:19:44]

I prefer not to have these functions in class Token. This function interprets
some meaning into the tokens, whereas the Token class should be a strictly
textual abstraction. I actually don't like the IsXXXOperator functions in Token.

 }
 
 
-bool Parser::IsPrefixOperator(Token::Kind token) {
+static bool IsPrefixOperator(Token::Kind token) {
   return (token == Token::kTIGHTADD) ||   // Valid for literals only!
          (token == Token::kSUB) ||
          (token == Token::kNOT) ||
          (token == Token::kBIT_NOT);

[srdjan, 2012/10/16 19:43:41]

Why does it differ from Token::IsPrefixOperator?

[hausner, 2012/10/16 20:19:44]

Because this function is called before the parser replaces kSUB with kNEGATE.
And eliminates kTIGHTADD altogether. The Token::IsXXX is used in the backend,
after the substitutions.

 }
 
 
 SequenceNode* Parser::NodeAsSequenceNode(intptr_t sequence_pos,
                                          AstNode* node,
                                          LocalScope* scope) {
   if ((node == NULL) || !node->IsSequenceNode()) {
     SequenceNode* sequence = new SequenceNode(sequence_pos, scope);
     if (node != NULL) {
       sequence->Add(node);
@@ skipping 448 matching lines @@
   return expr;
 }
 
 
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
   const intptr_t op_pos = TokenPos();
   if (IsPrefixOperator(CurrentToken())) {
     Token::Kind unary_op = CurrentToken();
+    if (unary_op == Token::kSUB) {
+      unary_op = Token::kNEGATE;
+    }
     ConsumeToken();
     expr = ParseUnaryExpr();
     if (unary_op == Token::kTIGHTADD) {
       // kTIGHADD is added only in front of a number literal.
       if (!expr->IsLiteralNode()) {
         ErrorMsg(op_pos, "unexpected operator '+'");
       }
       // Expression is the literal itself.
     } else {
       expr = UnaryOpNode::UnaryOpOrLiteral(op_pos, unary_op, expr);
@@ skipping 2628 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart