Declare 'this' as DYNAMIC_GLOBAL on the script_scope

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 191 matching lines @@
   language_mode_ = is_module_scope() ? STRICT : SLOPPY;
 
   scope_inside_with_ = false;
   scope_calls_eval_ = false;
   scope_uses_super_property_ = false;
   has_arguments_parameter_ = false;
   asm_module_ = false;
   asm_function_ = false;
   scope_nonlinear_ = false;
   is_hidden_ = false;
+  is_debug_evaluate_scope_ = false;
 
   outer_scope_calls_sloppy_eval_ = false;
   inner_scope_calls_eval_ = false;
   force_eager_compilation_ = false;
   force_context_allocation_ = false;
 
   is_declaration_scope_ = false;
 }
 
 bool Scope::HasSimpleParameters() {
   DeclarationScope* scope = GetClosureScope();
   return !scope->is_function_scope() || scope->has_simple_parameters();
 }
 
 Scope* Scope::DeserializeScopeChain(Isolate* isolate, Zone* zone,
                                     Context* context,
                                     DeclarationScope* script_scope,
                                     AstValueFactory* ast_value_factory,
                                     DeserializationMode deserialization_mode) {
   // Reconstruct the outer scope chain from a closure's context chain.
   Scope* current_scope = nullptr;
   Scope* innermost_scope = nullptr;
   while (!context->IsNativeContext()) {
     if (context->IsWithContext() || context->IsDebugEvaluateContext()) {
       // For scope analysis, debug-evaluate is equivalent to a with scope.
       Scope* with_scope = new (zone)
           Scope(zone, current_scope, WITH_SCOPE, Handle<ScopeInfo>::null());
+      // TODO(yangguo): Remove once debug-evaluate properly keeps track of the
+      // function scope in which we are evaluating.
+      if (context->IsDebugEvaluateContext()) {
+        with_scope->set_is_debug_evaluate_scope();
+      }
       current_scope = with_scope;
       // All the inner scopes are inside a with.
       for (Scope* s = innermost_scope; s != nullptr; s = s->outer_scope()) {
         s->scope_inside_with_ = true;
       }
     } else if (context->IsScriptContext()) {
       ScopeInfo* scope_info = context->scope_info();
       current_scope = new (zone) DeclarationScope(
           zone, current_scope, SCRIPT_SCOPE, Handle<ScopeInfo>(scope_info));
     } else if (context->IsFunctionContext()) {
@@ skipping 298 matching lines @@
   Variable* result = variables_.Lookup(name);
   if (result != NULL || scope_info_.is_null()) {
     return result;
   }
   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 || is_block_scope());

[Toon Verwaest, 2016/08/12 08:50:20]

I don't see how this would be valid for block scopes. We should only get here
for resolving variables of a scope outside of a function, and block-scoped
variables shouldn't be stack-allocated there either.

+  DCHECK(scope_info_->StackSlotIndex(*name_handle) < 0);
 
   // Check context slot lookup.
   VariableMode mode;
   VariableLocation location = VariableLocation::CONTEXT;
   InitializationFlag init_flag;
   MaybeAssignedFlag maybe_assigned_flag;
   int index = ScopeInfo::ContextSlotIndex(scope_info_, name_handle, &mode,
                                           &init_flag, &maybe_assigned_flag);
   if (index < 0) {
     location = VariableLocation::GLOBAL;
@@ skipping 668 matching lines @@
   }
 }
 
 void Scope::CheckZones() {
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
     CHECK_EQ(scope->zone(), zone());
   }
 }
 #endif  // DEBUG
 
