Class syntax parsing

src/preparser.cc

 // Copyright 2011 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.
 
 #include <cmath>
 
 #include "include/v8stdint.h"
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
@@ skipping 60 matching lines @@
     return PreParserIdentifier::Let();
   } else if (scanner->current_token() == Token::YIELD) {
     return PreParserIdentifier::Yield();
   }
   if (scanner->UnescapedLiteralMatches("eval", 4)) {
     return PreParserIdentifier::Eval();
   }
   if (scanner->UnescapedLiteralMatches("arguments", 9)) {
     return PreParserIdentifier::Arguments();
   }
+  if (scanner->UnescapedLiteralMatches("prototype", 9)) {
+    return PreParserIdentifier::Prototype();
+  }
+  if (scanner->UnescapedLiteralMatches("constructor", 11)) {
+    return PreParserIdentifier::Constructor();
+  }
   return PreParserIdentifier::Default();
 }
 
 
 PreParserIdentifier PreParserTraits::GetNumberAsSymbol(Scanner* scanner) {
   return PreParserIdentifier::Default();
 }
 
 
 PreParserExpression PreParserTraits::ExpressionFromString(
@@ skipping 80 matching lines @@
   //
   // In harmony mode we allow additionally the following productions
   // SourceElement:
   //    LetDeclaration
   //    ConstDeclaration
   //    GeneratorDeclaration
 
   switch (peek()) {
     case Token::FUNCTION:
       return ParseFunctionDeclaration(ok);
+    case Token::CLASS:
+      return ParseClassDeclaration(ok);
     case Token::CONST:
       return ParseVariableStatement(kSourceElement, ok);
     case Token::LET:
       DCHECK(allow_harmony_scoping());
       if (strict_mode() == STRICT) {
         return ParseVariableStatement(kSourceElement, ok);
       }
       // Fall through.
     default:
       return ParseStatement(ok);
@@ skipping 107 matching lines @@
         PreParserTraits::ReportMessageAt(start_location.beg_pos,
                                          end_location.end_pos,
                                          "strict_function");
         *ok = false;
         return Statement::Default();
       } else {
         return statement;
       }
     }
 
+    case Token::CLASS:
+      return ParseClassDeclaration(CHECK_OK);
+
     case Token::DEBUGGER:
       return ParseDebuggerStatement(ok);
 
     case Token::VAR:
     case Token::CONST:
       return ParseVariableStatement(kStatement, ok);
 
     case Token::LET:
       DCHECK(allow_harmony_scoping());
       if (strict_mode() == STRICT) {
@@ skipping 20 matching lines @@
       &is_strict_reserved, CHECK_OK);
   ParseFunctionLiteral(name, scanner()->location(), is_strict_reserved,
                        is_generator ? FunctionKind::kGeneratorFunction
                                     : FunctionKind::kNormalFunction,
                        pos, FunctionLiteral::DECLARATION,
                        FunctionLiteral::NORMAL_ARITY, CHECK_OK);
   return Statement::FunctionDeclaration();
 }
 
 
+PreParser::Statement PreParser::ParseClassDeclaration(bool* ok) {
+  Expect(Token::CLASS, CHECK_OK);
+  int pos = position();
+  bool is_strict_reserved = false;
+  Identifier name =
+      ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
+  ParseClassLiteral(name, scanner()->location(), is_strict_reserved, pos,
+                    CHECK_OK);
+  return Statement::ClassDeclaration();
+}
+
+
 PreParser::Statement PreParser::ParseBlock(bool* ok) {
   // Block ::
   //   '{' Statement* '}'
 
   // Note that a Block does not introduce a new execution scope!
   // (ECMA-262, 3rd, 12.2)
   //
   Expect(Token::LBRACE, CHECK_OK);
   while (peek() != Token::RBRACE) {
     if (allow_harmony_scoping() && strict_mode() == STRICT) {
@@ skipping 570 matching lines @@
   ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   ParseArguments(ok);
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal