diff options
3 files changed, 729 insertions, 29 deletions
diff --git a/third_party/WebKit/Source/devtools/scripts/compile_frontend.py b/third_party/WebKit/Source/devtools/scripts/compile_frontend.py index fa792f0..b95dee3 100755 --- a/third_party/WebKit/Source/devtools/scripts/compile_frontend.py +++ b/third_party/WebKit/Source/devtools/scripts/compile_frontend.py @@ -78,6 +78,8 @@ global_externs_file = to_platform_path(path.join(devtools_frontend_path, 'extern protocol_externs_file = path.join(devtools_frontend_path, 'protocol_externs.js') injected_script_source_name = path.join(v8_inspector_path, 'InjectedScriptSource.js') injected_script_externs_file = path.join(v8_inspector_path, 'injected_script_externs.js') +debugger_script_source_name = path.join(v8_inspector_path, 'DebuggerScript.js') +debugger_script_externs_file = path.join(v8_inspector_path, 'debugger_script_externs.js') jsmodule_name_prefix = 'jsmodule_' runtime_module_name = '_runtime' @@ -403,6 +405,16 @@ command = spawned_compiler_command + [ injectedScriptCompileProc = popen(command) +print 'Compiling DebuggerScript.js...' + +command = spawned_compiler_command + [ + '--externs', to_platform_path_exact(debugger_script_externs_file), + '--module', jsmodule_name_prefix + 'debugger_script' + ':1', + '--js', to_platform_path(debugger_script_source_name) +] + +debuggerScriptCompileProc = popen(command) + print 'Compiling devtools.js...' command = spawned_compiler_command + [ @@ -492,6 +504,10 @@ if error_count: print 'InjectedScriptSource.js compilation output:%s' % os.linesep, injectedScriptCompileOut errors_found |= hasErrors(injectedScriptCompileOut) +(debuggerScriptCompilerOut, _) = debuggerScriptCompileProc.communicate() +print 'DebuggerScript.js compilation output:%s' % os.linesep, debuggerScriptCompilerOut +errors_found |= hasErrors(debuggerScriptCompilerOut) + (devtoolsJSCompileOut, _) = devtoolsJSCompileProc.communicate() print 'devtools.js compilation output:%s' % os.linesep, devtoolsJSCompileOut errors_found |= hasErrors(devtoolsJSCompileOut) diff --git a/third_party/WebKit/Source/platform/v8_inspector/DebuggerScript.js b/third_party/WebKit/Source/platform/v8_inspector/DebuggerScript.js index 7d8c166..c4992db 100644 --- a/third_party/WebKit/Source/platform/v8_inspector/DebuggerScript.js +++ b/third_party/WebKit/Source/platform/v8_inspector/DebuggerScript.js @@ -33,6 +33,7 @@ var DebuggerScript = {}; +/** @enum */ DebuggerScript.PauseOnExceptionsState = { DontPauseOnExceptions: 0, PauseOnAllExceptions: 1, @@ -43,36 +44,45 @@ DebuggerScript._pauseOnExceptionsState = DebuggerScript.PauseOnExceptionsState.D Debug.clearBreakOnException(); Debug.clearBreakOnUncaughtException(); +/** + * @param {!CompileEvent} eventData + */ DebuggerScript.getAfterCompileScript = function(eventData) { - return DebuggerScript._formatScript(eventData.script_.script_); + return DebuggerScript._formatScript(eventData.script().value()); } -DebuggerScript._scopeTypeNames = { __proto__: null }; -DebuggerScript._scopeTypeNames[ScopeType.Global] = "global"; -DebuggerScript._scopeTypeNames[ScopeType.Local] = "local"; -DebuggerScript._scopeTypeNames[ScopeType.With] = "with"; -DebuggerScript._scopeTypeNames[ScopeType.Closure] = "closure"; -DebuggerScript._scopeTypeNames[ScopeType.Catch] = "catch"; -DebuggerScript._scopeTypeNames[ScopeType.Block] = "block"; -DebuggerScript._scopeTypeNames[ScopeType.Script] = "script"; - +/** @type {!Map<!ScopeType, string>} */ +DebuggerScript._scopeTypeNames = new Map(); +DebuggerScript._scopeTypeNames.set(ScopeType.Global, "global"); +DebuggerScript._scopeTypeNames.set(ScopeType.Local, "local"); +DebuggerScript._scopeTypeNames.set(ScopeType.With, "with"); +DebuggerScript._scopeTypeNames.set(ScopeType.Closure, "closure"); +DebuggerScript._scopeTypeNames.set(ScopeType.Catch, "catch"); +DebuggerScript._scopeTypeNames.set(ScopeType.Block, "block"); +DebuggerScript._scopeTypeNames.set(ScopeType.Script, "script"); + +/** + * @param {function()} fun + * @return {?Array<!Scope>} + */ DebuggerScript.getFunctionScopes = function(fun) { var mirror = MakeMirror(fun); if (!mirror.isFunction()) return null; - var count = mirror.scopeCount(); + var functionMirror = /** @type {!FunctionMirror} */(mirror); + var count = functionMirror.scopeCount(); if (count == 0) return null; var result = []; for (var i = 0; i < count; i++) { - var scopeDetails = mirror.scope(i).details(); + var scopeDetails = functionMirror.scope(i).details(); var scopeObject = DebuggerScript._buildScopeObject(scopeDetails.type(), scopeDetails.object()); if (!scopeObject) continue; result.push({ - type: DebuggerScript._scopeTypeNames[scopeDetails.type()], + type: /** @type {string} */(DebuggerScript._scopeTypeNames.get(scopeDetails.type())), object: scopeObject, name: scopeDetails.name() || "" }); @@ -80,21 +90,26 @@ DebuggerScript.getFunctionScopes = function(fun) return result; } +/** + * @param {Object} object + * @return {?GeneratorObjectDetails} + */ DebuggerScript.getGeneratorObjectDetails = function(object) { var mirror = MakeMirror(object, true /* transient */); if (!mirror.isGenerator()) return null; - var funcMirror = mirror.func(); + var generatorMirror = /** @type {!GeneratorMirror} */(mirror); + var funcMirror = generatorMirror.func(); if (!funcMirror.resolved()) return null; var result = { "function": funcMirror.value(), "functionName": funcMirror.debugName(), - "status": mirror.status() + "status": generatorMirror.status() }; var script = funcMirror.script(); - var location = mirror.sourceLocation() || funcMirror.sourceLocation(); + var location = generatorMirror.sourceLocation() || funcMirror.sourceLocation(); if (script && location) { result["location"] = { "scriptId": String(script.id()), @@ -105,20 +120,28 @@ DebuggerScript.getGeneratorObjectDetails = function(object) return result; } +/** + * @param {Object} object + * @return {!Array<!{value: *}>|undefined} + */ DebuggerScript.getCollectionEntries = function(object) { var mirror = MakeMirror(object, true /* transient */); if (mirror.isMap()) - return mirror.entries(); + return /** @type {!MapMirror} */(mirror).entries(); if (mirror.isSet() || mirror.isIterator()) { var result = []; - var values = mirror.isSet() ? mirror.values() : mirror.preview(); + var values = mirror.isSet() ? /** @type {!SetMirror} */(mirror).values() : /** @type {!IteratorMirror} */(mirror).preview(); for (var i = 0; i < values.length; ++i) result.push({ value: values[i] }); return result; } } +/** + * @param {string} contextGroupId + * @return {!Array<!FormattedScript>} + */ DebuggerScript.getScripts = function(contextGroupId) { var result = []; @@ -141,6 +164,10 @@ DebuggerScript.getScripts = function(contextGroupId) return result; } +/** + * @param {!Script} script + * @return {!FormattedScript} + */ DebuggerScript._formatScript = function(script) { var lineEnds = script.line_ends; @@ -192,6 +219,11 @@ DebuggerScript._formatScript = function(script) }; } +/** + * @param {!ExecutionState} execState + * @param {!BreakpointInfo} info + * @return {string|undefined} + */ DebuggerScript.setBreakpoint = function(execState, info) { var positionAlignment = info.interstatementLocation ? Debug.BreakPositionAlignment.BreakPosition : Debug.BreakPositionAlignment.Statement; @@ -205,16 +237,26 @@ DebuggerScript.setBreakpoint = function(execState, info) return breakId.toString(); } +/** + * @param {!ExecutionState} execState + * @param {!{breakpointId: number}} info + */ DebuggerScript.removeBreakpoint = function(execState, info) { Debug.findBreakPoint(info.breakpointId, true); } +/** + * @return {number} + */ DebuggerScript.pauseOnExceptionsState = function() { return DebuggerScript._pauseOnExceptionsState; } +/** + * @param {number} newState + */ DebuggerScript.setPauseOnExceptionsState = function(newState) { DebuggerScript._pauseOnExceptionsState = newState; @@ -230,11 +272,19 @@ DebuggerScript.setPauseOnExceptionsState = function(newState) Debug.clearBreakOnUncaughtException(); } +/** + * @param {!ExecutionState} execState + * @return {number} + */ DebuggerScript.frameCount = function(execState) { return execState.frameCount(); } +/** + * @param {!ExecutionState} execState + * @return {!JavaScriptCallFrame|undefined} + */ DebuggerScript.currentCallFrame = function(execState) { var frameCount = execState.frameCount(); @@ -246,6 +296,11 @@ DebuggerScript.currentCallFrame = function(execState) return topFrame; } +/** + * @param {!ExecutionState} execState + * @param {number} index + * @return {!JavaScriptCallFrame|undefined} + */ DebuggerScript.currentCallFrameByIndex = function(execState, index) { if (index < 0) @@ -256,21 +311,33 @@ DebuggerScript.currentCallFrameByIndex = function(execState, index) return DebuggerScript._frameMirrorToJSCallFrame(execState.frame(index), undefined); } +/** + * @param {!ExecutionState} execState + */ DebuggerScript.stepIntoStatement = function(execState) { execState.prepareStep(Debug.StepAction.StepIn); } +/** + * @param {!ExecutionState} execState + */ DebuggerScript.stepFrameStatement = function(execState) { execState.prepareStep(Debug.StepAction.StepFrame); } +/** + * @param {!ExecutionState} execState + */ DebuggerScript.stepOverStatement = function(execState) { execState.prepareStep(Debug.StepAction.StepNext); } +/** + * @param {!ExecutionState} execState + */ DebuggerScript.stepOutOfFunction = function(execState) { execState.prepareStep(Debug.StepAction.StepOut); @@ -285,6 +352,12 @@ DebuggerScript.clearStepping = function() // [ 0, <v8_result_report> ] in case of success // or [ 1, <general_error_message>, <compiler_message>, <line_number>, <column_number> ] in case of compile error, numbers are 1-based. // or throws exception with message. +/** + * @param {number} scriptId + * @param {string} newSource + * @param {boolean} preview + * @return {!Array<*>} + */ DebuggerScript.liveEditScriptSource = function(scriptId, newSource, preview) { var scripts = Debug.scripts(); @@ -304,7 +377,7 @@ DebuggerScript.liveEditScriptSource = function(scriptId, newSource, preview) return [0, result.stack_modified]; } catch (e) { if (e instanceof Debug.LiveEdit.Failure && "details" in e) { - var details = e.details; + var details = /** @type {!LiveEditErrorDetails} */(e.details); if (details.type === "liveedit_compile_error") { var startPosition = details.position.start; return [1, String(e), String(details.syntaxErrorMessage), Number(startPosition.line), Number(startPosition.column)]; @@ -314,16 +387,26 @@ DebuggerScript.liveEditScriptSource = function(scriptId, newSource, preview) } } -DebuggerScript.clearBreakpoints = function(execState, info) +/** + * @param {!ExecutionState} execState + */ +DebuggerScript.clearBreakpoints = function(execState) { Debug.clearAllBreakPoints(); } +/** + * @param {!ExecutionState} execState + * @param {!{enabled: boolean}} info + */ DebuggerScript.setBreakpointsActivated = function(execState, info) { Debug.debuggerFlags().breakPointsActive.setValue(info.enabled); } +/** + * @param {!BreakEvent} eventData + */ DebuggerScript.getBreakpointNumbers = function(eventData) { var breakpoints = eventData.breakPointsHit(); @@ -342,6 +425,11 @@ DebuggerScript.getBreakpointNumbers = function(eventData) // NOTE: This function is performance critical, as it can be run on every // statement that generates an async event (like addEventListener) to support // asynchronous call stacks. Thus, when possible, initialize the data lazily. +/** + * @param {!FrameMirror} frameMirror + * @param {!JavaScriptCallFrame|undefined} callerFrame + * @return {!JavaScriptCallFrame} + */ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) { // Stuff that can not be initialized lazily (i.e. valid while paused with a valid break_id). @@ -356,11 +444,17 @@ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) var returnValue = isAtReturn ? frameDetails.returnValue() : undefined; var scopeMirrors = frameMirror.allScopes(false); + /** @type {!Array<ScopeType>} */ var scopeTypes = new Array(scopeMirrors.length); + /** @type {?Array<!Object>} */ var scopeObjects = new Array(scopeMirrors.length); + /** @type {!Array<string|undefined>} */ var scopeNames = new Array(scopeMirrors.length); + /** @type {?Array<number>} */ var scopeStartPositions = new Array(scopeMirrors.length); + /** @type {?Array<number>} */ var scopeEndPositions = new Array(scopeMirrors.length); + /** @type {?Array<function()|null>} */ var scopeFunctions = new Array(scopeMirrors.length); for (var i = 0; i < scopeMirrors.length; ++i) { var scopeDetails = scopeMirrors[i].details(); @@ -376,10 +470,17 @@ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) var scopeChain; var funcMirror; var location; + /** @type {!Array<?RawLocation>} */ var scopeStartLocations; + /** @type {!Array<?RawLocation>} */ var scopeEndLocations; var details; + /** + * @param {!ScriptMirror|undefined} script + * @param {number} pos + * @return {?RawLocation} + */ function createLocation(script, pos) { if (!script) @@ -393,7 +494,10 @@ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) } } - function lazyScopeChain() + /** + * @return {!Array<!Object>} + */ + function ensureScopeChain() { if (!scopeChain) { scopeChain = []; @@ -402,7 +506,7 @@ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) for (var i = 0, j = 0; i < scopeObjects.length; ++i) { var scopeObject = DebuggerScript._buildScopeObject(scopeTypes[i], scopeObjects[i]); if (scopeObject) { - scopeTypes[j] = DebuggerScript._scopeTypeNames[scopeTypes[i]]; + scopeTypes[j] = scopeTypes[i]; scopeNames[j] = scopeNames[i]; scopeChain[j] = scopeObject; @@ -410,7 +514,7 @@ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) if (!funcMirror || !funcMirror.isFunction()) funcMirror = new UnresolvedFunctionMirror(funcObject); - var script = funcMirror.script(); + var script = /** @type {!FunctionMirror} */(funcMirror).script(); scopeStartLocations[j] = createLocation(script, scopeStartPositions[i]); scopeEndLocations[j] = createLocation(script, scopeEndPositions[i]); ++j; @@ -426,23 +530,27 @@ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) return scopeChain; } + /** + * @return {!JavaScriptCallFrameDetails} + */ function lazyDetails() { if (!details) { - var scopeObjects = lazyScopeChain(); + var scopeObjects = ensureScopeChain(); var script = ensureFuncMirror().script(); + /** @type {!Array<Scope>} */ var scopes = []; for (var i = 0; i < scopeObjects.length; ++i) { var scope = { - "type": scopeTypes[i], + "type": /** @type {string} */(DebuggerScript._scopeTypeNames.get(scopeTypes[i])), "object": scopeObjects[i], }; if (scopeNames[i]) scope.name = scopeNames[i]; if (scopeStartLocations[i]) - scope.startLocation = scopeStartLocations[i]; + scope.startLocation = /** @type {!RawLocation} */(scopeStartLocations[i]); if (scopeEndLocations[i]) - scope.endLocation = scopeEndLocations[i]; + scope.endLocation = /** @type {!RawLocation} */(scopeEndLocations[i]); scopes.push(scope); } details = { @@ -469,6 +577,9 @@ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) return details; } + /** + * @return {!FunctionMirror} + */ function ensureFuncMirror() { if (!funcMirror) { @@ -476,9 +587,12 @@ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) if (!funcMirror.isFunction()) funcMirror = new UnresolvedFunctionMirror(funcObject); } - return funcMirror; + return /** @type {!FunctionMirror} */(funcMirror); } + /** + * @return {!{line: number, column: number}} + */ function ensureLocation() { if (!location) { @@ -491,32 +605,51 @@ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) return location; } + /** + * @return {number} + */ function line() { return ensureLocation().line; } + /** + * @return {number} + */ function column() { return ensureLocation().column; } + /** + * @return {number|undefined} + */ function sourceID() { var script = ensureFuncMirror().script(); return script && script.id(); } + /** + * @param {string} expression + * @return {*} + */ function evaluate(expression) { return frameMirror.evaluate(expression, false).value(); } + /** @return {undefined} */ function restart() { return frameMirror.restart(); } + /** + * @param {number} scopeNumber + * @param {string} variableName + * @param {*} newValue + */ function setVariableValue(scopeNumber, variableName, newValue) { var scopeMirror = frameMirror.scope(scopeNumber); @@ -539,6 +672,11 @@ DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame) }; } +/** + * @param {number} scopeType + * @param {!Object} scopeObject + * @return {!Object|undefined} + */ DebuggerScript._buildScopeObject = function(scopeType, scopeObject) { var result; @@ -552,7 +690,7 @@ DebuggerScript._buildScopeObject = function(scopeType, scopeObject) // the same properties. // Reset scope object prototype to null so that the proto properties // don't appear in the local scope section. - var properties = MakeMirror(scopeObject, true /* transient */).properties(); + var properties = /** @type {!ObjectMirror} */(MakeMirror(scopeObject, true /* transient */)).properties(); // Almost always Script scope will be empty, so just filter out that noise. // Also drop empty Block scopes, should we get any. if (!properties.length && (scopeType === ScopeType.Script || scopeType === ScopeType.Block)) diff --git a/third_party/WebKit/Source/platform/v8_inspector/debugger_script_externs.js b/third_party/WebKit/Source/platform/v8_inspector/debugger_script_externs.js new file mode 100644 index 0000000..75e7a16 --- /dev/null +++ b/third_party/WebKit/Source/platform/v8_inspector/debugger_script_externs.js @@ -0,0 +1,546 @@ +// Copyright 2016 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +/** @typedef {{ + type: string, + object: !Object, + name: (string|undefined), + startLocation: (!RawLocation|undefined), + endLocation: (!RawLocation|undefined) + }} */ +var Scope; + +/** @typedef {{ + scriptId: string, + lineNumber: number, + columnNumber: number + }} */ +var RawLocation; + +/** @typedef {{ + function: function(), + functionName: string, + status: string, + location: (!RawLocation|undefined) + }} */ +var GeneratorObjectDetails; + +/** @typedef {{ + id: number, + name: string, + sourceURL: (string|undefined), + sourceMappingURL: (string|undefined), + source: string, + startLine: number, + endLine: number, + startColumn: number, + endColumn: number, + executionContextId: number, + isContentScript: boolean, + isInternalScript: boolean + }} */ +var FormattedScript; + +/** @typedef {{ + functionName: string, + location: !RawLocation, + this: !Object, + scopeChain: !Array<!Scope>, + functionLocation: (RawLocation|undefined), + returnValue: (*|undefined) + }} */ +var JavaScriptCallFrameDetails; + +/** @typedef {{ + sourceID: function():(number|undefined), + line: function():number, + column: function():number, + thisObject: !Object, + evaluate: function(string):*, + caller: *, + restart: function():undefined, + setVariableValue: function(number, string, *):undefined, + isAtReturn: boolean, + details: function():!JavaScriptCallFrameDetails + }} */ +var JavaScriptCallFrame; + +/** @interface */ +function DebugClass() +{ + /** @type {!LiveEditClass} */ + this.LiveEdit; +} + +DebugClass.prototype.setBreakOnException = function() {} + +DebugClass.prototype.clearBreakOnException = function() {} + +DebugClass.prototype.setBreakOnUncaughtException = function() {} + +DebugClass.prototype.clearBreakOnUncaughtException = function() {} + +DebugClass.prototype.clearStepping = function() {} + +DebugClass.prototype.clearAllBreakPoints = function() {} + +/** @return {!Array<!Script>} */ +DebugClass.prototype.scripts = function() {} + +/** + * @param {number} scriptId + * @param {number=} line + * @param {number=} column + * @param {string=} condition + * @param {string=} groupId + * @param {Debug.BreakPositionAlignment=} positionAlignment + */ +DebugClass.prototype.setScriptBreakPointById = function(scriptId, line, column, condition, groupId, positionAlignment) {} + +/** + * @param {number} breakId + * @return {!Array<!SourceLocation>} + */ +DebugClass.prototype.findBreakPointActualLocations = function(breakId) {} + +/** + * @param {number} breakId + * @param {boolean} remove + * @return {!BreakPoint|undefined} + */ +DebugClass.prototype.findBreakPoint = function(breakId, remove) {} + +/** @return {!DebuggerFlags} */ +DebugClass.prototype.debuggerFlags = function() {} + +/** @type {!DebugClass} */ +var Debug; + + +/** @enum */ +Debug.BreakPositionAlignment = { + Statement: 0, + BreakPosition: 1 +}; + +/** @enum */ +Debug.StepAction = { StepOut: 0, + StepNext: 1, + StepIn: 2, + StepFrame: 3 }; + +/** @enum */ +Debug.ScriptCompilationType = { Host: 0, + Eval: 1, + JSON: 2 }; + + +/** @interface */ +function DebuggerFlag() {} + +/** @param {boolean} value */ +DebuggerFlag.prototype.setValue = function(value) {} + + +/** @interface */ +function DebuggerFlags() +{ + /** @type {!DebuggerFlag} */ + this.breakPointsActive; +} + + +/** @interface */ +function LiveEditClass() {} + +/** + * @param {!Script} script + * @param {string} newSource + * @param {boolean} previewOnly + * @return {!{stack_modified: (boolean|undefined)}} + */ +LiveEditClass.prototype.SetScriptSource = function(script, newSource, previewOnly, change_log) {} + + +/** @interface */ +function LiveEditErrorDetails() +{ + /** @type {string} */ + this.syntaxErrorMessage; + /** @type {!{start: !{line: number, column: number}}} */ + this.position; +} + + +/** @interface */ +function BreakpointInfo() +{ + /** @type {number} */ + this.breakpointId; + /** @type {number} */ + this.sourceID; + /** @type {number|undefined} */ + this.lineNumber; + /** @type {number|undefined} */ + this.columnNumber; + /** @type {string|undefined} */ + this.condition; + /** @type {boolean|undefined} */ + this.interstatementLocation; +} + + +/** @interface */ +function BreakPoint() {} + +/** @return {!BreakPoint|undefined} */ +BreakPoint.prototype.script_break_point = function() {} + +/** @return {number} */ +BreakPoint.prototype.number = function() {} + + +/** @interface */ +function CompileEvent() {} + +/** @return {!ScriptMirror} */ +CompileEvent.prototype.script = function() {} + + +/** @interface */ +function BreakEvent() {} + +/** @return {!Array<!BreakPoint>|undefined} */ +BreakEvent.prototype.breakPointsHit = function() {} + + +/** @interface */ +function ExecutionState() {} + +/** @param {!Debug.StepAction} action */ +ExecutionState.prototype.prepareStep = function(action) {} + +/** + * @param {string} source + * @param {boolean} disableBreak + * @param {*=} additionalContext + */ +ExecutionState.prototype.evaluateGlobal = function(source, disableBreak, additionalContext) {} + +/** @return {number} */ +ExecutionState.prototype.frameCount = function() {} + +/** + * @param {number} index + * @return {!FrameMirror} + */ +ExecutionState.prototype.frame = function(index) {} + +/** @param {number} index */ +ExecutionState.prototype.setSelectedFrame = function(index) {} + +/** @return {number} */ +ExecutionState.prototype.selectedFrame = function() {} + + +/** @enum */ +var ScopeType = { Global: 0, + Local: 1, + With: 2, + Closure: 3, + Catch: 4, + Block: 5, + Script: 6 }; + + +/** @interface */ +function SourceLocation() +{ + /** @type {number} */ + this.script; + /** @type {number} */ + this.position; + /** @type {number} */ + this.line; + /** @type {number} */ + this.column; + /** @type {number} */ + this.start; + /** @type {number} */ + this.end; +} + + +/** @interface */ +function Script() +{ + /** @type {number} */ + this.id; + /** @type {string|undefined} */ + this.context_data; + /** @type {string|undefined} */ + this.source_url; + /** @type {string|undefined} */ + this.source_mapping_url; + /** @type {boolean} */ + this.is_debugger_script; + /** @type {string} */ + this.source; + /** @type {!Array<number>} */ + this.line_ends; + /** @type {number} */ + this.line_offset; + /** @type {number} */ + this.column_offset; +} + +/** @return {string} */ +Script.prototype.nameOrSourceURL = function() {} + +/** @return {!Debug.ScriptCompilationType} */ +Script.prototype.compilationType = function() {} + + +/** @interface */ +function ScopeDetails() {} + +/** @return {!Object} */ +ScopeDetails.prototype.object = function() {} + +/** @return {string|undefined} */ +ScopeDetails.prototype.name = function() {} + + +/** @interface */ +function FrameDetails() {} + +/** @return {!Object} */ +FrameDetails.prototype.receiver = function() {} + +/** @return {function()} */ +FrameDetails.prototype.func = function() {} + +/** @return {boolean} */ +FrameDetails.prototype.isAtReturn = function() {} + +/** @return {number} */ +FrameDetails.prototype.sourcePosition = function() {} + +/** @return {*} */ +FrameDetails.prototype.returnValue = function() {} + +/** @return {number} */ +FrameDetails.prototype.scopeCount = function() {} + + +/** @param {boolean} value */ +function ToggleMirrorCache(value) {} + +/** + * @param {*} value + * @param {boolean=} transient + * @return {!Mirror} + */ +function MakeMirror(value, transient) {} + + +/** @interface */ +function Mirror() {} + +/** @return {boolean} */ +Mirror.prototype.isFunction = function() {} + +/** @return {boolean} */ +Mirror.prototype.isGenerator = function() {} + +/** @return {boolean} */ +Mirror.prototype.isMap = function() {} + +/** @return {boolean} */ +Mirror.prototype.isSet = function() {} + +/** @return {boolean} */ +Mirror.prototype.isIterator = function() {} + + +/** + * @interface + * @extends {Mirror} + */ +function ObjectMirror() {} + +/** @return {!Array<!PropertyMirror>} */ +ObjectMirror.prototype.properties = function() {} + + +/** + * @interface + * @extends {ObjectMirror} + */ +function FunctionMirror () {} + +/** @return {number} */ +FunctionMirror.prototype.scopeCount = function() {} + +/** + * @param {number} index + * @return {!ScopeMirror|undefined} + */ +FunctionMirror.prototype.scope = function(index) {} + +/** @return {boolean} */ +FunctionMirror.prototype.resolved = function() {} + +/** @return {function()} */ +FunctionMirror.prototype.value = function() {} + +/** @return {string} */ +FunctionMirror.prototype.debugName = function() {} + +/** @return {!ScriptMirror|undefined} */ +FunctionMirror.prototype.script = function() {} + +/** @return {!SourceLocation|undefined} */ +FunctionMirror.prototype.sourceLocation = function() {} + + +/** + * @constructor + * @param {*} value + */ +function UnresolvedFunctionMirror(value) {} + + +/** + * @interface + * @extends {ObjectMirror} + */ +function MapMirror () {} + +/** + * @param {number=} limit + * @return {!Array<!{key: *, value: *}>} + */ +MapMirror.prototype.entries = function(limit) {} + + +/** + * @interface + * @extends {ObjectMirror} + */ +function SetMirror () {} + +/** + * @param {number=} limit + * @return {!Array<*>} + */ +SetMirror.prototype.values = function(limit) {} + + +/** + * @interface + * @extends {ObjectMirror} + */ +function IteratorMirror () {} + +/** + * @param {number=} limit + * @return {!Array<*>} + */ +IteratorMirror.prototype.preview = function(limit) {} + + +/** + * @interface + * @extends {ObjectMirror} + */ +function GeneratorMirror () {} + +/** @return {string} */ +GeneratorMirror.prototype.status = function() {} + +/** @return {!SourceLocation|undefined} */ +GeneratorMirror.prototype.sourceLocation = function() {} + +/** @return {!FunctionMirror} */ +GeneratorMirror.prototype.func = function() {} + + +/** + * @interface + * @extends {Mirror} + */ +function PropertyMirror() +{ + /** @type {*} */ + this.value_; +} + +/** @return {!Mirror} */ +PropertyMirror.prototype.value = function() {} + +/** @return {string} */ +PropertyMirror.prototype.name = function() {} + + +/** + * @interface + * @extends {Mirror} + */ +function FrameMirror() {} + +/** + * @param {boolean=} ignoreNestedScopes + * @return {!Array<!ScopeMirror>} + */ +FrameMirror.prototype.allScopes = function(ignoreNestedScopes) {} + +/** @return {!FrameDetails} */ +FrameMirror.prototype.details = function() {} + +/** + * @param {string} source + * @param {boolean} disableBreak + */ +FrameMirror.prototype.evaluate = function(source, disableBreak) {} + +FrameMirror.prototype.restart = function() {} + +/** @param {number} index */ +FrameMirror.prototype.scope = function(index) {} + + +/** + * @interface + * @extends {Mirror} + */ +function ScriptMirror() {} + +/** @return {!Script} */ +ScriptMirror.prototype.value = function() {} + +/** @return {number} */ +ScriptMirror.prototype.id = function() {} + +/** + * @param {number} position + * @param {boolean=} includeResourceOffset + */ +ScriptMirror.prototype.locationFromPosition = function(position, includeResourceOffset) {} + + +/** + * @interface + * @extends {Mirror} + */ +function ScopeMirror() {} + +/** @return {!ScopeDetails} */ +ScopeMirror.prototype.details = function() {} + +/** + * @param {string} name + * @param {*} newValue + */ +ScopeMirror.prototype.setVariableValue = function(name, newValue) {} |