[destructuring] Parse binding patterns in formal parameters.

src/parser.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 1165 matching lines @@
               : FunctionLiteral::NAMED_EXPRESSION)
         : FunctionLiteral::DECLARATION;
     bool ok = true;
 
     if (shared_info->is_arrow()) {
       Scope* scope =
           NewScope(scope_, ARROW_SCOPE, FunctionKind::kArrowFunction);
       scope->set_start_position(shared_info->start_position());
       ExpressionClassifier formals_classifier;
       bool has_rest = false;
-      if (Check(Token::LPAREN)) {
-        // '(' StrictFormalParameters ')'
-        ParseFormalParameterList(scope, &has_rest, &formals_classifier, &ok);
-        if (ok) ok = Check(Token::RPAREN);
-      } else {
-        // BindingIdentifier
-        ParseFormalParameter(scope, has_rest, &formals_classifier, &ok);
+      {
+        BlockState block_state(&scope_, scope);

[arv (Not doing code reviews), 2015/06/15 15:21:59]

Why was this block state added? It does not seem like it is needed for parsing.

[Dmitry Lomov (no reviews), 2015/06/15 16:12:51]

Ah, this is a tricky bit. Parsing patterns as variable reference expressions
creates NewUnresolved references in current scope. This BlockState makes arrow
function scope the current scope - otherwise we will create NewUnresolved in
outer scope - this is logically wrong, but not only - in case of lazy parsing
the outer scope is immutable, so we assert.

+        if (Check(Token::LPAREN)) {
+          // '(' StrictFormalParameters ')'
+          ParseFormalParameterList(scope, &has_rest, &formals_classifier, &ok);
+          if (ok) ok = Check(Token::RPAREN);
+        } else {
+          // BindingIdentifier
+          ParseFormalParameter(scope, has_rest, &formals_classifier, &ok);
+        }
       }
 
       if (ok) {
         Expression* expression =
             ParseArrowFunctionLiteral(scope, has_rest, formals_classifier, &ok);
         if (ok) {
           // Scanning must end at the same position that was recorded
           // previously. If not, parsing has been interrupted due to a stack
           // overflow, at which point the partially parsed arrow function
           // concise body happens to be a valid expression. This is a problem
@@ skipping 2593 matching lines @@
   }
 
   // Only the right-most expression may be a rest parameter.
   DCHECK(!*has_rest);
 
   if (expr->IsSpread()) {
     *has_rest = true;
     expr = expr->AsSpread()->expression();
   }
 
-  DCHECK(expr->IsVariableProxy());
+  if (!expr->IsVariableProxy()) {
+    // TODO(dslomov): support pattern desugaring
+    return;
+  }
+  // TODO(wingo): Support rest parameters.

[arv (Not doing code reviews), 2015/06/15 15:21:59]

Andy implemented this last week.

[Dmitry Lomov (no reviews), 2015/06/15 16:12:51]

Removed.

   DCHECK(!expr->AsVariableProxy()->is_this());
 
   const AstRawString* raw_name = expr->AsVariableProxy()->raw_name();
   Scanner::Location param_location(expr->position(),
                                    expr->position() + raw_name->length());
 
   // When the formal parameter was originally seen, it was parsed as a
   // VariableProxy and recorded as unresolved in the scope.  Here we undo that
   // parse-time side-effect.
   parser_->scope_->RemoveUnresolved(expr->AsVariableProxy());
 
   ExpressionClassifier classifier;
-  DeclareFormalParameter(scope, raw_name, &classifier, *has_rest);
+  DeclareFormalParameter(scope, expr, &classifier, *has_rest);
   if (!duplicate_loc->IsValid()) {
     *duplicate_loc = classifier.duplicate_formal_parameter_error().location;
   }
 }
 
 
 FunctionLiteral* Parser::ParseFunctionLiteral(
     const AstRawString* function_name, Scanner::Location function_name_location,
     bool name_is_strict_reserved, FunctionKind kind, int function_token_pos,
     FunctionLiteral::FunctionType function_type,
@@ skipping 1994 matching lines @@
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 }  // namespace internal
 }  // namespace v8