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

src/ast/ast-numbering.h

 // Copyright 2014 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_AST_NUMBERING_H_
 #define V8_AST_AST_NUMBERING_H_
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class FunctionLiteral;
 class Isolate;
 class Zone;
+template <typename T>
+class ZoneVector;
 
 namespace AstNumbering {
 // Assign type feedback IDs, bailout IDs, and generator yield IDs to an AST node
-// tree; perform catch prediction for TryStatements.
-bool Renumber(Isolate* isolate, Zone* zone, FunctionLiteral* function);
+// tree; perform catch prediction for TryStatements. Adds any eager inner
+// literal functions found into |eager_inner_functions|.
+bool Renumber(Isolate* isolate, Zone* zone, FunctionLiteral* function,
+              ZoneVector<FunctionLiteral*>* eager_inner_functions);

[marja, 2017/01/05 19:25:22]

I was thinking about the ZoneVector usage here... the number of eager inner
functions can be big, and ZoneVectors are wasteful (every time it is expanded,
we cannot discard the old backing store).

Do you have some numbers based on which we could decide whether this choice of
data structure is fine or not? Can we initialize the ZoneVector intelligently so
that it wouldn't need to expand so much?

ThreadedList (sic) would be an alternative, but then you'd need to create a
separate class for holding the FunctionLiteral* and the next pointer. (Maybe
adding such a class in a templatized way would be a good idea.)

[rmcilroy, 2017/01/06 17:08:14]

Yes good point, I'm not sure we have a good default which we could intelligently
initialize ZoneVector with. I'll have a look at ThreadedList instead.

[rmcilroy, 2017/01/09 16:50:10]

Done.

 }
 
 // Some details on yield IDs
 // -------------------------
 //
 // In order to assist Ignition in generating bytecode for a generator function,
 // we assign a unique number (the yield ID) to each Yield node in its AST. We
 // also annotate loops with the number of yields they contain (loop.yield_count)
 // and the smallest ID of those (loop.first_yield_id), and we annotate the
 // function itself with the number of yields it contains (function.yield_count).
 //
 // The way in which we choose the IDs is simply by enumerating the Yield nodes.
 // Ignition relies on the following properties:
 // - For each loop l and each yield y of l:
 //     l.first_yield_id  <=  y.yield_id  <  l.first_yield_id + l.yield_count
 // - For the generator function f itself and each yield y of f:
 //                    0  <=  y.yield_id  <  f.yield_count
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_NUMBERING_H_