[es6] Implement destructuring for `catch`

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/parser.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/ast-literal-reindexer.h"
 #include "src/bailout-reason.h"
@@ skipping 3023 matching lines @@
   Token::Value tok = peek();
   if (tok != Token::CATCH && tok != Token::FINALLY) {
     ReportMessage(MessageTemplate::kNoCatchOrFinally);
     *ok = false;
     return NULL;
   }
 
   Scope* catch_scope = NULL;
   Variable* catch_variable = NULL;
   Block* catch_block = NULL;
-  const AstRawString* name = NULL;
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
 
     Expect(Token::LPAREN, CHECK_OK);
     catch_scope = NewScope(scope_, CATCH_SCOPE);
     catch_scope->set_start_position(scanner()->location().beg_pos);
-    name = ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
+
+    ExpressionClassifier pattern_classifier;
+    Token::Value next = peek();
+    Expression* pattern =
+        ParsePrimaryExpression(&pattern_classifier, CHECK_OK);
+    ValidateBindingPattern(&pattern_classifier, CHECK_OK);
+
+    if (!allow_harmony_destructuring() && !pattern->IsVariableProxy()) {
+      ReportUnexpectedToken(next);
+      *ok = false;
+      return NULL;
+    }
 
     Expect(Token::RPAREN, CHECK_OK);
 
-    catch_variable = catch_scope->DeclareLocal(name, VAR, kCreatedInitialized,
-                                               Variable::NORMAL);
-    BlockState block_state(&scope_, catch_scope);
-    catch_block = ParseBlock(NULL, CHECK_OK);
+    if (pattern->IsVariableProxy()) {
+      const AstRawString* name = pattern->AsVariableProxy()->raw_name();
+      catch_variable = catch_scope->DeclareLocal(name, VAR, kCreatedInitialized,
+                                                 Variable::NORMAL);
+      BlockState block_state(&scope_, catch_scope);
+      catch_block = ParseBlock(NULL, CHECK_OK);
+    } else {
+      Variable* temp = scope_->NewTemporary(
+          ast_value_factory()->dot_catch_string());
+      Scope* destruct_scope = NewScope(catch_scope, BLOCK_SCOPE);
+      Block* destruct_block =
+          factory()->NewBlock(nullptr, 1, false, RelocInfo::kNoPosition);
+
+      DeclarationDescriptor descriptor;
+      descriptor.declaration_kind = DeclarationDescriptor::NORMAL;
+      descriptor.parser = this;
+      descriptor.declaration_scope = destruct_scope->DeclarationScope();
+      descriptor.scope = destruct_scope;
+      descriptor.hoist_scope = nullptr;
+      descriptor.mode = LET;
+      descriptor.is_const = false;
+      descriptor.needs_init = true;
+      descriptor.declaration_pos = RelocInfo::kNoPosition;
+      descriptor.initialization_pos = RelocInfo::kNoPosition;
+      descriptor.init_op = Token::INIT_LET;
+      Expression* initial_value = factory()->NewVariableProxy(temp);
+
+      BlockState block_state(&scope_, destruct_scope);
+      DeclarationParsingResult::Declaration decl(
+          pattern, pattern->position(), initial_value);
+      PatternRewriter::DeclareAndInitializeVariables(
+          destruct_block, &descriptor, &decl, nullptr, CHECK_OK);
+
+      catch_block->AddStatement(destruct_block, zone());
+      catch_block = ParseBlock(NULL, CHECK_OK);
+    }
 
     catch_scope->set_end_position(scanner()->location().end_pos);
     tok = peek();
   }
 
   Block* finally_block = NULL;
   DCHECK(tok == Token::FINALLY || catch_block != NULL);
   if (tok == Token::FINALLY) {
     Consume(Token::FINALLY);
     finally_block = ParseBlock(NULL, CHECK_OK);
@@ skipping 3002 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