- Remove support for ">>>" operator.

vm/parser.cc

 // Copyright (c) 2011, 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 2852 matching lines @@
 }
 
 
 // Consumes exactly one right angle bracket. If the current token is a single
 // bracket token, it is consumed normally. However, if it is a double or triple
 // bracket, it is replaced by a single or double bracket token without
 // incrementing the token index.
 void Parser::ConsumeRightAngleBracket() {
   if (token_kind_ == Token::kGT) {
     ConsumeToken();
-  } else if (token_kind_ == Token::kSAR) {
+  } else if (token_kind_ == Token::kSHR) {
     token_kind_ = Token::kGT;
-  } else if (token_kind_ == Token::kSHR) {
-    token_kind_ = Token::kSAR;
   } else {
     UNREACHABLE();
   }
 }
 
 
 void Parser::SkipTypeArguments() {
   if (CurrentToken() == Token::kLT) {
     do {
       ConsumeToken();
       SkipType(false);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) ||
-        (token == Token::kSAR) ||
         (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
   }
 }
 
 
 void Parser::SkipType(bool allow_void) {
@@ skipping 28 matching lines @@
       AbstractType& type_extends = Type::ZoneHandle(Type::DynamicType());
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         type_extends = ParseType(kCanResolve);
       }
       type_parameters.Add(&type_parameter_name);
       type_parameter_extends.Add(&type_extends);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) ||
-        (token == Token::kSAR) ||
         (token == Token::kSHR)) {

[hausner, 2012/01/13 07:22:53]

Probably fits on one line now. Also in other places.

[Ivan Posva, 2012/01/13 09:04:18]

Done.

       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     cls.set_type_parameters(Array::Handle(NewArray<String>(type_parameters)));
     const TypeArguments& extends_array =
         TypeArguments::Handle(NewTypeArguments(type_parameter_extends));
     cls.set_type_parameter_extends(extends_array);
     // Try to resolve the upper bounds, which will at least resolve the
     // referenced type parameters.
@@ skipping 12 matching lines @@
     TypeResolution type_resolution) {
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> types;
     do {
       ConsumeToken();
       AbstractType& type = AbstractType::ZoneHandle(ParseType(type_resolution));
       types.Add(&type);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) ||
-        (token == Token::kSAR) ||
         (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     return NewTypeArguments(types);
   }
   return TypeArguments::null();
 }
 
@@ skipping 919 matching lines @@
 // parameters. Current token position is not saved and restored.
 bool Parser::IsTypeParameter() {
   if (CurrentToken() == Token::kLT) {
     // We are possibly looking at type parameters. Find closing ">".
     int nesting_level = 0;
     do {
       if (CurrentToken() == Token::kLT) {
         nesting_level++;
       } else if (CurrentToken() == Token::kGT) {
         nesting_level--;
-      } else if (CurrentToken() == Token::kSAR) {
+      } else if (CurrentToken() == Token::kSHR) {
         nesting_level -= 2;
-      } else if (CurrentToken() == Token::kSHR) {
-        nesting_level -= 3;
       } else if (CurrentToken() == Token::kIDENT) {
         // Check to see if it is a qualified identifier.
         if (LookaheadToken(1) == Token::kPERIOD) {
           // Consume the identifier, the period will be consumed below.
           ConsumeToken();
         }
       } else if (CurrentToken() != Token::kCOMMA &&
                  CurrentToken() != Token::kEXTENDS) {
         // We are looking at something other than type parameters.
         return false;
@@ skipping 1642 matching lines @@
     case Token::kASSIGN_SUB:
       return new BinaryOpNode(op_pos, Token::kSUB, lhs, rhs);
     case Token::kASSIGN_MUL:
       return new BinaryOpNode(op_pos, Token::kMUL, lhs, rhs);
     case Token::kASSIGN_TRUNCDIV:
       return new BinaryOpNode(op_pos, Token::kTRUNCDIV, lhs, rhs);
     case Token::kASSIGN_DIV:
       return new BinaryOpNode(op_pos, Token::kDIV, lhs, rhs);
     case Token::kASSIGN_MOD:
       return new BinaryOpNode(op_pos, Token::kMOD, lhs, rhs);
-    case Token::kASSIGN_SAR:
-      return new BinaryOpNode(op_pos, Token::kSAR, lhs, rhs);
+    case Token::kASSIGN_SHR:
+      return new BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
     case Token::kASSIGN_SHL:
       return new BinaryOpNode(op_pos, Token::kSHL, lhs, rhs);
-    case Token::kASSIGN_SHR:
-      return new BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
     case Token::kASSIGN_OR:
       return new BinaryOpNode(op_pos, Token::kBIT_OR, lhs, rhs);
     case Token::kASSIGN_AND:
       return new BinaryOpNode(op_pos, Token::kBIT_AND, lhs, rhs);
     case Token::kASSIGN_XOR:
       return new BinaryOpNode(op_pos, Token::kBIT_XOR, lhs, rhs);
     default:
       ErrorMsg(op_pos, "internal error: ExpandAssignableOp '%s' unimplemented",
           Token::Name(assignment_op));
       UNIMPLEMENTED();
@@ skipping 2130 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart