Add a mode to completely deserialize scope chains

test/unittests/compiler-dispatcher/compiler-dispatcher-job-unittest.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 <memory>
 
+#include "src/ast/scopes.h"
 #include "src/compiler-dispatcher/compiler-dispatcher-job.h"
+#include "src/compiler.h"
 #include "src/flags.h"
 #include "src/isolate-inl.h"
+#include "src/parsing/parser.h"
 #include "test/unittests/test-utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace v8 {
 namespace internal {
 
 typedef TestWithContext CompilerDispatcherJobTest;
 
 namespace {
 
+const char test_script[] = "x*x";
+
 class ScriptResource : public v8::String::ExternalOneByteStringResource {
  public:
   ScriptResource(const char* data, size_t length)
       : data_(data), length_(length) {}
   ~ScriptResource() override = default;
 
   const char* data() const override { return data_; }
   size_t length() const override { return length_; }
 
  private:
   const char* data_;
   size_t length_;
 
   DISALLOW_COPY_AND_ASSIGN(ScriptResource);
 };
 
 Handle<JSFunction> CreateFunction(
     Isolate* isolate, ExternalOneByteString::Resource* maybe_resource) {
   HandleScope scope(isolate);
   Handle<String> source;
   if (maybe_resource) {
     source = isolate->factory()
                  ->NewExternalStringFromOneByte(maybe_resource)
                  .ToHandleChecked();
   } else {
-    source = isolate->factory()->NewStringFromStaticChars("source");
+    source = isolate->factory()->NewStringFromAsciiChecked(test_script);
   }
   Handle<Script> script = isolate->factory()->NewScript(source);
   Handle<SharedFunctionInfo> shared = isolate->factory()->NewSharedFunctionInfo(
-      isolate->factory()->NewStringFromStaticChars("f"), MaybeHandle<Code>(),
+      isolate->factory()->NewStringFromAsciiChecked("f"), MaybeHandle<Code>(),
       false);
   SharedFunctionInfo::SetScript(shared, script);
-  shared->set_end_position(source->length() - 1);
+  shared->set_end_position(source->length());
   Handle<JSFunction> function =
       isolate->factory()->NewFunctionFromSharedFunctionInfo(
           shared, handle(isolate->context(), isolate));
   return scope.CloseAndEscape(function);
 }
 
+// A CatchContext is the easiest way to get a context with a variable in a
+// slot.
+Handle<Context> GetContextWithVariable(Isolate* isolate, const char* var) {
+  HandleScope handle_scope(isolate);
+  Handle<JSFunction> closure(isolate->native_context()->closure());
+  Handle<Context> context = isolate->factory()->NewCatchContext(
+      closure, handle(isolate->context()),
+      isolate->factory()->NewStringFromAsciiChecked(var),
+      isolate->factory()->undefined_value());
+  return handle_scope.CloseAndEscape(context);
+}
+
 }  // namespace
 
 TEST_F(CompilerDispatcherJobTest, Construct) {
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
       i_isolate(), CreateFunction(i_isolate(), nullptr), FLAG_stack_size));
 }
 
 TEST_F(CompilerDispatcherJobTest, CanParseOnBackgroundThread) {
   {
     std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
         i_isolate(), CreateFunction(i_isolate(), nullptr), FLAG_stack_size));
     ASSERT_FALSE(job->can_parse_on_background_thread());
   }
   {
-    ScriptResource script("script", strlen("script"));
+    ScriptResource script(test_script, strlen(test_script));
     std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
         i_isolate(), CreateFunction(i_isolate(), &script), FLAG_stack_size));
     ASSERT_TRUE(job->can_parse_on_background_thread());
   }
 }
 
 TEST_F(CompilerDispatcherJobTest, StateTransitions) {
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
       i_isolate(), CreateFunction(i_isolate(), nullptr), FLAG_stack_size));
 
@@ skipping 17 matching lines @@
   job->Parse();
   job->FinalizeParsingOnMainThread();
 
   ASSERT_TRUE(job->status() == CompileJobStatus::kFailed);
   ASSERT_FALSE(i_isolate()->has_pending_exception());
   job->ReportErrorsOnMainThread();
   ASSERT_TRUE(job->status() == CompileJobStatus::kDone);
   ASSERT_TRUE(i_isolate()->has_pending_exception());
 }
 
+TEST_F(CompilerDispatcherJobTest, ScopeChain) {
+  Handle<Context> outer_scope = GetContextWithVariable(i_isolate(), "g");
+  const char source[] = "g = 1;";
+  ScriptResource script(source, strlen(source));
+  Handle<JSFunction> fun = CreateFunction(i_isolate(), &script);
+  fun->set_context(*outer_scope);
+
+  std::unique_ptr<CompilerDispatcherJob> job(
+      new CompilerDispatcherJob(i_isolate(), fun, FLAG_stack_size));
+  job->PrepareToParseOnMainThread();
+  job->Parse();
+  job->FinalizeParsingOnMainThread();
+  ASSERT_TRUE(job->status() == CompileJobStatus::kReadyToCompile);
+
+  Scope* scope = job->parse_info_->literal()->scope();
+  Scope* inner_scope = scope->inner_scope();
+  const AstRawString* var_name =
+      job->parse_info_->ast_value_factory()->GetOneByteString("g");
+  Variable* var = inner_scope->Lookup(var_name);
+  ASSERT_TRUE(var);
+  // If the parser didn't use our outer_scope, "g" would be a global variable.
+  ASSERT_TRUE(var->IsContextSlot());
+
+  job->ResetOnMainThread();
+}
+
 }  // namespace internal
 }  // namespace v8