[parser] Skipping inner funcs: produce the same scopes / variables for sloppy block funcs.

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 48 matching lines @@
   if (added) *added = p->value == nullptr;
   if (p->value == nullptr) {
     // The variable has not been declared yet -> insert it.
     DCHECK_EQ(name, p->key);
     p->value = new (zone) Variable(scope, name, mode, kind, initialization_flag,
                                    maybe_assigned_flag);
   }
   return reinterpret_cast<Variable*>(p->value);
 }
 
-void VariableMap::DeclareName(Zone* zone, const AstRawString* name,
-                              VariableMode mode) {
+Variable* VariableMap::DeclareName(Zone* zone, const AstRawString* name,
+                                   VariableMode mode) {
   Entry* p =
       ZoneHashMap::LookupOrInsert(const_cast<AstRawString*>(name), name->hash(),
                                   ZoneAllocationPolicy(zone));
   if (p->value == nullptr) {
     // The variable has not been declared yet -> insert it.
     DCHECK_EQ(name, p->key);
     p->value =
         mode == VAR ? kDummyPreParserVariable : kDummyPreParserLexicalVariable;
   }
+  return reinterpret_cast<Variable*>(p->value);
 }
 
 void VariableMap::Remove(Variable* var) {
   const AstRawString* name = var->raw_name();
   ZoneHashMap::Remove(const_cast<AstRawString*>(name), name->hash());
 }
 
 void VariableMap::Add(Zone* zone, Variable* var) {
   const AstRawString* name = var->raw_name();
   Entry* p =
@@ skipping 411 matching lines @@
     if (!has_simple_parameters) {
       if (outer_scope_->LookupLocal(name) != nullptr) {
         continue;
       }
     } else {
       if (IsDeclaredParameter(name)) {
         continue;
       }
     }
 
-    bool var_created = false;
+    Variable* created_variable = nullptr;
 
     // Write in assignments to var for each block-scoped function declaration
     auto delegates = static_cast<SloppyBlockFunctionMap::Delegate*>(p->value);
 
     DeclarationScope* decl_scope = this;
     while (decl_scope->is_eval_scope()) {
       decl_scope = decl_scope->outer_scope()->GetDeclarationScope();
     }
     Scope* outer_scope = decl_scope->outer_scope();
 
@@ skipping 14 matching lines @@
         if (var != nullptr && IsLexical(var)) {
           should_hoist = false;
           break;
         }
         query_scope = query_scope->outer_scope();
       } while (query_scope != outer_scope);
 
       if (!should_hoist) continue;
 
       // Declare a var-style binding for the function in the outer scope
-      if (!var_created) {
-        var_created = true;
+      if (created_variable == nullptr) {
         if (factory) {
           VariableProxy* proxy =
               factory->NewVariableProxy(name, NORMAL_VARIABLE);
           auto declaration =
               factory->NewVariableDeclaration(proxy, this, kNoSourcePosition);
           // Based on the preceding check, it doesn't matter what we pass as
           // allow_harmony_restrictive_generators and
           // sloppy_mode_block_scope_function_redefinition.
           bool ok = true;
-          DeclareVariable(declaration, VAR,
-                          Variable::DefaultInitializationFlag(VAR), false,
-                          nullptr, &ok);
+          created_variable = DeclareVariable(
+              declaration, VAR, Variable::DefaultInitializationFlag(VAR), false,
+              nullptr, &ok);
           CHECK(ok);  // Based on the preceding check, this should not fail
         } else {
-          DeclareVariableName(name, VAR);
+          created_variable = DeclareVariableName(name, VAR);
         }
       }
 
       if (factory) {
         Expression* assignment = factory->NewAssignment(
             Token::ASSIGN, NewUnresolved(factory, name),
             delegate->scope()->NewUnresolved(factory, name), kNoSourcePosition);
         Statement* statement =
             factory->NewExpressionStatement(assignment, kNoSourcePosition);
         delegate->set_statement(statement);
+      } else if (created_variable != kDummyPreParserVariable &&
+                 created_variable != kDummyPreParserLexicalVariable) {
+        created_variable->set_maybe_assigned();

[marja, 2017/02/02 11:56:17]

The Variable passing is needed to be able to do this

[vogelheim, 2017/02/02 19:00:42]

I can't parse that sentence. Care to explain?

[marja, 2017/02/03 21:03:01]

I need to return Variable* and transmit it up until here so that I can do
set_maybe_assigned.

       }

[vogelheim, 2017/02/02 19:00:42]

I don't really understand what this whole block does... I have a hunch it might
be a bit easier to read if "if (factory).." becomes the outer condition. Not
sure, though.

[marja, 2017/02/03 21:03:01]

This creates the assignmentstatement which assigns the lazy sloppy block
function into a variable in the outer scope. The variable gets created only
once, but if there are multiple sloppy block functions with the same name, an
assignment is created for each of them.

And an assignment naturally sets maybe_assigned.

When preparsing, AssignmentStatements are not created, but I still need to set
the relevant variable as maybe_assigned.

You're right, this is clearer if I move if (factory) out; I also added some
DCHECKs to make it clear when we're parsing and when we're preparsing.

An additional complication is that we're only creating variables in the
preparser when FLAG_preparser_scope_analysis is on. Oh well. Another possibility
would be to pass the maybe-assignedness-boolean to DeclareVariableName but I
didn't want to make that decision yet... let's see how this develops.

     }
   }
 }
 
 void DeclarationScope::Analyze(ParseInfo* info, AnalyzeMode mode) {
   RuntimeCallTimerScope runtimeTimer(info->isolate(),
                                      &RuntimeCallStats::CompileScopeAnalysis);
   DCHECK(info->literal() != NULL);
   DeclarationScope* scope = info->literal()->scope();
 
@@ skipping 472 matching lines @@
   //
   // This will lead to multiple declaration nodes for the
   // same variable if it is declared several times. This is not a
   // semantic issue, but it may be a performance issue since it may
   // lead to repeated DeclareEvalVar or DeclareEvalFunction calls.
   decls_.Add(declaration);
   proxy->BindTo(var);
   return var;
 }
 
-void Scope::DeclareVariableName(const AstRawString* name, VariableMode mode) {
+Variable* Scope::DeclareVariableName(const AstRawString* name,
+                                     VariableMode mode) {
   DCHECK(IsDeclaredVariableMode(mode));
   DCHECK(!already_resolved_);
   DCHECK(GetDeclarationScope()->is_being_lazily_parsed());
 
   if (mode == VAR && !is_declaration_scope()) {
     return GetDeclarationScope()->DeclareVariableName(name, mode);
   }
   DCHECK(!is_with_scope());
   DCHECK(!is_eval_scope());
   // Unlike DeclareVariable, DeclareVariableName allows declaring variables in
@@ skipping 10 matching lines @@
     DCHECK_NE(var, kDummyPreParserLexicalVariable);
     DCHECK_NE(var, kDummyPreParserVariable);
     if (var == nullptr) {
       var = DeclareLocal(name, mode);
     } else if (!IsLexicalVariableMode(var->mode()) &&
                !IsLexicalVariableMode(mode)) {
       DCHECK_EQ(mode, VAR);
       var->set_maybe_assigned();
     }
     var->set_is_used();
+    return var;
   } else {
-    variables_.DeclareName(zone(), name, mode);
+    return variables_.DeclareName(zone(), name, mode);
   }
 }
 
 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_);
@@ skipping 1113 matching lines @@
   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