blob: 590e9e9bfe627dc950b7589c1ea7ffa8574767c8 [file] [log] [blame]
// 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 <vector>
#include "src/debug/debug-frames.h"
namespace v8 {
namespace internal {
class JavaScriptFrame;
class ParseInfo;
// Iterate over the actual scopes visible from a stack frame or from a closure.
// The iteration proceeds from the innermost visible nested scope outwards.
// All scopes are backed by an actual context except the local scope,
// which is inserted "artificially" in the context chain.
class ScopeIterator {
enum ScopeType {
ScopeTypeGlobal = 0,
static const int kScopeDetailsTypeIndex = 0;
static const int kScopeDetailsObjectIndex = 1;
static const int kScopeDetailsNameIndex = 2;
static const int kScopeDetailsStartPositionIndex = 3;
static const int kScopeDetailsEndPositionIndex = 4;
static const int kScopeDetailsFunctionIndex = 5;
static const int kScopeDetailsSize = 6;
enum class ReparseStrategy {
ScopeIterator(Isolate* isolate, FrameInspector* frame_inspector,
ReparseStrategy strategy);
ScopeIterator(Isolate* isolate, Handle<JSFunction> function);
ScopeIterator(Isolate* isolate, Handle<JSGeneratorObject> generator);
Handle<JSObject> MaterializeScopeDetails();
// More scopes?
bool Done() const { return context_.is_null(); }
// Move to the next scope.
void Next();
// Restart to the first scope and context.
void Restart();
// Return the type of the current scope.
ScopeType Type() const;
// Indicates which variables should be visited. Either only variables from the
// scope that are available on the stack, or all variables.
enum class Mode { STACK, ALL };
// Return the JavaScript object with the content of the current scope.
Handle<JSObject> ScopeObject(Mode mode);
// Returns whether the current scope declares any variables.
bool DeclaresLocals(Mode mode) const;
// Set variable value and return true on success.
bool SetVariableValue(Handle<String> variable_name, Handle<Object> new_value);
bool ClosureScopeHasThisReference() const;
// Populate the set with collected non-local variable names.
Handle<StringSet> GetLocals() { return locals_; }
// Similar to JSFunction::GetName return the function's name or it's inferred
// name.
Handle<Object> GetFunctionDebugName() const;
Handle<Script> GetScript() const { return script_; }
bool HasPositionInfo();
int start_position();
int end_position();
#ifdef DEBUG
// Debug print of the content of the current scope.
void DebugPrint();
bool InInnerScope() const { return !function_.is_null(); }
bool HasContext() const;
bool NeedsAndHasContext() const;
Handle<Context> CurrentContext() const {
return context_;
Isolate* isolate_;
std::unique_ptr<ParseInfo> info_;
FrameInspector* const frame_inspector_ = nullptr;
Handle<JSGeneratorObject> generator_;
// The currently-executing function from the inspected frame, or null if this
// ScopeIterator has already iterated to any Scope outside that function.
Handle<JSFunction> function_;
Handle<Context> context_;
Handle<Script> script_;
Handle<StringSet> locals_;
DeclarationScope* closure_scope_ = nullptr;
Scope* start_scope_ = nullptr;
Scope* current_scope_ = nullptr;
bool seen_script_scope_ = false;
inline JavaScriptFrame* GetFrame() const {
return frame_inspector_->javascript_frame();
void AdvanceOneScope();
void AdvanceToNonHiddenScope();
void AdvanceContext();
void CollectLocalsFromCurrentScope();
int GetSourcePosition();
void TryParseAndRetrieveScopes(ReparseStrategy strategy);
void UnwrapEvaluationContext();
using Visitor = std::function<bool(Handle<String> name, Handle<Object> value,
ScopeType scope_type)>;
Handle<JSObject> WithContextExtension();
bool SetLocalVariableValue(Handle<String> variable_name,
Handle<Object> new_value);
bool SetContextVariableValue(Handle<String> variable_name,
Handle<Object> new_value);
bool SetContextExtensionValue(Handle<String> variable_name,
Handle<Object> new_value);
bool SetScriptVariableValue(Handle<String> variable_name,
Handle<Object> new_value);
bool SetModuleVariableValue(Handle<String> variable_name,
Handle<Object> new_value);
// Helper functions.
void VisitScope(const Visitor& visitor, Mode mode) const;
void VisitLocalScope(const Visitor& visitor, Mode mode,
ScopeType scope_type) const;
void VisitScriptScope(const Visitor& visitor) const;
void VisitModuleScope(const Visitor& visitor) const;
bool VisitLocals(const Visitor& visitor, Mode mode,
ScopeType scope_type) const;
bool VisitContextLocals(const Visitor& visitor, Handle<ScopeInfo> scope_info,
Handle<Context> context, ScopeType scope_type) const;
} // namespace internal
} // namespace v8