[debugger] fix debug-evaluate wrt shadowed context var.

src/debug/debug-scopes.cc

 // Copyright 2015 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/debug/debug-scopes.h"
 
 #include "src/ast/scopes.h"
 #include "src/debug/debug.h"
 #include "src/frames-inl.h"
 #include "src/globals.h"
 #include "src/isolate-inl.h"
 #include "src/parsing/parser.h"
 
 namespace v8 {
 namespace internal {
 
 ScopeIterator::ScopeIterator(Isolate* isolate, FrameInspector* frame_inspector,
-                             bool ignore_nested_scopes)
+                             ScopeIterator::Option option)
     : isolate_(isolate),
       frame_inspector_(frame_inspector),
       nested_scope_chain_(4),
+      non_locals_(nullptr),
       seen_script_scope_(false),
       failed_(false) {
   if (!frame_inspector->GetContext()->IsContext() ||
       !frame_inspector->GetFunction()->IsJSFunction()) {
     // Optimized frame, context or function cannot be materialized. Give up.
     return;
   }
 
   context_ = Handle<Context>(Context::cast(frame_inspector->GetContext()));
 
   // Catch the case when the debugger stops in an internal function.
   Handle<JSFunction> function = GetFunction();
   Handle<SharedFunctionInfo> shared_info(function->shared());
   Handle<ScopeInfo> scope_info(shared_info->scope_info());
   if (shared_info->script() == isolate->heap()->undefined_value()) {
     while (context_->closure() == *function) {
       context_ = Handle<Context>(context_->previous(), isolate_);
     }
     return;
   }
 
   // Currently it takes too much time to find nested scopes due to script
   // parsing. Sometimes we want to run the ScopeIterator as fast as possible
   // (for example, while collecting async call stacks on every
   // addEventListener call), even if we drop some nested scopes.
   // Later we may optimize getting the nested scopes (cache the result?)
   // and include nested scopes into the "fast" iteration case as well.
-
+  bool ignore_nested_scopes = (option == IGNORE_NESTED_SCOPES);
+  bool collect_non_locals = (option == COLLECT_NON_LOCALS);
   if (!ignore_nested_scopes && shared_info->HasDebugInfo()) {
     // The source position at return is always the end of the function,
     // which is not consistent with the current scope chain. Therefore all
     // nested with, catch and block contexts are skipped, and we can only
     // inspect the function scope.
     // This can only happen if we set a break point inside right before the
     // return, which requires a debug info to be available.
     Handle<DebugInfo> debug_info(shared_info->GetDebugInfo());
 
     // PC points to the instruction after the current one, possibly a break
@@ skipping 11 matching lines @@
     if (scope_info->HasContext()) {
       context_ = Handle<Context>(context_->declaration_context(), isolate_);
     } else {
       while (context_->closure() == *function) {
         context_ = Handle<Context>(context_->previous(), isolate_);
       }
     }
     if (scope_info->scope_type() == FUNCTION_SCOPE) {
       nested_scope_chain_.Add(scope_info);
     }
+    if (!collect_non_locals) return;
+  }
+
+  // Reparse the code and analyze the scopes.
+  Scope* scope = NULL;
+  // Check whether we are in global, eval or function code.
+  Zone zone;
+  if (scope_info->scope_type() != FUNCTION_SCOPE) {
+    // Global or eval code.
+    Handle<Script> script(Script::cast(shared_info->script()));
+    ParseInfo info(&zone, script);
+    if (scope_info->scope_type() == SCRIPT_SCOPE) {
+      info.set_global();
+    } else {
+      DCHECK(scope_info->scope_type() == EVAL_SCOPE);
+      info.set_eval();
+      info.set_context(Handle<Context>(function->context()));
+    }
+    if (Parser::ParseStatic(&info) && Scope::Analyze(&info)) {
+      scope = info.literal()->scope();
+    }
+    if (!ignore_nested_scopes) RetrieveScopeChain(scope);
+    if (collect_non_locals) CollectNonLocals(scope);
   } else {
-    // Reparse the code and analyze the scopes.
-    Handle<Script> script(Script::cast(shared_info->script()));
-    Scope* scope = NULL;
-
-    // Check whether we are in global, eval or function code.
-    Zone zone;
-    if (scope_info->scope_type() != FUNCTION_SCOPE) {
-      // Global or eval code.
-      ParseInfo info(&zone, script);
-      if (scope_info->scope_type() == SCRIPT_SCOPE) {
-        info.set_global();
-      } else {
-        DCHECK(scope_info->scope_type() == EVAL_SCOPE);
-        info.set_eval();
-        info.set_context(Handle<Context>(function->context()));
-      }
-      if (Parser::ParseStatic(&info) && Scope::Analyze(&info)) {
-        scope = info.literal()->scope();
-      }
-      RetrieveScopeChain(scope, shared_info);
-    } else {
-      // Function code
-      ParseInfo info(&zone, function);
-      if (Parser::ParseStatic(&info) && Scope::Analyze(&info)) {
-        scope = info.literal()->scope();
-      }
-      RetrieveScopeChain(scope, shared_info);
+    // Function code
+    ParseInfo info(&zone, function);
+    if (Parser::ParseStatic(&info) && Scope::Analyze(&info)) {
+      scope = info.literal()->scope();
     }
+    if (!ignore_nested_scopes) RetrieveScopeChain(scope);
+    if (collect_non_locals) CollectNonLocals(scope);
   }
 }
 
 
 ScopeIterator::ScopeIterator(Isolate* isolate, Handle<JSFunction> function)
     : isolate_(isolate),
       frame_inspector_(NULL),
       context_(function->context()),
+      non_locals_(nullptr),
       seen_script_scope_(false),
       failed_(false) {
   if (!function->shared()->IsSubjectToDebugging()) context_ = Handle<Context>();
 }
 
 
 MUST_USE_RESULT MaybeHandle<JSObject> ScopeIterator::MaterializeScopeDetails() {
   // Calculate the size of the result.
   Handle<FixedArray> details =
       isolate_->factory()->NewFixedArray(kScopeDetailsSize);
@@ skipping 185 matching lines @@
   if (Type() == ScopeTypeGlobal || Type() == ScopeTypeScript ||
       nested_scope_chain_.is_empty()) {
     return context_;
   } else if (nested_scope_chain_.last()->HasContext()) {
     return context_;
   } else {
     return Handle<Context>();
   }
 }
 
+
+void ScopeIterator::GetNonLocals(List<Handle<String> >* list_out) {
+  Handle<String> this_string = isolate_->factory()->this_string();
+  for (HashMap::Entry* entry = non_locals_->Start(); entry != nullptr;
+       entry = non_locals_->Next(entry)) {
+    Handle<String> name(reinterpret_cast<String**>(entry->key));
+    // We need to treat "this" differently.
+    if (name.is_identical_to(this_string)) continue;
+    list_out->Add(Handle<String>(reinterpret_cast<String**>(entry->key)));
+  }
+}
+
+
+bool ScopeIterator::ThisIsNonLocal() {
+  Handle<String> this_string = isolate_->factory()->this_string();
+  void* key = reinterpret_cast<void*>(this_string.location());
+  HashMap::Entry* entry = non_locals_->Lookup(key, this_string->Hash());
+  return entry != nullptr;
+}
+
+
 #ifdef DEBUG
 // Debug print of the content of the current scope.
 void ScopeIterator::DebugPrint() {
   OFStream os(stdout);
   DCHECK(!failed_);
   switch (Type()) {
     case ScopeIterator::ScopeTypeGlobal:
       os << "Global:\n";
       CurrentContext()->Print(os);
       break;
@@ skipping 45 matching lines @@
       break;
 
     default:
       UNREACHABLE();
   }
   PrintF("\n");
 }
 #endif
 
 
-void ScopeIterator::RetrieveScopeChain(Scope* scope,
-                                       Handle<SharedFunctionInfo> shared_info) {
+void ScopeIterator::RetrieveScopeChain(Scope* scope) {
   if (scope != NULL) {
     int source_position = frame_inspector_->GetSourcePosition();
     scope->GetNestedScopeChain(isolate_, &nested_scope_chain_, source_position);
   } else {
     // A failed reparse indicates that the preparser has diverged from the
     // parser or that the preparse data given to the initial parse has been
     // faulty. We fail in debug mode but in release mode we only provide the
     // information we get from the context chain but nothing about
     // completely stack allocated scopes or stack allocated locals.
     // Or it could be due to stack overflow.
     DCHECK(isolate_->has_pending_exception());
     failed_ = true;
   }
 }
 
 
+void ScopeIterator::CollectNonLocals(Scope* scope) {
+  if (scope != NULL) {
+    DCHECK_NULL(non_locals_);
+    non_locals_ = new HashMap(InternalizedStringMatch);
+    scope->CollectNonLocals(non_locals_);
+  }
+}
+
+
 MaybeHandle<JSObject> ScopeIterator::MaterializeScriptScope() {
   Handle<JSGlobalObject> global(CurrentContext()->global_object());
   Handle<ScriptContextTable> script_contexts(
       global->native_context()->script_context_table());
 
   Handle<JSObject> script_scope =
       isolate_->factory()->NewJSObject(isolate_->object_function());
 
   for (int context_index = 0; context_index < script_contexts->used();
        context_index++) {
@@ skipping 367 matching lines @@
         isolate_, value, Object::GetPropertyOrElement(extension, key), false);
     RETURN_ON_EXCEPTION_VALUE(
         isolate_, JSObject::SetOwnPropertyIgnoreAttributes(
             scope_object, key, value, NONE), false);
   }
   return true;
 }
 
 }  // namespace internal
 }  // namespace v8