[Interpreter] Add array literal support.

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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/interpreter/bytecode-generator.h"
 
 #include <stack>
 
 #include "src/compiler.h"
 #include "src/interpreter/control-flow-builders.h"
 #include "src/objects.h"
+#include "src/parser.h"
 #include "src/scopes.h"
 #include "src/token.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 
 // Scoped class tracking context objects created by the visitor. Represents
 // mutations of the context chain within the function body and allows to
@@ skipping 429 matching lines @@
   CHECK(!shared_info.is_null());  // TODO(rmcilroy): Set stack overflow?
 
   // Call the runtime to create a new closure.
   // TODO(rmcilroy): Possibly call FastNewClosureStub when possible instead of
   // calling into the runtime.
   Runtime::FunctionId function_id =
       expr->pretenure() ? Runtime::kNewClosure_Tenured : Runtime::kNewClosure;
 
   TemporaryRegisterScope temporary_register_scope(builder());
   Register shared = temporary_register_scope.NewRegister();
-  builder()->LoadLiteral(shared_info)
+  builder()
+      ->LoadLiteral(shared_info)
       .StoreAccumulatorInRegister(shared)
       .CallRuntime(function_id, shared, 1);
 }
 
 
 void BytecodeGenerator::VisitClassLiteral(ClassLiteral* expr) {
   UNIMPLEMENTED();
 }
 
 
@@ skipping 30 matching lines @@
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
-  UNIMPLEMENTED();
+  // Deep-copy the literal boilerplate.
+  expr->BuildConstantElements(isolate());
+  builder()
+      ->LoadLiteral(expr->constant_elements())
+      .CreateArrayLiteral(expr->literal_index(), expr->ComputeFlags(true));
+
+  TemporaryRegisterScope temporary_register_scope(builder());
+  Register index, literal_array;
+
+  // Create nodes to evaluate all the non-constant subexpressions and to store
+  // them into the newly cloned array.
+  bool literal_array_in_accumulator = true;
+  for (int array_index = 0; array_index < expr->values()->length();
+       array_index++) {
+    Expression* subexpr = expr->values()->at(array_index);
+    if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
+    if (subexpr->IsSpread()) {
+      // TODO(rmcilroy): Deal with spread expressions.
+      UNIMPLEMENTED();
+    }
+
+    if (literal_array_in_accumulator) {
+      index = temporary_register_scope.NewRegister();
+      literal_array = temporary_register_scope.NewRegister();
+      builder()->StoreAccumulatorInRegister(literal_array);
+      literal_array_in_accumulator = false;
+    }
+
+    builder()
+        ->LoadLiteral(Smi::FromInt(array_index))
+        .StoreAccumulatorInRegister(index);
+    Visit(subexpr);
+    builder()->GenericStoreKeyedProperty(literal_array, index);
+  }
+
+  if (!literal_array_in_accumulator) {
+    // Restore literal array into accumulator.
+    builder()->LoadAccumulatorWithRegister(literal_array);
+  }
 }
 
 
 void BytecodeGenerator::VisitVariableProxy(VariableProxy* proxy) {
   VisitVariableLoad(proxy->var(), proxy->VariableFeedbackSlot());
 }
 
 
 void BytecodeGenerator::VisitVariableLoad(Variable* variable,
                                           FeedbackVectorSlot slot) {
@@ skipping 218 matching lines @@
       builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
       // Load callee as a global variable.
       VariableProxy* proxy = callee_expr->AsVariableProxy();
       VisitVariableLoad(proxy->var(), proxy->VariableFeedbackSlot());
       builder()->StoreAccumulatorInRegister(callee);
       break;
     }
     case Call::OTHER_CALL: {
       Visit(callee_expr);
       builder()->StoreAccumulatorInRegister(callee);
-      builder()->LoadUndefined()
-          .StoreAccumulatorInRegister(receiver);
+      builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
       break;
     }
     case Call::LOOKUP_SLOT_CALL:
     case Call::SUPER_CALL:
     case Call::POSSIBLY_EVAL_CALL:
       UNIMPLEMENTED();
   }
 
   // Evaluate all arguments to the function call and store in sequential
   // registers.
@@ skipping 196 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8