Support lazy parsing of inner functions

src/parser.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_PARSER_H_
 #define V8_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/compiler.h"  // For CachedDataMode
 #include "src/preparse-data.h"
 #include "src/preparse-data-format.h"
 #include "src/preparser.h"
 #include "src/scopes.h"
 
 namespace v8 {
 class ScriptCompiler;
 
 namespace internal {
 
 class CompilationInfo;
 class ParserLog;
 class PositionStack;
 class Target;
 
 template <typename T> class ZoneListWrapper;
 
 
+// An entry in ScriptData containing everything we need to know to skip over a
+// lazily-parsed function body.
 class FunctionEntry BASE_EMBEDDED {
  public:
   enum {
     kStartPositionIndex,
     kEndPositionIndex,
     kLiteralCountIndex,
     kPropertyCountIndex,
     kStrictModeIndex,
+    kCallsEvalIndex,
+    kIdentifierCountIndex,
     kSize
   };
 
   explicit FunctionEntry(Vector<unsigned> backing)
     : backing_(backing) { }
 
   FunctionEntry() : backing_() { }
 
+  // Get the length (number of unsigned ints) of this FunctionEntry.
+  // This requires walking through all the identifiers in the FunctionEntry, so
+  // Size() is not a trivial accessor, and is typically only called once for
+  // each FunctionEntry.
+  int Size();
+
+  class IdentifierIterator {
+    friend class FunctionEntry;
+
+   public:
+    const AstRawString* Next(AstValueFactory* ast_value_factory);
+
+    bool AtEnd() { return backing_.is_empty(); }
+
+   private:
+    explicit IdentifierIterator(Vector<unsigned> backing) : backing_(backing) {}
+
+    Vector<unsigned> backing_;
+  };
+
+  IdentifierIterator Identifiers() {
+    return IdentifierIterator(backing_.SubVector(kSize, Size()));
+  }
+
   int start_pos() { return backing_[kStartPositionIndex]; }
   int end_pos() { return backing_[kEndPositionIndex]; }
   int literal_count() { return backing_[kLiteralCountIndex]; }
   int property_count() { return backing_[kPropertyCountIndex]; }
   StrictMode strict_mode() {
     DCHECK(backing_[kStrictModeIndex] == SLOPPY ||
            backing_[kStrictModeIndex] == STRICT);
     return static_cast<StrictMode>(backing_[kStrictModeIndex]);
   }
+  bool calls_eval() { return static_cast<bool>(backing_[kCallsEvalIndex]); }
+
+  int identifier_count() { return backing_[kIdentifierCountIndex]; }
 
   bool is_valid() { return !backing_.is_empty(); }
 
  private:
   Vector<unsigned> backing_;
 };
 
 
 // Wrapper around ScriptData to provide parser-specific functionality.
 class ParseData {
@@ skipping 284 matching lines @@
     // TODO(marja): To be removed. The Traits object should contain all the data
     // it needs.
     typedef v8::internal::Parser* Parser;
 
     // Used by FunctionState and BlockState.
     typedef v8::internal::Scope Scope;
     typedef v8::internal::Scope* ScopePtr;
     inline static Scope* ptr_to_scope(ScopePtr scope) { return scope; }
 
     typedef Variable GeneratorVariable;
-    typedef v8::internal::Zone Zone;
 
     typedef v8::internal::AstProperties AstProperties;
     typedef Vector<VariableProxy*> ParameterIdentifierVector;
 
     // Return types for traversing functions.
     typedef const AstRawString* Identifier;
     typedef v8::internal::Expression* Expression;
     typedef Yield* YieldExpression;
     typedef v8::internal::FunctionLiteral* FunctionLiteral;
     typedef v8::internal::ClassLiteral* ClassLiteral;
@@ skipping 72 matching lines @@
 
   // Keep track of eval() calls since they disable all local variable
   // optimizations. This checks if expression is an eval call, and if yes,
   // forwards the information to scope.
   void CheckPossibleEvalCall(Expression* expression, Scope* scope);
 
   // Determine if the expression is a variable proxy and mark it as being used
   // in an assignment or with a increment/decrement operator.
   static Expression* MarkExpressionAsAssigned(Expression* expression);
 
+  static void RecordCurrentSymbolAsIdentifierExpression() {}
+
   // Returns true if we have a binary expression between two numeric
   // literals. In that case, *x will be changed to an expression which is the
   // computed value.
   bool ShortcutNumericLiteralBinaryExpression(
       Expression** x, Expression* y, Token::Value op, int pos,
       AstNodeFactory<AstConstructionVisitor>* factory);
 
   // Rewrites the following types of unary expressions:
   // not <literal> -> true / false
   // + <numeric literal> -> <numeric literal>
@@ skipping 458 matching lines @@
  private:
   static const int kLiteralTypeSlot = 0;
   static const int kElementsSlot = 1;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_