Don't dereference handles in DoParseLazy

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.h"
@@ skipping 34 matching lines @@
       flags_(0),
       source_stream_(nullptr),
       source_stream_encoding_(ScriptCompiler::StreamedSource::ONE_BYTE),
       character_stream_(nullptr),
       extension_(nullptr),
       compile_options_(ScriptCompiler::kNoCompileOptions),
       script_scope_(nullptr),
       unicode_cache_(nullptr),
       stack_limit_(0),
       hash_seed_(0),
+      compiler_hints_(0),
+      start_position_(0),
+      end_position_(0),
       isolate_(nullptr),
       cached_data_(nullptr),
       ast_value_factory_(nullptr),
       literal_(nullptr),
       scope_(nullptr) {}
 
 ParseInfo::ParseInfo(Zone* zone, Handle<JSFunction> function)
     : ParseInfo(zone, Handle<SharedFunctionInfo>(function->shared())) {
   set_context(Handle<Context>(function->context()));
 }
 
 
 ParseInfo::ParseInfo(Zone* zone, Handle<SharedFunctionInfo> shared)
     : ParseInfo(zone) {
   isolate_ = shared->GetIsolate();
 
   set_lazy();
   set_hash_seed(isolate_->heap()->HashSeed());
+  set_is_named_expression(shared->is_named_expression());
+  set_calls_eval(shared->scope_info()->CallsEval());
+  set_compiler_hints(shared->compiler_hints());
+  set_start_position(shared->start_position());
+  set_end_position(shared->end_position());
   set_stack_limit(isolate_->stack_guard()->real_climit());
   set_unicode_cache(isolate_->unicode_cache());
   set_language_mode(shared->language_mode());
   set_shared_info(shared);
 
   Handle<Script> script(Script::cast(shared->script()));
   set_script(script);
   if (!script.is_null() && script->type() == Script::TYPE_NATIVE) {
     set_native();
   }
 }
 
 
 ParseInfo::ParseInfo(Zone* zone, Handle<Script> script) : ParseInfo(zone) {
   isolate_ = script->GetIsolate();
 
   set_hash_seed(isolate_->heap()->HashSeed());
   set_stack_limit(isolate_->stack_guard()->real_climit());
   set_unicode_cache(isolate_->unicode_cache());
   set_script(script);
 
   if (script->type() == Script::TYPE_NATIVE) {
     set_native();
   }
 }
 
+bool ParseInfo::is_declaration() const {
+  return (compiler_hints_ & (1 << SharedFunctionInfo::kIsDeclaration)) != 0;
+}
+
+bool ParseInfo::is_arrow() const {
+  return (compiler_hints_ & (1 << SharedFunctionInfo::kIsArrow)) != 0;
+}
+
+bool ParseInfo::is_async() const {
+  return (compiler_hints_ & (1 << SharedFunctionInfo::kIsAsyncFunction)) != 0;
+}
+
+bool ParseInfo::is_default_constructor() const {
+  return (compiler_hints_ & (1 << SharedFunctionInfo::kIsDefaultConstructor)) !=
+         0;
+}
+
+FunctionKind ParseInfo::function_kind() const {
+  return SharedFunctionInfo::FunctionKindBits::decode(compiler_hints_);
+}
 
 FunctionEntry ParseData::GetFunctionEntry(int start) {
   // The current pre-data entry must be a FunctionEntry with the given
   // start position.
   if ((function_index_ + FunctionEntry::kSize <= Length()) &&
       (static_cast<int>(Data()[function_index_]) == start)) {
     int index = function_index_;
     function_index_ += FunctionEntry::kSize;
     Vector<unsigned> subvector(&(Data()[index]), FunctionEntry::kSize);
     return FunctionEntry(subvector);
@@ skipping 964 matching lines @@
           Handle<ExternalTwoByteString>::cast(source),
           shared_info->start_position(), shared_info->end_position()));
     } else if (source->IsExternalOneByteString()) {
       stream.reset(new ExternalOneByteStringUtf16CharacterStream(
           Handle<ExternalOneByteString>::cast(source),
           shared_info->start_position(), shared_info->end_position()));
     } else {
       stream.reset(new GenericStringUtf16CharacterStream(
           source, shared_info->start_position(), shared_info->end_position()));
     }
-    result = DoParseLazy(isolate, info, stream.get());
+    Handle<String> name(String::cast(shared_info->name()));
+    result = DoParseLazy(isolate, info, ast_value_factory()->GetString(name),
+                         stream.get());
+    if (result != nullptr) {
+      Handle<String> inferred_name(shared_info->inferred_name());
+      result->set_inferred_name(inferred_name);
+    }
   }
 
   if (FLAG_trace_parse && result != NULL) {
     double ms = timer.Elapsed().InMillisecondsF();
     std::unique_ptr<char[]> name_chars = result->debug_name()->ToCString();
     PrintF("[parsing function: %s - took %0.3f ms]\n", name_chars.get(), ms);
   }
   return result;
 }
 
