Class syntax parsing

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 28 matching lines @@
 //   // In particular...
 //   struct Type {
 //     // Used by FunctionState and BlockState.
 //     typedef Scope;
 //     typedef GeneratorVariable;
 //     typedef Zone;
 //     // Return types for traversing functions.
 //     typedef Identifier;
 //     typedef Expression;
 //     typedef FunctionLiteral;
+//     typedef ClassLiteral;
 //     typedef ObjectLiteralProperty;
 //     typedef Literal;
 //     typedef ExpressionList;
 //     typedef PropertyList;
 //     // For constructing objects returned by the traversing functions.
 //     typedef Factory;
 //   };
 //   // ...
 // };
 
 template <typename Traits>
 class ParserBase : public Traits {
  public:
   // Shorten type names defined by Traits.
   typedef typename Traits::Type::Expression ExpressionT;
   typedef typename Traits::Type::Identifier IdentifierT;
   typedef typename Traits::Type::FunctionLiteral FunctionLiteralT;
+  typedef typename Traits::Type::ClassLiteral ClassLiteralT;
   typedef typename Traits::Type::Literal LiteralT;
   typedef typename Traits::Type::ObjectLiteralProperty ObjectLiteralPropertyT;
 
   ParserBase(Scanner* scanner, uintptr_t stack_limit, v8::Extension* extension,
              ParserRecorder* log, typename Traits::Type::Zone* zone,
              AstNode::IdGen* ast_node_id_gen,
              typename Traits::Type::Parser this_object)
       : Traits(this_object),
         parenthesized_function_(false),
         scope_(NULL),
@@ skipping 400 matching lines @@
   // Parses an identifier and determines whether or not it is 'get' or 'set'.
   IdentifierT ParseIdentifierNameOrGetOrSet(bool* is_get,
                                             bool* is_set,
                                             bool* ok);
 
   ExpressionT ParseRegExpLiteral(bool seen_equal, bool* ok);
 
   ExpressionT ParsePrimaryExpression(bool* ok);
   ExpressionT ParseExpression(bool accept_IN, bool* ok);
   ExpressionT ParseArrayLiteral(bool* ok);
+  IdentifierT ParsePropertyName(bool* is_get, bool* is_set, bool* is_static,
+                                bool* ok);
   ExpressionT ParseObjectLiteral(bool* ok);
   ObjectLiteralPropertyT ParsePropertyDefinition(ObjectLiteralChecker* checker,
+                                                 bool in_class, bool is_static,
                                                  bool* ok);
-  IdentifierT ParsePropertyName(bool* is_getter, bool* is_setter, bool* ok);
   typename Traits::Type::ExpressionList ParseArguments(bool* ok);
   ExpressionT ParseAssignmentExpression(bool accept_IN, bool* ok);
   ExpressionT ParseYieldExpression(bool* ok);
   ExpressionT ParseConditionalExpression(bool accept_IN, bool* ok);
   ExpressionT ParseBinaryExpression(int prec, bool accept_IN, bool* ok);
   ExpressionT ParseUnaryExpression(bool* ok);
   ExpressionT ParsePostfixExpression(bool* ok);
   ExpressionT ParseLeftHandSideExpression(bool* ok);
   ExpressionT ParseMemberWithNewPrefixesExpression(bool* ok);
   ExpressionT ParseMemberExpression(bool* ok);
   ExpressionT ParseMemberExpressionContinuation(ExpressionT expression,
                                                 bool* ok);
   ExpressionT ParseArrowFunctionLiteral(int start_pos, ExpressionT params_ast,
                                         bool* ok);
+  ClassLiteralT ParseClassLiteral(IdentifierT name,
+                                  Scanner::Location function_name_location,
+                                  bool name_is_strict_reserved, int pos,
+                                  bool* ok);
 
   // Checks if the expression is a valid reference expression (e.g., on the
   // left-hand side of assignments). Although ruled out by ECMA as early errors,
   // we allow calls for web compatibility and rewrite them to a runtime throw.
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression,
       Scanner::Location location, const char* message, bool* ok);
 
   // Used to detect duplicates in object literals. Each of the values
   // kGetterProperty, kSetterProperty and kValueProperty represents
