[parser] Skipping inner funcs: add info about variables.

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 8693 matching lines @@
     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;
     }
     CHECK_EQ(data->backing_store_[index++], inner_scope_count);
 
-    // Variable count is 0. TODO(marja): implement.
-    CHECK_EQ(data->backing_store_[index++], 0);
+    int variable_count = 0;
+    for (Variable* local : scope->locals_) {
+      if (local->mode() == VAR || local->mode() == LET ||
+          local->mode() == CONST) {
+        ++variable_count;
+      }
+    }
+
+    CHECK_EQ(data->backing_store_[index++], variable_count);

[vogelheim, 2017/01/26 09:34:35]

Why does this work? The way I read Scope::CollectVariableData it will add all
locals inside the recursion over the inner-scope sub-tree, so I'd expect it to
have - at each scope - all variables of all inner scopes.

This one only counts local variables in the current scope, and compares it to
the value computed as above. Am I missing something? Also, is there a test case
that would distinguish those two cases?

[marja, 2017/01/26 09:40:59]

Offline discussion: the scope contains only the variables in that scope, and
then CollectVariableData recurses into the subscope which adds a new ScopeScope
to the data.

+
+    for (Variable* local : scope->locals_) {
+      if (local->mode() == VAR || local->mode() == LET ||
+          local->mode() == CONST) {
+        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);
     }
   }
 };
 }  // namespace internal
 }  // namespace v8
 
@@ skipping 289 matching lines @@
   const char* lazy_inner = " function inner(%s) { %s }";
   const char* eager_inner = "(function inner(%s) { %s })()";
 
   struct {
     const char* params;
     const char* source;
   } inners[] = {
       {"", "var1"},
       {"", "if (true) {}"},
       {"", "function f1() {}"},
-      {"", "if (true) { function f1() {} }"},
   };
 
   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 33 matching lines @@
     i::SNPrintF(eager_program + prefix_len + inner_function_len + params_len +
                     source_len,
                 "%s", suffix);
 
     source = factory->InternalizeUtf8String(eager_program.start());
     source->PrintOn(stdout);
     printf("\n");
 
     script = factory->NewScript(source);
     i::ParseInfo eager_info(&zone, script);
+    eager_info.set_allow_lazy_parsing(false);
 
     CHECK(i::parsing::ParseProgram(&eager_info));
     CHECK(i::Compiler::Analyze(&eager_info));
 
     i::Scope* scope =
         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);
   }
 }