Fully deserialize the scope chain after parsing, not before

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/base/hashmap.h"
 #include "src/globals.h"
 #include "src/objects.h"
@@ skipping 80 matching lines @@
     void Reparent(DeclarationScope* new_parent) const;
 
    private:
     Scope* outer_scope_;
     Scope* top_inner_scope_;
     VariableProxy* top_unresolved_;
     int top_local_;
     int top_decl_;
   };
 
-  enum class DeserializationMode { kDeserializeOffHeap, kKeepScopeInfo };
-
-  static Scope* DeserializeScopeChain(Isolate* isolate, Zone* zone,
-                                      Context* context,
-                                      DeclarationScope* script_scope,
-                                      AstValueFactory* ast_value_factory,
-                                      DeserializationMode deserialization_mode);
+  static Scope* DeserializeScopeChainForTesting(
+      Isolate* isolate, Zone* zone, Context* context,
+      DeclarationScope* script_scope, AstValueFactory* ast_value_factory);
 
   // Checks if the block scope is redundant, i.e. it does not contain any
   // block scoped declarations. In that case it is removed from the scope
   // tree and its children are reparented.
   Scope* FinalizeBlockScope();
 
   // Inserts outer_scope into this scope's scope chain (and removes this
   // from the current outer_scope_'s inner scope list).
   // Assumes outer_scope_ is non-null.
   void ReplaceOuterScope(Scope* outer_scope);
@@ skipping 447 matching lines @@
          scope = scope->sibling_) {
       if (scope->sibling_ == inner_scope) {
         scope->sibling_ = scope->sibling_->sibling_;
         return;
       }
     }
   }
 
   void SetDefaults();
 
-  void DeserializeScopeInfo(Isolate* isolate,
-                            AstValueFactory* ast_value_factory);
+  static Scope* DeserializeScopeChain(Isolate* isolate, Zone* zone,
+                                      Context* context,
+                                      DeclarationScope* script_scope,
+                                      AstValueFactory* ast_value_factory);
 
   friend class DeclarationScope;
 };
 
 class DeclarationScope : public Scope {
  public:
   DeclarationScope(Zone* zone, Scope* outer_scope, ScopeType scope_type,
                    FunctionKind function_kind = kNormalFunction);
   DeclarationScope(Zone* zone, ScopeType scope_type,
                    Handle<ScopeInfo> scope_info);
@@ skipping 210 matching lines @@
   // processed (parsed) to ensure that unresolved variables can be
   // resolved properly.
   //
   // In the case of code compiled and run using 'eval', the context
   // parameter is the context in which eval was called.  In all other
   // cases the context parameter is an empty handle.
   void AllocateVariables(ParseInfo* info, AnalyzeMode mode);
 
   void SetDefaults();
 
+  void DeserializeScopeChain(ParseInfo* parse_info);
+
+  void HoistSloppyBlockFunctionsInternal(AstNodeFactory* factory, bool* ok);
+
   // If the scope is a function scope, this is the function kind.
   const FunctionKind function_kind_;
 
   bool has_simple_parameters_ : 1;
   // This scope contains an "use asm" annotation.
   bool asm_module_ : 1;
   // This scope's outer context is an asm module.
   bool asm_function_ : 1;
   bool force_eager_compilation_ : 1;
   // This function scope has a rest parameter.
@@ skipping 38 matching lines @@
   void AllocateModuleVariables();
 
  private:
   ModuleDescriptor* module_descriptor_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_