-static FunctionLiteral::FunctionType ComputeFunctionType(
-    Handle<SharedFunctionInfo> shared_info) {
-  if (shared_info->is_declaration()) {
+static FunctionLiteral::FunctionType ComputeFunctionType(ParseInfo* info) {
+  if (info->is_declaration()) {
     return FunctionLiteral::kDeclaration;
-  } else if (shared_info->is_named_expression()) {
+  } else if (info->is_named_expression()) {
     return FunctionLiteral::kNamedExpression;
-  } else if (IsConciseMethod(shared_info->kind()) ||
-             IsAccessorFunction(shared_info->kind())) {
+  } else if (IsConciseMethod(info->function_kind()) ||
+             IsAccessorFunction(info->function_kind())) {
     return FunctionLiteral::kAccessorOrMethod;
   }
   return FunctionLiteral::kAnonymousExpression;
 }
 
 FunctionLiteral* Parser::DoParseLazy(Isolate* isolate, ParseInfo* info,
+                                     const AstRawString* raw_name,
                                      Utf16CharacterStream* source) {
-  Handle<SharedFunctionInfo> shared_info = info->shared_info();
   scanner_.Initialize(source);
   DCHECK_NULL(scope_state_);
   DCHECK_NULL(target_stack_);
 
-  Handle<String> name(String::cast(shared_info->name()));
   DCHECK(ast_value_factory());
   fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
-  const AstRawString* raw_name = ast_value_factory()->GetString(name);
   fni_->PushEnclosingName(raw_name);
 
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
 
   // Place holder for the result.
   FunctionLiteral* result = nullptr;
 
   {
     // Parse the function literal.
     Scope* scope = original_scope_;
     DCHECK(scope);
     FunctionState function_state(&function_state_, &scope_state_, scope,
-                                 shared_info->kind());
+                                 info->function_kind());
     DCHECK(is_sloppy(scope->language_mode()) ||
            is_strict(info->language_mode()));
-    DCHECK(info->language_mode() == shared_info->language_mode());
-    FunctionLiteral::FunctionType function_type =
-        ComputeFunctionType(shared_info);
+    FunctionLiteral::FunctionType function_type = ComputeFunctionType(info);
     bool ok = true;
 
-    if (shared_info->is_arrow()) {
-      bool is_async = allow_harmony_async_await() && shared_info->is_async();
+    if (info->is_arrow()) {
+      bool is_async = allow_harmony_async_await() && info->is_async();
       if (is_async) {
         DCHECK(!scanner()->HasAnyLineTerminatorAfterNext());
         if (!Check(Token::ASYNC)) {
           CHECK(stack_overflow());
           return nullptr;
         }
         if (!(peek_any_identifier() || peek() == Token::LPAREN)) {
           CHECK(stack_overflow());
           return nullptr;
         }
       }
 
       // TODO(adamk): We should construct this scope from the ScopeInfo.
       Scope* scope = NewFunctionScope(FunctionKind::kArrowFunction);
 
       // These two bits only need to be explicitly set because we're
       // not passing the ScopeInfo to the Scope constructor.
       // TODO(adamk): Remove these calls once the above NewScope call
       // passes the ScopeInfo.
-      if (shared_info->scope_info()->CallsEval()) {
+      if (info->calls_eval()) {
         scope->RecordEvalCall();
       }
-      SetLanguageMode(scope, shared_info->language_mode());
+      SetLanguageMode(scope, info->language_mode());
 
-      scope->set_start_position(shared_info->start_position());
+      scope->set_start_position(info->start_position());
       ExpressionClassifier formals_classifier(this);
       ParserFormalParameters formals(scope);
       Checkpoint checkpoint(this);
       {
         // Parsing patterns as variable reference expression creates
         // NewUnresolved references in current scope. Entrer arrow function
         // scope for formal parameter parsing.
         BlockState block_state(&scope_state_, scope);
         if (Check(Token::LPAREN)) {
           // '(' StrictFormalParameters ')'
@@ skipping 15 matching lines @@
         // not be observable, or else the preparser would have failed.
         Expression* expression = ParseArrowFunctionLiteral(
             true, formals, is_async, formals_classifier, &ok);
         if (ok) {
           // Scanning must end at the same position that was recorded
           // previously. If not, parsing has been interrupted due to a stack
           // overflow, at which point the partially parsed arrow function
           // concise body happens to be a valid expression. This is a problem
           // only for arrow functions with single expression bodies, since there
           // is no end token such as "}" for normal functions.
-          if (scanner()->location().end_pos == shared_info->end_position()) {
+          if (scanner()->location().end_pos == info->end_position()) {
             // The pre-parser saw an arrow function here, so the full parser
             // must produce a FunctionLiteral.
             DCHECK(expression->IsFunctionLiteral());
             result = expression->AsFunctionLiteral();
           } else {
             ok = false;
           }
         }
       }
-    } else if (shared_info->is_default_constructor()) {
+    } else if (info->is_default_constructor()) {
       DCHECK_EQ(this->scope(), scope);
       result = DefaultConstructor(
-          raw_name, IsSubclassConstructor(shared_info->kind()),
-          shared_info->start_position(), shared_info->end_position(),
-          shared_info->language_mode());
+          raw_name, IsSubclassConstructor(info->function_kind()),
+          info->start_position(), info->end_position(), info->language_mode());
     } else {
       result = ParseFunctionLiteral(raw_name, Scanner::Location::invalid(),
-                                    kSkipFunctionNameCheck, shared_info->kind(),
-                                    kNoSourcePosition, function_type,
-                                    shared_info->language_mode(), &ok);
+                                    kSkipFunctionNameCheck,
+                                    info->function_kind(), kNoSourcePosition,
+                                    function_type, info->language_mode(), &ok);
     }
     // Make sure the results agree.
     DCHECK(ok == (result != nullptr));
   }
 
   // Make sure the target stack is empty.
   DCHECK_NULL(target_stack_);
-
-  if (result != nullptr) {
-    Handle<String> inferred_name(shared_info->inferred_name());
-    result->set_inferred_name(inferred_name);
-  }
   return result;
 }
 
 
 void Parser::ParseStatementList(ZoneList<Statement*>* body, int end_token,
                                 bool* ok) {
   // StatementList ::
   //   (StatementListItem)* <end_token>
 
   // Allocate a target stack to use for this set of source
@@ skipping 5855 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8