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

src/ast/scopes.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/ast/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/ast/ast.h"
@@ skipping 932 matching lines @@
 }
 
 Variable* Scope::DeclareLocal(const AstRawString* name, VariableMode mode,
                               InitializationFlag init_flag, VariableKind kind,
                               MaybeAssignedFlag maybe_assigned_flag) {
   DCHECK(!already_resolved_);
   // This function handles VAR, LET, and CONST modes.  DYNAMIC variables are
   // introduced during variable allocation, and TEMPORARY variables are
   // allocated via NewTemporary().
   DCHECK(IsDeclaredVariableMode(mode));
-  DCHECK(!GetDeclarationScope()->is_being_lazily_parsed());
+  DCHECK_IMPLIES(GetDeclarationScope()->is_being_lazily_parsed(),
+                 mode == VAR || mode == LET || mode == CONST);
   DCHECK(!GetDeclarationScope()->was_lazily_parsed());
   return Declare(zone(), name, mode, kind, init_flag, maybe_assigned_flag);
 }
 
 Variable* Scope::DeclareVariable(
     Declaration* declaration, VariableMode mode, InitializationFlag init,
     bool allow_harmony_restrictive_generators,
     bool* sloppy_mode_block_scope_function_redefinition, bool* ok) {
   DCHECK(IsDeclaredVariableMode(mode));
   DCHECK(!already_resolved_);
@@ skipping 108 matching lines @@
   DCHECK(!is_with_scope());
   DCHECK(!is_eval_scope());
   // Unlike DeclareVariable, DeclareVariableName allows declaring variables in
   // catch scopes: Parser::RewriteCatchPattern bypasses DeclareVariable by
   // calling DeclareLocal directly, and it doesn't make sense to add a similar
   // bypass mechanism for PreParser.
   DCHECK(is_declaration_scope() || (IsLexicalVariableMode(mode) &&
                                     (is_block_scope() || is_catch_scope())));
   DCHECK(scope_info_.is_null());
 
-  // Declare the variable in the declaration scope.
-  variables_.DeclareName(zone(), name, mode);
+  Variable* var = LookupLocal(name);

[jochen (gone - plz use gerrit), 2017/01/25 16:34:14]

can you please explain this change?

[marja, 2017/01/25 17:10:44]

This is kinda covered by the title line; in order to add data about Variables we
need to create Variables.

I was going a bit of back and forth wrt should I put this change behind the
flag. I decided not to but now I'm having second thoughts.

Btw, now all DeclareName stuff and everything hanging from it (dummy variables
and such) are dead code and I should've removed them if I took the non-flag
approach...

But now I think I should put this behind the flag. Opinions?

+  if (var == nullptr) {
+    var = DeclareLocal(name, mode);
+  }
+  var->set_is_used();
 }
 
 VariableProxy* Scope::NewUnresolved(AstNodeFactory* factory,
                                     const AstRawString* name,
                                     int start_position, VariableKind kind) {
   // Note that we must not share the unresolved variables with
   // the same name because they may be removed selectively via
   // RemoveUnresolved().
   DCHECK(!already_resolved_);
   DCHECK_EQ(factory->zone(), zone());
@@ skipping 983 matching lines @@
   }
 
   for (const auto& it : module()->regular_exports()) {
     Variable* var = LookupLocal(it.first);
     var->AllocateTo(VariableLocation::MODULE, it.second->cell_index);
     DCHECK(var->IsExport());
   }
 }
 
 void Scope::AllocateVariablesRecursively() {
-  DCHECK(!already_resolved_);
-  DCHECK_EQ(0, num_stack_slots_);
   // Don't allocate variables of preparsed scopes.
   if (is_declaration_scope() && AsDeclarationScope()->was_lazily_parsed()) {
     return;
   }
 
+  DCHECK(!already_resolved_);
+  DCHECK_EQ(0, num_stack_slots_);
+
   // Allocate variables for inner scopes.
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
     scope->AllocateVariablesRecursively();
   }
 
   DCHECK(!already_resolved_);
   DCHECK_EQ(Context::MIN_CONTEXT_SLOTS, num_heap_slots_);
 
   // Allocate variables for this scope.
   // Parameters must be allocated first, if any.
@@ skipping 53 matching lines @@
   MaybeHandle<ScopeInfo> outer = NeedsContext() ? scope_info_ : outer_scope;
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
     if (scope->is_function_scope()) continue;
     scope->AllocateDebuggerScopeInfos(isolate, outer);
   }
 }
 
 void Scope::CollectVariableData(PreParsedScopeData* data) {
   PreParsedScopeData::ScopeScope scope_scope(data, scope_type(),
                                              start_position(), end_position());
-  // TODO(marja): Add data about the variables.
-
+  for (Variable* local : locals_) {
+    if (local->mode() == VAR || local->mode() == LET ||
+        local->mode() == CONST) {
+      scope_scope.AddVariable(local->location(), local->maybe_assigned());
+    }
+  }
   for (Scope* inner = inner_scope_; inner != nullptr; inner = inner->sibling_) {
     inner->CollectVariableData(data);
   }
 }
 
 int Scope::StackLocalCount() const {
   Variable* function =
       is_function_scope() ? AsDeclarationScope()->function_var() : nullptr;
   return num_stack_slots() -
          (function != nullptr && function->IsStackLocal() ? 1 : 0);
 }
 
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
   Variable* function =
       is_function_scope() ? AsDeclarationScope()->function_var() : nullptr;
   bool is_function_var_in_context =
       function != nullptr && function->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
          (is_function_var_in_context ? 1 : 0);
 }
 
 }  // namespace internal
 }  // namespace v8