[es7] implement exponentiation operator proposal

src/parsing/token.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PARSING_TOKEN_H_
 #define V8_PARSING_TOKEN_H_
 
 #include "src/base/logging.h"
 #include "src/globals.h"
 
@@ skipping 45 matching lines @@
   T(ASSIGN_BIT_XOR, "^=", 2)                                         \
   T(ASSIGN_BIT_AND, "&=", 2)                                         \
   T(ASSIGN_SHL, "<<=", 2)                                            \
   T(ASSIGN_SAR, ">>=", 2)                                            \
   T(ASSIGN_SHR, ">>>=", 2)                                           \
   T(ASSIGN_ADD, "+=", 2)                                             \
   T(ASSIGN_SUB, "-=", 2)                                             \
   T(ASSIGN_MUL, "*=", 2)                                             \
   T(ASSIGN_DIV, "/=", 2)                                             \
   T(ASSIGN_MOD, "%=", 2)                                             \
+  T(ASSIGN_EXP, "**=", 2)                                            \
                                                                      \
   /* Binary operators sorted by precedence. */                       \
   /* IsBinaryOp() relies on this block of enum values */             \
   /* being contiguous and sorted in the same order! */               \
   T(COMMA, ",", 1)                                                   \
   T(OR, "||", 4)                                                     \
   T(AND, "&&", 5)                                                    \
   T(BIT_OR, "|", 6)                                                  \
   T(BIT_XOR, "^", 7)                                                 \
   T(BIT_AND, "&", 8)                                                 \
   T(SHL, "<<", 11)                                                   \
   T(SAR, ">>", 11)                                                   \
   T(SHR, ">>>", 11)                                                  \
   T(ROR, "rotate right", 11) /* only used by Crankshaft */           \
   T(ADD, "+", 12)                                                    \
   T(SUB, "-", 12)                                                    \
   T(MUL, "*", 13)                                                    \
   T(DIV, "/", 13)                                                    \
   T(MOD, "%", 13)                                                    \
+  T(EXP, "**", 14)                                                   \
                                                                      \
   /* Compare operators sorted by precedence. */                      \
   /* IsCompareOp() relies on this block of enum values */            \
   /* being contiguous and sorted in the same order! */               \
   T(EQ, "==", 9)                                                     \
   T(NE, "!=", 9)                                                     \
   T(EQ_STRICT, "===", 9)                                             \
   T(NE_STRICT, "!==", 9)                                             \
   T(LT, "<", 10)                                                     \
   T(GT, ">", 10)                                                     \
@@ skipping 69 matching lines @@
   T(ESCAPED_STRICT_RESERVED_WORD, NULL, 0)                           \
                                                                      \
   /* Scanner-internal use only. */                                   \
   T(WHITESPACE, NULL, 0)                                             \
   T(UNINITIALIZED, NULL, 0)                                          \
                                                                      \
   /* ES6 Template Literals */                                        \
   T(TEMPLATE_SPAN, NULL, 0)                                          \
   T(TEMPLATE_TAIL, NULL, 0)
 
-

[Dan Ehrenberg, 2016/02/11 08:16:50]

Why a change here?

 class Token {
  public:
   // All token values.
 #define T(name, string, precedence) name,
   enum Value {
     TOKEN_LIST(T, T)
     NUM_TOKENS
   };
 #undef T
 
@@ skipping 22 matching lines @@
       case YIELD:
         return !is_generator && is_sloppy(language_mode);
       default:
         return false;
     }
     UNREACHABLE();
     return false;
   }
 
   static bool IsAssignmentOp(Value tok) {
-    return INIT <= tok && tok <= ASSIGN_MOD;
+    return INIT <= tok && tok <= ASSIGN_EXP;

[Dan Ehrenberg, 2016/02/11 08:16:50]

Maybe make constants expressing the start and end?

   }
 
-  static bool IsBinaryOp(Value op) {
-    return COMMA <= op && op <= MOD;
-  }
+  static bool IsBinaryOp(Value op) { return COMMA <= op && op <= EXP; }
 
   static bool IsTruncatingBinaryOp(Value op) {
     return BIT_OR <= op && op <= ROR;
   }
 
   static bool IsCompareOp(Value op) {
     return EQ <= op && op <= IN;
   }
 
   static bool IsOrderedRelationalCompareOp(Value op) {
@@ skipping 98 matching lines @@
   static const char* const name_[NUM_TOKENS];
   static const char* const string_[NUM_TOKENS];
   static const int8_t precedence_[NUM_TOKENS];
   static const char token_type[NUM_TOKENS];
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_TOKEN_H_