[destructuring] Implement initializers in patterns.

src/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.h"
 #include "src/messages.h"
 #include "src/parser.h"
 
 namespace v8 {
 
@@ skipping 190 matching lines @@
     VariableProxy* proxy = initialization_scope->NewUnresolved(factory(), name);
     Assignment* assignment = factory()->NewAssignment(
         descriptor_->init_op, proxy, value, descriptor_->pos);
     block_->AddStatement(
         factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
         zone());
   }
 }
 
 
+Variable* Parser::PatternRewriter::CreateTempVar(Expression* value) {
+  auto temp_scope = descriptor_->parser->scope_->DeclarationScope();
+  auto temp = temp_scope->NewTemporary(ast_value_factory()->empty_string());
+  auto assignment =
+      factory()->NewAssignment(Token::ASSIGN, factory()->NewVariableProxy(temp),
+                               value, RelocInfo::kNoPosition);
+
+  block_->AddStatement(
+      factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
+      zone());
+  return temp;
+}
+
+
 void Parser::PatternRewriter::VisitObjectLiteral(ObjectLiteral* pattern) {
-  auto temp = TemporaryDeclarationScope()->NewTemporary(
-      ast_value_factory()->empty_string());
-  auto assignment =
-      factory()->NewAssignment(Token::ASSIGN, factory()->NewVariableProxy(temp),
-                               current_value_, RelocInfo::kNoPosition);
-
-  block_->AddStatement(
-      factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
-      zone());
-
+  auto temp = CreateTempVar(current_value_);
   if (pattern->properties()->length() == 0) {
     block_->AddStatement(descriptor_->parser->BuildAssertIsCoercible(temp),
                          zone());
   }
 
   for (ObjectLiteralProperty* property : *pattern->properties()) {
     // TODO(dslomov): computed property names.
     RecurseIntoSubpattern(
         property->value(),
         factory()->NewProperty(factory()->NewVariableProxy(temp),
                                property->key(), RelocInfo::kNoPosition));
   }
 }
 
 
 void Parser::PatternRewriter::VisitArrayLiteral(ArrayLiteral* node) {
   // TODO(dslomov): implement.
 }
 
 
 void Parser::PatternRewriter::VisitAssignment(Assignment* node) {
-  // TODO(dslomov): implement.
+  // let {<pattern> = <init>} = <value>
+  //   becomes
+  // temp = <value>;
+  // <pattern> = temp === undefined ? <init> : temp;
+  DCHECK(node->op() == Token::ASSIGN);
+  auto temp = CreateTempVar(current_value_);
+  Expression* is_undefined = factory()->NewCompareOperation(
+      Token::EQ_STRICT, factory()->NewVariableProxy(temp),
+      factory()->NewUndefinedLiteral(RelocInfo::kNoPosition),
+      RelocInfo::kNoPosition);
+  Expression* value = factory()->NewConditional(
+      is_undefined, node->value(), factory()->NewVariableProxy(temp),
+      RelocInfo::kNoPosition);
+  RecurseIntoSubpattern(node->target(), value);
 }
 
 
 void Parser::PatternRewriter::VisitSpread(Spread* node) {
   // TODO(dslomov): implement.
 }
 
 
 // =============== UNREACHABLE =============================
 
@@ skipping 41 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 v8::internal