@@ skipping 95 matching lines @@
   }
   static PreParserIdentifier FutureStrictReserved() {
     return PreParserIdentifier(kFutureStrictReservedIdentifier);
   }
   static PreParserIdentifier Let() {
     return PreParserIdentifier(kLetIdentifier);
   }
   static PreParserIdentifier Yield() {
     return PreParserIdentifier(kYieldIdentifier);
   }
+  static PreParserIdentifier Prototype() {
+    return PreParserIdentifier(kPrototypeIdentifier);
+  }
+  static PreParserIdentifier Constructor() {
+    return PreParserIdentifier(kConstructorIdentifier);
+  }
   bool IsEval() const { return type_ == kEvalIdentifier; }
   bool IsArguments() const { return type_ == kArgumentsIdentifier; }
+  bool IsYield() const { return type_ == kYieldIdentifier; }
+  bool IsPrototype() const { return type_ == kPrototypeIdentifier; }
+  bool IsConstructor() const { return type_ == kConstructorIdentifier; }
   bool IsEvalOrArguments() const { return type_ >= kEvalIdentifier; }

[marja, 2014/09/15 09:24:29]

Nit: I'd just get rid of the >= trickery altogether (I don't see any real reason
for it and it's just error prone), and add Prototype and Constructor at the end
of the enum instead of in the middle.

[rossberg, 2014/09/15 12:32:48]

I agree.

[arv (Not doing code reviews), 2014/09/15 15:12:32]

Done.

-  bool IsYield() const { return type_ == kYieldIdentifier; }
   bool IsFutureReserved() const { return type_ == kFutureReservedIdentifier; }
   bool IsFutureStrictReserved() const {
     return type_ == kFutureStrictReservedIdentifier;
   }
   bool IsValidStrictVariable() const { return type_ == kUnknownIdentifier; }
 
   // Allow identifier->name()[->length()] to work. The preparser
   // does not need the actual positions/lengths of the identifiers.
   const PreParserIdentifier* operator->() const { return this; }
   const PreParserIdentifier raw_name() const { return *this; }
 
   int position() const { return 0; }
   int length() const { return 0; }
 
  private:
   enum Type {
     kUnknownIdentifier,
     kFutureReservedIdentifier,
     kFutureStrictReservedIdentifier,
     kLetIdentifier,
     kYieldIdentifier,
+    kPrototypeIdentifier,
+    kConstructorIdentifier,
     kEvalIdentifier,
     kArgumentsIdentifier
   };
   explicit PreParserIdentifier(Type type) : type_(type) {}
   Type type_;
 
   friend class PreParserExpression;
   friend class PreParserScope;
 };
 
@@ skipping 270 matching lines @@
  public:
   explicit PreParserScope(PreParserScope* outer_scope, ScopeType scope_type,
                           void* = NULL)
       : scope_type_(scope_type) {
     strict_mode_ = outer_scope ? outer_scope->strict_mode() : SLOPPY;
   }
 
   ScopeType type() { return scope_type_; }
   StrictMode strict_mode() const { return strict_mode_; }
   void SetStrictMode(StrictMode strict_mode) { strict_mode_ = strict_mode; }
+  void SetScopeName(PreParserIdentifier name) {}
 
   // When PreParser is in use, lazy compilation is already being done,
   // things cannot get lazier than that.
   bool AllowsLazyCompilation() const { return false; }
 
   void set_start_position(int position) {}
   void set_end_position(int position) {}
 
   bool IsDeclared(const PreParserIdentifier& identifier) const { return false; }
   void DeclareParameter(const PreParserIdentifier& identifier, VariableMode) {}
