Allow lazy parsing of functions nested in eager compiled functions

src/compiler.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/compiler.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "src/asmjs/asm-js.h"
@@ skipping 1037 matching lines @@
   parse_info->set_toplevel();
 
   Handle<SharedFunctionInfo> result;
 
   { VMState<COMPILER> state(info->isolate());
     if (parse_info->literal() == NULL) {
       // Parse the script if needed (if it's already parsed, literal() is
       // non-NULL). If compiling for debugging, we may eagerly compile inner
       // functions, so do not parse lazily in that case.
       ScriptCompiler::CompileOptions options = parse_info->compile_options();
-      bool parse_allow_lazy = (options == ScriptCompiler::kConsumeParserCache ||
-                               String::cast(script->source())->length() >
-                                   FLAG_min_preparse_length) &&
-                              !info->is_debug();
-
-      // Consider parsing eagerly when targeting the code cache.
-      parse_allow_lazy &= !(FLAG_serialize_eager && info->will_serialize());
-
-      // Consider parsing eagerly when targeting Ignition.
-      parse_allow_lazy &= !(FLAG_ignition && FLAG_ignition_eager &&
-                            !isolate->serializer_enabled());
+      bool parse_allow_lazy =
+          options == ScriptCompiler::kConsumeParserCache ||
+          String::cast(script->source())->length() > FLAG_min_preparse_length;
 
       parse_info->set_allow_lazy_parsing(parse_allow_lazy);
       if (!parse_allow_lazy &&
           (options == ScriptCompiler::kProduceParserCache ||
            options == ScriptCompiler::kConsumeParserCache)) {
         // We are going to parse eagerly, but we either 1) have cached data
         // produced by lazy parsing or 2) are asked to generate cached data.
         // Eager parsing cannot benefit from cached data, and producing cached
         // data while parsing eagerly is not implemented.
         parse_info->set_cached_data(nullptr);
         parse_info->set_compile_options(ScriptCompiler::kNoCompileOptions);
       }
 
       if (!Parse(parse_info)) {
         return Handle<SharedFunctionInfo>::null();
       }
     }
 
-    DCHECK(!info->is_debug() || !parse_info->allow_lazy_parsing());
-
     FunctionLiteral* lit = parse_info->literal();
 
     // Measure how long it takes to do the compilation; only take the
     // rest of the function into account to avoid overlap with the
     // parsing statistics.
     RuntimeCallTimerScope runtimeTimer(
         isolate, parse_info->is_eval() ? &RuntimeCallStats::CompileEval
                                        : &RuntimeCallStats::Compile);
     HistogramTimer* rate = parse_info->is_eval()
                                ? info->isolate()->counters()->compile_eval()
@@ skipping 769 matching lines @@
     DCHECK(shared->is_compiled());
     function->set_literals(cached.literals);
   } else if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8