Revert of Always deserialize scope infos for parsing

src/ast/scopes.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/ast/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
@@ skipping 268 matching lines @@
       if (context->IsDebugEvaluateContext()) {
         outer_scope->set_is_debug_evaluate_scope();
       }
     } else if (context->IsScriptContext()) {
       // If we reach a script context, it's the outermost context with scope
       // info. The next context will be the native context. Install the scope
       // info of this script context onto the existing script scope to avoid
       // nesting script scopes.
       Handle<ScopeInfo> scope_info(context->scope_info(), isolate);
       script_scope->SetScriptScopeInfo(scope_info);
-      script_scope->DeserializeScopeInfo(isolate, ast_value_factory);
-      if (deserialization_mode == DeserializationMode::kDeserializeOffHeap) {
-        script_scope->scope_info_ = Handle<ScopeInfo>::null();
-      }
       DCHECK(context->previous()->IsNativeContext());
       break;
     } else if (context->IsFunctionContext()) {
       Handle<ScopeInfo> scope_info(context->closure()->shared()->scope_info(),
                                    isolate);
       // TODO(neis): For an eval scope, we currently create an ordinary function
       // context.  This is wrong and needs to be fixed.
       // https://bugs.chromium.org/p/v8/issues/detail?id=5295
       DCHECK(scope_info->scope_type() == FUNCTION_SCOPE ||
              scope_info->scope_type() == EVAL_SCOPE);
@@ skipping 15 matching lines @@
     } else {
       DCHECK(context->IsCatchContext());
       String* name = context->catch_name();
       outer_scope = new (zone)
           Scope(zone, ast_value_factory->GetString(handle(name, isolate)));
     }
     if (current_scope != nullptr) {
       outer_scope->AddInnerScope(current_scope);
     }
     current_scope = outer_scope;
-    current_scope->DeserializeScopeInfo(isolate, ast_value_factory);
     if (deserialization_mode == DeserializationMode::kDeserializeOffHeap) {
-      current_scope->scope_info_ = Handle<ScopeInfo>::null();
+      current_scope->DeserializeScopeInfo(isolate, ast_value_factory);
     }
     if (innermost_scope == nullptr) innermost_scope = current_scope;
     context = context->previous();
   }
 
   if (innermost_scope == nullptr) return script_scope;
   script_scope->AddInnerScope(current_scope);
   script_scope->PropagateScopeInfo();
   return innermost_scope;
 }
@@ skipping 55 matching lines @@
     Handle<String> name_handle(scope_info_->FunctionName(), isolate);
     const AstRawString* name = ast_value_factory->GetString(name_handle);
     VariableMode mode;
     int index = scope_info_->FunctionContextSlotIndex(*name_handle, &mode);
     if (index >= 0) {
       Variable* result = AsDeclarationScope()->DeclareFunctionVar(name);
       DCHECK_EQ(mode, result->mode());
       result->AllocateTo(VariableLocation::CONTEXT, index);
     }
   }
+
+  scope_info_ = Handle<ScopeInfo>::null();
 }
 
 DeclarationScope* Scope::AsDeclarationScope() {
   DCHECK(is_declaration_scope());
   return static_cast<DeclarationScope*>(this);
 }
 
 const DeclarationScope* Scope::AsDeclarationScope() const {
   DCHECK(is_declaration_scope());
   return static_cast<const DeclarationScope*>(this);
@@ skipping 189 matching lines @@
 }
 
 
 void Scope::PropagateUsageFlagsToScope(Scope* other) {
   DCHECK_NOT_NULL(other);
   DCHECK(!already_resolved_);
   DCHECK(!other->already_resolved_);
   if (calls_eval()) other->RecordEvalCall();
 }
 
+Variable* Scope::LookupInScopeInfo(const AstRawString* name) {
+  Handle<String> name_handle = name->string();
+  // The Scope is backed up by ScopeInfo. This means it cannot operate in a
+  // heap-independent mode, and all strings must be internalized immediately. So
+  // it's ok to get the Handle<String> here.
+  // If we have a serialized scope info, we might find the variable there.
+  // There should be no local slot with the given name.
+  DCHECK(scope_info_->StackSlotIndex(*name_handle) < 0);
+
+  VariableMode mode;
+  InitializationFlag init_flag;
+  MaybeAssignedFlag maybe_assigned_flag;
+
+  VariableLocation location = VariableLocation::CONTEXT;
+  int index = ScopeInfo::ContextSlotIndex(scope_info_, name_handle, &mode,
+                                          &init_flag, &maybe_assigned_flag);
+  if (index < 0) {
+    location = VariableLocation::GLOBAL;
+    index = ScopeInfo::ContextGlobalSlotIndex(scope_info_, name_handle, &mode,
+                                              &init_flag, &maybe_assigned_flag);
+    DCHECK(index < 0 || (is_script_scope() && mode == VAR));
+  }
+  if (index < 0) {
+    location = VariableLocation::LOOKUP;
+    index = scope_info_->ParameterIndex(*name_handle);
+    if (index >= 0) {
+      mode = DYNAMIC;
+      init_flag = kCreatedInitialized;
+      // Be conservative and flag parameters as maybe assigned. Better
+      // information would require ScopeInfo to serialize the maybe_assigned bit
+      // also for parameters.
+      maybe_assigned_flag = kMaybeAssigned;
+    }
+  }
+  if (index < 0 && scope_type() == MODULE_SCOPE) {
+    location = VariableLocation::MODULE;
+    index = -1;  // TODO(neis): Find module variables in scope info.
+  }
+  if (index < 0) return nullptr;  // Nowhere found.
+
+  Variable::Kind kind = Variable::NORMAL;
+  if (location == VariableLocation::CONTEXT &&
+      index == scope_info_->ReceiverContextSlotIndex()) {
+    kind = Variable::THIS;
+  }
+  // TODO(marja, rossberg): Correctly declare FUNCTION, CLASS, NEW_TARGET, and
+  // ARGUMENTS bindings as their corresponding Variable::Kind.
+
+  Variable* var = variables_.Declare(zone(), this, name, mode, kind, init_flag,
+                                     maybe_assigned_flag);
+  var->AllocateTo(location, index);
+  return var;
+}
+
 Variable* DeclarationScope::LookupFunctionVar(const AstRawString* name) {
-  if (function_ != nullptr && function_->raw_name() == name) return function_;
-  return nullptr;
+  if (function_ != nullptr && function_->raw_name() == name) {
+    return function_;
+  } else if (!scope_info_.is_null()) {
+    // If we are backed by a scope info, try to lookup the variable there.
+    VariableMode mode;
+    int index = scope_info_->FunctionContextSlotIndex(*(name->string()), &mode);
+    if (index < 0) return nullptr;
+    Variable* var = DeclareFunctionVar(name);
+    DCHECK_EQ(mode, var->mode());
+    var->AllocateTo(VariableLocation::CONTEXT, index);
+    return var;
+  } else {
+    return nullptr;
+  }
 }
 
 
 Variable* Scope::Lookup(const AstRawString* name) {
   for (Scope* scope = this;
        scope != NULL;
        scope = scope->outer_scope()) {
     Variable* var = scope->LookupLocal(name);
     if (var != NULL) return var;
   }
@@ skipping 959 matching lines @@
       function != nullptr && function->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8