First simple implementation of class literals in TurboFan.

src/compiler/ast-graph-builder.cc

 // Copyright 2014 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/compiler/ast-graph-builder.h"
 
 #include "src/compiler.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/machine-operator.h"
@@ skipping 302 matching lines @@
 
 
 void AstGraphBuilder::VisitForValueOrNull(Expression* expr) {
   if (expr == NULL) {
     return environment()->Push(jsgraph()->NullConstant());
   }
   VisitForValue(expr);
 }
 
 
+void AstGraphBuilder::VisitForValueOrTheHole(Expression* expr) {
+  if (expr == NULL) {
+    return environment()->Push(jsgraph()->TheHoleConstant());
+  }
+  VisitForValue(expr);
+}
+
+
 void AstGraphBuilder::VisitForValues(ZoneList<Expression*>* exprs) {
   for (int i = 0; i < exprs->length(); ++i) {
     VisitForValue(exprs->at(i));
   }
 }
 
 
 void AstGraphBuilder::VisitForValue(Expression* expr) {
   AstValueContext for_value(this);
   if (!CheckStackOverflow()) {
@@ skipping 129 matching lines @@
 
 
 void AstGraphBuilder::VisitBlock(Block* stmt) {
   BlockBuilder block(this);
   BreakableScope scope(this, stmt, &block, 0);
   if (stmt->labels() != NULL) block.BeginBlock();
   if (stmt->scope() == NULL) {
     // Visit statements in the same scope, no declarations.
     VisitStatements(stmt->statements());
   } else {
-    const Operator* op = javascript()->CreateBlockContext();
-    Node* scope_info = jsgraph()->Constant(stmt->scope()->GetScopeInfo());
-    Node* context = NewNode(op, scope_info, GetFunctionClosure());
+    // Visit declarations and statements in a block scope.
+    Node* context = BuildLocalBlockContext(stmt->scope());
     ContextScope scope(this, stmt->scope(), context);
-
-    // Visit declarations and statements in a block scope.
     VisitDeclarations(stmt->scope()->declarations());
     VisitStatements(stmt->statements());
   }
   if (stmt->labels() != NULL) block.EndBlock();
 }
 
 
 void AstGraphBuilder::VisitModuleStatement(ModuleStatement* stmt) {
   UNREACHABLE();
 }
@@ skipping 339 matching lines @@
   // Create node to instantiate a new closure.
   Node* info = jsgraph()->Constant(shared_info);
   Node* pretenure = jsgraph()->BooleanConstant(expr->pretenure());
   const Operator* op = javascript()->CallRuntime(Runtime::kNewClosure, 3);
   Node* value = NewNode(op, context, info, pretenure);
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitClassLiteral(ClassLiteral* expr) {
-  UNREACHABLE();
+  if (expr->scope() == NULL) {
+    // Visit class literal in the same scope, no declarations.
+    VisitClassLiteralContents(expr);
+  } else {
+    // Visit declarations and class literal in a block scope.
+    Node* context = BuildLocalBlockContext(expr->scope());
+    ContextScope scope(this, expr->scope(), context);
+    VisitDeclarations(expr->scope()->declarations());
+    VisitClassLiteralContents(expr);
+  }
 }
 
 
+void AstGraphBuilder::VisitClassLiteralContents(ClassLiteral* expr) {
+  Node* class_name = expr->raw_name() ? jsgraph()->Constant(expr->name())
+                                      : jsgraph()->UndefinedConstant();
+
+  // The class name is expected on the operand stack.
+  environment()->Push(class_name);
+  VisitForValueOrTheHole(expr->extends());
+  VisitForValue(expr->constructor());
+
+  // Create node to instantiate a new class.
+  Node* constructor = environment()->Pop();
+  Node* extends = environment()->Pop();
+  Node* name = environment()->Pop();
+  Node* script = jsgraph()->Constant(info()->script());
+  Node* start = jsgraph()->Constant(expr->start_position());
+  Node* end = jsgraph()->Constant(expr->end_position());
+  const Operator* opc = javascript()->CallRuntime(Runtime::kDefineClass, 6);
+  Node* literal = NewNode(opc, name, extends, constructor, script, start, end);
+
+  // The prototype is ensured to exist by Runtime_DefineClass. No access check
+  // is needed here since the constructor is created by the class literal.
+  Node* proto =
+      BuildLoadObjectField(literal, JSFunction::kPrototypeOrInitialMapOffset);
+
+  // The class literal and the prototype are both expected on the operand stack
+  // during evaluation of the method values.
+  environment()->Push(literal);
+  environment()->Push(proto);
+
+  // Create nodes to store method values into the literal.
+  for (int i = 0; i < expr->properties()->length(); i++) {
+    ObjectLiteral::Property* property = expr->properties()->at(i);
+    environment()->Push(property->is_static() ? literal : proto);
+
+    VisitForValue(property->key());
+    VisitForValue(property->value());
+    Node* value = environment()->Pop();
+    Node* key = environment()->Pop();
+    Node* receiver = environment()->Pop();
+    switch (property->kind()) {
+      case ObjectLiteral::Property::CONSTANT:
+      case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+      case ObjectLiteral::Property::COMPUTED:
+      case ObjectLiteral::Property::PROTOTYPE: {

[rossberg, 2015/01/15 15:31:19]

It seems to me that none but MATERIALIZED_LITERAL should possibly appear here,
so we might want to mark the others unreachable (similarly, in full-codegens).

[arv (Not doing code reviews), 2015/01/15 16:12:24]

I believe PROTOTYPE can happen too

class C {
  __proto__() {}
}

[rossberg, 2015/01/15 16:35:11]

That is just considered a regular method definition, isn't it? As such, it
shouldn't have PROTOTYPE kind AFAICT.

[arv (Not doing code reviews), 2015/01/15 16:51:02]

The AST only checks the value of the property name and since that matches
__proto__ it uses PROTOTYPE as the kind.

Let me refactor that in a different CL.

[Michael Starzinger, 2015/01/16 09:43:54]

Done. Made CONSTANT and MATERIALIZED_LITERAL unreachable. Normally all
FunctionLiterals should be COMPUTED, still need PROTOTYPE as per Arv's
explanation. I left the full-codegens untouched.

[arv (Not doing code reviews), 2015/01/16 14:42:07]

I'll take care of this in a follow up CL

+        const Operator* op =
+            javascript()->CallRuntime(Runtime::kDefineClassMethod, 3);
+        NewNode(op, receiver, key, value);
+        break;
+      }
+      case ObjectLiteral::Property::GETTER: {
+        const Operator* op =
+            javascript()->CallRuntime(Runtime::kDefineClassGetter, 3);
+        NewNode(op, receiver, key, value);
+        break;
+      }
+      case ObjectLiteral::Property::SETTER: {
+        const Operator* op =
+            javascript()->CallRuntime(Runtime::kDefineClassSetter, 3);
+        NewNode(op, receiver, key, value);
+        break;
+      }
+    }
+
+    // TODO(mstarzinger): This is temporary to make "super" work and replicates
+    // the existing FullCodeGenerator::NeedsHomeObject predicate.
+    if (FunctionLiteral::NeedsHomeObject(property->value())) {
+      Unique<Name> name =
+          MakeUnique(isolate()->factory()->home_object_symbol());
+      NewNode(javascript()->StoreNamed(strict_mode(), name), value, receiver);
+    }
+  }
+
+  // Transform both the class literal and the prototype to fast properties.
+  const Operator* op = javascript()->CallRuntime(Runtime::kToFastProperties, 1);
+  NewNode(op, environment()->Pop());  // prototype
+  NewNode(op, environment()->Pop());  // literal
+
+  // Assign to class variable.
+  if (expr->scope() != NULL) {
+    DCHECK_NOT_NULL(expr->class_variable_proxy());
+    Variable* var = expr->class_variable_proxy()->var();
+    BuildVariableAssignment(var, literal, Token::INIT_CONST, BailoutId::None());
+  }
+
+  ast_context()->ProduceValue(literal);
+}
+
+
 void AstGraphBuilder::VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
   UNREACHABLE();
 }
 
 
 void AstGraphBuilder::VisitConditional(Conditional* expr) {
   IfBuilder compare_if(this);
   VisitForTest(expr->condition());
   Node* condition = environment()->Pop();
   compare_if.If(condition);
@@ skipping 963 matching lines @@
     // Context variable (at bottom of the context chain).
     DCHECK_EQ(0, info()->scope()->ContextChainLength(variable->scope()));
     const Operator* op = javascript()->StoreContext(0, variable->index());
     NewNode(op, local_context, parameter);
   }
 
   return local_context;
 }
 
 
+Node* AstGraphBuilder::BuildLocalBlockContext(Scope* scope) {
+  Node* closure = GetFunctionClosure();
+
+  // Allocate a new local context.
+  const Operator* op = javascript()->CreateBlockContext();
+  Node* scope_info = jsgraph()->Constant(scope->GetScopeInfo());
+  Node* local_context = NewNode(op, scope_info, closure);
+
+  return local_context;
+}
+
+
 Node* AstGraphBuilder::BuildArgumentsObject(Variable* arguments) {
   if (arguments == NULL) return NULL;
 
   // Allocate and initialize a new arguments object.
   Node* callee = GetFunctionClosure();
   const Operator* op = javascript()->CallRuntime(Runtime::kNewArguments, 1);
   Node* object = NewNode(op, callee);
 
   // Assign the object to the arguments variable.
   DCHECK(arguments->IsContextSlot() || arguments->IsStackAllocated());
@@ skipping 403 matching lines @@
 
 BitVector* AstGraphBuilder::GetVariablesAssignedInLoop(
     IterationStatement* stmt) {
   if (loop_assignment_analysis_ == NULL) return NULL;
   return loop_assignment_analysis_->GetVariablesAssignedInLoop(stmt);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8