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);
 }
 
+Handle<Context> GetScopeWithVariable(Isolate* isolate, const char* var) {

[marja, 2016/08/03 08:07:48]

This function name is surprising given that it doesn't create a Scope.
GetContextWithVariable?

[jochen (gone - plz use gerrit), 2016/08/03 09:14:49]

done

+  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> outter_scope = GetScopeWithVariable(i_isolate(), "g");

[marja, 2016/08/03 08:07:48]

Typo: outter

[jochen (gone - plz use gerrit), 2016/08/03 09:14:49]

done

+  const char source[] = "g = 1;";
+  ScriptResource script(source, strlen(source));
+  Handle<JSFunction> fun = CreateFunction(i_isolate(), &script);
+  fun->set_context(*outter_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);
+  ASSERT_TRUE(var->IsContextSlot());

[marja, 2016/08/03 08:07:48]

Hmm, this test is not clear to me... Is g a function-scope variable anyway?
Aren't global variables always in the context? Is it a global variable? Does
this test fail if you remove the parsing step?

[jochen (gone - plz use gerrit), 2016/08/03 09:14:49]

well, without the parsing step, there is no literal...

If I remove fun->set_context() above the scope looks like this:

global { // (0, 6)
  // scope has trivial outer context
}

and the lookup of the variable fails.

As is, the scope looks like this:

global { // (0, 6)
  // scope has trivial outer context

  catch { // (-1, -1)
    // scope has trivial outer context
    // 5 heap slots (including 0 global slots)
    // local vars:
    VAR g;  // context[4]
  }
}

+
+  job->ResetOnMainThread();
+}
+
 }  // namespace internal
 }  // namespace v8