@@ skipping 24 matching lines @@
                                        int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewArrayLiteral(PreParserExpressionList values,
                                       int literal_index,
                                       int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewObjectLiteralProperty(bool is_getter,
                                                PreParserExpression value,
-                                               int pos) {
+                                               int pos, bool is_static) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewObjectLiteralProperty(PreParserExpression key,
-                                               PreParserExpression value) {
+                                               PreParserExpression value,
+                                               bool is_static) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewObjectLiteral(PreParserExpressionList properties,
                                        int literal_index,
                                        int boilerplate_properties,
                                        bool has_function,
                                        int pos) {
     return PreParserExpression::Default();
   }
-  PreParserExpression NewVariableProxy(void* generator_variable) {
+  PreParserExpression NewVariableProxy(void* variable) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewProperty(PreParserExpression obj,
                                   PreParserExpression key,
                                   int pos) {
     if (obj.IsThis()) {
       return PreParserExpression::ThisProperty();
     }
     return PreParserExpression::Property();
   }
@@ skipping 55 matching lines @@
       const PreParserScope& scope, PreParserStatementList body,
       int materialized_literal_count, int expected_property_count,
       int handler_count, int parameter_count,
       FunctionLiteral::ParameterFlag has_duplicate_parameters,
       FunctionLiteral::FunctionType function_type,
       FunctionLiteral::IsFunctionFlag is_function,
       FunctionLiteral::IsParenthesizedFlag is_parenthesized, FunctionKind kind,
       int position) {
     return PreParserExpression::Default();
   }
+  PreParserExpression NewClassLiteral(PreParserIdentifier name,
+                                      PreParserExpression extends,
+                                      PreParserExpression constructor,
+                                      PreParserExpressionList properties,
+                                      AstValueFactory* ast_value_factory,
+                                      int position) {
+    return PreParserExpression::Default();
+  }
 
   // Return the object itself as AstVisitor and implement the needed
   // dummy method right in this class.
   PreParserFactory* visitor() { return this; }
   BailoutReason dont_optimize_reason() { return kNoReason; }
   int* ast_properties() {
     static int dummy = 42;
     return &dummy;
   }
 };
@@ skipping 18 matching lines @@
     typedef void Zone;
 
     typedef int AstProperties;
     typedef Vector<PreParserIdentifier> ParameterIdentifierVector;
 
     // Return types for traversing functions.
     typedef PreParserIdentifier Identifier;
     typedef PreParserExpression Expression;
     typedef PreParserExpression YieldExpression;
     typedef PreParserExpression FunctionLiteral;
+    typedef PreParserExpression ClassLiteral;
     typedef PreParserExpression ObjectLiteralProperty;
     typedef PreParserExpression Literal;
     typedef PreParserExpressionList ExpressionList;
     typedef PreParserExpressionList PropertyList;
     typedef PreParserStatementList StatementList;
 
     // For constructing objects returned by the traversing functions.
     typedef PreParserFactory Factory;
   };
 
   class Checkpoint;
 
   explicit PreParserTraits(PreParser* pre_parser) : pre_parser_(pre_parser) {}
 
   // Custom operations executed when FunctionStates are created and
   // destructed. (The PreParser doesn't need to do anything.)
   template <typename FunctionState>
   static void SetUpFunctionState(FunctionState* function_state) {}
   template <typename FunctionState>
   static void TearDownFunctionState(FunctionState* function_state) {}
 
   // Helper functions for recursive descent.
   static bool IsEvalOrArguments(PreParserIdentifier identifier) {
     return identifier.IsEvalOrArguments();
   }
 
+  static bool IsPrototype(PreParserIdentifier identifier) {
+    return identifier.IsPrototype();
+  }
+
+  static bool IsConstructor(PreParserIdentifier identifier) {
+    return identifier.IsConstructor();
+  }
+
   // Returns true if the expression is of type "this.foo".
   static bool IsThisProperty(PreParserExpression expression) {
     return expression.IsThisProperty();
   }
 
   static bool IsIdentifier(PreParserExpression expression) {
     return expression.IsIdentifier();
   }
 
   static PreParserIdentifier AsIdentifier(PreParserExpression expression) {
@@ skipping 100 matching lines @@
   }
   static PreParserExpression EmptyArrowParamList() {
     return PreParserExpression::EmptyArrowParamList();
   }
   static PreParserExpression EmptyLiteral() {
     return PreParserExpression::Default();
   }
   static PreParserExpression EmptyObjectLiteralProperty() {
     return PreParserExpression::Default();
   }
+  static PreParserExpression EmptyFunctionLiteral() {
+    return PreParserExpression::Default();
+  }
+  static PreParserExpression EmptyClassLiteral() {
+    return PreParserExpression::Default();
+  }
   static PreParserExpressionList NullExpressionList() {
     return PreParserExpressionList();
   }
 
   // Odd-ball literal creators.
   static PreParserExpression GetLiteralTheHole(int position,
                                                PreParserFactory* factory) {
     return PreParserExpression::Default();
   }
 
