Move parenthesized_function_ to ParserBase.

src/preparser.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 24 matching lines @@
 namespace v8 {
 namespace internal {
 
 // Common base class shared between parser and pre-parser.
 template <typename Traits>
 class ParserBase : public Traits {
  public:
   ParserBase(Scanner* scanner, uintptr_t stack_limit,
              typename Traits::ParserType this_object)
       : Traits(this_object),
+        parenthesized_function_(false),
         scanner_(scanner),
         stack_limit_(stack_limit),
         stack_overflow_(false),
         allow_lazy_(false),
         allow_natives_syntax_(false),
         allow_generators_(false),
         allow_for_of_(false) { }
 
   // Getters that indicate whether certain syntactical constructs are
   // allowed to be parsed by this instance of the parser.
@@ skipping 219 matching lines @@
     }
     bool IsAccessorAccessorConflict(PropertyKind type1, PropertyKind type2) {
       return ((type1 | type2) & kValueFlag) == 0;
     }
 
     ParserBase* parser_;
     DuplicateFinder finder_;
     LanguageMode language_mode_;
   };
 
+  // If true, the next (and immediately following) function literal is
+  // preceded by a parenthesis.
+  // Heuristically that means that the function will be called immediately,
+  // so never lazily compile it.
+  bool parenthesized_function_;
+
  private:
   Scanner* scanner_;
   uintptr_t stack_limit_;
   bool stack_overflow_;
 
   bool allow_lazy_;
   bool allow_natives_syntax_;
   bool allow_generators_;
   bool allow_for_of_;
 };
@@ skipping 204 matching lines @@
   enum PreParseResult {
     kPreParseStackOverflow,
     kPreParseSuccess
   };
 
   PreParser(Scanner* scanner,
             ParserRecorder* log,
             uintptr_t stack_limit)
       : ParserBase<PreParserTraits>(scanner, stack_limit, this),
         log_(log),
-        scope_(NULL),
-        parenthesized_function_(false) { }
+        scope_(NULL) { }
 
   ~PreParser() {}
 
   // Pre-parse the program from the character stream; returns true on
   // success (even if parsing failed, the pre-parse data successfully
   // captured the syntax error), and false if a stack-overflow happened
   // during parsing.
   PreParseResult PreParseProgram() {
     Scope top_scope(&scope_, kTopLevelScope);
     bool ok = true;
@@ skipping 221 matching lines @@
   bool is_extended_mode() {
     return scope_->language_mode() == EXTENDED_MODE;
   }
 
   LanguageMode language_mode() { return scope_->language_mode(); }
 
   bool CheckInOrOf(bool accept_OF);
 
   ParserRecorder* log_;
   Scope* scope_;
-  bool parenthesized_function_;
 };
 
 
 template<class Traits>
 void ParserBase<Traits>::ReportUnexpectedToken(Token::Value token) {
   // We don't report stack overflows here, to avoid increasing the
   // stack depth even further.  Instead we report it after parsing is
   // over, in ParseProgram.
   if (token == Token::ILLEGAL && stack_overflow()) {
     return;
@@ skipping 159 matching lines @@
                                "accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H