Fix for bug 1229: Unary operator plus is not allowed ... except for literals.

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 5316 matching lines @@
   return IsIdentifier() && CurrentLiteral()->Equals(characters, len);
 }
 
 
 bool Parser::IsIncrementOperator(Token::Kind token) {
   return token == Token::kINCR || token == Token::kDECR;
 }
 
 
 bool Parser::IsPrefixOperator(Token::Kind token) {
-  return token == Token::kADD || token == Token::kSUB
-      || token == Token::kNOT || token == Token::kBIT_NOT;
+  return (token == Token::kTIGHTADD) ||   // Valid for literals only!
+         (token == Token::kSUB) ||
+         (token == Token::kNOT) ||
+         (token == Token::kBIT_NOT);
 }
 
 
 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);
     }
     return sequence;
   }
   return node->AsSequenceNode();
 }
 
 
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= 4);
   AstNode* left_operand = ParseUnaryExpr();
   int current_preced = Token::Precedence(CurrentToken());
   while (current_preced >= min_preced) {
     while (Token::Precedence(CurrentToken()) == current_preced) {
       Token::Kind op_kind = CurrentToken();
+      if (op_kind == Token::kTIGHTADD) {
+        op_kind = Token::kADD;
+      }
       const intptr_t op_pos = token_index_;
       ConsumeToken();
       AstNode* right_operand = NULL;
       if (op_kind != Token::kIS) {
         right_operand = ParseBinaryExpr(current_preced + 1);
       } else {
         // For 'is' we expect the right operand to be a type.
         if (CurrentToken() == Token::kNOT) {
           ConsumeToken();
           op_kind = Token::kISNOT;
@@ skipping 279 matching lines @@
 
 
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
   const intptr_t op_pos = token_index_;
   if (IsPrefixOperator(CurrentToken())) {
     Token::Kind unary_op = CurrentToken();
     ConsumeToken();
     expr = ParseUnaryExpr();
-    expr = UnaryOpNode::UnaryOpOrLiteral(op_pos, unary_op, expr);
+    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);
+    }
   } else if (IsIncrementOperator(CurrentToken())) {
     Token::Kind incr_op = CurrentToken();
     ConsumeToken();
     expr = ParseUnaryExpr();
     if (!IsAssignableExpr(expr)) {
       ErrorMsg("expression is not assignable");
     }
     // is_prefix.
     AstNode* incr_op_node = expr->MakeIncrOpNode(op_pos, incr_op, true);
     if (incr_op_node == NULL) {
@@ skipping 2043 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart