Add a mode to completely deserialize scope chains

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 924 matching lines @@
   // background thread. We should not access anything Isolate / heap dependent
   // via ParseInfo, and also not pass it forward.
   DCHECK_NULL(scope_state_);
   DCHECK_NULL(target_stack_);
 
   Mode parsing_mode = FLAG_lazy && allow_lazy() ? PARSE_LAZILY : PARSE_EAGERLY;
   if (allow_natives() || extension_ != NULL) parsing_mode = PARSE_EAGERLY;
 
   FunctionLiteral* result = NULL;
   {
-    // TODO(wingo): Add an outer SCRIPT_SCOPE corresponding to the native
-    // context, which will have the "this" binding for script scopes.
-    Scope* scope = NewScriptScope();
-    info->set_script_scope(scope);
-    if (!info->context().is_null() && !info->context()->IsNativeContext()) {
-      scope = Scope::DeserializeScopeChain(info->isolate(), zone(),
-                                           *info->context(), scope,
-                                           ast_value_factory());
-      // The Scope is backed up by ScopeInfo (which is in the V8 heap); this
-      // means the Parser cannot operate independent of the V8 heap. Tell the
-      // string table to internalize strings and values right after they're
-      // created. This kind of parsing can only be done in the main thread.
-      DCHECK(parsing_on_main_thread_);
-      ast_value_factory()->Internalize(info->isolate());
+    Scope* scope;
+    if (info->script_scope()) {

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

"script_scope" as a name is very generic, could something like
"deserialized_scope" be clearer? (No, that's not a really good name either, but
something... outer? Lazy?)

Somebody reading only this file is not at all in the mental context of scope
deserialization, so it's hard to understand when do we have a script_scope and
when not (doesn't each script have a scope...).

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

well, it's corresponding to the existing set_script_scope()

+      scope = info->script_scope();
+    } else {
+      // TODO(wingo): Add an outer SCRIPT_SCOPE corresponding to the native
+      // context, which will have the "this" binding for script scopes.
+      scope = NewScriptScope();
+      info->set_script_scope(scope);
+      if (!info->context().is_null() && !info->context()->IsNativeContext()) {
+        scope = Scope::DeserializeScopeChain(
+            info->isolate(), zone(), *info->context(), scope,
+            ast_value_factory(), Scope::DeserializationMode::kKeepScopeInfo);
+        // The Scope is backed up by ScopeInfo (which is in the V8 heap); this
+        // means the Parser cannot operate independent of the V8 heap. Tell the
+        // string table to internalize strings and values right after they're
+        // created. This kind of parsing can only be done in the main thread.
+        DCHECK(parsing_on_main_thread_);
+        ast_value_factory()->Internalize(info->isolate());
+      }
+      original_scope_ = scope;
     }
-    original_scope_ = scope;
     if (info->is_eval()) {
       if (!scope->is_script_scope() || is_strict(info->language_mode())) {
         parsing_mode = PARSE_EAGERLY;
       }
       scope = NewScopeWithParent(scope, EVAL_SCOPE);
     } else if (info->is_module()) {
       scope = NewScopeWithParent(scope, MODULE_SCOPE);
     }
 
     scope->set_start_position(0);
@@ skipping 138 matching lines @@
   FunctionLiteral* result = nullptr;
 
   {
     // Parse the function literal.
     Scope* scope = NewScriptScope();
     info->set_script_scope(scope);
     if (!info->context().is_null()) {
       // Ok to use Isolate here, since lazy function parsing is only done in the
       // main thread.
       DCHECK(parsing_on_main_thread_);
-      scope = Scope::DeserializeScopeChain(isolate, zone(), *info->context(),
-                                           scope, ast_value_factory());
+      scope = Scope::DeserializeScopeChain(
+          isolate, zone(), *info->context(), scope, ast_value_factory(),
+          Scope::DeserializationMode::kKeepScopeInfo);
     }
     original_scope_ = scope;
     FunctionState function_state(&function_state_, &scope_state_, scope,
                                  shared_info->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);
     bool ok = true;
@@ skipping 5956 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8