Get rid of PropagateScopeInfo, update asm_function in set_asm_module instead.

src/ast/scopes.h

 // 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.
 
 #ifndef V8_AST_SCOPES_H_
 #define V8_AST_SCOPES_H_
 
 #include "src/ast/ast.h"
 #include "src/base/hashmap.h"
 #include "src/globals.h"
@@ skipping 584 matching lines @@
                        AstNodeFactory* factory);
   void ResolveVariablesRecursively(ParseInfo* info, AstNodeFactory* factory);
 
   // Finds free variables of this scope. This mutates the unresolved variables
   // list along the way, so full resolution cannot be done afterwards.
   // If a ParseInfo* is passed, non-free variables will be resolved.
   VariableProxy* FetchFreeVariables(DeclarationScope* max_outer_scope,
                                     ParseInfo* info = nullptr,
                                     VariableProxy* stack = nullptr);
 
-  // Scope analysis.
-  void PropagateScopeInfo();
-
   // Predicates.
   bool MustAllocate(Variable* var);
   bool MustAllocateInContext(Variable* var);
 
   // Variable allocation.
   void AllocateStackSlot(Variable* var);
   void AllocateHeapSlot(Variable* var);
   void AllocateNonParameterLocal(Variable* var);
   void AllocateDeclaredGlobal(Variable* var);
   void AllocateNonParameterLocalsAndDeclaredGlobals();
@@ skipping 59 matching lines @@
   }
 
   bool NeedsHomeObject() const {
     return scope_uses_super_property_ ||
            (inner_scope_calls_eval_ && (IsConciseMethod(function_kind()) ||
                                         IsAccessorFunction(function_kind()) ||
                                         IsClassConstructor(function_kind())));
   }
 
   bool asm_module() const { return asm_module_; }
-  void set_asm_module() { asm_module_ = true; }
+  void set_asm_module() {

[titzer, 2016/08/23 13:08:59]

Move to cc file? Not performance sensitive, I guess.

+    asm_module_ = true;
+    // Mark any existing inner function scopes as asm function scopes.
+    for (Scope* inner = inner_scope_; inner != nullptr;

[titzer, 2016/08/23 13:08:59]

You could, e.g. recurse through block scopes as well, if you wanted to catch the
special case of functions within block scopes, but it is probably better that
the validator checks that there are no such functions.

[Toon Verwaest, 2016/08/23 13:17:51]

The block scopes I'm talking about aren't in this list. They are the cases where
in DeclarationScope::DeclarationScope we set asm_function_ to true. It could be
that they currently have an outer block scope, but that we Finalize that block
scope at some point. We could extend FinalizeBlockScope to set asm_function_ to
true when it's removing a block scope in between an asm module and a function
scope ... but that's slower and probably not what we want anyway?

+         inner = inner->sibling_) {
+      if (inner->is_function_scope()) {
+        inner->AsDeclarationScope()->set_asm_function();
+      }
+    }
+  }
   bool asm_function() const { return asm_function_; }
   void set_asm_function() { asm_module_ = true; }
 
   void DeclareThis(AstValueFactory* ast_value_factory);
   void DeclareDefaultFunctionVariables(AstValueFactory* ast_value_factory);
 
   // This lookup corresponds to a lookup in the "intermediate" scope sitting
   // between this scope and the outer scope. (ECMA-262, 3rd., requires that
   // the name of named function literal is kept in an intermediate scope
   // in between this scope and the next outer scope.)
@@ skipping 226 matching lines @@
   void AllocateModuleVariables();
 
  private:
   ModuleDescriptor* module_descriptor_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_