ReparseStrategy strategy)

: isolate_(isolate),

frame_inspector_(frame_inspector),

function_(frame_inspector_->GetFunction()),

script_(frame_inspector_->GetScript()),

locals_(StringSet::New(isolate)) {

if (!IsContext(*frame_inspector->GetContext())) {

// Optimized frame, context or function cannot be materialized. Give up.

return;

}

context_ = Cast<Context>(frame_inspector->GetContext());

#if V8_ENABLE_WEBASSEMBLY

// We should not instantiate a ScopeIterator for wasm frames.

DCHECK_NE(Script::Type::kWasm, frame_inspector->GetScript()->type());

#endif // V8_ENABLE_WEBASSEMBLY

TryParseAndRetrieveScopes(strategy);

if (!function_.is_null())

return JSFunction::GetDebugName(isolate_, function_);

if (!IsNativeContext(*context_)) {

DisallowGarbageCollection no_gc;

Tagged<ScopeInfo> closure_info = context_->closure_context()->scope_info();

DirectHandle<String> debug_name(closure_info->FunctionDebugName(),

isolate_);

if (debug_name->length() > 0) return debug_name;

}

return isolate_->factory()->undefined_value();

DirectHandle<JSFunction> function)

: isolate_(isolate),

context_(function->context(), isolate),

locals_(StringSet::New(isolate)) {

if (!function->shared()->IsSubjectToDebugging()) {

context_ = Handle<Context>();

return;

}

script_ = handle(Cast<Script>(function->shared()->script()), isolate);

UnwrapEvaluationContext();

Handle<JSGeneratorObject> generator)

: isolate_(isolate),

generator_(generator),

function_(generator->function(), isolate),

context_(generator->context(), isolate),

script_(Cast<Script>(function_->shared()->script()), isolate),

