[destructuring] Implement parameter pattern matching.

src/scopes.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_SCOPES_H_
 #define V8_SCOPES_H_
 
 #include "src/ast.h"
 #include "src/pending-compilation-error-handler.h"
 #include "src/zone.h"
@@ skipping 107 matching lines @@
   // is in an intermediate scope between this function scope and the the
   // outer scope. Only possible for function scopes; at most one variable.
   void DeclareFunctionVar(VariableDeclaration* declaration) {
     DCHECK(is_function_scope());
     function_ = declaration;
   }
 
   // Declare a parameter in this scope.  When there are duplicated
   // parameters the rightmost one 'wins'.  However, the implementation
   // expects all parameters to be declared and from left to right.
-  Variable* DeclareParameter(const AstRawString* name, VariableMode mode,
-                             bool is_rest, bool* is_duplicate);
+  Variable* DeclareParameter(const AstRawString* name, Expression* pattern,
+                             VariableMode mode, bool is_rest,
+                             bool* is_duplicate);
 
   // Declare a local variable in this scope. If the variable has been
   // declared before, the previously declared variable is returned.
   Variable* DeclareLocal(const AstRawString* name, VariableMode mode,
                          InitializationFlag init_flag, Variable::Kind kind,
                          MaybeAssignedFlag maybe_assigned_flag = kNotAssigned,
                          int declaration_group_start = -1);
 
   // Declare an implicit global variable in this scope which must be a
   // script scope.  The variable was introduced (possibly from an inner
@@ skipping 221 matching lines @@
   // The variable corresponding to the 'new.target' value.
   Variable* new_target_var() { return new_target_; }
 
   // The variable holding the function literal for named function
   // literals, or NULL.  Only valid for function scopes.
   VariableDeclaration* function() const {
     DCHECK(is_function_scope());
     return function_;
   }
 
+  struct Parameter {
+    Parameter(Variable* var, Expression* pattern)
+        : var(var), pattern(pattern) {}
+
+    Variable* var;
+    Expression* pattern;

[rossberg, 2015/06/16 17:02:13]

Can we not abuse the scope abstraction to pass around parts of the AST? It
should be possible to get this information to the Build function in parser.cc
without piggybacking on the scope. It doesn't belong there.

[Dmitry Lomov (no reviews), 2015/06/17 12:28:48]

Good point. Addressed.

+  };
+
   // Parameters. The left-most parameter has index 0.
   // Only valid for function scopes.
-  Variable* parameter(int index) const {
+  Variable* parameter_var(int index) const { return parameter(index).var; }
+
+  // Parameters. The left-most parameter has index 0.
+  // Only valid for function scopes.
+  const Parameter& parameter(int index) const {
     DCHECK(is_function_scope());
     return params_[index];
   }
 
   // Returns the default function arity --- does not include rest parameters.
   int default_function_length() const {
     int count = params_.length();
     if (rest_index_ >= 0) {
       DCHECK(count > 0);
       DCHECK(is_function_scope());
@@ skipping 127 matching lines @@
     // "this" is an invalid parameter name and "arguments" is invalid parameter
     // name in strict mode. Therefore looking up with the map which includes
     // "this" and "arguments" in addition to all formal parameters is safe.
     return variables_.Lookup(name) != NULL;
   }
 
   bool IsDeclaredParameter(const AstRawString* name) {
     // If IsSimpleParameterList is false, duplicate parameters are not allowed,
     // however `arguments` may be allowed if function is not strict code. Thus,
     // the assumptions explained above do not hold.
-    return params_.Contains(variables_.Lookup(name));
+    auto var = variables_.Lookup(name);
+    for (auto p : params_) {
+      if (p.var == var) return true;
+    }
+    return false;
   }
 
   // Error handling.
   void ReportMessage(int start_position, int end_position,
                      MessageTemplate::Template message,
                      const AstRawString* arg);
 
   // ---------------------------------------------------------------------------
   // Debugging.
 
@@ skipping 23 matching lines @@
   // The variables declared in this scope:
   //
   // All user-declared variables (incl. parameters).  For script scopes
   // variables may be implicitly 'declared' by being used (possibly in
   // an inner scope) with no intervening with statements or eval calls.
   VariableMap variables_;
   // Compiler-allocated (user-invisible) internals.
   ZoneList<Variable*> internals_;
   // Compiler-allocated (user-invisible) temporaries.
   ZoneList<Variable*> temps_;
+
   // Parameter list in source order.
-  ZoneList<Variable*> params_;
+  ZoneList<Parameter> params_;
+
   // Variables that must be looked up dynamically.
   DynamicScopePart* dynamics_;
   // Unresolved variables referred to from this scope.
   ZoneList<VariableProxy*> unresolved_;
   // Declarations.
   ZoneList<Declaration*> decls_;
   // Convenience variable.
   Variable* receiver_;
   // Function variable, if any; function scopes only.
   VariableDeclaration* function_;
@@ skipping 188 matching lines @@
   PendingCompilationErrorHandler pending_error_handler_;
 
   // For tracking which classes are declared consecutively. Needed for strong
   // mode.
   int class_declaration_group_start_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_