Function variablesRequest

src/debug/dart_debug_impl.ts:841–1041

(response: DebugProtocol.VariablesResponse, args: DebugProtocol.VariablesArguments)

	}

	protected async variablesRequest(response: DebugProtocol.VariablesResponse, args: DebugProtocol.VariablesArguments): Promise<void> {
		if (!this.vmService) {
			this.errorResponse(response, `No VM service connection`);
			return;
		}

		const variablesReference = args.variablesReference;

		// implement paged arrays
		// let filter = args.filter; // optional; either "indexed" or "named"
		const requestedStart = args.start; // (optional) index of the first variable to return; if omitted children start at 0
		const startNumeric = requestedStart || 0;
		const requestedCount = args.count; // (optional) number of variables to return. If count is missing or 0, all variables are returned

		const data = this.threadManager.getStoredData(variablesReference);
		if (!data) {
			this.errorResponse(response, `Variable is no longer available (maybe debug session finished?)`);
			return;
		}
		const thread = data.thread;

		if (data.data.type === "Frame") {
			const frame: VMFrame = data.data as VMFrame;
			let variables: DebugProtocol.Variable[] = [];
			if (frame.vars) {
				const framePromises = frame.vars
					.filter((variable) => !variable.value || variable.value.type !== "@TypeArguments")
					.map((variable, i) => this.instanceRefToVariable(thread, true, variable.name, variable.name, variable.value, i <= maxValuesToCallToString));
				const frameVariables = await Promise.all(framePromises);
				variables = variables.concat(frameVariables);
			}
			variables = sortBy(variables, (v) => v.name);
			response.body = { variables };
			this.sendResponse(response);
		} else if (data.data.type === "MapEntry") {
			const mapRef = data.data as VMMapEntry;

			const keyResult = this.vmService.getObject(thread.ref.id, mapRef.keyId);
			const valueResult = this.vmService.getObject(thread.ref.id, mapRef.valueId);

			const variables: DebugProtocol.Variable[] = [];
			let canEvaluateValueName = false;
			let valueEvaluateName = "value";

			try {
				const keyDebuggerResult = await keyResult;
				const keyInstanceRef = keyDebuggerResult.result as VMInstanceRef;

				variables.push(await this.instanceRefToVariable(thread, false, "key", "key", keyInstanceRef, true));

				if (this.isSimpleKind(keyInstanceRef.kind) && mapRef.mapEvaluateName) {
					canEvaluateValueName = true;
					valueEvaluateName = `${mapRef.mapEvaluateName}[${this.valueAsString(keyInstanceRef)}]`;
				}
			} catch (error) {
				variables.push({ name: "key", value: this.errorAsDisplayValue(error), variablesReference: 0 });
			}