-Variable* Scope::NonLocal(const AstRawString* name, VariableMode mode,
-                          Variable::Kind kind) {
+Variable* Scope::NonLocal(const AstRawString* name, VariableMode mode) {
   if (dynamics_ == NULL) dynamics_ = new (zone()) DynamicScopePart(zone());
   VariableMap* map = dynamics_->GetMap(mode);
   Variable* var = map->Lookup(name);
   if (var == NULL) {
     // Declare a new non-local.
     DCHECK(!IsLexicalVariableMode(mode));
-    var = map->Declare(zone(), NULL, name, mode, kind, kCreatedInitialized);
+    var = map->Declare(zone(), NULL, name, mode, Variable::NORMAL,
+                       kCreatedInitialized);
     // Allocate it by giving it a dynamic lookup.
     var->AllocateTo(VariableLocation::LOOKUP, -1);
   }
   return var;
 }
 
 Variable* Scope::LookupRecursive(VariableProxy* proxy,
                                  BindingKind* binding_kind,
                                  AstNodeFactory* factory,
                                  Scope* outer_scope_end) {
   DCHECK_NE(outer_scope_end, this);
   DCHECK_NOT_NULL(binding_kind);
   DCHECK_EQ(UNBOUND, *binding_kind);
-  if (already_resolved() && is_with_scope()) {
-    // Short-cut: if the scope is deserialized from a scope info, variable
-    // allocation is already fixed.  We can simply return with dynamic lookup.
+  // Short-cut: whenever we find a debug-evaluate scope, just look everything up
+  // dynamically. Debug-evaluate doesn't properly create scope info for the
+  // lookups it does. It may not have a valid 'this' declaration, and anything
+  // accessed through debug-evaluate might invalidly resolve to stack-allocated
+  // variables.
+  // TODO(yangguo): Remove once debug-evaluate creates proper ScopeInfo for the
+  // scopes in which it's evaluating.
+  if (is_debug_evaluate_scope_) {
     *binding_kind = DYNAMIC_LOOKUP;
     return nullptr;
   }
 
   // Try to find the variable in this scope.
   Variable* var = LookupLocal(proxy->raw_name());
 
   // We found a variable and we are done. (Even if there is an 'eval' in this
   // scope which introduces the same variable again, the resulting variable
   // remains the same.)
@@ skipping 17 matching lines @@
                                         outer_scope_end);
     if (*binding_kind == BOUND && is_function_scope()) {
       var->ForceContextAllocation();
     }
     // "this" can't be shadowed by "eval"-introduced bindings or by "with"
     // scopes.
     // TODO(wingo): There are other variables in this category; add them.
     if (var != nullptr && var->is_this()) return var;
 
     if (is_with_scope()) {
-      DCHECK(!already_resolved());
       // The current scope is a with scope, so the variable binding can not be
       // statically resolved. However, note that it was necessary to do a lookup
       // in the outer scope anyway, because if a binding exists in an outer
       // scope, the associated variable has to be marked as potentially being
       // accessed from inside of an inner with scope (the property may not be in
       // the 'with' object).
-      if (var != nullptr) {
+      if (var != nullptr && !already_resolved()) {
         var->set_is_used();
         var->ForceContextAllocation();
         if (proxy->is_assigned()) var->set_maybe_assigned();
       }
       *binding_kind = DYNAMIC_LOOKUP;
       return nullptr;
     }
   } else {
     DCHECK(is_function_scope() || is_script_scope() || is_eval_scope());
     DCHECK(!is_with_scope());
@@ skipping 48 matching lines @@
                name->ToCString().get());
     }
     VariableLocation location = var->location();
     CHECK(location == VariableLocation::LOCAL ||
           location == VariableLocation::CONTEXT ||
           location == VariableLocation::PARAMETER ||
           location == VariableLocation::UNALLOCATED);
   }
 #endif
 
-  // TODO(verwaest): 'this' should always be declared and found. That way we can
-  // remove this workaround.
-  Variable::Kind kind = proxy->is_this() ? Variable::THIS : Variable::NORMAL;
   switch (binding_kind) {
     case BOUND:
       break;
 
     case BOUND_EVAL_SHADOWED:
       // We either found a variable binding that might be shadowed by eval  or
       // gave up on it (e.g. by encountering a local with the same in the outer
       // scope which was not promoted to a context, this can happen if we use
       // debugger to evaluate arbitrary expressions at a break point).
       if (var->IsGlobalObjectProperty()) {
-        var = NonLocal(proxy->raw_name(), DYNAMIC_GLOBAL, kind);
+        var = NonLocal(proxy->raw_name(), DYNAMIC_GLOBAL);
       } else if (var->is_dynamic()) {
-        var = NonLocal(proxy->raw_name(), DYNAMIC, kind);
+        var = NonLocal(proxy->raw_name(), DYNAMIC);
       } else {
         Variable* invalidated = var;
-        var = NonLocal(proxy->raw_name(), DYNAMIC_LOCAL, kind);
+        var = NonLocal(proxy->raw_name(), DYNAMIC_LOCAL);
         var->set_local_if_not_shadowed(invalidated);
       }
       break;
 
     case UNBOUND:
       // No binding has been found. Declare a variable on the global object.
-      var = info->script_scope()->DeclareDynamicGlobal(proxy->raw_name(), kind);
+      var = info->script_scope()->DeclareDynamicGlobal(proxy->raw_name(),
+                                                       Variable::NORMAL);
       break;
 
     case UNBOUND_EVAL_SHADOWED:
       // No binding has been found. But some scope makes a sloppy 'eval' call.
-      var = NonLocal(proxy->raw_name(), DYNAMIC_GLOBAL, kind);
+      var = NonLocal(proxy->raw_name(), DYNAMIC_GLOBAL);
       break;
 
     case DYNAMIC_LOOKUP:
       // The variable could not be resolved statically.
-      var = NonLocal(proxy->raw_name(), DYNAMIC, kind);
+      var = NonLocal(proxy->raw_name(), DYNAMIC);
       break;
   }
 
   DCHECK(var != NULL);
   if (proxy->is_assigned()) var->set_maybe_assigned();
 
   proxy->BindTo(var);
 }
 
 void Scope::ResolveVariablesRecursively(ParseInfo* info,
@@ skipping 360 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