Explicitly check for lazy parser when dealing with parser cache

src/parsing/parser.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/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 132 matching lines @@
   AstNodeFactory::BodyScope ast_node_factory_scope_;
   FuncNameInferrer fni_;
   Parser* parser_;
   FuncNameInferrer* prev_fni_;
   Zone* prev_zone_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableZoneScope);
 };
 
 void Parser::SetCachedData(ParseInfo* info) {
-  if (compile_options_ == ScriptCompiler::kNoCompileOptions) {
-    cached_parse_data_ = NULL;
-  } else {
-    DCHECK(info->cached_data() != NULL);
-    if (compile_options_ == ScriptCompiler::kConsumeParserCache) {
-      cached_parse_data_ = ParseData::FromCachedData(*info->cached_data());
+  DCHECK_NULL(cached_parse_data_);
+  if (consume_cached_parse_data()) {
+    cached_parse_data_ = ParseData::FromCachedData(*info->cached_data());
+    if (cached_parse_data_ == nullptr) {
+      compile_options_ = ScriptCompiler::kNoCompileOptions;
     }
   }
 }
 
 Expression* Parser::CallClassFieldInitializer(Scope* scope,
                                               Expression* this_expr) {
   // This produces the expression
   // `.class_field_intializer(this_expr)`, where '.class_field_intializer' is
   // the name
   // of a synthetic variable.
@@ skipping 462 matching lines @@
 }
 
 Parser::Parser(ParseInfo* info)
     : ParserBase<Parser>(info->zone(), &scanner_, info->stack_limit(),
                          info->extension(), info->ast_value_factory(), NULL),
       scanner_(info->unicode_cache()),
       reusable_preparser_(NULL),
       original_scope_(NULL),
       target_stack_(NULL),
       compile_options_(info->compile_options()),
-      cached_parse_data_(NULL),
+      cached_parse_data_(nullptr),
       total_preparse_skipped_(0),
       pre_parse_timer_(NULL),
       parsing_on_main_thread_(true) {
   // Even though we were passed ParseInfo, we should not store it in
   // Parser - this makes sure that Isolate is not accidentally accessed via
   // ParseInfo during background parsing.
   DCHECK(!info->script().is_null() || info->source_stream() != nullptr ||
          info->character_stream() != nullptr);
   // Determine if functions can be lazily compiled. This is necessary to
   // allow some of our builtin JS files to be lazily compiled. These
@@ skipping 10 matching lines @@
   can_compile_lazily &= !(FLAG_serialize_eager && info->will_serialize());
 
   // Consider compiling eagerly when compiling bytecode for Ignition.
   can_compile_lazily &= !(FLAG_ignition && FLAG_ignition_eager &&
                           info->isolate()->serializer_enabled());
 
   set_default_eager_compile_hint(can_compile_lazily
                                      ? FunctionLiteral::kShouldLazyCompile
                                      : FunctionLiteral::kShouldEagerCompile);
   set_allow_lazy(FLAG_lazy && info->allow_lazy_parsing() &&
-                 !info->is_native() && info->extension() == nullptr);
+                 !info->is_native() && info->extension() == nullptr &&
+                 can_compile_lazily);
   set_allow_natives(FLAG_allow_natives_syntax || info->is_native());
   set_allow_tailcalls(FLAG_harmony_tailcalls && !info->is_native() &&
                       info->isolate()->is_tail_call_elimination_enabled());
   set_allow_harmony_do_expressions(FLAG_harmony_do_expressions);
   set_allow_harmony_function_sent(FLAG_harmony_function_sent);
   set_allow_harmony_restrictive_declarations(
       FLAG_harmony_restrictive_declarations);
   set_allow_harmony_async_await(FLAG_harmony_async_await);
   set_allow_harmony_restrictive_generators(FLAG_harmony_restrictive_generators);
   set_allow_harmony_trailing_commas(FLAG_harmony_trailing_commas);
@@ skipping 4759 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8