[destructuring] Adapting PatternRewriter to work in for-statements.

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 851 matching lines @@
   bool Parse(ParseInfo* info);
   void ParseOnBackground(ParseInfo* info);
 
   // Handle errors detected during parsing, move statistics to Isolate,
   // internalize strings (move them to the heap).
   void Internalize(Isolate* isolate, Handle<Script> script, bool error);
   void HandleSourceURLComments(Isolate* isolate, Handle<Script> script);
 
  private:
   friend class ParserTraits;
-  class PatternRewriter;
 
   // Limit the allowed number of local variables in a function. The hard limit
   // is that offsets computed by FullCodeGenerator::StackOperand and similar
   // functions are ints, and they should not overflow. In addition, accessing
   // local variables creates user-controlled constants in the generated code,
   // and we don't want too much user-controlled memory inside the code (this was
   // the reason why this limit was introduced in the first place; see
   // https://codereview.chromium.org/7003030/ ).
   static const int kMaxNumFunctionLocals = 4194303;  // 2^22-1
 
@@ skipping 48 matching lines @@
                                    bool* ok);
   Statement* ParseFunctionDeclaration(ZoneList<const AstRawString*>* names,
                                       bool* ok);
   Statement* ParseClassDeclaration(ZoneList<const AstRawString*>* names,
                                    bool* ok);
   Statement* ParseNativeDeclaration(bool* ok);
   Block* ParseBlock(ZoneList<const AstRawString*>* labels, bool* ok);
   Block* ParseVariableStatement(VariableDeclarationContext var_context,
                                 ZoneList<const AstRawString*>* names,
                                 bool* ok);
-  Block* ParseVariableDeclarations(VariableDeclarationContext var_context,
-                                   int* num_decl,
-                                   ZoneList<const AstRawString*>* names,
-                                   const AstRawString** out,
-                                   Scanner::Location* first_initializer_loc,
-                                   Scanner::Location* bindings_loc, bool* ok);
+
+  struct DeclarationDescriptor {
+    Parser* parser;
+    Scope* declaration_scope;
+    Scope* scope;
+    VariableMode mode;
+    bool is_const;
+    bool needs_init;
+    int pos;
+    Token::Value init_op;
+  };
+
+
+  class PatternRewriter : private AstVisitor {
+   public:
+    explicit PatternRewriter(Expression* pattern)
+        : pattern_(pattern),
+          initializer_position_(RelocInfo::kNoPosition),
+          state_(nullptr) {}
+
+    PatternRewriter()
+        : pattern_(nullptr),
+          initializer_position_(RelocInfo::kNoPosition),
+          state_(nullptr) {}
+
+    PatternRewriter(const PatternRewriter& other)
+        : AstVisitor(other),
+          pattern_(other.pattern_),
+          initializer_position_(other.initializer_position_),
+          state_(nullptr) {}
+
+    bool IsSingleVariableBinding() const;
+    const AstRawString* SingleName() const;
+
+    void DeclareAndInitializeVariables(Block* block,
+                                       const DeclarationDescriptor* decl,
+                                       Expression* value,
+                                       ZoneList<const AstRawString*>* names,
+                                       bool* ok);
+
+    void set_initializer_position(int pos) { initializer_position_ = pos; }
+
+   private:
+    // Group all state local to visting AST.
+    struct VisitorState {
+      Block* block;
+      const DeclarationDescriptor* decl;
+      ZoneList<const AstRawString*>* names;
+      Expression* current_value;
+      bool* ok;
+    };
+
+#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
+    virtual void Visit(AstNode* node) override;
+
+    void RecurseIntoSubpattern(AstNode* pattern, Expression* value) {
+      Expression* old_value = state_->current_value;
+      state_->current_value = value;
+      pattern->Accept(this);
+      state_->current_value = old_value;
+    }
+
+    AstNodeFactory* factory() const { return state_->decl->parser->factory(); }
+    AstValueFactory* ast_value_factory() const {
+      return state_->decl->parser->ast_value_factory();
+    }
+    bool inside_with() const { return state_->decl->parser->inside_with(); }
+    Zone* zone() const { return state_->decl->parser->zone(); }
+
+    Expression* pattern_;
+    int initializer_position_;
+
+    VisitorState* state_;
+  };
+
+  struct DeclarationParsingResult {
+    struct Declaration {
+      Declaration(const PatternRewriter& p, Expression* initializer)
+          : pattern(p), initializer(initializer) {}
+
+      PatternRewriter pattern;
+      Expression* initializer;
+    };
+
+    DeclarationParsingResult()
+        : declarations(4),
+          out(nullptr),
+          first_initializer_loc(Scanner::Location::invalid()),
+          bindings_loc(Scanner::Location::invalid()) {}
+
+    DeclarationDescriptor decl;
+    List<Declaration> declarations;
+    const AstRawString* out;
+    Scanner::Location first_initializer_loc;
+    Scanner::Location bindings_loc;
+  };
+
+  void ParseVariableDeclarations(VariableDeclarationContext var_context,
+                                 DeclarationParsingResult* parsing_result,
+                                 bool* ok);
   Statement* ParseExpressionOrLabelledStatement(
       ZoneList<const AstRawString*>* labels, bool* ok);
   IfStatement* ParseIfStatement(ZoneList<const AstRawString*>* labels,
                                 bool* ok);
   Statement* ParseContinueStatement(bool* ok);
   Statement* ParseBreakStatement(ZoneList<const AstRawString*>* labels,
                                  bool* ok);
   Statement* ParseReturnStatement(bool* ok);
   Statement* ParseWithStatement(ZoneList<const AstRawString*>* labels,
                                 bool* ok);
@@ skipping 222 matching lines @@
 }
 
 
 Expression* ParserTraits::SpreadCallNew(
     Expression* function, ZoneList<v8::internal::Expression*>* args, int pos) {
   return parser_->SpreadCallNew(function, args, pos);
 }
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_