vscode-java-debug/src/JavaInlineValueProvider.ts at test_samples · microsoft/vscode-java-debug · GitHub

86 lines (74 loc) · 4.57 KB

// Licensed under the MIT license.

import * as compareVersions from "compare-versions";

import { debug, InlineValue, InlineValueContext, InlineValueEvaluatableExpression, InlineValuesProvider, InlineValueText, InlineValueVariableLookup,

Range, TextDocument, version } from "vscode";

import { instrumentOperation, instrumentOperationStep, sendInfo } from "vscode-extension-telemetry-wrapper";

import * as CodeConverter from "vscode-languageclient/lib/codeConverter";

import * as ProtocolConverter from "vscode-languageclient/lib/protocolConverter";

import { InlineKind, InlineVariable, resolveInlineVariables } from "./languageServerPlugin";

// In VS Code 1.55.0, viewport doesn't change while scrolling the editor and it's fixed in 1.56.0.

// So dynamically enable viewport support based on the user's VS Code version.

const isViewPortSupported = compareVersions(version.replace(/-insider$/i, ""), "1.56.0") >= 0;

const protoConverter: ProtocolConverter.Converter = ProtocolConverter.createConverter();

const codeConverter: CodeConverter.Converter = CodeConverter.createConverter();

export class JavaInlineValuesProvider implements InlineValuesProvider {

public async provideInlineValues(document: TextDocument, viewPort: Range, context: InlineValueContext): Promise<InlineValue[]> {

const provideInlineValuesOperation = instrumentOperation("provideInlineValues", async (operationId) => {

const resolveInlineVariablesStep = instrumentOperationStep(operationId, "resolveInlineVariables", async () => {

return <InlineVariable[]> (await resolveInlineVariables({

uri: document.uri.toString(),

viewPort: isViewPortSupported ? codeConverter.asRange(viewPort) : undefined,

stoppedLocation: codeConverter.asRange(context.stoppedLocation),

}));

});

const variables: InlineVariable[] = await resolveInlineVariablesStep();

const resolveInlineValuesStep = instrumentOperationStep(operationId, "resolveInlineValues", async () => {

if (!variables || !variables.length) {

sendInfo(operationId, {

inlineVariableCount: 0,

});

return [];

}

const unresolvedVariables: any[] = variables.filter((variable) => variable.kind === InlineKind.Evaluation).map((variable) => {

return {

expression: variable.expression || variable.name,

declaringClass: variable.declaringClass,

};

});

sendInfo(operationId, {

inlineVariableCount: variables.length,

inlineVariableLookupCount: variables.length - unresolvedVariables.length,

inlineVariableEvaluationCount: unresolvedVariables.length,

});

let resolvedVariables: any;

if (unresolvedVariables.length && debug.activeDebugSession) {

const response = await debug.activeDebugSession.customRequest("inlineValues", {

frameId: context.frameId,

variables: unresolvedVariables,

});

resolvedVariables = response?.variables;

}

const result: InlineValue[] = [];

let next = 0;

for (const variable of variables) {

if (variable.kind === InlineKind.VariableLookup) {

result.push(new InlineValueVariableLookup(protoConverter.asRange(variable.range), variable.name, true));

} else if (resolvedVariables && resolvedVariables.length > next) {

const resolvedValue = resolvedVariables[next++];

if (resolvedValue) {

result.push(new InlineValueText(protoConverter.asRange(variable.range), `${variable.name} = ${resolvedValue.value}`));

} else {

result.push(new InlineValueEvaluatableExpression(protoConverter.asRange(variable.range), variable.name));

}

} else {

result.push(new InlineValueEvaluatableExpression(protoConverter.asRange(variable.range), variable.name));

}

return result;

});

return resolveInlineValuesStep();

});

return provideInlineValuesOperation();

}

vscode-java-debug/src/JavaInlineValueProvider.ts at test_samples · microsoft/vscode-java-debug · GitHub

Uh oh!

Expand file tree

Breadcrumbs

JavaInlineValueProvider.ts

Latest commit

History

Breadcrumbs

JavaInlineValueProvider.ts

File metadata and controls