[compiler] Collect eager inner functions for compilation during renumbering.

src/parsing/parse-info.h

 // Copyright 2016 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_PARSING_PARSE_INFO_H_
 #define V8_PARSING_PARSE_INFO_H_
 
 #include "include/v8.h"
 #include "src/globals.h"
 #include "src/handles.h"
 #include "src/objects/scope-info.h"
+#include "src/zone/zone-containers.h"
 
 namespace v8 {
 
 class Extension;
 
 namespace internal {
 
 class AstRawString;
 class AstValueFactory;
 class DeclarationScope;
@@ skipping 95 matching lines @@
   }
 
   const AstRawString* function_name() const { return function_name_; }
   void set_function_name(const AstRawString* function_name) {
     function_name_ = function_name;
   }
 
   FunctionLiteral* literal() const { return literal_; }
   void set_literal(FunctionLiteral* literal) { literal_ = literal; }
 
+  ThreadedList<ThreadedListZoneEntry<FunctionLiteral*>>*
+  eager_inner_function_literals() {
+    return &eager_inner_function_literals_;
+  }
+
   DeclarationScope* scope() const;
 
   UnicodeCache* unicode_cache() const { return unicode_cache_; }
   void set_unicode_cache(UnicodeCache* unicode_cache) {
     unicode_cache_ = unicode_cache;
   }
 
   uintptr_t stack_limit() const { return stack_limit_; }
   void set_stack_limit(uintptr_t stack_limit) { stack_limit_ = stack_limit; }
 
@@ skipping 112 matching lines @@
   MaybeHandle<ScopeInfo> maybe_outer_scope_info_;
 
   //----------- Inputs+Outputs of parsing and scope analysis -----------------
   ScriptData** cached_data_;  // used if available, populated if requested.
   AstValueFactory* ast_value_factory_;  // used if available, otherwise new.
   const AstRawString* function_name_;
 
   //----------- Output of parsing and scope analysis ------------------------
   FunctionLiteral* literal_;
 
+  //----------- Output of renumbering ------------------------
+  ThreadedList<ThreadedListZoneEntry<FunctionLiteral*>>
+      eager_inner_function_literals_;
+
   void SetFlag(Flag f) { flags_ |= f; }
   void SetFlag(Flag f, bool v) { flags_ = v ? flags_ | f : flags_ & ~f; }
   bool GetFlag(Flag f) const { return (flags_ & f) != 0; }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSE_INFO_H_