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

src/ast/ast-numbering.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/ast-numbering.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
+#include "src/zone/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 
 class AstNumberingVisitor final : public AstVisitor<AstNumberingVisitor> {
  public:
-  AstNumberingVisitor(Isolate* isolate, Zone* zone)
+  AstNumberingVisitor(Isolate* isolate, Zone* zone,
+                      ThreadedList<ThreadedListZoneEntry<FunctionLiteral*>>*
+                          eager_inner_functions)
       : isolate_(isolate),
         zone_(zone),
+        eager_inner_functions_(eager_inner_functions),
         next_id_(BailoutId::FirstUsable().ToInt()),
         yield_count_(0),
         properties_(zone),
         slot_cache_(zone),
         disable_crankshaft_reason_(kNoReason),
         dont_optimize_reason_(kNoReason),
         catch_prediction_(HandlerTable::UNCAUGHT) {
     InitializeAstVisitor(isolate);
   }
 
@@ skipping 34 matching lines @@
   }
 
   template <typename Node>
   void ReserveFeedbackSlots(Node* node) {
     node->AssignFeedbackVectorSlots(isolate_, properties_.get_spec(),
                                     &slot_cache_);
   }
 
   BailoutReason dont_optimize_reason() const { return dont_optimize_reason_; }
 
+  Zone* zone() const { return zone_; }
+
   Isolate* isolate_;
   Zone* zone_;
+  ThreadedList<ThreadedListZoneEntry<FunctionLiteral*>>* eager_inner_functions_;
   int next_id_;
   int yield_count_;
   AstProperties properties_;
   // The slot cache allows us to reuse certain feedback vector slots.
   FeedbackVectorSlotCache slot_cache_;
   BailoutReason disable_crankshaft_reason_;
   BailoutReason dont_optimize_reason_;
   HandlerTable::CatchPrediction catch_prediction_;
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
@@ skipping 502 matching lines @@
 void AstNumberingVisitor::VisitArguments(ZoneList<Expression*>* arguments) {
   for (int i = 0; i < arguments->length(); i++) {
     Visit(arguments->at(i));
   }
 }
 
 
 void AstNumberingVisitor::VisitFunctionLiteral(FunctionLiteral* node) {
   IncrementNodeCount();
   node->set_base_id(ReserveIdRange(FunctionLiteral::num_ids()));
+  if (node->ShouldEagerCompile()) {
+    eager_inner_functions_->Add(
+        new (zone()) ThreadedListZoneEntry<FunctionLiteral*>(node));
+  }
   // We don't recurse into the declarations or body of the function literal:
   // you have to separately Renumber() each FunctionLiteral that you compile.
 }
 
 
 void AstNumberingVisitor::VisitRewritableExpression(
     RewritableExpression* node) {
   IncrementNodeCount();
   node->set_base_id(ReserveIdRange(RewritableExpression::num_ids()));
   Visit(node->expression());
@@ skipping 35 matching lines @@
     if (disable_crankshaft_reason_ != kNoReason) {
       PrintF("[enforcing Ignition and TurboFan for %s because: %s\n",
              node->debug_name()->ToCString().get(),
              GetBailoutReason(disable_crankshaft_reason_));
     }
   }
 
   return !HasStackOverflow();
 }
 
-
-bool AstNumbering::Renumber(Isolate* isolate, Zone* zone,
-                            FunctionLiteral* function) {
-  AstNumberingVisitor visitor(isolate, zone);
+bool AstNumbering::Renumber(
+    Isolate* isolate, Zone* zone, FunctionLiteral* function,
+    ThreadedList<ThreadedListZoneEntry<FunctionLiteral*>>*
+        eager_inner_functions) {
+  AstNumberingVisitor visitor(isolate, zone, eager_inner_functions);
   return visitor.Renumber(function);
 }
 }  // namespace internal
 }  // namespace v8