[es6] implement destructuring assignment

src/parser.h

 // 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.
 
 #ifndef V8_PARSER_H_
 #define V8_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/compiler.h"  // TODO(titzer): remove this include dependency
@@ skipping 858 matching lines @@
   V8_INLINE ZoneList<v8::internal::Expression*>* PrepareSpreadArguments(
       ZoneList<v8::internal::Expression*>* list);
   V8_INLINE void MaterializeUnspreadArgumentsLiterals(int count) {}
   V8_INLINE Expression* SpreadCall(Expression* function,
                                    ZoneList<v8::internal::Expression*>* args,
                                    int pos);
   V8_INLINE Expression* SpreadCallNew(Expression* function,
                                       ZoneList<v8::internal::Expression*>* args,
                                       int pos);
 
+  // Rewrite all DestructuringAssignments in the current FunctionState.
+  V8_INLINE void RewriteDestructuringAssignments();
+
+  V8_INLINE Expression* RewriteDestructuringAssignmentExpression(
+      Expression* expression);
+
+  V8_INLINE void ShouldRewriteDestructuringAssignment(Expression* assignment);
+
  private:
   Parser* parser_;
 };
 
 
 class Parser : public ParserBase<ParserTraits> {
  public:
   explicit Parser(ParseInfo* info);
   ~Parser() {
     delete reusable_preparser_;
@@ skipping 128 matching lines @@
     Scanner::Location bindings_loc;
   };
 
   class PatternRewriter : private AstVisitor {
    public:
     static void DeclareAndInitializeVariables(
         Block* block, const DeclarationDescriptor* declaration_descriptor,
         const DeclarationParsingResult::Declaration* declaration,
         ZoneList<const AstRawString*>* names, bool* ok);
 
+    static void RewriteDestructuringAssignment(Parser* parser,
+                                               Assignment* assignment,
+                                               Scope* Scope, bool* ok);
+
     void set_initializer_position(int pos) { initializer_position_ = pos; }
 
    private:
     PatternRewriter() {}
 
 #define DECLARE_VISIT(type) void Visit##type(v8::internal::type* node) override;
     // Visiting functions for AST nodes make this an AstVisitor.
     AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
     void Visit(AstNode* node) override;
 
+    enum PatternContext { BINDING, INITIALIZER, ASSIGNMENT };
+
+    PatternContext context() const { return context_; }
+    void set_context(PatternContext context) { context_ = context; }
+
     void RecurseIntoSubpattern(AstNode* pattern, Expression* value) {
       Expression* old_value = current_value_;
       current_value_ = value;
       pattern->Accept(this);
       current_value_ = old_value;
     }
 
+    void VisitObjectLiteral(ObjectLiteral* node, Variable** temp_var);
+    void VisitArrayLiteral(ArrayLiteral* node, Variable** temp_var);
+
     Variable* CreateTempVar(Expression* value = nullptr);
 
-    AstNodeFactory* factory() const { return descriptor_->parser->factory(); }
+    AstNodeFactory* factory() const { return parser_->factory(); }
     AstValueFactory* ast_value_factory() const {
-      return descriptor_->parser->ast_value_factory();
+      return parser_->ast_value_factory();
     }
-    Zone* zone() const { return descriptor_->parser->zone(); }
+    Zone* zone() const { return parser_->zone(); }
+    Scope* scope() const { return scope_; }
 
+    Scope* scope_;
+    Parser* parser_;
+    PatternContext context_;
     Expression* pattern_;
     int initializer_position_;
     Block* block_;
     const DeclarationDescriptor* descriptor_;
     ZoneList<const AstRawString*>* names_;
     Expression* current_value_;
     bool* ok_;
   };
 
 
@@ skipping 129 matching lines @@
   ZoneList<v8::internal::Expression*>* PrepareSpreadArguments(
       ZoneList<v8::internal::Expression*>* list);
   Expression* SpreadCall(Expression* function,
                          ZoneList<v8::internal::Expression*>* args, int pos);
   Expression* SpreadCallNew(Expression* function,
                             ZoneList<v8::internal::Expression*>* args, int pos);
 
   void SetLanguageMode(Scope* scope, LanguageMode mode);
   void RaiseLanguageMode(LanguageMode mode);
 
+  V8_INLINE void RewriteDestructuringAssignments();
+
+  friend class InitializerRewriter;
+  void RewriteParameterInitializer(Expression* expr, Scope* scope);
+
+  Expression* RewriteDestructuringAssignmentExpression(Expression* expression);
+
   Scanner scanner_;
   PreParser* reusable_preparser_;
   Scope* original_scope_;  // for ES5 function declarations in sloppy eval
   Target* target_stack_;  // for break, continue statements
   ScriptCompiler::CompileOptions compile_options_;
   ParseData* cached_parse_data_;
 
   PendingCompilationErrorHandler pending_error_handler_;
 
   // Other information which will be stored in Parser and moved to Isolate after
@@ skipping 168 matching lines @@
     }
   }
 }
 
 
 DoExpression* ParserTraits::ParseDoExpression(bool* ok) {
   return parser_->ParseDoExpression(ok);
 }
 
 
