Implement experimental exponentiation operator

src/preparser.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_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 99 matching lines @@
   }
   bool allow_harmony_templates() const { return scanner()->HarmonyTemplates(); }
   bool allow_harmony_sloppy() const { return allow_harmony_sloppy_; }
   bool allow_harmony_unicode() const { return scanner()->HarmonyUnicode(); }
   bool allow_harmony_computed_property_names() const {
     return allow_harmony_computed_property_names_;
   }
   bool allow_harmony_rest_params() const {
     return allow_harmony_rest_params_;
   }
-
+  bool allow_harmony_exponentiation() const {
+    return scanner()->HarmonyExponentiation();
+  }
   bool allow_strong_mode() const { return allow_strong_mode_; }
 
   // Setters that determine whether certain syntactical constructs are
   // allowed to be parsed by this instance of the parser.
   void set_allow_lazy(bool allow) { allow_lazy_ = allow; }
   void set_allow_natives(bool allow) { allow_natives_ = allow; }
   void set_allow_harmony_arrow_functions(bool allow) {
     allow_harmony_arrow_functions_ = allow;
   }
   void set_allow_harmony_modules(bool allow) {
@@ skipping 19 matching lines @@
   }
   void set_allow_harmony_unicode(bool allow) {
     scanner()->SetHarmonyUnicode(allow);
   }
   void set_allow_harmony_computed_property_names(bool allow) {
     allow_harmony_computed_property_names_ = allow;
   }
   void set_allow_harmony_rest_params(bool allow) {
     allow_harmony_rest_params_ = allow;
   }
+  void set_allow_harmony_exponentiation(bool allow) {
+    scanner()->SetHarmonyExponentiation(allow);
+  }
   void set_allow_strong_mode(bool allow) { allow_strong_mode_ = allow; }
 
  protected:
   enum AllowEvalOrArgumentsAsIdentifier {
     kAllowEvalOrArguments,
     kDontAllowEvalOrArguments
   };
 
   enum Mode {
     PARSE_LAZILY,
@@ skipping 2288 matching lines @@
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseBinaryExpression(int prec, bool accept_IN, bool* ok) {
   DCHECK(prec >= 4);
   ExpressionT x = this->ParseUnaryExpression(CHECK_OK);
   for (int prec1 = Precedence(peek(), accept_IN); prec1 >= prec; prec1--) {
     // prec1 >= 4
     while (Precedence(peek(), accept_IN) == prec1) {
       Token::Value op = Next();
       Scanner::Location op_location = scanner()->location();
       int pos = position();
-      ExpressionT y = ParseBinaryExpression(prec1 + 1, accept_IN, CHECK_OK);
+      ExpressionT y = Traits::EmptyExpression();
+
+      if (op != Token::EXP) {
+        //  Left-to-right associativity
+        y = ParseBinaryExpression(prec1 + 1, accept_IN, CHECK_OK);
+      } else {
+        // Right-to-left associativity
+        y = ParseBinaryExpression(prec1, accept_IN, 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.)
       if (Token::IsCompareOp(op)) {
@@ skipping 630 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H