Use InlineValuesProvider to provide inline debugging feature (#977)

* Use InlineValuesProvider to provide inline debugging feature
* Add metrics to track the performance of inline values feature

Author: testforstephen

package-lock.json

@@ -14,7 +14,7 @@
     "debugger"
   ],
   "engines": {
-    "vscode": "^1.54.0"
+    "vscode": "^1.55.0"
   },
   "license": "SEE LICENSE IN LICENSE.txt",
   "repository": {
@@ -768,7 +768,7 @@
     "@types/mocha": "^5.2.7",
     "@types/node": "^14.14.10",
     "@types/uuid": "^8.3.0",
-    "@types/vscode": "1.54.0",
+    "@types/vscode": "1.55.0",
     "cross-env": "^5.2.0",
     "gulp": "^4.0.2",
     "gulp-tslint": "^8.1.4",
@@ -787,6 +787,8 @@
     "uuid": "^8.3.1",
     "vscode-extension-telemetry": "^0.1.6",
     "vscode-extension-telemetry-wrapper": "^0.9.0",
+    "vscode-languageclient": "6.0.0-next.9",
+    "vscode-languageserver-types": "3.16.0",
     "vscode-tas-client": "^0.1.22"
   }
 }

package.json

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// 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();
+    }
+
+}

src/JavaInlineValueProvider.ts

@@ -44,6 +44,8 @@ export const JAVA_RESOLVE_CLASSFILTERS = "vscode.java.resolveClassFilters";
 
 export const JAVA_RESOLVE_SOURCE_URI = "vscode.java.resolveSourceUri";
 
+export const JAVA_RESOLVE_INLINE_VARIABLES = "vscode.java.resolveInlineVariables";
+
 export function executeJavaLanguageServerCommand(...rest: any[]) {
     return executeJavaExtensionCommand(JAVA_EXECUTE_WORKSPACE_COMMAND, ...rest);
 }

src/commands.ts

@@ -15,6 +15,7 @@ import { initializeCodeLensProvider, startDebugging } from "./debugCodeLensProvi
 import { initExpService } from "./experimentationService";
 import { handleHotCodeReplaceCustomEvent, initializeHotCodeReplace, NO_BUTTON, YES_BUTTON } from "./hotCodeReplace";
 import { JavaDebugAdapterDescriptorFactory } from "./javaDebugAdapterDescriptorFactory";
+import { JavaInlineValuesProvider } from "./JavaInlineValueProvider";
 import { logJavaException, logJavaInfo } from "./javaLogger";
 import { IMainClassOption, IMainMethod, resolveMainMethod } from "./languageServerPlugin";
 import { logger, Type } from "./logger";
@@ -78,6 +79,7 @@ function initializeExtension(_operationId: string, context: vscode.ExtensionCont
     initializeCodeLensProvider(context);
     initializeThreadOperations(context);
 
+    context.subscriptions.push(vscode.languages.registerInlineValuesProvider("java", new JavaInlineValuesProvider()));
     return {
         progressProvider,
     };

src/extension.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT license.
 
 import * as vscode from "vscode";
+import { Range } from "vscode-languageserver-types";
 
 import * as commands from "./commands";
 
@@ -116,3 +117,29 @@ export async function resolveClassFilters(patterns: string[]): Promise<string[]>
 export async function resolveSourceUri(line: string): Promise<string> {
     return <string> await commands.executeJavaLanguageServerCommand(commands.JAVA_RESOLVE_SOURCE_URI, line);
 }
+
+export async function resolveInlineVariables(inlineParams: InlineParams): Promise<InlineVariable[]> {
+    return <InlineVariable[]> await commands.executeJavaLanguageServerCommand(commands.JAVA_RESOLVE_INLINE_VARIABLES, JSON.stringify(inlineParams));
+}
+
+// tslint:disable-next-line:interface-name
+export interface InlineParams {
+    uri: string;
+    viewPort?: Range;
+    stoppedLocation: Range;
+}
+
+// tslint:disable-next-line:interface-name
+export enum InlineKind {
+    VariableLookup = 0,
+    Evaluation = 1,
+}
+
+// tslint:disable-next-line:interface-name
+export interface InlineVariable {
+    range: Range;
+    name: string;
+    kind: InlineKind;
+    expression: string;
+    declaringClass: string;
+}

src/languageServerPlugin.ts

@@ -36,6 +36,7 @@
             true,
             "log",
             "error"
-        ]
+        ],
+        "no-submodule-imports": false
     }
 }