Refactor class declaration logic to the parser and runtime

src/parsing/parser.cc

 // 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.
 
 #include "src/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 751 matching lines @@
 FunctionLiteral* ParserTraits::ParseFunctionLiteral(
     const AstRawString* name, Scanner::Location function_name_location,
     FunctionNameValidity function_name_validity, FunctionKind kind,
     int function_token_position, FunctionLiteral::FunctionType type,
     LanguageMode language_mode, bool* ok) {
   return parser_->ParseFunctionLiteral(
       name, function_name_location, function_name_validity, kind,
       function_token_position, type, language_mode, ok);
 }
 
-ClassLiteral* ParserTraits::ParseClassLiteral(
+Expression* ParserTraits::ParseClassLiteral(
     Type::ExpressionClassifier* classifier, const AstRawString* name,
     Scanner::Location class_name_location, bool name_is_strict_reserved,
     int pos, bool* ok) {
   return parser_->ParseClassLiteral(classifier, name, class_name_location,
                                     name_is_strict_reserved, pos, ok);
 }
 
 void ParserTraits::MarkTailPosition(Expression* expression) {
   expression->MarkTail();
 }
@@ skipping 1447 matching lines @@
   const AstRawString* variable_name;
   if (default_export && (peek() == Token::EXTENDS || peek() == Token::LBRACE)) {
     name = ast_value_factory()->default_string();
     is_strict_reserved = false;
     variable_name = ast_value_factory()->star_default_star_string();
   } else {
     name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
     variable_name = name;
   }
 
-  ClassLiteral* value = ParseClassLiteral(nullptr, name, scanner()->location(),
-                                          is_strict_reserved, pos, CHECK_OK);
+  Expression* value = ParseClassLiteral(nullptr, name, scanner()->location(),
+                                        is_strict_reserved, pos, CHECK_OK);
 
   VariableProxy* proxy = NewUnresolved(variable_name, LET);
   Declaration* declaration =
       factory()->NewVariableDeclaration(proxy, LET, scope_, pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   proxy->var()->set_initializer_position(position());
   Assignment* assignment =
       factory()->NewAssignment(Token::INIT, proxy, value, pos);
   Statement* assignment_statement =
       factory()->NewExpressionStatement(assignment, kNoSourcePosition);
@@ skipping 2670 matching lines @@
   }
   PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction(
       language_mode(), function_state_->kind(), scope_->has_simple_parameters(),
       parsing_module_, logger, bookmark, use_counts_);
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Stop();
   }
   return result;
 }
 
