[es7] implement exponentiation operator proposal

src/parsing/parser-base.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_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/hashmap.h"
@@ skipping 104 matching lines @@
         allow_harmony_destructuring_assignment_(false),
         allow_strong_mode_(false),
         allow_legacy_const_(true),
         allow_harmony_do_expressions_(false),
         allow_harmony_function_name_(false) {}
 
 #define ALLOW_ACCESSORS(name)                           \
   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);
   ALLOW_ACCESSORS(harmony_sloppy_function);
   ALLOW_ACCESSORS(harmony_sloppy_let);
   ALLOW_ACCESSORS(harmony_default_parameters);
   ALLOW_ACCESSORS(harmony_destructuring_bind);
   ALLOW_ACCESSORS(harmony_destructuring_assignment);
   ALLOW_ACCESSORS(strong_mode);
   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_; }
 
  protected:
   enum AllowRestrictedIdentifiers {
     kAllowRestrictedIdentifiers,
     kDontAllowRestrictedIdentifiers
   };
 
@@ skipping 1957 matching lines @@
       fni_->Infer();
     } else {
       fni_->RemoveLastFunction();
     }
   }
 
   if (op == Token::ASSIGN && allow_harmony_function_name()) {
     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) {
     result = factory()->NewRewritableAssignmentExpression(result);
     Traits::QueueDestructuringAssignmentForRewriting(result);
   }
 
   return result;
 }
 
@@ skipping 80 matching lines @@
 }
 
 
 // Precedence >= 4
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 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) {
       x = Traits::RewriteNonPattern(x, classifier, CHECK_OK);
       BindingPatternUnexpectedToken(classifier);
       ArrowFormalParametersUnexpectedToken(classifier);
       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,
                                                        factory())) {
         continue;
       }
 
       // For now we distinguish between comparisons and other binary
       // operations.  (We could combine the two and get rid of this
       // code and AST node eventually.)
@@ skipping 65 matching lines @@
       }
     }
 
     // Allow Traits do rewrite the expression.
     return this->BuildUnaryExpression(expression, op, pos, factory());
   } else if (Token::IsCountOp(op)) {
     BindingPatternUnexpectedToken(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 {
     return this->ParsePostfixExpression(classifier, ok);
   }
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
@@ skipping 1043 matching lines @@
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H