[parser] Skipping inner funcs: make preparser scope analysis work w/ destructuring declarations.

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 8689 matching lines @@
 
   static void CompareScopeToData(Scope* scope, const PreParsedScopeData* data,
                                  size_t& index) {
     CHECK_EQ(data->backing_store_[index++], scope->scope_type());
     CHECK_EQ(data->backing_store_[index++], scope->start_position());
     CHECK_EQ(data->backing_store_[index++], scope->end_position());
 
     int inner_scope_count = 0;
     for (Scope* inner = scope->inner_scope(); inner != nullptr;
          inner = inner->sibling()) {
-      ++inner_scope_count;
+      if (!inner->is_hidden()) {
+        ++inner_scope_count;
+      }
     }
     CHECK_EQ(data->backing_store_[index++], inner_scope_count);
 
     int variable_count = 0;
     for (Variable* local : scope->locals_) {
       if (local->mode() == VAR || local->mode() == LET ||
           local->mode() == CONST) {
         ++variable_count;
       }
     }
@@ skipping 11 matching lines @@
           CHECK_EQ(data->backing_store_[index++], local_name->raw_data()[i]);
         }
 #endif
         CHECK_EQ(data->backing_store_[index++], local->location());
         CHECK_EQ(data->backing_store_[index++], local->maybe_assigned());
       }
     }
 
     for (Scope* inner = scope->inner_scope(); inner != nullptr;
          inner = inner->sibling()) {
-      CompareScopeToData(inner, data, index);
+      if (!inner->is_hidden()) {
+        CompareScopeToData(inner, data, index);
+      }
     }
   }
 };
 }  // namespace internal
 }  // namespace v8
 
 // Test that lazily parsed inner functions don't result in overly pessimistic
 // context allocations.
 TEST(NoPessimisticContextAllocation) {
   i::FLAG_lazy_inner_functions = true;
@@ skipping 340 matching lines @@
       {"", "let arguments; arguments = 5;"},
       {"", "if (true) { let arguments; }"},
       {"", "if (true) { let arguments; arguments = 5; }"},
       {"", "let arguments; function f() { arguments; }"},
       {"", "let arguments; arguments = 5; function f() { arguments; }"},
       {"", "let arguments; function f() { arguments = 5; }"},
 
       {"", "const arguments = 5;"},
       {"", "if (true) { const arguments = 5; }"},
       {"", "const arguments = 5; function f() { arguments; }"},
+
+      {"", "var [var1, var2] = [1, 2];"},
+      {"", "var [var1, var2, [var3, var4]] = [1, 2, [3, 4]];"},
+      {"", "var [{var1: var2}, {var3: var4}] = [{var1: 1}, {var3: 2}];"},
+      {"", "var [var1, ...var2] = [1, 2, 3];"},
+
+      {"", "var {var1: var2, var3: var4} = {var1: 1, var3: 2};"},
+      {"",
+       "var {var1: var2, var3: {var4: var5}} = {var1: 1, var3: {var4: 2}};"},
+      {"", "var {var1: var2, var3: [var4, var5]} = {var1: 1, var3: [2, 3]};"},
+
+      {"", "let [var1, var2] = [1, 2];"},
+      {"", "let [var1, var2, [var3, var4]] = [1, 2, [3, 4]];"},
+      {"", "let [{var1: var2}, {var3: var4}] = [{var1: 1}, {var3: 2}];"},
+      {"", "let [var1, ...var2] = [1, 2, 3];"},
+
+      {"", "let {var1: var2, var3: var4} = {var1: 1, var3: 2};"},
+      {"",
+       "let {var1: var2, var3: {var4: var5}} = {var1: 1, var3: {var4: 2}};"},
+      {"", "let {var1: var2, var3: [var4, var5]} = {var1: 1, var3: [2, 3]};"},
+
+      {"", "const [var1, var2] = [1, 2];"},
+      {"", "const [var1, var2, [var3, var4]] = [1, 2, [3, 4]];"},
+      {"", "const [{var1: var2}, {var3: var4}] = [{var1: 1}, {var3: 2}];"},
+      {"", "const [var1, ...var2] = [1, 2, 3];"},
+
+      {"", "const {var1: var2, var3: var4} = {var1: 1, var3: 2};"},
+      {"",
+       "const {var1: var2, var3: {var4: var5}} = {var1: 1, var3: {var4: 2}};"},
+      {"", "const {var1: var2, var3: [var4, var5]} = {var1: 1, var3: [2, 3]};"},
   };
 
   for (unsigned i = 0; i < arraysize(inners); ++i) {
     // First compile with the lazy inner function and extract the scope data.
     const char* inner_function = lazy_inner;
     int inner_function_len = Utf8LengthHelper(inner_function) - 4;
 
     int params_len = Utf8LengthHelper(inners[i].params);
     int source_len = Utf8LengthHelper(inners[i].source);
     int len =
@@ skipping 49 matching lines @@
         eager_info.literal()->scope()->inner_scope()->inner_scope();
     DCHECK_NOT_NULL(scope);
     DCHECK_NULL(scope->sibling());
     DCHECK(scope->is_function_scope());
 
     size_t index = 0;
     i::ScopeTestHelper::CompareScopeToData(
         scope, lazy_info.preparsed_scope_data(), index);
   }
 }