locals_(StringSet::New(isolate)) {

CHECK(function_->shared()->IsSubjectToDebugging());

TryParseAndRetrieveScopes(ReparseStrategy::kFunctionLiteral);

DCHECK_NOT_NULL(frame_inspector_);

function_ = frame_inspector_->GetFunction();

context_ = Cast<Context>(frame_inspector_->GetContext());

current_scope_ = start_scope_;

DCHECK_NOT_NULL(current_scope_);

UnwrapEvaluationContext();

seen_script_scope_ = false;

calculate_blocklists_ = false;

public:

ScopeChainRetriever(DeclarationScope* scope,

DirectHandle<JSFunction> function, int position)

: scope_(scope),

break_scope_start_(function->shared()->StartPosition()),

break_scope_end_(function->shared()->EndPosition()),

break_scope_type_(function->shared()->scope_info()->scope_type()),

position_(position) {

DCHECK_NOT_NULL(scope);

RetrieveScopes();

}

DeclarationScope* ClosureScope() { return closure_scope_; }

Scope* StartScope() { return start_scope_; }

private:

DeclarationScope* scope_;

const int break_scope_start_;

const int break_scope_end_;

const ScopeType break_scope_type_;

const int position_;

DeclarationScope* closure_scope_ = nullptr;

Scope* start_scope_ = nullptr;

void RetrieveScopes() {

// 1. Find the closure scope with a DFS.

RetrieveClosureScope(scope_);

DCHECK_NOT_NULL(closure_scope_);

// 2. Starting from the closure scope search inwards. Given that V8's scope

// tree doesn't guarantee that siblings don't overlap, we look at all

// scopes and pick the one with the tightest bounds around `position_`.

start_scope_ = closure_scope_;

RetrieveStartScope(closure_scope_);

DCHECK_NOT_NULL(start_scope_);

}

bool RetrieveClosureScope(Scope* scope) {

// The closure scope is the scope that matches exactly the function we

// paused in.

// Note that comparing the position alone is not enough and we also need to

// match the scope type. E.g. class member initializer have the exact same

// scope positions as their class scope.

if (break_scope_type_ == scope->scope_type() &&

break_scope_start_ == scope->start_position() &&

break_scope_end_ == scope->end_position()) {

closure_scope_ = scope->AsDeclarationScope();

return true;

}

for (Scope* inner_scope = scope->inner_scope(); inner_scope != nullptr;

inner_scope = inner_scope->sibling()) {

if (RetrieveClosureScope(inner_scope)) return true;

}

return false;

}

void RetrieveStartScope(Scope* scope) {

const int start = scope->start_position();

const int end = scope->end_position();

// Update start_scope_ if scope contains `position_` and scope is a tighter

// fit than the currently set start_scope_.

// Generators have the same source position so we also check for equality.

if (ContainsPosition(scope) && start >= start_scope_->start_position() &&

end <= start_scope_->end_position()) {

start_scope_ = scope;

}

for (Scope* inner_scope = scope->inner_scope(); inner_scope != nullptr;

inner_scope = inner_scope->sibling()) {

RetrieveStartScope(inner_scope);

}

}

bool ContainsPosition(Scope* scope) {

const int start = scope->start_position();

const int end = scope->end_position();

// In case the closure_scope_ hasn't been found yet, we are less strict

// about recursing downwards. This might be the case for nested arrow

// functions that have the same end position.

const bool position_fits_end =

closure_scope_ ? position_ < end : position_ <= end;

// While we're evaluating a class, the calling function will have a class

// context on the stack with a range that starts at Token::kClass, and the

// source position will also point to Token::kClass. To identify the

// matching scope we include start in the accepted range for class scopes.

//

// Similarly "with" scopes can already have bytecodes where the source

// position points to the closing parenthesis with the "with" context

// already pushed.

const bool position_fits_start =

scope->is_class_scope() || scope->is_with_scope() ? start <= position_

: start < position_;

return position_fits_start && position_fits_end;

}

Tagged<ScopeInfo> start_scope) {

Tagged<ScopeInfo> scope = start_scope;

while (scope->scope_type() != ScopeType::EVAL_SCOPE &&

scope->HasOuterScopeInfo()) {

scope = scope->OuterScopeInfo();

}

return scope->scope_type() == ScopeType::EVAL_SCOPE

? MaybeHandle<ScopeInfo>(scope, isolate)

: kNullMaybeHandle;

// Catch the case when the debugger stops in an internal function.

DirectHandle<SharedFunctionInfo> shared_info(function_->shared(), isolate_);

DirectHandle<ScopeInfo> scope_info(shared_info->scope_info(), isolate_);

if (IsUndefined(shared_info->script(), isolate_)) {

current_scope_ = closure_scope_ = nullptr;

context_ = handle(function_->context(), isolate_);

function_ = Handle<JSFunction>();

return;

}

bool ignore_nested_scopes = false;

if (shared_info->HasBreakInfo(isolate_) && frame_inspector_ != nullptr) {

// 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(isolate_), isolate_);

// Find the break point where execution has stopped.

BreakLocation location = BreakLocation::FromFrame(debug_info, GetFrame());

ignore_nested_scopes = location.IsReturn();

}

if (strategy == ReparseStrategy::kScriptIfNeeded) {

Tagged<Object> maybe_block_list =

isolate_->LocalsBlockListCacheGet(scope_info);

calculate_blocklists_ = IsTheHole(maybe_block_list);

strategy = calculate_blocklists_ ? ReparseStrategy::kScriptIfNeeded

: ReparseStrategy::kFunctionLiteral;

}

// Reparse the code and analyze the scopes.

// Depending on the chosen strategy, the whole script or just

// the closure is re-parsed for function scopes.

DirectHandle<Script> script(Cast<Script>(shared_info->script()), isolate_);

// Pick between flags for a single function compilation, or an eager

// compilation of the whole script.

UnoptimizedCompileFlags flags =

(scope_info->scope_type() == FUNCTION_SCOPE &&

strategy == ReparseStrategy::kFunctionLiteral)

? UnoptimizedCompileFlags::ForFunctionCompile(isolate_, *shared_info)

: UnoptimizedCompileFlags::ForScriptCompile(isolate_, *script)

.set_is_eager(true);

flags.set_is_reparse(true);

MaybeDirectHandle<ScopeInfo> maybe_outer_scope;

if (flags.is_toplevel() &&

script->compilation_type() == Script::CompilationType::kEval) {

// Re-parsing a full eval script requires us to correctly set the outer

// language mode and potentially an outer scope info.

//

// We walk the runtime scope chain and look for an EVAL scope. If we don't

// find one, we assume sloppy mode and no outer scope info.

DCHECK(flags.is_eval());

DirectHandle<ScopeInfo> eval_scope;

if (FindEvalScope(isolate_, *scope_info).ToHandle(&eval_scope)) {

flags.set_outer_language_mode(eval_scope->language_mode());

if (eval_scope->HasOuterScopeInfo()) {

maybe_outer_scope =

direct_handle(eval_scope->OuterScopeInfo(), isolate_);

}

} else {

DCHECK_EQ(flags.outer_language_mode(), LanguageMode::kSloppy);

DCHECK(maybe_outer_scope.is_null());

}

} else if (scope_info->scope_type() == EVAL_SCOPE || script->is_wrapped()) {

flags.set_is_eval(true);

if (!IsNativeContext(*context_)) {

maybe_outer_scope = direct_handle(context_->scope_info(), isolate_);

}

// Language mode may be inherited from the eval caller.

// Retrieve it from shared function info.

flags.set_outer_language_mode(shared_info->language_mode());

} else if (scope_info->scope_type() == MODULE_SCOPE) {

DCHECK(script->origin_options().IsModule());

DCHECK(flags.is_module());

} else {

DCHECK(scope_info->is_script_scope() ||

scope_info->scope_type() == FUNCTION_SCOPE);

}

UnoptimizedCompileState compile_state;

reusable_compile_state_ =

std::make_unique<ReusableUnoptimizedCompileState>(isolate_);

info_ = std::make_unique<ParseInfo>(isolate_, flags, &compile_state,

reusable_compile_state_.get());

const bool parse_result =

flags.is_toplevel()

? parsing::ParseProgram(info_.get(), script, maybe_outer_scope,

isolate_, parsing::ReportStatisticsMode::kNo)

: parsing::ParseFunction(info_.get(), shared_info, isolate_,

parsing::ReportStatisticsMode::kNo);

if (parse_result) {

DeclarationScope* literal_scope = info_->literal()->scope();

ScopeChainRetriever scope_chain_retriever(literal_scope, function_,

GetSourcePosition());

start_scope_ = scope_chain_retriever.StartScope();

current_scope_ = start_scope_;

// In case of a FUNCTION_SCOPE, the ScopeIterator expects

// {closure_scope_} to be set to the scope of the function.

closure_scope_ = scope_info->scope_type() == FUNCTION_SCOPE

? scope_chain_retriever.ClosureScope()

: literal_scope;

if (ignore_nested_scopes) {

current_scope_ = closure_scope_;

start_scope_ = current_scope_;

// ignore_nested_scopes is only used for the return-position breakpoint,

// so we can safely assume that the closure context for the current

// function exists if it needs one.

if (closure_scope_->NeedsContext()) {

context_ = handle(context_->closure_context(), isolate_);

}

}

MaybeCollectAndStoreLocalBlocklists();

UnwrapEvaluationContext();

} else {

// A failed reparse indicates that the preparser has diverged from the

// parser, that the preparse data given to the initial parse was faulty, or

// a stack overflow.

// TODO(leszeks): This error is pretty unexpected, so we could report the

// error in debug mode. Better to not fail in release though, in case it's

// just a stack overflow.

// Silently fail by presenting an empty context chain.

context_ = Handle<Context>();

}

if (!context_->IsDebugEvaluateContext()) return;

Tagged<Context> current = *context_;

do {

Tagged<Object> wrapped = current->GetNoCell(Context::WRAPPED_CONTEXT_INDEX);

if (IsContext(wrapped)) {

current = Cast<Context>(wrapped);

} else {

DCHECK(!current->previous().is_null());

current = current->previous();

}

} while (current->IsDebugEvaluateContext());

context_ = handle(current, isolate_);

// Calculate the size of the result.

DirectHandle<FixedArray> details =

isolate_->factory()->NewFixedArray(kScopeDetailsSize);

// Fill in scope details.

details->set(kScopeDetailsTypeIndex, Smi::FromInt(Type()));

DirectHandle<JSObject> scope_object = ScopeObject(Mode::ALL);

details->set(kScopeDetailsObjectIndex, *scope_object);

if (Type() == ScopeTypeGlobal || Type() == ScopeTypeScript) {

return isolate_->factory()->NewJSArrayWithElements(details);

} else if (HasContext()) {

DirectHandle<Object> closure_name = GetFunctionDebugName();

details->set(kScopeDetailsNameIndex, *closure_name);

details->set(kScopeDetailsStartPositionIndex,

Smi::FromInt(start_position()));

details->set(kScopeDetailsEndPositionIndex, Smi::FromInt(end_position()));

if (InInnerScope()) {

details->set(kScopeDetailsFunctionIndex, *function_);

}

}

return isolate_->factory()->NewJSArrayWithElements(details);

if (InInnerScope()) return current_scope_->start_position();

if (IsNativeContext(*context_)) return 0;

return context_->closure_context()->scope_info()->StartPosition();

if (InInnerScope()) return current_scope_->end_position();

if (IsNativeContext(*context_)) return 0;

return context_->closure_context()->scope_info()->EndPosition();

ScopeType type = Type();

if (type == ScopeTypeWith) return mode == Mode::ALL;

if (type == ScopeTypeGlobal) return mode == Mode::ALL;

bool declares_local = false;

auto visitor = [&](DirectHandle<String> name, DirectHandle<Object> value,

ScopeType scope_type) {

declares_local = true;

return true;

};

VisitScope(visitor, mode);

return declares_local;

const bool needs_context = current_scope_->NeedsContext();

// We try very hard to ensure that a function's context is already

// available when we pause right at the beginning of that function.

// This can be tricky when we pause via stack check or via

// `BreakOnNextFunctionCall`, which happens normally in the middle of frame

// construction and we have to "step into" the function first.

//

// We check this by ensuring that the current context is not the closure

// context should the function need one. In that case the function has already

// pushed the context and we are good.

CHECK_IMPLIES(needs_context && current_scope_ == closure_scope_ &&

current_scope_->is_function_scope() && !function_.is_null(),

function_->context() != *context_);

return needs_context;

if (!current_scope_ || !current_scope_->outer_scope()) return false;

current_scope_ = current_scope_->outer_scope();

CollectLocalsFromCurrentScope();

return true;

DCHECK(!IsNativeContext(*context_));

DCHECK(!context_->previous().is_null());

context_ = handle(context_->previous(), isolate_);

// The locals blocklist is always associated with a context. So when we

// move one context up, we also reset the locals_ blocklist.

locals_ = StringSet::New(isolate_);

DCHECK(InInnerScope());

do {

if (NeedsContext()) {

// current_scope_ needs a context so moving one scope up requires us to

// also move up one context.

AdvanceOneContext();

}

CHECK(AdvanceOneScope());

} while (current_scope_->is_hidden());

AdvanceOneContext();

// While advancing one context, we need to advance at least one

// scope, but until we hit the next scope that actually requires

// a context. All the locals collected along the way build the

// blocklist for debug-evaluate for this context.

while (AdvanceOneScope() && !NeedsContext()) {

}

DCHECK(!Done());

ScopeType scope_type = Type();

if (scope_type == ScopeTypeGlobal) {

// The global scope is always the last in the chain.

DCHECK(IsNativeContext(*context_));

context_ = Handle<Context>();

DCHECK(Done());

return;

}

bool leaving_closure = current_scope_ == closure_scope_;

if (scope_type == ScopeTypeScript) {

DCHECK_IMPLIES(InInnerScope() && !leaving_closure,

current_scope_->is_script_scope());

seen_script_scope_ = true;

if (context_->IsScriptContext()) {

context_ = handle(context_->previous(), isolate_);

}

} else if (!InInnerScope()) {

AdvanceContext();

} else {

DCHECK_NOT_NULL(current_scope_);

AdvanceScope();

if (leaving_closure) {

DCHECK(current_scope_ != closure_scope_);

// If the current_scope_ doesn't need a context, we advance the scopes

// and collect the blocklist along the way until we find the scope

// that should match `context_`.

// But only do this if we have complete scope information.

while (!NeedsContext() && AdvanceOneScope()) {

}

}

}

MaybeCollectAndStoreLocalBlocklists();

UnwrapEvaluationContext();

if (leaving_closure) function_ = Handle<JSFunction>();

DCHECK(!Done());

if (InInnerScope()) {

switch (current_scope_->scope_type()) {

case FUNCTION_SCOPE:

DCHECK_IMPLIES(NeedsContext(), context_->IsFunctionContext() ||

context_->IsDebugEvaluateContext());

return ScopeTypeLocal;

case MODULE_SCOPE:

DCHECK_IMPLIES(NeedsContext(), context_->IsModuleContext());

return ScopeTypeModule;

case SCRIPT_SCOPE:

case REPL_MODE_SCOPE:

DCHECK_IMPLIES(NeedsContext(), context_->IsScriptContext() ||

IsNativeContext(*context_));

return ScopeTypeScript;

case WITH_SCOPE:

DCHECK_IMPLIES(NeedsContext(), context_->IsWithContext());

return ScopeTypeWith;

case CATCH_SCOPE:

DCHECK(context_->IsCatchContext());

return ScopeTypeCatch;

case BLOCK_SCOPE:

case CLASS_SCOPE:

DCHECK_IMPLIES(NeedsContext(), context_->IsBlockContext());

return ScopeTypeBlock;

case EVAL_SCOPE:

DCHECK_IMPLIES(NeedsContext(), context_->IsEvalContext());

return ScopeTypeEval;

case SHADOW_REALM_SCOPE:

DCHECK_IMPLIES(NeedsContext(), IsNativeContext(*context_));

// TODO(v8:11989): New ScopeType for ShadowRealms?

return ScopeTypeScript;

}

UNREACHABLE();

}

if (IsNativeContext(*context_)) {

DCHECK(IsJSGlobalObject(context_->global_object()));

// If we are at the native context and have not yet seen script scope,

// fake it.

return seen_script_scope_ ? ScopeTypeGlobal : ScopeTypeScript;

}

if (context_->IsFunctionContext() || context_->IsEvalContext() ||

context_->IsDebugEvaluateContext()) {

return ScopeTypeClosure;

}

if (context_->IsCatchContext()) {

return ScopeTypeCatch;

}

if (context_->IsBlockContext()) {

return ScopeTypeBlock;

}

if (context_->IsModuleContext()) {

return ScopeTypeModule;

}

if (context_->IsScriptContext()) {

return ScopeTypeScript;

}

DCHECK(context_->IsWithContext());

return ScopeTypeWith;

DCHECK(!Done());

ScopeType type = Type();

if (type == ScopeTypeGlobal) {

DCHECK_EQ(Mode::ALL, mode);

return handle(context_->global_proxy(), isolate_);

}

if (type == ScopeTypeWith) {

DCHECK_EQ(Mode::ALL, mode);

return WithContextExtension();

}

Handle<JSObject> scope = isolate_->factory()->NewSlowJSObjectWithNullProto();

auto visitor = [=, this](DirectHandle<String> name,

DirectHandle<Object> value, ScopeType scope_type) {

if (IsOptimizedOut(*value, isolate_)) {

JSObject::SetAccessor(

scope, name, isolate_->factory()->value_unavailable_accessor(), NONE)

.Check();

} else if (IsTheHole(*value, isolate_)) {

const bool is_overriden_repl_let =

scope_type == ScopeTypeScript &&

JSReceiver::HasOwnProperty(isolate_, scope, name).FromMaybe(true);

if (!is_overriden_repl_let) {

// We also use the hole to represent overridden let-declarations via

// REPL mode in a script context. Don't install the unavailable accessor

// in that case.

JSObject::SetAccessor(scope, name,

isolate_->factory()->value_unavailable_accessor(),

NONE)

.Check();

}

} else {

// Overwrite properties. Sometimes names in the same scope can collide,

// e.g. with extension objects introduced via local eval.

Object::SetPropertyOrElement(isolate_, scope, name, value,

Just(ShouldThrow::kDontThrow))

.Check();

}

return false;

};

VisitScope(visitor, mode);

return scope;

switch (Type()) {

case ScopeTypeLocal:

case ScopeTypeClosure:

case ScopeTypeCatch:

case ScopeTypeBlock:

case ScopeTypeEval:

return VisitLocalScope(visitor, mode, Type());

case ScopeTypeModule:

if (InInnerScope()) {

return VisitLocalScope(visitor, mode, Type());

}

DCHECK_EQ(Mode::ALL, mode);

return VisitModuleScope(visitor);

case ScopeTypeScript:

DCHECK_EQ(Mode::ALL, mode);

return VisitScriptScope(visitor);

case ScopeTypeWith:

case ScopeTypeGlobal:

UNREACHABLE();

}

DirectHandle<Object> value) {

DCHECK(!Done());

name = isolate_->factory()->InternalizeString(name);

switch (Type()) {

case ScopeTypeGlobal:

case ScopeTypeWith:

break;

case ScopeTypeEval:

case ScopeTypeBlock:

case ScopeTypeCatch:

case ScopeTypeModule:

if (InInnerScope()) return SetLocalVariableValue(name, value);

if (Type() == ScopeTypeModule && SetModuleVariableValue(name, value)) {

return true;

}

return SetContextVariableValue(name, value);

case ScopeTypeLocal:

case ScopeTypeClosure:

if (InInnerScope()) {

DCHECK_EQ(ScopeTypeLocal, Type());

if (SetLocalVariableValue(name, value)) return true;

// There may not be an associated context since we're InInnerScope().

if (!NeedsContext()) return false;

} else {

DCHECK_EQ(ScopeTypeClosure, Type());

if (SetContextVariableValue(name, value)) return true;

}

// The above functions only set variables statically declared in the

// function. There may be eval-introduced variables. Check them in

// SetContextExtensionValue.

return SetContextExtensionValue(name, value);

case ScopeTypeScript:

return SetScriptVariableValue(name, value);

}

return false;

// closure_scope_ can be nullptr if parsing failed. See the TODO in

// TryParseAndRetrieveScopes.

return closure_scope_ && !closure_scope_->has_this_declaration() &&

closure_scope_->HasThisReference();

DCHECK(IsStringSet(*locals_));

for (Variable* var : *current_scope_->locals()) {

if (var->location() == VariableLocation::PARAMETER ||

var->location() == VariableLocation::LOCAL) {

locals_ = StringSet::Add(isolate_, locals_, var->name());

}

}

StdoutStream os;

DCHECK(!Done());

switch (Type()) {

case ScopeIterator::ScopeTypeGlobal:

os << "Global:\n";

Print(*context_, os);

break;

case ScopeIterator::ScopeTypeLocal: {

os << "Local:\n";

if (NeedsContext()) {

Print(*context_, os);

if (context_->has_extension()) {

DirectHandle<HeapObject> extension(context_->extension(), isolate_);

DCHECK(IsJSContextExtensionObject(*extension));

Print(*extension, os);

}

}

break;

}

case ScopeIterator::ScopeTypeWith:

os << "With:\n";

Print(context_->extension(), os);

break;

case ScopeIterator::ScopeTypeCatch:

os << "Catch:\n";

Print(context_->extension(), os);

Print(context_->GetNoCell(Context::THROWN_OBJECT_INDEX), os);

break;

case ScopeIterator::ScopeTypeClosure:

os << "Closure:\n";

Print(*context_, os);

if (context_->has_extension()) {

DirectHandle<HeapObject> extension(context_->extension(), isolate_);

DCHECK(IsJSContextExtensionObject(*extension));

Print(*extension, os);

}

break;

case ScopeIterator::ScopeTypeScript:

os << "Script:\n";

Print(context_->native_context()->script_context_table(), os);

break;

default:

UNREACHABLE();

}

PrintF("\n");

if (frame_inspector_) {

return frame_inspector_->GetSourcePosition();

} else {

DCHECK(!generator_.is_null());

SharedFunctionInfo::EnsureSourcePositionsAvailable(

isolate_, direct_handle(generator_->function()->shared(), isolate_));

return generator_->source_position();

}

DirectHandle<ScriptContextTable> script_contexts(

context_->native_context()->script_context_table(), isolate_);

// Skip the first script since that just declares 'this'.

for (int i = 1; i < script_contexts->length(kAcquireLoad); i++) {

DirectHandle<Context> context(script_contexts->get(i), isolate_);

DirectHandle<ScopeInfo> scope_info(context->scope_info(), isolate_);

if (VisitContextLocals(visitor, scope_info, context, ScopeTypeScript)) {

return;

}

}

DCHECK(context_->IsModuleContext());

DirectHandle<ScopeInfo> scope_info(context_->scope_info(), isolate_);

if (VisitContextLocals(visitor, scope_info, context_, ScopeTypeModule)) {

return;

}

int module_variable_count = scope_info->ModuleVariableCount();

DirectHandle<SourceTextModule> module(context_->module(), isolate_);

for (int i = 0; i < module_variable_count; ++i) {

int index;

Handle<String> name;

{

Tagged<String> raw_name;

scope_info->ModuleVariable(i, &raw_name, &index);

if (ScopeInfo::VariableIsSynthetic(raw_name)) continue;

name = handle(raw_name, isolate_);

}

Handle<Object> value =

SourceTextModule::LoadVariable(isolate_, module, index);

if (visitor(name, value, ScopeTypeModule)) return;

}

DirectHandle<ScopeInfo> scope_info,

DirectHandle<Context> context,

ScopeType scope_type) const {

// Fill all context locals to the context extension.

for (auto it : ScopeInfo::IterateLocalNames(scope_info)) {

Handle<String> name(it->name(), isolate_);

if (ScopeInfo::VariableIsSynthetic(*name)) continue;

int context_index = scope_info->ContextHeaderLength() + it->index();

Handle<Object> value = indirect_handle(

Context::Get(context, context_index, isolate_), isolate_);

if (visitor(name, value, scope_type)) return true;

}

return false;

ScopeType scope_type) const {

if (mode == Mode::STACK && current_scope_->is_declaration_scope() &&

current_scope_->AsDeclarationScope()->has_this_declaration()) {

// TODO(bmeurer): We should refactor the general variable lookup

// around "this", since the current way is rather hacky when the

// receiver is context-allocated.

auto this_var = current_scope_->AsDeclarationScope()->receiver();

Handle<Object> receiver =

this_var->location() == VariableLocation::CONTEXT

? handle(context_->GetNoCell(this_var->index()), isolate_)

: frame_inspector_ == nullptr ? handle(generator_->receiver(), isolate_)

: frame_inspector_->GetReceiver();

if (visitor(isolate_->factory()->this_string(), receiver, scope_type))

return true;

}

if (current_scope_->is_function_scope()) {

Variable* function_var =

current_scope_->AsDeclarationScope()->function_var();

if (function_var != nullptr) {

Handle<JSFunction> function = frame_inspector_ == nullptr

? function_

: frame_inspector_->GetFunction();

Handle<String> name = function_var->name();

if (visitor(name, function, scope_type)) return true;

}

}

for (Variable* var : *current_scope_->locals()) {

if (ScopeInfo::VariableIsSynthetic(*var->name())) {

// We want to materialize "new.target" for debug-evaluate.

if (mode != Mode::STACK ||

!var->name()->Equals(*isolate_->factory()->dot_new_target_string())) {

continue;

}

}

int index = var->index();

Handle<Object> value;

switch (var->location()) {

case VariableLocation::LOOKUP:

UNREACHABLE();

case VariableLocation::REPL_GLOBAL:

// REPL declared variables are ignored for now.

case VariableLocation::UNALLOCATED:

continue;

case VariableLocation::PARAMETER: {

if (frame_inspector_ == nullptr) {

// Get the variable from the suspended generator.

DCHECK(!generator_.is_null());

Tagged<FixedArray> parameters_and_registers =

generator_->parameters_and_registers();

DCHECK_LT(index, parameters_and_registers->length());

value = handle(parameters_and_registers->get(index), isolate_);

} else if (var->IsReceiver()) {

value = frame_inspector_->GetReceiver();

} else {

value = frame_inspector_->GetParameter(index);

}

break;

}

case VariableLocation::LOCAL:

if (frame_inspector_ == nullptr) {

// Get the variable from the suspended generator.

DCHECK(!generator_.is_null());

Tagged<FixedArray> parameters_and_registers =

generator_->parameters_and_registers();

int parameter_count =

function_->shared()->scope_info()->ParameterCount();

index += parameter_count;

DCHECK_LT(index, parameters_and_registers->length());

value = handle(parameters_and_registers->get(index), isolate_);

} else {

value = frame_inspector_->GetExpression(index);

if (IsOptimizedOut(*value, isolate_)) {

// We'll rematerialize this later.

if (current_scope_->is_declaration_scope() &&

current_scope_->AsDeclarationScope()->arguments() == var) {

continue;

}

} else if (IsLexicalVariableMode(var->mode()) &&

IsUndefined(*value, isolate_) &&

GetSourcePosition() != kNoSourcePosition &&

GetSourcePosition() <= var->initializer_position()) {

// Variables that are `undefined` could also mean an elided hole

// write. We explicitly check the static scope information if we

// are currently stopped before the variable is actually initialized

// which means we are in the middle of that var's TDZ.

value = isolate_->factory()->the_hole_value();

}

}

break;

case VariableLocation::CONTEXT:

if (mode == Mode::STACK) continue;

DCHECK(var->IsContextSlot());

DCHECK_EQ(context_->scope_info()->ContextSlotIndex(*var->name()),

index);

value =

indirect_handle(Context::Get(context_, index, isolate_), isolate_);

break;

case VariableLocation::MODULE: {

if (mode == Mode::STACK) continue;

// if (var->IsExport()) continue;

DirectHandle<SourceTextModule> module(context_->module(), isolate_);

value = SourceTextModule::LoadVariable(isolate_, module, var->index());

break;

}

}

if (visitor(var->name(), value, scope_type)) return true;

}

return false;

DCHECK(context_->IsWithContext());

if (!IsJSObject(context_->extension_receiver())) {

DCHECK(IsJSProxy(context_->extension_receiver()) ||

IsWasmObject(context_->extension_receiver()));

return isolate_->factory()->NewSlowJSObjectWithNullProto();

}

return handle(Cast<JSObject>(context_->extension_receiver()), isolate_);

ScopeType scope_type) const {

if (InInnerScope()) {

if (VisitLocals(visitor, mode, scope_type)) return;

if (mode == Mode::STACK && Type() == ScopeTypeLocal) {

// Hide |this| in arrow functions that may be embedded in other functions