+void ParserTraits::RewriteDestructuringAssignments() {
+  parser_->RewriteDestructuringAssignments();
+}
+
+
+void Parser::RewriteDestructuringAssignments() {
+  FunctionState* func = function_state_;
+  typedef typename ParserBase<ParserTraits>::DestructuringAssignment Pair;
+  const List<Pair>& assignments = func->destructuring_assignments_to_rewrite();
+  for (int i = assignments.length() - 1; i >= 0; --i) {

[adamk, 2015/11/20 22:42:58]

Any particular reason for iterating backwards here?

+    Pair pair = assignments.at(i);
+    Assignment* to_rewrite = pair.assignment->AsAssignment();
+    Scope* scope = pair.scope;
+    AssignmentPattern* pattern = to_rewrite->target()->AsAssignmentPattern();
+    if (pattern && !pattern->is_rewritten()) {
+      bool ok = true;
+      PatternRewriter::RewriteDestructuringAssignment(this, to_rewrite, scope,
+                                                      &ok);
+      DCHECK(ok);
+    }
+  }
+}
+
+
+Expression* ParserTraits::RewriteDestructuringAssignmentExpression(
+    Expression* expression) {
+  return parser_->RewriteDestructuringAssignmentExpression(expression);
+}
+
+
+void ParserTraits::ShouldRewriteDestructuringAssignment(Expression* expr) {

[adamk, 2015/11/20 22:42:58]

The name of this function doesn't make sense to me. Perhaps 
"QueueDestructuringAssignmentForRewriting"? "Should" prefix suggests a const
method that answers a question. 

+  DCHECK(expr->IsAssignment());

[adamk, 2015/11/20 22:42:58]

Why can't this method just take an Assignment* to avoid this DCHECK?

+  Assignment* assignment = expr->AsAssignment();
+  DCHECK(assignment->target()->IsAssignmentPattern());
+  DCHECK_EQ(Token::ASSIGN, assignment->op());
+  parser_->function_state_->AddDestructuringAssignment(
+      Parser::DestructuringAssignment(assignment, parser_->scope_));
+}
+
+inline void Parser::PatternRewriter::VisitObjectLiteral(ObjectLiteral* node) {

[adamk, 2015/11/20 22:42:58]

Can these methods move to the .cc file? Seems like this header's already plenty
big.

+  Variable* temp_var = nullptr;
+  VisitObjectLiteral(node, &temp_var);
+}
+
+inline void Parser::PatternRewriter::VisitArrayLiteral(ArrayLiteral* node) {
+  Variable* temp_var = nullptr;
+  VisitArrayLiteral(node, &temp_var);
+}
+
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSER_H_