Use codeLens to run Java program (#410)

* Use codeLens to run Java program

Signed-off-by: Jinbo Wang <[email protected]>

* Move codeLens action name to local constants

* use lodash _.flatten to flatten the codeLens result

* Add return statement

Author: testforstephen

src/commands.ts

@@ -23,6 +23,8 @@ export const JAVA_FETCH_USAGE_DATA = "vscode.java.fetchUsageData";
 
 export const JAVA_UPDATE_DEBUG_SETTINGS = "vscode.java.updateDebugSettings";
 
+export const JAVA_RESOLVE_MAINMETHOD = "vscode.java.resolveMainMethod";
+
 export function executeJavaLanguageServerCommand(...rest) {
     // TODO: need to handle error and trace telemetry
     return vscode.commands.executeCommand(JAVA_EXECUTE_WORKSPACE_COMMAND, ...rest);

src/configurationProvider.ts

@@ -189,23 +189,10 @@ export class JavaDebugConfigurationProvider implements vscode.DebugConfiguration
             }
 
             const errorMessage = (ex && ex.message) || ex;
-            const exception = (ex && ex.data && ex.data.cause)
-                || { stackTrace: (ex && ex.stack), detailMessage: String((ex && ex.message) || ex || "Unknown exception") };
-            const properties = {
-                message: "",
-                stackTrace: "",
-            };
-            if (exception && typeof exception === "object") {
-                properties.message = exception.detailMessage;
-                properties.stackTrace = (Array.isArray(exception.stackTrace) && JSON.stringify(exception.stackTrace))
-                    || String(exception.stackTrace);
-            } else {
-                properties.message = String(exception);
-            }
             utility.showErrorMessageWithTroubleshooting({
                 message: String(errorMessage),
                 type: Type.EXCEPTION,
-                details: properties,
+                details: utility.formatErrorProperties(ex),
             });
             return undefined;
         }

src/debugCodeLensProvider.ts

@@ -0,0 +1,133 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import * as _ from "lodash";
+import * as vscode from "vscode";
+
+import * as commands from "./commands";
+import { JAVA_LANGID } from "./constants";
+import { logger, Type } from "./logger";
+import * as utility from "./utility";
+
+const onDidChange: vscode.EventEmitter<void> = new vscode.EventEmitter<void>();
+const JAVA_RUN_COMMAND = "vscode.java.run";
+const JAVA_DEBUG_COMMAND = "vscode.java.debug";
+
+export function initializeCodeLensProvider(context: vscode.ExtensionContext): void {
+    const watcher = vscode.workspace.createFileSystemWatcher("**/*.{[jJ][aA][vV][aA]}");
+    context.subscriptions.push(watcher);
+    watcher.onDidChange((uri) => {
+        onDidChange.fire();
+    });
+
+    context.subscriptions.push(vscode.languages.registerCodeLensProvider(JAVA_LANGID, new DebugCodeLensProvider(onDidChange)));
+    context.subscriptions.push(vscode.commands.registerCommand(JAVA_RUN_COMMAND, runJavaProgram));
+    context.subscriptions.push(vscode.commands.registerCommand(JAVA_DEBUG_COMMAND, debugJavaProgram));
+}
+
+class DebugCodeLensProvider implements vscode.CodeLensProvider {
+    constructor(private _onDidChange: vscode.EventEmitter<void>) {
+    }
+
+    get onDidChangeCodeLenses(): vscode.Event<void> {
+        return this._onDidChange.event;
+    }
+
+    public async provideCodeLenses(document: vscode.TextDocument, token: vscode.CancellationToken): Promise<vscode.CodeLens[]> {
+        const mainMethods: IMainMethod[] = await resolveMainMethod(document);
+        return _.flatten(mainMethods.map((method) => {
+            return [
+                new vscode.CodeLens(method.range, {
+                    title: "▶ Run",
+                    command: JAVA_RUN_COMMAND,
+                    tooltip: "Run Java Program",
+                    arguments: [ method.mainClass, method.projectName, document.uri ],
+                }),
+                new vscode.CodeLens(method.range, {
+                    title: "🐞 Debug",
+                    command: JAVA_DEBUG_COMMAND,
+                    tooltip: "Debug Java Program",
+                    arguments: [ method.mainClass, method.projectName, document.uri ],
+                }),
+            ];
+        }));
+    }
+}
+
+function runJavaProgram(mainClass: string, projectName: string, uri: vscode.Uri): Promise<void> {
+    return runCodeLens(mainClass, projectName, uri, true);
+}
+
+function debugJavaProgram(mainClass: string, projectName: string, uri: vscode.Uri): Promise<void> {
+    return runCodeLens(mainClass, projectName, uri, false);
+}
+
+async function runCodeLens(mainClass: string, projectName: string, uri: vscode.Uri, noDebug: boolean): Promise<void> {
+    const workspaceFolder: vscode.WorkspaceFolder = vscode.workspace.getWorkspaceFolder(uri);
+    const workspaceUri: vscode.Uri = workspaceFolder ? workspaceFolder.uri : undefined;
+
+    const debugConfig: vscode.DebugConfiguration = await constructDebugConfig(mainClass, projectName, workspaceUri);
+    debugConfig.projectName = projectName;
+    debugConfig.noDebug = noDebug;
+
+    vscode.debug.startDebugging(workspaceFolder, debugConfig);
+
+    logger.log(Type.USAGEDATA, {
+        runCodeLens: "yes",
+        noDebug: String(noDebug),
+    });
+}
+
+async function constructDebugConfig(mainClass: string, projectName: string, workspace: vscode.Uri): Promise<vscode.DebugConfiguration> {
+    const launchConfigurations: vscode.WorkspaceConfiguration = vscode.workspace.getConfiguration("launch", workspace);
+    const rawConfigs: vscode.DebugConfiguration[] = launchConfigurations.configurations;
+
+    let debugConfig: vscode.DebugConfiguration = _.find(rawConfigs, (config) => {
+        return config.mainClass === mainClass && _.toString(config.projectName) === _.toString(projectName);
+    });
+
+    if (!debugConfig) {
+        debugConfig = _.find(rawConfigs, (config) => {
+            return config.mainClass === mainClass && !config.projectName;
+        });
+    }
+
+    if (!debugConfig) {
+        debugConfig = {
+            type: "java",
+            name: `CodeLens (Launch) - ${mainClass.substr(mainClass.lastIndexOf(".") + 1)}`,
+            request: "launch",
+            // tslint:disable-next-line
+            cwd: workspace ? "${workspaceFolder}" : undefined,
+            console: "internalConsole",
+            stopOnEntry: false,
+            mainClass,
+            args: "",
+            projectName,
+        };
+
+        // Persist the default debug configuration only if the workspace exists.
+        if (workspace) {
+            // Insert the default debug configuration to the beginning of launch.json.
+            rawConfigs.splice(0, 0, debugConfig);
+            await launchConfigurations.update("configurations", rawConfigs, vscode.ConfigurationTarget.WorkspaceFolder);
+        }
+    }
+
+    return _.cloneDeep(debugConfig);
+}
+
+async function resolveMainMethod(document: vscode.TextDocument): Promise<IMainMethod[]> {
+    try {
+        return <IMainMethod[]> await commands.executeJavaLanguageServerCommand(commands.JAVA_RESOLVE_MAINMETHOD, document.uri.toString());
+    } catch (ex) {
+        logger.log(Type.EXCEPTION, utility.formatErrorProperties(ex));
+        return [];
+    }
+}
+
+interface IMainMethod {
+    range: vscode.Range;
+    mainClass: string;
+    projectName: string;
+}

