FYI Implementing '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 634 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 422 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 1104 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 (peek() == Token::SUPER) {
+      Consume(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 211 matching lines @@
       parser()->ReportMessage("accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H