-ClassLiteral* Parser::ParseClassLiteral(ExpressionClassifier* classifier,
-                                        const AstRawString* name,
-                                        Scanner::Location class_name_location,
-                                        bool name_is_strict_reserved, int pos,
-                                        bool* ok) {
+Expression* Parser::ParseClassLiteral(ExpressionClassifier* classifier,
+                                      const AstRawString* name,
+                                      Scanner::Location class_name_location,
+                                      bool name_is_strict_reserved, int pos,
+                                      bool* ok) {
   // All parts of a ClassDeclaration and ClassExpression are strict code.
   if (name_is_strict_reserved) {
     ReportMessageAt(class_name_location,
                     MessageTemplate::kUnexpectedStrictReserved);
     *ok = false;
     return NULL;
   }
   if (IsEvalOrArguments(name)) {
     ReportMessageAt(class_name_location, MessageTemplate::kStrictEvalArguments);
     *ok = false;
@@ skipping 23 matching lines @@
     if (classifier != nullptr) {
       classifier->Accumulate(&extends_classifier,
                              ExpressionClassifier::ExpressionProductions);
     }
   } else {
     block_scope->set_start_position(scanner()->location().end_pos);
   }
 
 
   ClassLiteralChecker checker(this);
-  ZoneList<ObjectLiteral::Property*>* properties = NewPropertyList(4, zone());
   FunctionLiteral* constructor = NULL;
+
+  ZoneList<Expression*>* property_names =
+      new (zone()) ZoneList<Expression*>(4, zone());
+  ZoneList<Expression*>* property_funcs =
+      new (zone()) ZoneList<Expression*>(4, zone());
+  ZoneList<Expression*>* property_infos =
+      new (zone()) ZoneList<Expression*>(4, zone());
+
   bool has_seen_constructor = false;
 
   Expect(Token::LBRACE, CHECK_OK);
 
   const bool has_extends = extends != nullptr;
   while (peek() != Token::RBRACE) {
     if (Check(Token::SEMICOLON)) continue;
     FuncNameInferrer::State fni_state(fni_);
     const bool in_class = true;
     bool is_computed_name = false;  // Classes do not care about computed
                                     // property names here.
     ExpressionClassifier property_classifier(this);
     const AstRawString* property_name = nullptr;
     ObjectLiteral::Property* property = ParsePropertyDefinition(
         &checker, in_class, has_extends, MethodKind::Normal, &is_computed_name,
         &has_seen_constructor, &property_classifier, &property_name, CHECK_OK);
     RewriteNonPattern(&property_classifier, CHECK_OK);
     if (classifier != nullptr) {
       classifier->Accumulate(&property_classifier,
                              ExpressionClassifier::ExpressionProductions);
     }
 
     if (has_seen_constructor && constructor == NULL) {
       constructor = GetPropertyValue(property)->AsFunctionLiteral();
       DCHECK_NOT_NULL(constructor);
       constructor->set_raw_name(
           name != nullptr ? name : ast_value_factory()->empty_string());
     } else {
-      properties->Add(property, zone());
+      auto prop_pos =

[adamk, 2016/07/13 20:57:32]

The general practice in v8 has been to use "auto" only where the type is
obvious, which isn't the case here. Also "int" is shorter :)

Also, I'd name this "property_pos", you already have several variables with a
"property_" prefix.

+          GetPropertyValue(property)->AsFunctionLiteral()->position();

[adamk, 2016/07/13 20:57:32]

GetPropertyValue() isn't needed here, you already pulled the value out on the
next line. Don't need the AsFunctionLiteral() either, all Expressions have a
position().

+      Expression* value = property->value();
+
+      Expression* property_key;
+
+      if (property_name != nullptr) {

[adamk, 2016/07/13 20:57:32]

For the common case of non-numeric properties, you can add an extra if before
this:

if (property->key()->IsStringLiteral()) {
  property_key = property->key();
} else if (property_name != nullptr) {
  // handle the smi case as you're already doing
} else {
  // handle the computed case
}

+        // For static keys, no ToName call is necessary.
+        property_key = factory()->NewStringLiteral(property_name, prop_pos);
+      } else {
+        ZoneList<Expression*>* toName_args =

[adamk, 2016/07/13 20:57:32]

Style nit: to_name_args

+            new (zone()) ZoneList<Expression*>(1, zone());
+        toName_args->Add(property->key(), zone());
+
+        property_key =
+            factory()->NewCallRuntime(Runtime::kToName, toName_args, prop_pos);

[adamk, 2016/07/13 20:57:32]

You can use kInlineToName, which in TurboFan will be much faster and elsewhere
will fall back to the runtime.

+      }
+
+      int info = property->is_static() ? kIsStaticMask : 0;
+      switch (property->kind()) {
+        case ObjectLiteral::Property::CONSTANT:
+        case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+        case ObjectLiteral::Property::PROTOTYPE:
+          UNREACHABLE();
+        case ObjectLiteral::Property::COMPUTED:
+          break;
+
+        case ObjectLiteral::Property::GETTER:
+          info |= kIsAccessorMask;
+          break;
+
+        case ObjectLiteral::Property::SETTER:
+          info |= kIsAccessorMask | kIsSetterMask;
+          break;
+      }
+
+      property_names->Add(property_key, zone());
+      property_funcs->Add(value, zone());
+      property_infos->Add(factory()->NewNumberLiteral(info, kNoSourcePosition),
+                          zone());
     }
 
     if (fni_ != NULL) fni_->Infer();
 
     if (property_name != ast_value_factory()->constructor_string()) {
       SetFunctionNameFromPropertyName(property, property_name);
     }
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   int end_pos = scanner()->location().end_pos;
 
   if (constructor == NULL) {
     constructor = DefaultConstructor(name, has_extends, block_scope, pos,
                                      end_pos, block_scope->language_mode());
   }
 
   // Note that we do not finalize this block scope because it is
   // used as a sentinel value indicating an anonymous class.
   block_scope->set_end_position(end_pos);
 
   if (name != NULL) {
     DCHECK_NOT_NULL(proxy);
     proxy->var()->set_initializer_position(end_pos);
   }
 
-  return factory()->NewClassLiteral(block_scope, proxy, extends, constructor,
-                                    properties, pos, end_pos);
+  // Construct a DoExpression representing the class literal.
+  Block* do_block = factory()->NewBlock(nullptr, 16, false, pos);
+  do_block->set_scope(scope_);
+
+  // Call DefineClass. It takes seven arguments:
+  // 1. The superclass constructor, or the Hole if not present.
+  // 2. The constructor function.
+  // 3. An array of method names.
+  // 4. An array of said method's corresponding functions.
+  // 5. An array of flags signalling if they are accessors and/or static.
+  // 6. The location where the class's source starts.
+  // 7. The location where the class's source ends.
+  ZoneList<Expression*>* define_class_args =
+      new (zone()) ZoneList<Expression*>(7, zone());
+  define_class_args->Add(extends != nullptr
+                             ? extends
+                             : factory()->NewTheHoleLiteral(kNoSourcePosition),
+                         zone());
+  define_class_args->Add(constructor, zone());
+
+  int names_idx = function_state_->NextMaterializedLiteralIndex();
+  int funcs_idx = function_state_->NextMaterializedLiteralIndex();
+  int infos_idx = function_state_->NextMaterializedLiteralIndex();
+
+  define_class_args->Add(
+      factory()->NewArrayLiteral(property_names, names_idx, kNoSourcePosition),
+      zone());
+  define_class_args->Add(
+      factory()->NewArrayLiteral(property_funcs, funcs_idx, kNoSourcePosition),
+      zone());
+  define_class_args->Add(
+      factory()->NewArrayLiteral(property_infos, infos_idx, kNoSourcePosition),
+      zone());
+
+  define_class_args->Add(factory()->NewNumberLiteral(pos, kNoSourcePosition),
+                         zone());
+  define_class_args->Add(
+      factory()->NewNumberLiteral(end_pos, kNoSourcePosition), zone());
+
+  Expression* define_class_call = factory()->NewCallRuntime(
+      Runtime::kDefineClass, define_class_args, kNoSourcePosition);
+
+  // Set the constructor to have fast properties.
+  ZoneList<Expression*>* fast_properties_args =
+      new (zone()) ZoneList<Expression*>(1, zone());
+  fast_properties_args->Add(define_class_call, zone());
+
+  Expression* fast_properties_call = factory()->NewCallRuntime(
+      Runtime::kToFastProperties, fast_properties_args, kNoSourcePosition);
+
+  if (name != nullptr) {
+    DCHECK_NOT_NULL(proxy);
+    // Init the variable representing the class name only after evaluating all
+    // property names.
+    Expression* name_assignment = factory()->NewAssignment(
+        Token::INIT, proxy, fast_properties_call, end_pos);
+
+    do_block->statements()->Add(
+        factory()->NewExpressionStatement(name_assignment, end_pos), zone());
+  } else {
+    do_block->statements()->Add(factory()->NewExpressionStatement(
+                                    fast_properties_call, kNoSourcePosition),
+                                zone());
+  }
+
+  Variable* result = scope_->NewTemporary(ast_value_factory()->empty_string());
+  DoExpression* expr = factory()->NewDoExpression(do_block, result, pos);
+
+  Rewriter::Rewrite(this, expr,
+                    ast_value_factory());  // TODO(bakkot) This is just going to
+                                           // turn the final ExpressionStatement
+                                           // into an assignment to result; we
+                                           // could do that ourselves slightly
+                                           // cheaper.
+
+  // This enables function name inference.
+  expr->set_represented_function(constructor);
+
+  return expr;
 }
 
 
 Expression* Parser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
   //   '%' Identifier Arguments
 
   int pos = peek_position();
   Expect(Token::MOD, CHECK_OK);
   // Allow "eval" or "arguments" for backward compatibility.
@@ skipping 955 matching lines @@
   DCHECK_NOT_NULL(name);
 
   // Ignore "__proto__" as a name when it's being used to set the [[Prototype]]
   // of an object literal.
   if (property->kind() == ObjectLiteralProperty::PROTOTYPE) return;
 
   if (function != nullptr) {
     function->set_raw_name(name);
     DCHECK_EQ(ObjectLiteralProperty::COMPUTED, property->kind());
   } else {
-    DCHECK(value->IsClassLiteral());
+    DCHECK(value->IsDoExpression());
     DCHECK_EQ(ObjectLiteralProperty::COMPUTED, property->kind());
-    value->AsClassLiteral()->constructor()->set_raw_name(name);
+    DCHECK_NOT_NULL(value->AsDoExpression()->represented_function());
+    value->AsDoExpression()->represented_function()->set_raw_name(name);
   }
 }
 
 
 void ParserTraits::SetFunctionNameFromIdentifierRef(Expression* value,
                                                     Expression* identifier) {
   if (!value->IsAnonymousFunctionDefinition()) return;
   if (!identifier->IsVariableProxy()) return;
 
   auto name = identifier->AsVariableProxy()->raw_name();
   DCHECK_NOT_NULL(name);
 
   auto function = value->AsFunctionLiteral();
   if (function != nullptr) {
     function->set_raw_name(name);
   } else {
-    DCHECK(value->IsClassLiteral());
-    value->AsClassLiteral()->constructor()->set_raw_name(name);
+    DCHECK(value->IsDoExpression());
+    DCHECK_NOT_NULL(value->AsDoExpression()->represented_function());
+    value->AsDoExpression()->represented_function()->set_raw_name(name);
   }
 }
 
 
 // Desugaring of yield*
 // ====================
 //
 // With the help of do-expressions and function.sent, we desugar yield* into a
 // loop containing a "raw" yield (a yield that doesn't wrap an iterator result
 // object around its argument).  Concretely, "yield* iterable" turns into
@@ skipping 956 matching lines @@
 
 #ifdef DEBUG
 void Parser::Print(AstNode* node) {
   ast_value_factory()->Internalize(Isolate::Current());
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 }  // namespace internal
 }  // namespace v8