@@ skipping 170 matching lines @@
   };
 
   // All ParseXXX functions take as the last argument an *ok parameter
   // which is set to false if parsing failed; it is unchanged otherwise.
   // By making the 'exception handling' explicit, we are forced to check
   // for failure at the call sites.
   Statement ParseSourceElement(bool* ok);
   SourceElements ParseSourceElements(int end_token, bool* ok);
   Statement ParseStatement(bool* ok);
   Statement ParseFunctionDeclaration(bool* ok);
+  Statement ParseClassDeclaration(bool* ok);
   Statement ParseBlock(bool* ok);
   Statement ParseVariableStatement(VariableDeclarationContext var_context,
                                    bool* ok);
   Statement ParseVariableDeclarations(VariableDeclarationContext var_context,
                                       VariableDeclarationProperties* decl_props,
                                       int* num_decl,
                                       bool* ok);
   Statement ParseExpressionOrLabelledStatement(bool* ok);
   Statement ParseIfStatement(bool* ok);
   Statement ParseContinueStatement(bool* ok);
@@ skipping 253 matching lines @@
   //   'this'
   //   'null'
   //   'true'
   //   'false'
   //   Identifier
   //   Number
   //   String
   //   ArrayLiteral
   //   ObjectLiteral
   //   RegExpLiteral
