[ESnext] Implement Object Rest

src/parsing/pattern-rewriter.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/ast/ast.h"
 #include "src/messages.h"
 #include "src/objects-inl.h"
 #include "src/parsing/parameter-initializer-rewriter.h"
 #include "src/parsing/parser.h"
 
@@ skipping 314 matching lines @@
   DCHECK(scope()->outer_scope()->is_function_scope());
   DCHECK(scope()->calls_sloppy_eval());
 
   ReparentParameterExpressionScope(parser_->stack_limit(), expr, scope());
 }
 
 void Parser::PatternRewriter::VisitObjectLiteral(ObjectLiteral* pattern,
                                                  Variable** temp_var) {
   auto temp = *temp_var = CreateTempVar(current_value_);
 
+  ZoneList<Expression*>* rest_runtime_callargs = nullptr;
+  if (pattern->has_rest_property()) {
+    // non_rest_properties_count = pattern->properties()->length - 1;
+    // args_length = 1 + non_rest_properties_count because we need to
+    // pass temp as well to the runtime function.
+    int args_length = pattern->properties()->length();
+    rest_runtime_callargs =
+        new (zone()) ZoneList<Expression*>(args_length, zone());
+    rest_runtime_callargs->Add(factory()->NewVariableProxy(temp), zone());
+  }
+
   block_->statements()->Add(parser_->BuildAssertIsCoercible(temp), zone());
 
   for (ObjectLiteralProperty* property : *pattern->properties()) {
     PatternContext context = SetInitializerContextIfNeeded(property->value());
+    Expression* value;
 
-    // Computed property names contain expressions which might require
-    // scope rewriting.
-    if (!property->key()->IsLiteral()) RewriteParameterScopes(property->key());
+    if (property->kind() == ObjectLiteralProperty::Kind::SPREAD) {
+      // var { a, b, ...c } = temp
+      //     becomes
+      // var c;
+      // c = %CopyDataPropertiesWithExcludedProperties(temp, a, b);
+      value = factory()->NewCallRuntime(
+          Runtime::kCopyDataPropertiesWithExcludedProperties,
+          rest_runtime_callargs, kNoSourcePosition);
+    } else {
+      Expression* key = property->key();
 
-    RecurseIntoSubpattern(
-        property->value(),
-        factory()->NewProperty(factory()->NewVariableProxy(temp),
-                               property->key(), kNoSourcePosition));
+      if (!key->IsLiteral()) {
+        // Computed property names contain expressions which might require
+        // scope rewriting.
+        RewriteParameterScopes(key);
+      }
+
+      if (pattern->has_rest_property()) {
+        Expression* excluded_property = property->key();
+
+        // We create a temporary variable for a computed property name
+        // so that we don't evaluate it twice when we include it in

[adamk, 2017/01/12 22:43:08]

This isn't sufficient as it turns out: we need to store not only the output of
the expression, but also the ToPropertyKey() of that output. Otherwise a case
like:

var x = 0;
var {[{valueOf() { return x++ }}]: y, ...z} = {};

will call valueOf() twice!

I begin to wonder if that means we should move more of this logic to the
BytecodeGenerator, since it already has access to that ToPropertyKey'd value.
The thing I don't know enough to answer is the best way to accumulate a list in
BytecodeGenerator.

[gsathya, 2017/01/17 19:28:59]

Done.

+        // the excluded_properties list.
+        if (!key->IsLiteral()) {
+          auto temp_key = CreateTempVar(key);
+          key = factory()->NewVariableProxy(temp_key);
+          excluded_property = factory()->NewVariableProxy(temp_key);
+        }
+
+        DCHECK(rest_runtime_callargs != nullptr);
+        rest_runtime_callargs->Add(excluded_property, zone());
+      }
+
+      value = factory()->NewProperty(factory()->NewVariableProxy(temp), key,
+                                     kNoSourcePosition);
+    }
+
+    RecurseIntoSubpattern(property->value(), value);
     set_context(context);
   }
 }
 
 
 void Parser::PatternRewriter::VisitObjectLiteral(ObjectLiteral* node) {
   Variable* temp_var = nullptr;
   VisitObjectLiteral(node, &temp_var);
 }
 
@@ skipping 334 matching lines @@
 NOT_A_PATTERN(TryFinallyStatement)
 NOT_A_PATTERN(UnaryOperation)
 NOT_A_PATTERN(VariableDeclaration)
 NOT_A_PATTERN(WhileStatement)
 NOT_A_PATTERN(WithStatement)
 NOT_A_PATTERN(Yield)
 
 #undef NOT_A_PATTERN
 }  // namespace internal
 }  // namespace v8