src/extension.ts

@@ -6,6 +6,7 @@ import * as vscode from "vscode";
 import * as commands from "./commands";
 import { JavaDebugConfigurationProvider } from "./configurationProvider";
 import { HCR_EVENT, JAVA_LANGID, USER_NOTIFICATION_EVENT } from "./constants";
+import { initializeCodeLensProvider } from "./debugCodeLensProvider"
 import { handleHotCodeReplaceCustomEvent, initializeHotCodeReplace } from "./hotCodeReplace";
 import { logger, Type } from "./logger";
 import * as utility from "./utility";
@@ -53,6 +54,8 @@ export function activate(context: vscode.ExtensionContext) {
             handleUserNotification(customEvent);
         }
     }));
+
+    initializeCodeLensProvider(context);
 }
 
 // this method is called when your extension is deactivated

src/utility.ts

@@ -17,10 +17,14 @@ export class UserError extends Error {
     }
 }
 
+interface IProperties {
+    [key: string]: string;
+}
+
 interface ILoggingMessage {
     message: string;
     type?: Type;
-    details?: { [key: string]: string; };
+    details?: IProperties;
 }
 
 interface ITroubleshootingMessage extends ILoggingMessage {
@@ -85,3 +89,23 @@ function handleTroubleshooting(choice: string, message: string, anchor: string):
 
     return choice;
 }
+
+export function formatErrorProperties(ex: any): IProperties {
+    const exception = (ex && ex.data && ex.data.cause)
+        || { stackTrace: (ex && ex.stack), detailMessage: String((ex && ex.message) || ex || "Unknown exception") };
+
+    const properties = {
+        message: "",
+        stackTrace: "",
+    };
+
+    if (exception && typeof exception === "object") {
+        properties.message = exception.detailMessage;
+        properties.stackTrace = (Array.isArray(exception.stackTrace) && JSON.stringify(exception.stackTrace))
+            || String(exception.stackTrace);
+    } else {
+        properties.message = String(exception);
+    }
+
+    return properties;
+}