+  //   ClassLiteral
   //   '(' Expression ')'
 
   int pos = peek_position();
   ExpressionT result = this->EmptyExpression();
   Token::Value token = peek();
   switch (token) {
     case Token::THIS: {
       Consume(Token::THIS);
       result = this->ThisExpression(scope_, factory());
       break;
@@ skipping 50 matching lines @@
       } else {
         // Heuristically try to detect immediately called functions before
         // seeing the call parentheses.
         parenthesized_function_ = (peek() == Token::FUNCTION);
         result = this->ParseExpression(true, CHECK_OK);
         result->increase_parenthesization_level();
         Expect(Token::RPAREN, CHECK_OK);
       }
       break;
 
+    case Token::CLASS: {
+      Consume(Token::CLASS);
+      int class_token_position = position();
+      IdentifierT name = this->EmptyIdentifier();
+      bool is_strict_reserved_name = false;
+      Scanner::Location class_name_location = Scanner::Location::invalid();
+      if (peek_any_identifier()) {
+        name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved_name,
+                                                   CHECK_OK);
+        class_name_location = scanner()->location();
+      }
+      result = this->ParseClassLiteral(name, class_name_location,
+                                       is_strict_reserved_name,
+                                       class_token_position, CHECK_OK);
+      break;
+    }
+
     case Token::MOD:
       if (allow_natives_syntax() || extension_ != NULL) {
         result = this->ParseV8Intrinsic(CHECK_OK);
         break;
       }
       // If we're not allowing special syntax we fall-through to the
       // default case.
 
     default: {
       Next();
@@ skipping 50 matching lines @@
 
   // Update the scope information before the pre-parsing bailout.
   int literal_index = function_state_->NextMaterializedLiteralIndex();
 
   return factory()->NewArrayLiteral(values, literal_index, pos);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::IdentifierT ParserBase<Traits>::ParsePropertyName(
-    bool* is_getter, bool* is_setter, bool* ok) {
+    bool* is_get, bool* is_set, bool* is_static, bool* ok) {
   Token::Value next = peek();
   switch (next) {
     case Token::STRING:
       Consume(Token::STRING);
       return this->GetSymbol(scanner_);
     case Token::NUMBER:
       Consume(Token::NUMBER);
       return this->GetNumberAsSymbol(scanner_);
+    case Token::STATIC:
+      *is_static = true;
+      // Fall through.
     default:
-      return ParseIdentifierNameOrGetOrSet(is_getter, is_setter,
-                                           CHECK_OK_CUSTOM(EmptyIdentifier));
+      return ParseIdentifierNameOrGetOrSet(is_get, is_set, ok);
   }
+  UNREACHABLE();
+  return this->EmptyIdentifier();
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ObjectLiteralPropertyT ParserBase<
-    Traits>::ParsePropertyDefinition(ObjectLiteralChecker* checker, bool* ok) {
+    Traits>::ParsePropertyDefinition(ObjectLiteralChecker* checker,
+                                     bool in_class, bool is_static, bool* ok) {
   // TODO(arv): Add support for concise generator methods.
   ExpressionT value = this->EmptyExpression();
-  bool is_getter = false;
-  bool is_setter = false;
+  bool is_get = false;
+  bool is_set = false;
+  bool name_is_static = false;
   Token::Value name_token = peek();
   int next_pos = peek_position();
-  IdentifierT name = ParsePropertyName(
-      &is_getter, &is_setter, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+  IdentifierT name =
+      ParsePropertyName(&is_get, &is_set, &name_is_static,
+                        CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+
   if (fni_ != NULL) this->PushLiteralName(fni_, name);
 
-  if (peek() == Token::COLON) {
+  if (!in_class && peek() == Token::COLON) {
     // PropertyDefinition : PropertyName ':' AssignmentExpression
     checker->CheckProperty(name_token, kValueProperty,
                            CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     Consume(Token::COLON);
     value = this->ParseAssignmentExpression(
         true, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
   } else if (allow_harmony_object_literals_ && peek() == Token::LPAREN) {
     // Concise Method
+
+    if (is_static && this->IsPrototype(name)) {
+      ReportMessageAt(scanner()->location(), "static_prototype");
+      *ok = false;
+      return this->EmptyObjectLiteralProperty();
+    }
+
     checker->CheckProperty(name_token, kValueProperty,
                            CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     value = this->ParseFunctionLiteral(
         name, scanner()->location(),
         false,  // reserved words are allowed here
         FunctionKind::kConciseMethod, RelocInfo::kNoPosition,
         FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::NORMAL_ARITY,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
-  } else if (is_getter || is_setter) {
+  } else if (in_class && name_is_static && !is_static) {

[rossberg, 2014/09/15 12:32:48]

Hm, I'd prefer pulling recognising 'static' out of this method and avoid both
the funny recursion and computing the extra flag in ParsePropertyName. Let the
caller do it.

[arv (Not doing code reviews), 2014/09/15 15:12:32]

That gets a lot more complicated. The problem is that seeing 'static' does not
mean that it is a static property. You have to do a look ahead to determine that
before calling ParsePropertyDefinition. Consider the following valid cases, all
starting with static.

static() { }
static m() { }
static 'm'() { }
static "m"() { }
static 42() { }
static [expr]() { }
static *m() { }
static *'m'() { }
static *"m"() { }
static *42() { }
static *[expr]() { }

+    // static MethodDefinition
+    return ParsePropertyDefinition(checker, true, true, ok);
+
+  } else if (is_get || is_set) {
     // Accessor
     bool dont_care = false;
     name_token = peek();
-    name = ParsePropertyName(&dont_care, &dont_care,
+    name = ParsePropertyName(&dont_care, &dont_care, &dont_care,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+
     // Validate the property.
+    if (is_static && this->IsPrototype(name)) {
+      ReportMessageAt(scanner()->location(), "static_prototype");
+      *ok = false;
+      return this->EmptyObjectLiteralProperty();
+    } else if (in_class && this->IsConstructor(name)) {
+      ReportMessageAt(scanner()->location(), "constructor_special_method");
+      *ok = false;
+      return this->EmptyObjectLiteralProperty();
+    }
     checker->CheckProperty(name_token,
-                           is_getter ? kGetterProperty : kSetterProperty,
+                           is_get ? kGetterProperty : kSetterProperty,
                            CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+
     typename Traits::Type::FunctionLiteral value = this->ParseFunctionLiteral(
         name, scanner()->location(),
         false,  // reserved words are allowed here
         FunctionKind::kNormalFunction, RelocInfo::kNoPosition,
         FunctionLiteral::ANONYMOUS_EXPRESSION,
-        is_getter ? FunctionLiteral::GETTER_ARITY
-                  : FunctionLiteral::SETTER_ARITY,
+        is_get ? FunctionLiteral::GETTER_ARITY : FunctionLiteral::SETTER_ARITY,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
-    return factory()->NewObjectLiteralProperty(is_getter, value, next_pos);
+    return factory()->NewObjectLiteralProperty(is_get, value, next_pos,
+                                               is_static);
   } else {
     Token::Value next = Next();
     ReportUnexpectedToken(next);
     *ok = false;
     return this->EmptyObjectLiteralProperty();
   }
 
   uint32_t index;
   LiteralT key = this->IsArrayIndex(name, &index)
                      ? factory()->NewNumberLiteral(index, next_pos)
                      : factory()->NewStringLiteral(name, next_pos);
 
-  return factory()->NewObjectLiteralProperty(key, value);
+  return factory()->NewObjectLiteralProperty(key, value, is_static);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseObjectLiteral(
     bool* ok) {
   // ObjectLiteral ::
   // '{' (PropertyDefinition (',' PropertyDefinition)* ','? )? '}'
 
   int pos = peek_position();
   typename Traits::Type::PropertyList properties =
       this->NewPropertyList(4, zone_);
   int number_of_boilerplate_properties = 0;
   bool has_function = false;
 
   ObjectLiteralChecker checker(this, strict_mode());
 
   Expect(Token::LBRACE, CHECK_OK);
 
+  const bool in_class = false;
+  const bool is_static = false;
   while (peek() != Token::RBRACE) {
     if (fni_ != NULL) fni_->Enter();
 
     ObjectLiteralPropertyT property =
-        this->ParsePropertyDefinition(&checker, CHECK_OK);
+        this->ParsePropertyDefinition(&checker, in_class, is_static, CHECK_OK);
 
     // Mark top-level object literals that contain function literals and
     // pretenure the literal so it can be added as a constant function
     // property. (Parser only.)
     this->CheckFunctionLiteralInsideTopLevelObjectLiteral(scope_, property,
                                                           &has_function);
 
     // Count CONSTANT or COMPUTED properties to maintain the enumeration order.
     if (this->IsBoilerplateProperty(property)) {
       number_of_boilerplate_properties++;
@@ skipping 428 matching lines @@
   }
   // No 'new' or 'super' keyword.
   return this->ParseMemberExpression(ok);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseMemberExpression(bool* ok) {
   // MemberExpression ::
-  //   (PrimaryExpression | FunctionLiteral)
+  //   (PrimaryExpression | FunctionLiteral | ClassLiteral)
   //     ('[' Expression ']' | '.' Identifier | Arguments)*
 
   // The '[' Expression ']' and '.' Identifier parts are parsed by
   // ParseMemberExpressionContinuation, and the Arguments part is parsed by the
   // caller.
 
   // Parse the initial primary or function expression.
   ExpressionT result = this->EmptyExpression();
   if (peek() == Token::FUNCTION) {
     Consume(Token::FUNCTION);
@@ skipping 182 matching lines @@
   function_literal->set_function_token_position(start_pos);
   function_literal->set_ast_properties(&ast_properties);
   function_literal->set_dont_optimize_reason(dont_optimize_reason);
 
   if (fni_ != NULL) this->InferFunctionName(fni_, function_literal);
 
   return function_literal;
 }
 
 
+template <class Traits>
+typename ParserBase<Traits>::ClassLiteralT
+ParserBase<Traits>::ParseClassLiteral(IdentifierT name,
+                                      Scanner::Location class_name_location,
+                                      bool name_is_strict_reserved, int pos,
+                                      bool* ok) {
+  // All parts of a ClassDeclaration or a ClassExpression are strict code.
+  if (name_is_strict_reserved) {
+    ReportMessageAt(class_name_location, "unexpected_strict_reserved");
+    *ok = false;
+    return this->EmptyClassLiteral();
+  }
+  if (this->IsEvalOrArguments(name)) {
+    ReportMessageAt(class_name_location, "strict_eval_arguments");
+    *ok = false;
+    return this->EmptyClassLiteral();
+  }
+
+  typename Traits::Type::ScopePtr extends_scope =
+      this->NewScope(scope_, BLOCK_SCOPE);

[rossberg, 2014/09/15 12:32:48]

Why does the extends clause need its own scope?

[arv (Not doing code reviews), 2014/09/15 15:12:32]

This is premature. My thinking was this.

1. The extends expression is supposed to be strict so we I need to wrap that in
a block.
2. The name of the class is not supposed to be in scope for the extends
expression but for the class body.

I could do one scope for the extends expression and then close that scope. And
then a second one for the class body. At least the scope depth is only 1 in that
case.

Either way. This needs more work when I implement the actual visibility of the
class name.

[rossberg, 2014/09/16 15:25:40]

I see, oh dear. Having a strict pseudo scope for that probably makes sense,
although it should perhaps not be a block scope.
I don't see how that one is related, though. The name is only added to the inner
scope anyway, isn't it?
Yes, I would prefer that, since it doesn't mess up the scope/context chain with
an empty scope.

+  FunctionState extends_function_state(
+      &function_state_, &scope_, &extends_scope, zone(),
+      this->ast_value_factory(), ast_node_id_gen_);
+  scope_->SetStrictMode(STRICT);
+  scope_->SetScopeName(name);
+
+  ExpressionT extends = this->EmptyExpression();
+  if (Check(Token::EXTENDS)) {
+    extends =
+        this->ParseLeftHandSideExpression(CHECK_OK_CUSTOM(EmptyClassLiteral));
+  }
+
+  // The name binding is only visible inside the class body (not the extends
+  // expression).
+  typename Traits::Type::ScopePtr scope = this->NewScope(scope_, BLOCK_SCOPE);

[rossberg, 2014/09/15 12:32:48]

I'm not sure it will work out to reuse BLOCK_SCOPE here. We probably need a
separate CLASS_SCOPE. At least it would be cleaner. (I'm fine with making that a
TODO for now.)

[arv (Not doing code reviews), 2014/09/15 15:12:32]

I agree that this is not obvious at this point. I'll add a todo. I need to
revisit this area anyway.

+  FunctionState function_state(&function_state_, &scope_, &scope, zone(),
+                               this->ast_value_factory(), ast_node_id_gen_);
+  // TODO(arv): Add binding if the class literal has a name.
+
+  ObjectLiteralChecker checker(this, STRICT);
+  const bool in_class = true;
+  const bool is_static = false;

[rossberg, 2014/09/15 12:32:48]

Nit: If you find it worth naming these constants, then at least move them next
to the call using them.

[arv (Not doing code reviews), 2014/09/15 15:12:32]

Done.

+  typename Traits::Type::PropertyList properties =
+      this->NewPropertyList(4, zone_);
+  FunctionLiteralT constructor = this->EmptyFunctionLiteral();
+
+  Expect(Token::LBRACE, CHECK_OK_CUSTOM(EmptyClassLiteral));
+  while (peek() != Token::RBRACE) {
+    if (Check(Token::SEMICOLON)) continue;
+    if (fni_ != NULL) fni_->Enter();
+
+    ObjectLiteralPropertyT property = this->ParsePropertyDefinition(

[rossberg, 2014/09/15 12:32:48]

I'd prefer to check for 'static' here. That would also make it easy to store
static and non-static properties in separate lists, and avoid the extra flag on
their AST node.

[arv (Not doing code reviews), 2014/09/15 15:12:32]

Storing two separate list is not going to work because computed properties makes
the ordering observable.

let i = 0;
class C {
  [(assert(i === 0), i++)]() {}
  static [(assert(i === 1), i++)]() {}
  [(assert(i === 2), i++)]() {}
}

[rossberg, 2014/09/16 15:25:40]

Oh hell. Make sure to add the above as a test case in time. :)

+        &checker, in_class, is_static, CHECK_OK_CUSTOM(EmptyClassLiteral));
+
+    properties->Add(property, zone());
+
+    if (fni_ != NULL) {
+      fni_->Infer();
+      fni_->Leave();
+    }
+  }
+  Expect(Token::RBRACE, CHECK_OK_CUSTOM(EmptyClassLiteral));
+
+  return factory()->NewClassLiteral(name, extends, constructor, properties,
+                                    this->ast_value_factory(), pos);
+}
+
+
 template <typename Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::CheckAndRewriteReferenceExpression(
     ExpressionT expression,
     Scanner::Location location, const char* message, bool* ok) {
   if (strict_mode() == STRICT && this->IsIdentifier(expression) &&
       this->IsEvalOrArguments(this->AsIdentifier(expression))) {
     this->ReportMessageAt(location, "strict_eval_arguments", false);
     *ok = false;
     return this->EmptyExpression();
@@ skipping 39 matching lines @@
       DCHECK(IsAccessorAccessorConflict(old_type, type));
       // Both accessors of the same type.
       parser()->ReportMessage("accessor_get_set");
     }
     *ok = false;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H