Parse 'super' keyword.

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/func-name-inferrer.h"
@@ skipping 77 matching lines @@
   // allowed to be parsed by this instance of the parser.
   bool allow_lazy() const { return allow_lazy_; }
   bool allow_natives_syntax() const { return allow_natives_syntax_; }
   bool allow_generators() const { return allow_generators_; }
   bool allow_arrow_functions() const { return allow_arrow_functions_; }
   bool allow_modules() const { return scanner()->HarmonyModules(); }
   bool allow_harmony_scoping() const { return scanner()->HarmonyScoping(); }
   bool allow_harmony_numeric_literals() const {
     return scanner()->HarmonyNumericLiterals();
   }
+  bool allow_classes() const { return scanner()->HarmonyClasses(); }
 
   // 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_syntax(bool allow) { allow_natives_syntax_ = allow; }
   void set_allow_generators(bool allow) { allow_generators_ = allow; }
   void set_allow_arrow_functions(bool allow) { allow_arrow_functions_ = allow; }
   void set_allow_modules(bool allow) { scanner()->SetHarmonyModules(allow); }
   void set_allow_harmony_scoping(bool allow) {
     scanner()->SetHarmonyScoping(allow);
   }
   void set_allow_harmony_numeric_literals(bool allow) {
     scanner()->SetHarmonyNumericLiterals(allow);
   }
+  void set_allow_classes(bool allow) {
+    scanner()->SetHarmonyClasses(allow);
+  }
 
  protected:
   friend class Traits::Type::Checkpoint;
 
   enum AllowEvalOrArgumentsAsIdentifier {
     kAllowEvalOrArguments,
     kDontAllowEvalOrArguments
   };
 
   enum Mode {
@@ skipping 548 matching lines @@
   }
 
   static PreParserExpression UseStrictStringLiteral() {
     return PreParserExpression(kUseStrictString);
   }
 
   static PreParserExpression This() {
     return PreParserExpression(kThisExpression);
   }
 
+  static PreParserExpression Super() {
+    return PreParserExpression(kSuperExpression);
+  }
+
   static PreParserExpression ThisProperty() {
     return PreParserExpression(kThisPropertyExpression);
   }
 
   static PreParserExpression Property() {
     return PreParserExpression(kPropertyExpression);
   }
 
   static PreParserExpression Call() {
     return PreParserExpression(kCallExpression);
@@ skipping 101 matching lines @@
     // duplicated identifier in parameter lists for arrow functions, because
     // they are initially parsed as comma-separated expressions.
     kTypeBinaryOperation = 3,
     kBinaryOperationArrowParamList = (1 << 4),
 
     // Below here applies if neither identifier nor string literal. Reserve the
     // 2 least significant bits for flags.
     kThisExpression = (1 << 4),
     kThisPropertyExpression = (2 << 4),
     kPropertyExpression = (3 << 4),
-    kCallExpression = (4 << 4)
+    kCallExpression = (4 << 4),
+    kSuperExpression = (5 << 4)
   };
 
   explicit PreParserExpression(int expression_code) : code_(expression_code) {}
 
   V8_INLINE int ArrowParamListBit() const {
     if (IsBinaryOperation()) return code_ & kBinaryOperationArrowParamList;
     if (IsIdentifier()) {
       const PreParserIdentifier ident = AsIdentifier();
       // A valid identifier can be an arrow function parameter list
       // except for eval, arguments, yield, and reserved keywords.
@@ skipping 429 matching lines @@
 
   static PreParserIdentifier GetNextSymbol(Scanner* scanner) {
     return PreParserIdentifier::Default();
   }
 
   static PreParserExpression ThisExpression(PreParserScope* scope,
                                             PreParserFactory* factory) {
     return PreParserExpression::This();
   }
 
+  static PreParserExpression SuperReference(PreParserScope* scope,
+                                            PreParserFactory* factory) {
+    return PreParserExpression::Super();
+  }
+
   static PreParserExpression ExpressionFromLiteral(
       Token::Value token, int pos, Scanner* scanner,
       PreParserFactory* factory) {
     return PreParserExpression::Default();
   }
 
   static PreParserExpression ExpressionFromIdentifier(
       PreParserIdentifier name, int pos, PreParserScope* scope,
       PreParserFactory* factory) {
     return PreParserExpression::FromIdentifier(name);
@@ skipping 1115 matching lines @@
   // new foo.bar().baz means (new (foo.bar)()).baz
   // new foo()() means (new foo())()
   // new new foo()() means (new (new foo())())
   // new new foo means new (new foo)
   // new new foo() means new (new foo())
   // new new foo().bar().baz means (new (new foo()).bar()).baz
 
   if (peek() == Token::NEW) {
     Consume(Token::NEW);
     int new_pos = position();
-    ExpressionT result = this->ParseMemberWithNewPrefixesExpression(CHECK_OK);
+    ExpressionT result = this->EmptyExpression();
+    if (Check(Token::SUPER)) {
+      result = this->SuperReference(scope_, factory());
+    } else {
+      result = this->ParseMemberWithNewPrefixesExpression(CHECK_OK);
+    }
     if (peek() == Token::LPAREN) {
       // NewExpression with arguments.
       typename Traits::Type::ExpressionList args =
           this->ParseArguments(CHECK_OK);
       result = factory()->NewCallNew(result, args, new_pos);
       // The expression can still continue with . or [ after the arguments.
       result = this->ParseMemberExpressionContinuation(result, CHECK_OK);
       return result;
     }
     // NewExpression without arguments.
     return factory()->NewCallNew(result, this->NewExpressionList(0, zone_),
                                  new_pos);
   }
-  // No 'new' keyword.
+  // No 'new' or 'super' keyword.
   return this->ParseMemberExpression(ok);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseMemberExpression(bool* ok) {
   // MemberExpression ::
   //   (PrimaryExpression | FunctionLiteral)
   //     ('[' Expression ']' | '.' Identifier | Arguments)*
@@ skipping 20 matching lines @@
       function_type = FunctionLiteral::NAMED_EXPRESSION;
     }
     result = this->ParseFunctionLiteral(name,
                                         function_name_location,
                                         is_strict_reserved_name,
                                         is_generator,
                                         function_token_position,
                                         function_type,
                                         FunctionLiteral::NORMAL_ARITY,
                                         CHECK_OK);
+  } else if (peek() == Token::SUPER) {
+    int beg_pos = position();
+    Consume(Token::SUPER);
+    Token::Value next = peek();
+    if (next == Token::PERIOD || next == Token::LBRACK ||
+        next == Token::LPAREN) {
+      result = this->SuperReference(scope_, factory());
+    } else {
+      ReportMessageAt(Scanner::Location(beg_pos, position()),
+                      "unexpected_super");
+      *ok = false;
+      return this->EmptyExpression();
+    }
   } else {
     result = ParsePrimaryExpression(CHECK_OK);
   }
 
   result = ParseMemberExpressionContinuation(result, CHECK_OK);
   return result;
 }
 
 
 template <class Traits>
@@ skipping 203 matching lines @@
       parser()->ReportMessage("accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H