Get rid of ParseInfo::lazy

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 3808 matching lines @@
 
 
 bool Parser::Parse(ParseInfo* info) {
   DCHECK(info->literal() == NULL);
   FunctionLiteral* result = NULL;
   // Ok to use Isolate here; this function is only called in the main thread.
   DCHECK(parsing_on_main_thread_);
   Isolate* isolate = info->isolate();
   pre_parse_timer_ = isolate->counters()->pre_parse();
 
-  if (info->is_lazy()) {
+  if (!info->shared_info().is_null() && info->shared_info()->is_function()) {
     DCHECK(!info->is_eval());
-    if (info->shared_info()->is_function()) {
-      result = ParseLazy(isolate, info);
-    } else {
-      result = ParseProgram(isolate, info);
-    }
+    result = ParseLazy(isolate, info);
   } else {
     SetCachedData(info);
     result = ParseProgram(isolate, info);
   }
   info->set_literal(result);
 
   Internalize(isolate, info->script(), result == NULL);
   return (result != NULL);
 }
 
@@ skipping 21 matching lines @@
   DCHECK(info->maybe_outer_scope_info().is_null());
 
   DCHECK(original_scope_);
 
   // When streaming, we don't know the length of the source until we have parsed
   // it. The raw data can be UTF-8, so we wouldn't know the source length until
   // we have decoded it anyway even if we knew the raw data length (which we
   // don't). We work around this by storing all the scopes which need their end
   // position set at the end of the script (the top scope and possible eval
   // scopes) and set their end position after we know the script length.
-  if (info->is_lazy()) {
-    result = DoParseLazy(info, info->function_name(), stream_ptr);
-  } else {
+  if (info->is_toplevel()) {
     fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
     scanner_.Initialize(stream_ptr);
     result = DoParseProgram(info);
+  } else {
+    result = DoParseLazy(info, info->function_name(), stream_ptr);
   }
 
   info->set_literal(result);
 
   // We cannot internalize on a background thread; a foreground task will take
   // care of calling Parser::Internalize just before compilation.
 
   if (produce_cached_parse_data()) {
     if (result != NULL) *info->cached_data() = recorder.GetScriptData();
     log_ = NULL;
@@ skipping 1569 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8