[destructuring] Implement basic binding destructuring infrastructure

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 919 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);
+
+
+  class PatternMatcher : private AstVisitor {

[rossberg, 2015/05/11 11:49:33]

Can we call this PatternRewriter? It isn't a "matcher" by itself...  And would
it be possible to move the actual declaration to a separate .h file and just
forward-declare it here?

[Dmitry Lomov (no reviews), 2015/05/11 12:52:58]

Oh, good trick - I didn't realize it is allowed in C++!
Done

+   public:
+    struct DeclarationDescriptor {
+      Parser* parser;
+      Scope* declaration_scope;
+      Scope* scope;
+      int initializer_position;
+      VariableMode mode;
+      ZoneList<const AstRawString*>* names;
+      bool is_const;
+      Block* block;
+      bool needs_init;
+      int pos;
+      Token::Value init_op;
+      int* nvars;
+
+      Scope* initialization_scope() const {
+        return is_const ? declaration_scope : scope;

[rossberg, 2015/05/11 11:49:33]

I think this function is not very meaningful as an abstraction, see other
comment.

[Dmitry Lomov (no reviews), 2015/05/11 12:52:57]

Done.

+      }
+      Zone* zone() const { return parser->zone(); }
+      bool inside_with() const { return parser->inside_with(); }
+    };
+
+    explicit PatternMatcher(const DeclarationDescriptor* decl,
+                            Expression* pattern)
+        : decl_(decl), pattern_(pattern) {}
+
+    PatternMatcher() : decl_(nullptr), pattern_(nullptr) {}
+
+    bool IsSingleVariableBinding() const;
+    const AstRawString* SingleName() const;
+
+    void DeclareAndInitializeVariables(Expression* value, bool* ok);
+
+   private:
+#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 = current_value_;
+      current_value_ = value;
+      pattern->Accept(this);
+      current_value_ = old_value;
+    }
+
+    AstNodeFactory* factory() const { return decl_->parser->factory(); }
+    AstValueFactory* ast_value_factory() const {
+      return decl_->parser->ast_value_factory();
+    }
+    Zone* zone() const { return decl_->parser->zone(); }
+
+    const DeclarationDescriptor* decl_;
+    Expression* pattern_;
+    Expression* current_value_;
+    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);
   Statement* ParseExpressionOrLabelledStatement(
       ZoneList<const AstRawString*>* labels, bool* ok);
   IfStatement* ParseIfStatement(ZoneList<const AstRawString*>* labels,
                                 bool* ok);
@@ skipping 228 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_