Function stackTraceRequest

src/debug/dart_debug_impl.ts:646–727

(response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments)

	}

	protected async stackTraceRequest(response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments): Promise<void> {
		const stackFrameBatch = 20;
		const thread = this.threadManager.getThreadInfoFromNumber(args.threadId);
		const startFrame = args.startFrame || 0;
		const levels = args.levels;

		if (!thread) {
			this.errorResponse(response, `No thread with id ${args.threadId}`);
			return;
		}

		if (!thread.paused) {
			this.errorResponse(response, `Thread ${args.threadId} is not paused`);
			return;
		}

		if (!this.vmService) {
			this.errorResponse(response, `No VM service connection`);
			return;
		}

		try {
			let isTruncated: boolean;
			let totalFrames: number;
			let stackFrames: DebugProtocol.StackFrame[] = [];

			// Newer VM Service allows us to cap the frames to avoid fetching more than we need.
			// They do not support an offset, however earlier frames will be internally cached
			// so fetching 40 frames if we've already had 0-20 should only incur the cost of the
			// new 20.
			const supportsGetStackLimit = this.vmServiceCapabilities.supportsGetStackLimit;
			const limit = supportsGetStackLimit && levels
				? startFrame + levels
				: undefined;

			// If the request is only for the top frame, we may be able to satisfy this using the
			// `topFrame` field of the pause event.
			if (startFrame === 0 && levels === 1 && thread.pauseEvent?.topFrame) {
				totalFrames = 1 + stackFrameBatch; // Claim we had more +stackFrameBatch frames to force another request.
				stackFrames.push(await this.convertStackFrame(thread, thread.pauseEvent?.topFrame, true, true, Infinity));
			} else {
				const result = await this.vmService.getStack(thread.ref.id, limit);

				const stack: VMStack = result.result as VMStack;
				let vmFrames = stack.asyncCausalFrames || stack.frames;
				const framesReceived = vmFrames.length;
				isTruncated = stack.truncated ?? false;

				let firstAsyncMarkerIndex = vmFrames.findIndex((f) => f.kind === "AsyncSuspensionMarker");
				if (firstAsyncMarkerIndex === -1)
					firstAsyncMarkerIndex = Infinity;

				// Drop frames that are earlier than what we wanted.
				vmFrames = vmFrames.slice(startFrame);

				// Drop off any that are after where we wanted.
				if (levels && vmFrames.length > levels)
					vmFrames = vmFrames.slice(0, levels);