[es7] implement exponentiation operator proposal

src/parsing/parser-base.h

Index: src/parsing/parser-base.h
diff --git a/src/parsing/parser-base.h b/src/parsing/parser-base.h
index e75e87a65a427da96e9382f58b0a9a8c33fa8460..a11733a87596aebbc2b505d50b87beef382c765a 100644
--- a/src/parsing/parser-base.h
+++ b/src/parsing/parser-base.h
@@ -122,6 +122,12 @@ class ParserBase : public Traits {
   bool allow_##name() const { return allow_##name##_; } \
   void set_allow_##name(bool allow) { allow_##name##_ = allow; }
 
+#define SCANNER_ACCESSORS(name)                                  \
+  bool allow_##name() const { return scanner_->allow_##name(); } \
+  void set_allow_##name(bool allow) {                            \
+    return scanner_->set_allow_##name(allow);                    \
+  }
+
   ALLOW_ACCESSORS(lazy);
   ALLOW_ACCESSORS(natives);
   ALLOW_ACCESSORS(harmony_sloppy);
@@ -134,6 +140,7 @@ class ParserBase : public Traits {
   ALLOW_ACCESSORS(legacy_const);
   ALLOW_ACCESSORS(harmony_do_expressions);
   ALLOW_ACCESSORS(harmony_function_name);
+  SCANNER_ACCESSORS(harmony_exponentiation_operator);
 #undef ALLOW_ACCESSORS
 
   uintptr_t stack_limit() const { return stack_limit_; }
@@ -2111,6 +2118,11 @@ ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN, int flags,
     Traits::SetFunctionNameFromIdentifierRef(right, expression);
   }
 
+  if (op == Token::ASSIGN_EXP) {
+    DCHECK(!is_destructuring_assignment);
+    return Traits::RewriteAssignExponentiation(expression, right, pos);
+  }
+
   ExpressionT result = factory()->NewAssignment(op, expression, right, pos);
 
   if (is_destructuring_assignment) {
@@ -2211,7 +2223,15 @@ ParserBase<Traits>::ParseBinaryExpression(int prec, bool accept_IN,
                                           ExpressionClassifier* classifier,
                                           bool* ok) {
   DCHECK(prec >= 4);
+  bool is_unary_op = Token::IsUnaryOp(peek());
   ExpressionT x = this->ParseUnaryExpression(classifier, CHECK_OK);
+
+  if (peek() == Token::EXP && is_unary_op) {
+    ReportUnexpectedTokenAt(scanner()->peek_location(), Token::EXP);
+    *ok = false;
+    return this->EmptyExpression();
+  }
+
   for (int prec1 = Precedence(peek(), accept_IN); prec1 >= prec; prec1--) {
     // prec1 >= 4
     while (Precedence(peek(), accept_IN) == prec1) {
@@ -2221,8 +2241,11 @@ ParserBase<Traits>::ParseBinaryExpression(int prec, bool accept_IN,
       Token::Value op = Next();
       Scanner::Location op_location = scanner()->location();
       int pos = position();
+      // TODO(caitp): cleanup right associativity of exponentiation operator
+      // somehow
       ExpressionT y =
-          ParseBinaryExpression(prec1 + 1, accept_IN, classifier, CHECK_OK);
+          ParseBinaryExpression(op == Token::EXP ? prec1 : prec1 + 1, accept_IN,
+                                classifier, CHECK_OK);
       y = Traits::RewriteNonPattern(y, classifier, CHECK_OK);
 
       if (this->ShortcutNumericLiteralBinaryExpression(&x, y, op, pos,
@@ -2308,16 +2331,15 @@ ParserBase<Traits>::ParseUnaryExpression(ExpressionClassifier* classifier,
     ArrowFormalParametersUnexpectedToken(classifier);
     op = Next();
     int beg_pos = peek_position();
-    ExpressionT expression = this->ParseUnaryExpression(classifier, CHECK_OK);
+    ExpressionT expression =
+        this->ParseLeftHandSideExpression(classifier, CHECK_OK);
     expression = this->CheckAndRewriteReferenceExpression(
         expression, beg_pos, scanner()->location().end_pos,
         MessageTemplate::kInvalidLhsInPrefixOp, CHECK_OK);
     this->MarkExpressionAsAssigned(expression);
     expression = Traits::RewriteNonPattern(expression, classifier, CHECK_OK);
 
-    return factory()->NewCountOperation(op,
-                                        true /* prefix */,
-                                        expression,
+    return factory()->NewCountOperation(op, true /* prefix */, expression,
                                         position());
 
   } else {