| // Copyright 2022 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| import * as Common from '../../core/common/common.js'; |
| import * as Root from '../../core/root/root.js'; |
| import * as SDK from '../../core/sdk/sdk.js'; |
| import * as Protocol from '../../generated/protocol.js'; |
| import * as Bindings from '../bindings/bindings.js'; |
| import * as Formatter from '../formatter/formatter.js'; |
| import * as TextUtils from '../text_utils/text_utils.js'; |
| |
| interface CachedScopeMap { |
| sourceMap: SDK.SourceMap.SourceMap|undefined; |
| mappingPromise: Promise<{variableMapping: Map<string, string>, thisMapping: string|null}>; |
| } |
| |
| const scopeToCachedIdentifiersMap = new WeakMap<Formatter.FormatterWorkerPool.ScopeTreeNode, CachedScopeMap>(); |
| const cachedMapByCallFrame = new WeakMap<SDK.DebuggerModel.CallFrame, Map<string, string|null>>(); |
| |
| export async function getTextFor(contentProvider: TextUtils.ContentProvider.ContentProvider): |
| Promise<TextUtils.Text.Text|null> { |
| const contentData = await contentProvider.requestContentData(); |
| if (TextUtils.ContentData.ContentData.isError(contentData) || !contentData.isTextContent) { |
| return null; |
| } |
| return contentData.textObj; |
| } |
| |
| export class IdentifierPositions { |
| name: string; |
| positions: Array<{lineNumber: number, columnNumber: number}>; |
| |
| constructor(name: string, positions: Array<{lineNumber: number, columnNumber: number}> = []) { |
| this.name = name; |
| this.positions = positions; |
| } |
| |
| addPosition(lineNumber: number, columnNumber: number): void { |
| this.positions.push({lineNumber, columnNumber}); |
| } |
| } |
| |
| const computeScopeTree = async function(script: SDK.Script.Script): Promise<{ |
| scopeTree: |
| Formatter.FormatterWorkerPool.ScopeTreeNode, text: TextUtils.Text.Text, |
| }|null> { |
| if (!script.sourceMapURL) { |
| return null; |
| } |
| |
| return await SDK.ScopeTreeCache.scopeTreeForScript(script); |
| }; |
| |
| /** |
| * @returns the scope chain from outer-most to inner-most scope where the inner-most |
| * scope either contains or matches the "needle". |
| */ |
| const findScopeChain = function( |
| scopeTree: Formatter.FormatterWorkerPool.ScopeTreeNode, |
| scopeNeedle: {start: number, end: number}): Formatter.FormatterWorkerPool.ScopeTreeNode[] { |
| if (!contains(scopeTree, scopeNeedle)) { |
| return []; |
| } |
| |
| // Find the corresponding scope in the scope tree. |
| let containingScope = scopeTree; |
| const scopeChain = [scopeTree]; |
| while (true) { |
| let childFound = false; |
| for (const child of containingScope.children) { |
| if (contains(child, scopeNeedle)) { |
| // We found a nested containing scope, continue with search there. |
| scopeChain.push(child); |
| containingScope = child; |
| childFound = true; |
| break; |
| } |
| // Sanity check: |scope| should not straddle any of the scopes in the tree. That is: |
| // Either |scope| is disjoint from |child| or |child| must be inside |scope|. |
| // (Or the |scope| is inside |child|, but that case is covered above.) |
| if (!disjoint(scopeNeedle, child) && !contains(scopeNeedle, child)) { |
| console.error('Wrong nesting of scopes'); |
| return []; |
| } |
| } |
| if (!childFound) { |
| // We found the deepest scope in the tree that contains our scope chain entry. |
| break; |
| } |
| } |
| |
| return scopeChain; |
| |
| function contains(scope: {start: number, end: number}, candidate: {start: number, end: number}): boolean { |
| return (scope.start <= candidate.start) && (scope.end >= candidate.end); |
| } |
| function disjoint(scope: {start: number, end: number}, other: {start: number, end: number}): boolean { |
| return (scope.end <= other.start) || (other.end <= scope.start); |
| } |
| }; |
| |
| export async function findScopeChainForDebuggerScope(scope: SDK.DebuggerModel.ScopeChainEntry): |
| Promise<Formatter.FormatterWorkerPool.ScopeTreeNode[]> { |
| const startLocation = scope.range()?.start; |
| const endLocation = scope.range()?.end; |
| if (!startLocation || !endLocation) { |
| return []; |
| } |
| |
| const script = startLocation.script(); |
| if (!script) { |
| return []; |
| } |
| |
| const scopeTreeAndText = await computeScopeTree(script); |
| if (!scopeTreeAndText) { |
| return []; |
| } |
| const {scopeTree, text} = scopeTreeAndText; |
| |
| // Compute the offset within the scope tree coordinate space. |
| const scopeOffsets = { |
| start: text.offsetFromPosition(startLocation.lineNumber, startLocation.columnNumber), |
| end: text.offsetFromPosition(endLocation.lineNumber, endLocation.columnNumber), |
| }; |
| |
| return findScopeChain(scopeTree, scopeOffsets); |
| } |
| |
| export const scopeIdentifiers = async function( |
| script: SDK.Script.Script, scope: Formatter.FormatterWorkerPool.ScopeTreeNode, |
| ancestorScopes: Formatter.FormatterWorkerPool.ScopeTreeNode[]): Promise<{ |
| freeVariables: |
| IdentifierPositions[], boundVariables: IdentifierPositions[], |
| }|null> { |
| const text = await getTextFor(script); |
| if (!text) { |
| return null; |
| } |
| |
| // Now we have containing scope. Collect all the scope variables. |
| const boundVariables = []; |
| const cursor = new TextUtils.TextCursor.TextCursor(text.lineEndings()); |
| for (const variable of scope.variables) { |
| // Skip the fixed-kind variable (i.e., 'this' or 'arguments') if we only found their "definition" |
| // without any uses. |
| if (variable.kind === Formatter.FormatterWorkerPool.DefinitionKind.FIXED && variable.offsets.length <= 1) { |
| continue; |
| } |
| |
| const identifier = new IdentifierPositions(variable.name); |
| for (const offset of variable.offsets) { |
| cursor.resetTo(offset); |
| identifier.addPosition(cursor.lineNumber(), cursor.columnNumber()); |
| } |
| boundVariables.push(identifier); |
| } |
| |
| // Compute free variables by collecting all the ancestor variables that are used in |containingScope|. |
| const freeVariables = []; |
| for (const ancestor of ancestorScopes) { |
| for (const ancestorVariable of ancestor.variables) { |
| let identifier = null; |
| for (const offset of ancestorVariable.offsets) { |
| if (offset >= scope.start && offset < scope.end) { |
| if (!identifier) { |
| identifier = new IdentifierPositions(ancestorVariable.name); |
| } |
| cursor.resetTo(offset); |
| identifier.addPosition(cursor.lineNumber(), cursor.columnNumber()); |
| } |
| } |
| if (identifier) { |
| freeVariables.push(identifier); |
| } |
| } |
| } |
| return {boundVariables, freeVariables}; |
| }; |
| |
| const identifierAndPunctuationRegExp = /^\s*([A-Za-z_$][A-Za-z_$0-9]*)\s*([.;,=]?)\s*$/; |
| |
| const enum Punctuation { |
| NONE = 'none', |
| COMMA = 'comma', |
| DOT = 'dot', |
| SEMICOLON = 'semicolon', |
| EQUALS = 'equals', |
| } |
| |
| const resolveDebuggerScope = async(scope: SDK.DebuggerModel.ScopeChainEntry): |
| Promise<{variableMapping: Map<string, string>, thisMapping: string | null}> => { |
| if (!Common.Settings.Settings.instance().moduleSetting('js-source-maps-enabled').get()) { |
| return {variableMapping: new Map(), thisMapping: null}; |
| } |
| const script = scope.callFrame().script; |
| const scopeChain = await findScopeChainForDebuggerScope(scope); |
| return await resolveScope(script, scopeChain); |
| }; |
| |
| const resolveScope = async(script: SDK.Script.Script, scopeChain: Formatter.FormatterWorkerPool.ScopeTreeNode[]): |
| Promise<{variableMapping: Map<string, string>, thisMapping: string | null}> => { |
| const parsedScope = scopeChain[scopeChain.length - 1]; |
| if (!parsedScope) { |
| return {variableMapping: new Map<string, string>(), thisMapping: null}; |
| } |
| let cachedScopeMap = scopeToCachedIdentifiersMap.get(parsedScope); |
| const sourceMap = script.sourceMap(); |
| |
| if (!cachedScopeMap || cachedScopeMap.sourceMap !== sourceMap) { |
| const identifiersPromise = |
| (async () => { |
| const variableMapping = new Map<string, string>(); |
| let thisMapping = null; |
| |
| if (!sourceMap) { |
| return {variableMapping, thisMapping}; |
| } |
| // Extract as much as possible from SourceMap and resolve |
| // missing identifier names from SourceMap ranges. |
| const promises: Array<Promise<void>> = []; |
| |
| const resolveEntry = (id: IdentifierPositions, handler: (sourceName: string) => void): void => { |
| // First see if we have a source map entry with a name for the identifier. |
| for (const position of id.positions) { |
| const entry = sourceMap.findEntry(position.lineNumber, position.columnNumber); |
| if (entry?.name) { |
| handler(entry.name); |
| return; |
| } |
| } |
| /** If there is no entry with the name field, try to infer the name from the source positions. **/ |
| async function resolvePosition(): Promise<void> { |
| if (!sourceMap) { |
| return; |
| } |
| // Let us find the first non-empty mapping of |id| and return that. Ideally, we would |
| // try to compute all the mappings and only use the mapping if all the non-empty |
| // mappings agree. However, that can be expensive for identifiers with many uses, |
| // so we iterate sequentially, stopping at the first non-empty mapping. |
| for (const position of id.positions) { |
| const sourceName = await resolveSourceName(script, sourceMap, id.name, position); |
| if (sourceName) { |
| handler(sourceName); |
| return; |
| } |
| } |
| } |
| promises.push(resolvePosition()); |
| }; |
| |
| const parsedVariables = await scopeIdentifiers(script, parsedScope, scopeChain.slice(0, -1)); |
| if (!parsedVariables) { |
| return {variableMapping, thisMapping}; |
| } |
| for (const id of parsedVariables.boundVariables) { |
| resolveEntry(id, sourceName => { |
| // Let use ignore 'this' mappings - those are handled separately. |
| if (sourceName !== 'this') { |
| variableMapping.set(id.name, sourceName); |
| } |
| }); |
| } |
| for (const id of parsedVariables.freeVariables) { |
| resolveEntry(id, sourceName => { |
| if (sourceName === 'this') { |
| thisMapping = id.name; |
| } |
| }); |
| } |
| await Promise.all(promises).then(getScopeResolvedForTest()); |
| return {variableMapping, thisMapping}; |
| })(); |
| cachedScopeMap = {sourceMap, mappingPromise: identifiersPromise}; |
| scopeToCachedIdentifiersMap.set(parsedScope, {sourceMap, mappingPromise: identifiersPromise}); |
| } |
| return await cachedScopeMap.mappingPromise; |
| |
| async function resolveSourceName( |
| script: SDK.Script.Script, sourceMap: SDK.SourceMap.SourceMap, name: string, |
| position: {lineNumber: number, columnNumber: number}): Promise<string|null> { |
| const ranges = sourceMap.findEntryRanges(position.lineNumber, position.columnNumber); |
| if (!ranges) { |
| return null; |
| } |
| // Extract the underlying text from the compiled code's range and make sure that |
| // it starts with the identifier |name|. |
| const uiSourceCode = |
| Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance().uiSourceCodeForSourceMapSourceURL( |
| script.debuggerModel, ranges.sourceURL, script.isContentScript()); |
| if (!uiSourceCode) { |
| return null; |
| } |
| const compiledText = await getTextFor(script); |
| if (!compiledText) { |
| return null; |
| } |
| const compiledToken = compiledText.extract(ranges.range); |
| const parsedCompiledToken = extractIdentifier(compiledToken); |
| if (!parsedCompiledToken) { |
| return null; |
| } |
| const {name: compiledName, punctuation: compiledPunctuation} = parsedCompiledToken; |
| if (compiledName !== name) { |
| return null; |
| } |
| |
| // Extract the mapped name from the source code range and ensure that the punctuation |
| // matches the one from the compiled code. |
| const sourceText = await getTextFor(uiSourceCode); |
| if (!sourceText) { |
| return null; |
| } |
| const sourceToken = sourceText.extract(ranges.sourceRange); |
| const parsedSourceToken = extractIdentifier(sourceToken); |
| if (!parsedSourceToken) { |
| return null; |
| } |
| const {name: sourceName, punctuation: sourcePunctuation} = parsedSourceToken; |
| // Accept the source name if it is followed by the same punctuation. |
| if (compiledPunctuation === sourcePunctuation) { |
| return sourceName; |
| } |
| // Let us also allow semicolons into commas since that it is a common transformation. |
| if (compiledPunctuation === Punctuation.COMMA && sourcePunctuation === Punctuation.SEMICOLON) { |
| return sourceName; |
| } |
| |
| return null; |
| |
| function extractIdentifier(token: string): {name: string, punctuation: Punctuation}|null { |
| const match = token.match(identifierAndPunctuationRegExp); |
| if (!match) { |
| return null; |
| } |
| |
| const name = match[1]; |
| let punctuation: Punctuation|null = null; |
| switch (match[2]) { |
| case '.': |
| punctuation = Punctuation.DOT; |
| break; |
| case ',': |
| punctuation = Punctuation.COMMA; |
| break; |
| case ';': |
| punctuation = Punctuation.SEMICOLON; |
| break; |
| case '=': |
| punctuation = Punctuation.EQUALS; |
| break; |
| case '': |
| punctuation = Punctuation.NONE; |
| break; |
| default: |
| console.error(`Name token parsing error: unexpected token "${match[2]}"`); |
| return null; |
| } |
| |
| return {name, punctuation}; |
| } |
| } |
| }; |
| |
| export const resolveScopeChain = |
| async function(callFrame: SDK.DebuggerModel.CallFrame): Promise<SDK.DebuggerModel.ScopeChainEntry[]> { |
| const {pluginManager} = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance(); |
| let scopeChain: SDK.DebuggerModel.ScopeChainEntry[]|null|undefined = await pluginManager.resolveScopeChain(callFrame); |
| if (scopeChain) { |
| return scopeChain; |
| } |
| |
| scopeChain = Root.Runtime.experiments.isEnabled(Root.Runtime.ExperimentName.USE_SOURCE_MAP_SCOPES) ? |
| callFrame.script.sourceMap()?.resolveScopeChain(callFrame) : |
| null; |
| if (scopeChain) { |
| return scopeChain; |
| } |
| |
| if (callFrame.script.isWasm()) { |
| return callFrame.scopeChain(); |
| } |
| const thisObject = await resolveThisObject(callFrame); |
| return callFrame.scopeChain().map(scope => new ScopeWithSourceMappedVariables(scope, thisObject)); |
| }; |
| |
| /** |
| * @returns A mapping from original name -> compiled name. If the orignal name is unavailable (e.g. because the compiled name was |
| * shadowed) we set it to `null`. |
| */ |
| export const allVariablesInCallFrame = |
| async(callFrame: SDK.DebuggerModel.CallFrame): Promise<Map<string, string|null>> => { |
| if (!Common.Settings.Settings.instance().moduleSetting('js-source-maps-enabled').get()) { |
| return new Map<string, string|null>(); |
| } |
| const cachedMap = cachedMapByCallFrame.get(callFrame); |
| if (cachedMap) { |
| return cachedMap; |
| } |
| |
| const scopeChain = callFrame.scopeChain(); |
| const nameMappings = await Promise.all(scopeChain.map(resolveDebuggerScope)); |
| const reverseMapping = new Map<string, string|null>(); |
| const compiledNames = new Set<string>(); |
| for (const {variableMapping} of nameMappings) { |
| for (const [compiledName, originalName] of variableMapping) { |
| if (!originalName) { |
| continue; |
| } |
| if (!reverseMapping.has(originalName)) { |
| // An inner scope might have shadowed {compiledName}. Mark it as "unavailable" in that case. |
| const compiledNameOrNull = compiledNames.has(compiledName) ? null : compiledName; |
| reverseMapping.set(originalName, compiledNameOrNull); |
| } |
| compiledNames.add(compiledName); |
| } |
| } |
| cachedMapByCallFrame.set(callFrame, reverseMapping); |
| return reverseMapping; |
| }; |
| |
| /** |
| * @returns A mapping from original name -> compiled name. If the orignal name is unavailable (e.g. because the compiled name was |
| * shadowed) we set it to `null`. |
| */ |
| export const allVariablesAtPosition = |
| async(location: SDK.DebuggerModel.Location): Promise<Map<string, string|null>> => { |
| const reverseMapping = new Map<string, string|null>(); |
| if (!Common.Settings.Settings.instance().moduleSetting('js-source-maps-enabled').get()) { |
| return reverseMapping; |
| } |
| const script = location.script(); |
| if (!script) { |
| return reverseMapping; |
| } |
| |
| const scopeTreeAndText = await computeScopeTree(script); |
| if (!scopeTreeAndText) { |
| return reverseMapping; |
| } |
| |
| const {scopeTree, text} = scopeTreeAndText; |
| const locationOffset = text.offsetFromPosition(location.lineNumber, location.columnNumber); |
| const scopeChain = findScopeChain(scopeTree, {start: locationOffset, end: locationOffset}); |
| const compiledNames = new Set<string>(); |
| |
| while (scopeChain.length > 0) { |
| const {variableMapping} = await resolveScope(script, scopeChain); |
| for (const [compiledName, originalName] of variableMapping) { |
| if (!originalName) { |
| continue; |
| } |
| if (!reverseMapping.has(originalName)) { |
| // An inner scope might have shadowed {compiledName}. Mark it as "unavailable" in that case. |
| const compiledNameOrNull = compiledNames.has(compiledName) ? null : compiledName; |
| reverseMapping.set(originalName, compiledNameOrNull); |
| } |
| compiledNames.add(compiledName); |
| } |
| scopeChain.pop(); |
| } |
| return reverseMapping; |
| }; |
| |
| export const resolveThisObject = |
| async(callFrame: SDK.DebuggerModel.CallFrame): Promise<SDK.RemoteObject.RemoteObject|null> => { |
| const scopeChain = callFrame.scopeChain(); |
| if (scopeChain.length === 0) { |
| return callFrame.thisObject(); |
| } |
| |
| const {thisMapping} = await resolveDebuggerScope(scopeChain[0]); |
| if (!thisMapping) { |
| return callFrame.thisObject(); |
| } |
| |
| const result = await callFrame.evaluate(({ |
| expression: thisMapping, |
| objectGroup: 'backtrace', |
| includeCommandLineAPI: false, |
| silent: true, |
| returnByValue: false, |
| generatePreview: true, |
| })); |
| if ('exceptionDetails' in result) { |
| return !result.exceptionDetails && result.object ? result.object : callFrame.thisObject(); |
| } |
| return null; |
| }; |
| |
| export const resolveScopeInObject = function(scope: SDK.DebuggerModel.ScopeChainEntry): SDK.RemoteObject.RemoteObject { |
| const endLocation = scope.range()?.end; |
| const startLocationScript = scope.range()?.start.script() ?? null; |
| |
| if (scope.type() === Protocol.Debugger.ScopeType.Global || !startLocationScript || !endLocation || |
| !startLocationScript.sourceMapURL) { |
| return scope.object(); |
| } |
| |
| return new RemoteObject(scope); |
| }; |
| |
| /** |
| * Wraps a debugger `Scope` but returns a scope object where variable names are |
| * mapped to their authored name. |
| * |
| * This implementation does not utilize source map "Scopes" information but obtains |
| * original variable names via parsing + mappings + names. |
| */ |
| class ScopeWithSourceMappedVariables implements SDK.DebuggerModel.ScopeChainEntry { |
| readonly #debuggerScope: SDK.DebuggerModel.ScopeChainEntry; |
| /** The resolved `this` of the current call frame */ |
| readonly #thisObject: SDK.RemoteObject.RemoteObject|null; |
| |
| constructor(scope: SDK.DebuggerModel.ScopeChainEntry, thisObject: SDK.RemoteObject.RemoteObject|null) { |
| this.#debuggerScope = scope; |
| this.#thisObject = thisObject; |
| } |
| |
| callFrame(): SDK.DebuggerModel.CallFrame { |
| return this.#debuggerScope.callFrame(); |
| } |
| |
| type(): string { |
| return this.#debuggerScope.type(); |
| } |
| |
| typeName(): string { |
| return this.#debuggerScope.typeName(); |
| } |
| |
| name(): string|undefined { |
| return this.#debuggerScope.name(); |
| } |
| |
| range(): SDK.DebuggerModel.LocationRange|null { |
| return this.#debuggerScope.range(); |
| } |
| |
| object(): SDK.RemoteObject.RemoteObject { |
| return resolveScopeInObject(this.#debuggerScope); |
| } |
| |
| description(): string { |
| return this.#debuggerScope.description(); |
| } |
| |
| icon(): string|undefined { |
| return this.#debuggerScope.icon(); |
| } |
| |
| extraProperties(): SDK.RemoteObject.RemoteObjectProperty[] { |
| const extraProperties = this.#debuggerScope.extraProperties(); |
| if (this.#thisObject && this.type() === Protocol.Debugger.ScopeType.Local) { |
| extraProperties.unshift(new SDK.RemoteObject.RemoteObjectProperty( |
| 'this', this.#thisObject, undefined, undefined, undefined, undefined, undefined, /* synthetic */ true)); |
| } |
| return extraProperties; |
| } |
| } |
| |
| export class RemoteObject extends SDK.RemoteObject.RemoteObject { |
| private readonly scope: SDK.DebuggerModel.ScopeChainEntry; |
| private readonly object: SDK.RemoteObject.RemoteObject; |
| constructor(scope: SDK.DebuggerModel.ScopeChainEntry) { |
| super(); |
| this.scope = scope; |
| this.object = scope.object(); |
| } |
| |
| override customPreview(): Protocol.Runtime.CustomPreview|null { |
| return this.object.customPreview(); |
| } |
| |
| override get objectId(): Protocol.Runtime.RemoteObjectId|undefined { |
| return this.object.objectId; |
| } |
| |
| override get type(): string { |
| return this.object.type; |
| } |
| |
| override get subtype(): string|undefined { |
| return this.object.subtype; |
| } |
| |
| override get value(): typeof this.object.value { |
| return this.object.value; |
| } |
| |
| override get description(): string|undefined { |
| return this.object.description; |
| } |
| |
| override get hasChildren(): boolean { |
| return this.object.hasChildren; |
| } |
| |
| override get preview(): Protocol.Runtime.ObjectPreview|undefined { |
| return this.object.preview; |
| } |
| |
| override arrayLength(): number { |
| return this.object.arrayLength(); |
| } |
| |
| override getOwnProperties(generatePreview: boolean): Promise<SDK.RemoteObject.GetPropertiesResult> { |
| return this.object.getOwnProperties(generatePreview); |
| } |
| |
| override async getAllProperties(accessorPropertiesOnly: boolean, generatePreview: boolean): |
| Promise<SDK.RemoteObject.GetPropertiesResult> { |
| const allProperties = await this.object.getAllProperties(accessorPropertiesOnly, generatePreview); |
| const {variableMapping} = await resolveDebuggerScope(this.scope); |
| |
| const properties = allProperties.properties; |
| const internalProperties = allProperties.internalProperties; |
| const newProperties = properties?.map(property => { |
| const name = variableMapping.get(property.name); |
| return name !== undefined ? property.cloneWithNewName(name) : property; |
| }); |
| return {properties: newProperties ?? [], internalProperties}; |
| } |
| |
| override async setPropertyValue(argumentName: string|Protocol.Runtime.CallArgument, value: string): |
| Promise<string|undefined> { |
| const {variableMapping} = await resolveDebuggerScope(this.scope); |
| |
| let name; |
| if (typeof argumentName === 'string') { |
| name = argumentName; |
| } else { |
| name = (argumentName.value as string); |
| } |
| |
| let actualName: string = name; |
| for (const compiledName of variableMapping.keys()) { |
| if (variableMapping.get(compiledName) === name) { |
| actualName = compiledName; |
| break; |
| } |
| } |
| return await this.object.setPropertyValue(actualName, value); |
| } |
| |
| override async deleteProperty(name: Protocol.Runtime.CallArgument): Promise<string|undefined> { |
| return await this.object.deleteProperty(name); |
| } |
| |
| override callFunction<T, U>( |
| functionDeclaration: (this: U, ...args: any[]) => T, |
| args?: Protocol.Runtime.CallArgument[]): Promise<SDK.RemoteObject.CallFunctionResult> { |
| return this.object.callFunction(functionDeclaration, args); |
| } |
| |
| override callFunctionJSON<T, U>( |
| functionDeclaration: (this: U, ...args: any[]) => T, args?: Protocol.Runtime.CallArgument[]): Promise<T|null> { |
| return this.object.callFunctionJSON(functionDeclaration, args); |
| } |
| |
| override release(): void { |
| this.object.release(); |
| } |
| |
| override debuggerModel(): SDK.DebuggerModel.DebuggerModel { |
| return this.object.debuggerModel(); |
| } |
| |
| override runtimeModel(): SDK.RuntimeModel.RuntimeModel { |
| return this.object.runtimeModel(); |
| } |
| |
| override isNode(): boolean { |
| return this.object.isNode(); |
| } |
| } |
| |
| /** |
| * Resolve the frame's function name using the name associated with the opening |
| * paren that starts the scope. If there is no name associated with the scope |
| * start or if the function scope does not start with a left paren (e.g., arrow |
| * function with one parameter), the resolution returns null. |
| **/ |
| async function getFunctionNameFromScopeStart( |
| script: SDK.Script.Script, lineNumber: number, columnNumber: number): Promise<string|null> { |
| // To reduce the overhead of resolving function names, |
| // we check for source maps first and immediately leave |
| // this function if the script doesn't have a sourcemap. |
| const sourceMap = script.sourceMap(); |
| if (!sourceMap) { |
| return null; |
| } |
| |
| const scopeName = sourceMap.findOriginalFunctionName({line: lineNumber, column: columnNumber}); |
| if (scopeName !== null) { |
| return scopeName; |
| } |
| |
| const mappingEntry = sourceMap.findEntry(lineNumber, columnNumber); |
| if (!mappingEntry?.sourceURL) { |
| return null; |
| } |
| |
| const name = mappingEntry.name; |
| if (!name) { |
| return null; |
| } |
| |
| const text = await getTextFor(script); |
| if (!text) { |
| return null; |
| } |
| |
| const openRange = new TextUtils.TextRange.TextRange(lineNumber, columnNumber, lineNumber, columnNumber + 1); |
| |
| if (text.extract(openRange) !== '(') { |
| return null; |
| } |
| |
| return name; |
| } |
| |
| export async function resolveDebuggerFrameFunctionName(frame: SDK.DebuggerModel.CallFrame): Promise<string|null> { |
| const startLocation = frame.localScope()?.range()?.start; |
| if (!startLocation) { |
| return null; |
| } |
| return await getFunctionNameFromScopeStart(frame.script, startLocation.lineNumber, startLocation.columnNumber); |
| } |
| |
| export async function resolveProfileFrameFunctionName( |
| {scriptId, lineNumber, columnNumber}: Partial<Protocol.Runtime.CallFrame>, |
| target: SDK.Target.Target|null): Promise<string|null> { |
| if (!target || lineNumber === undefined || columnNumber === undefined || scriptId === undefined) { |
| return null; |
| } |
| const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel); |
| const script = debuggerModel?.scriptForId(String(scriptId)); |
| |
| if (!debuggerModel || !script) { |
| return null; |
| } |
| |
| const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance(); |
| const location = new SDK.DebuggerModel.Location(debuggerModel, scriptId, lineNumber, columnNumber); |
| const functionInfoFromPlugin = await debuggerWorkspaceBinding.pluginManager.getFunctionInfo(script, location); |
| if (functionInfoFromPlugin && 'frames' in functionInfoFromPlugin) { |
| const last = functionInfoFromPlugin.frames.at(-1); |
| if (last?.name) { |
| return last.name; |
| } |
| } |
| return await getFunctionNameFromScopeStart(script, lineNumber, columnNumber); |
| } |
| |
| let scopeResolvedForTest: (...arg0: unknown[]) => void = function(): void {}; |
| |
| export const getScopeResolvedForTest = (): (...arg0: unknown[]) => void => { |
| return scopeResolvedForTest; |
| }; |
| |
| export const setScopeResolvedForTest = (scope: (...arg0: unknown[]) => void): void => { |
| scopeResolvedForTest = scope; |
| }; |
