[Interpreter] Localize the CanonicalHandleScope to parsing and renumbering.

src/compiler-dispatcher/compiler-dispatcher-job.cc

 // Copyright 2016 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-dispatcher/compiler-dispatcher-job.h"
 
 #include "src/assert-scope.h"
 #include "src/compilation-info.h"
 #include "src/compiler.h"
 #include "src/global-handles.h"
@@ skipping 120 matching lines @@
   }
 
   if (parse_info_->literal() == nullptr) {
     status_ = CompileJobStatus::kFailed;
   } else {
     status_ = CompileJobStatus::kReadyToAnalyse;
   }
 
   DeferredHandleScope scope(isolate_);
   {
-    // Create a canonical handle scope before internalizing parsed values if
-    // compiling bytecode. This is required for off-thread bytecode generation.
-    std::unique_ptr<CanonicalHandleScope> canonical;
-    if (FLAG_ignition) canonical.reset(new CanonicalHandleScope(isolate_));
-
     Handle<SharedFunctionInfo> shared(function_->shared(), isolate_);
     Handle<Script> script(Script::cast(shared->script()), isolate_);
 
     parse_info_->set_script(script);
     parse_info_->set_context(handle(function_->context(), isolate_));
     parse_info_->set_shared_info(handle(function_->shared(), isolate_));
 
-    // Do the parsing tasks which need to be done on the main thread. This will
-    // also handle parse errors.
-    parser_->Internalize(isolate_, script, parse_info_->literal() == nullptr);
+    {
+      // Create a canonical handle scope if compiling ignition bytecode. This is
+      // required by the constant array builder to de-duplicate objects without
+      // dereferencing handles.
+      std::unique_ptr<CanonicalHandleScope> canonical;
+      if (FLAG_ignition) canonical.reset(new CanonicalHandleScope(isolate_));
+
+      // Do the parsing tasks which need to be done on the main thread. This
+      // will also handle parse errors.
+      parser_->Internalize(isolate_, script, parse_info_->literal() == nullptr);
+    }
     parser_->HandleSourceURLComments(isolate_, script);
 
     parse_info_->set_character_stream(nullptr);
     parse_info_->set_unicode_cache(nullptr);
     parser_.reset();
     unicode_cache_.reset();
     character_stream_.reset();
   }
   handles_from_parsing_.reset(scope.Detach());
 
   return status_ != CompileJobStatus::kFailed;
 }
 
 bool CompilerDispatcherJob::PrepareToCompileOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status() == CompileJobStatus::kReadyToAnalyse);
 
   compile_info_.reset(new CompilationInfo(parse_info_.get(), function_));
 
   DeferredHandleScope scope(isolate_);
-  {
-    // Create a canonical handle scope before ast numbering if compiling
-    // bytecode. This is required for off-thread bytecode generation.
-    std::unique_ptr<CanonicalHandleScope> canonical;
-    if (FLAG_ignition) canonical.reset(new CanonicalHandleScope(isolate_));
-
-    if (Compiler::Analyze(parse_info_.get())) {
-      compile_job_.reset(
-          Compiler::PrepareUnoptimizedCompilationJob(compile_info_.get()));
-    }
+  if (Compiler::Analyze(parse_info_.get())) {
+    compile_job_.reset(
+        Compiler::PrepareUnoptimizedCompilationJob(compile_info_.get()));
   }
   compile_info_->set_deferred_handles(scope.Detach());
 
   if (!compile_job_.get()) {
     if (!isolate_->has_pending_exception()) isolate_->StackOverflow();
     status_ = CompileJobStatus::kFailed;
     return false;
   }
 
   can_compile_on_background_thread_ =
@@ skipping 57 matching lines @@
   if (!source_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(source_).location());
     source_ = Handle<String>::null();
   }
 
   status_ = CompileJobStatus::kInitial;
 }
 
 }  // namespace internal
 }  // namespace v8