Refactor class declaration logic to the parser and runtime

src/ast/ast.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/ast/ast.h"
 
 #include <cmath>  // For isfinite.
 
 #include "src/ast/prettyprinter.h"
 #include "src/ast/scopes.h"
@@ skipping 128 matching lines @@
 }
 
 bool Expression::IsValidReferenceExpressionOrThis() const {
   return IsValidReferenceExpression() ||
          (IsVariableProxy() && AsVariableProxy()->is_this());
 }
 
 bool Expression::IsAnonymousFunctionDefinition() const {
   return (IsFunctionLiteral() &&
           AsFunctionLiteral()->IsAnonymousFunctionDefinition()) ||
-         (IsClassLiteral() &&
-          AsClassLiteral()->IsAnonymousFunctionDefinition());
+         (IsDoExpression() &&
+          AsDoExpression()->IsAnonymousFunctionDefinition());
 }
 
 void Expression::MarkTail() {
   if (IsConditional()) {
     AsConditional()->MarkTail();
   } else if (IsCall()) {
     AsCall()->MarkTail();
   } else if (IsBinaryOperation()) {
     AsBinaryOperation()->MarkTail();
   }
@@ skipping 112 matching lines @@
   AssignVectorSlots(target(), spec, &slot_);
 }
 
 
 void CountOperation::AssignFeedbackVectorSlots(Isolate* isolate,
                                                FeedbackVectorSpec* spec,
                                                FeedbackVectorSlotCache* cache) {
   AssignVectorSlots(expression(), spec, &slot_);
 }
 
+bool DoExpression::IsAnonymousFunctionDefinition() const {
+  return represented_function_ != nullptr &&
+         represented_function_->raw_name()->length() == 0;

[marja, 2016/07/19 09:54:33]

This second part looks hacky; why is it needed? When do we have a
represented_function_ but its name length is 0? Can we not have a
represented_function_ at all in that case? Or somehow otherwise make this look
less hacky.

+}
 
 Token::Value Assignment::binary_op() const {
   switch (op()) {
     case Token::ASSIGN_BIT_OR: return Token::BIT_OR;
     case Token::ASSIGN_BIT_XOR: return Token::BIT_XOR;
     case Token::ASSIGN_BIT_AND: return Token::BIT_AND;
     case Token::ASSIGN_SHL: return Token::SHL;
     case Token::ASSIGN_SAR: return Token::SAR;
     case Token::ASSIGN_SHR: return Token::SHR;
     case Token::ASSIGN_ADD: return Token::ADD;
@@ skipping 72 matching lines @@
   }
 }
 
 bool ObjectLiteralProperty::NeedsSetFunctionName() const {
   return is_computed_name_ &&
          (value_->IsAnonymousFunctionDefinition() ||
           (value_->IsFunctionLiteral() &&
            IsConciseMethod(value_->AsFunctionLiteral()->kind())));
 }
 
-void ClassLiteral::AssignFeedbackVectorSlots(Isolate* isolate,
-                                             FeedbackVectorSpec* spec,
-                                             FeedbackVectorSlotCache* cache) {
-  // This logic that computes the number of slots needed for vector store
-  // ICs must mirror FullCodeGenerator::VisitClassLiteral.
-  prototype_slot_ = spec->AddLoadICSlot();
-  if (NeedsProxySlot()) {
-    proxy_slot_ = spec->AddStoreICSlot();
-  }
-
-  for (int i = 0; i < properties()->length(); i++) {
-    ObjectLiteral::Property* property = properties()->at(i);
-    Expression* value = property->value();
-    if (FunctionLiteral::NeedsHomeObject(value)) {
-      property->SetSlot(spec->AddStoreICSlot());
-    }
-  }
-}
-
-
 bool ObjectLiteral::Property::IsCompileTimeValue() {
   return kind_ == CONSTANT ||
       (kind_ == MATERIALIZED_LITERAL &&
        CompileTimeValue::IsCompileTimeValue(value_));
 }
 
 
 void ObjectLiteral::Property::set_emit_store(bool emit_store) {
   emit_store_ = emit_store;
 }
@@ skipping 808 matching lines @@
   RECURSE_EXPRESSION(Visit(expr->right()));
 }
 
 void AstTraversalVisitor::VisitCompareOperation(CompareOperation* expr) {
   RECURSE_EXPRESSION(Visit(expr->left()));
   RECURSE_EXPRESSION(Visit(expr->right()));
 }
 
 void AstTraversalVisitor::VisitThisFunction(ThisFunction* expr) {}
 
-void AstTraversalVisitor::VisitClassLiteral(ClassLiteral* expr) {
-  if (expr->extends() != nullptr) {
-    RECURSE_EXPRESSION(Visit(expr->extends()));
-  }
-  RECURSE_EXPRESSION(Visit(expr->constructor()));
-  ZoneList<ObjectLiteralProperty*>* props = expr->properties();
-  for (int i = 0; i < props->length(); ++i) {
-    ObjectLiteralProperty* prop = props->at(i);
-    if (!prop->key()->IsLiteral()) {
-      RECURSE_EXPRESSION(Visit(prop->key()));
-    }
-    RECURSE_EXPRESSION(Visit(prop->value()));
-  }
-}
-
 void AstTraversalVisitor::VisitSpread(Spread* expr) {
   RECURSE_EXPRESSION(Visit(expr->expression()));
 }
 
 void AstTraversalVisitor::VisitEmptyParentheses(EmptyParentheses* expr) {}
 
 void AstTraversalVisitor::VisitSuperPropertyReference(
     SuperPropertyReference* expr) {
   RECURSE_EXPRESSION(VisitVariableProxy(expr->this_var()));
   RECURSE_EXPRESSION(Visit(expr->home_object()));
@@ skipping 31 matching lines @@
 bool Literal::Match(void* literal1, void* literal2) {
   const AstValue* x = static_cast<Literal*>(literal1)->raw_value();
   const AstValue* y = static_cast<Literal*>(literal2)->raw_value();
   return (x->IsString() && y->IsString() && x->AsString() == y->AsString()) ||
          (x->IsNumber() && y->IsNumber() && x->AsNumber() == y->AsNumber());
 }
 
 
 }  // namespace internal
 }  // namespace v8