[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

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

Seems like a good thing to do before submitting this patch. Does this code
ensure that there's a SyntaxError in the -x**y case?

[caitp (gmail), 2016/02/11 12:57:24]

Yes it does-- the model for existing right associativity in v8 is just hard to
understand how to model this, since it's the only right associative binary op,
and doesn't fit well with the preexisting model. I'm not sure what the best
refactoring is yet, so i went with the simple hack first.

Could make it clearer by having a variable like `asspciativity` set to
`kRightAssociative` or something of the op is **, and change how the loop works
based on that. It's the same hack, just expressed more clearly?

I am sure people have preferences for this, but it is a very unusual behavior
for a binary op in js, so i wasn't sure how we wanted to do it, thus wanted
feedback on it

[caitp (gmail), 2016/02/11 15:32:34]

I've simplified the unary-op SyntaxError code and refactored this slightly, to
look a little bit cleaner --- but it's really the same hack and adds a few lines
of code

       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 {