Merge remote-tracking branch 'upstream/lsp-refactored-code' into initial-unit-tests-setup

Author: Achal1607

vscode/src/commands/buildOperations.ts

@@ -14,7 +14,7 @@
   limitations under the License.
 */
 
-import { LOGGER } from "../extension";
+import { LOGGER } from "../logger";
 import { l10n } from "../localiser";
 import { extCommands, nbCommands } from "./commands";
 import { ICommand } from "./types";

vscode/src/commands/commands.ts

@@ -19,7 +19,7 @@ import { appendPrefixToCommand } from "../utils";
 
 export const extCommands = {
     configureRunSettings: appendPrefixToCommand('workspace.configureRunSettings'),
-    newFromTemplate : appendPrefixToCommand('workspace.new'),
+    newFromTemplate: appendPrefixToCommand('workspace.new'),
     newProject: appendPrefixToCommand('workspace.newproject'),
     openTest: appendPrefixToCommand('open.test'),
     deleteCache: appendPrefixToCommand('delete.cache'),
@@ -48,6 +48,8 @@ export const extCommands = {
     nbEventListener: appendPrefixToCommand('addEventListener'),
     selectEditorProjs: appendPrefixToCommand('select.editor.projects'),
     attachDebugger: appendPrefixToCommand("java.attachDebugger.connector"),
+    loadWorkspaceTests: appendPrefixToCommand("load.workspace.tests"),
+    projectDeleteEntry: "javals.foundProjects.deleteEntry"
 }
 
 export const builtInCommands = {
@@ -60,6 +62,7 @@ export const builtInCommands = {
     quickAccess: 'workbench.action.quickOpen',
     openSettings: 'workbench.action.openSettings',
     startDebug: 'workbench.action.debug.start',
+    focusReplDebug: 'workbench.debug.action.focusRepl',
 }
 
 export const nbCommands = {

vscode/src/commands/navigation.ts

@@ -20,7 +20,8 @@ import { l10n } from "../localiser";
 import * as path from 'path';
 import { ICommand } from "./types";
 import { LanguageClient } from "vscode-languageclient/node";
-import { globalVars, LOGGER } from "../extension";
+import { globalVars } from "../extension";
+import { LOGGER } from '../logger';
 import { getContextUri, isNbCommandRegistered, wrapCommandWithProgress } from "./utils";
 
 const goToTest = async (ctx: any) => {

vscode/src/commands/register.ts

@@ -24,6 +24,7 @@ import { registerBuildOperationCommands } from "./buildOperations";
 import { registerRefactorCommands } from "./refactor";
 import { registerUtilCommands } from "./utilCommands";
 import { registerDebugCommands } from "./debug";
+import { registerRunConfigurationCommands } from "./runConfiguration";
 
 type ICommandModules = Record<string, ICommand[]>;
 
@@ -35,7 +36,8 @@ const commandModules: ICommandModules = {
     buildOperations: registerBuildOperationCommands,
     refactor: registerRefactorCommands,
     util: registerUtilCommands,
-    debug: registerDebugCommands
+    debug: registerDebugCommands,
+    runConfiguration: registerRunConfigurationCommands
 }
 
 export const subscribeCommands = (context: ExtensionContext) => {

vscode/src/commands/runConfiguration.ts

@@ -0,0 +1,31 @@
+/*
+  Copyright (c) 2023-2024, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { extCommands } from "./commands";
+import { globalVars } from "../extension";
+import { configureRunSettings } from "../views/runConfiguration";
+import { ICommand } from "./types";
+
+
+const configureRunSettingsHandler = (...params: any[]) => {
+  configureRunSettings(globalVars.extensionInfo.getExtensionContext(), params);
+}
+
+
+export const registerRunConfigurationCommands: ICommand[] = [{
+  command: extCommands.configureRunSettings,
+  handler: configureRunSettingsHandler
+}]

vscode/src/commands/utils.ts

@@ -18,9 +18,9 @@ import { commands, OutputChannel, ProgressLocation, Uri, window } from "vscode";
 import { nbCommands } from "./commands";
 import { ProjectActionParams } from "../lsp/protocol";
 import { LanguageClient } from "vscode-languageclient/node";
-import { globalVars, LOGGER } from "../extension";
+import { globalVars } from "../extension";
 import { l10n } from "../localiser";
-import { LogLevel } from "../logger";
+import { LOGGER } from "../logger";
 
 export const getContextUri = (ctx: any): Uri | undefined => {
     if (ctx?.fsPath) {
@@ -99,14 +99,14 @@ export const wrapCommandWithProgress = (lsCommand: string, title: string, log?:
                             resolve(res);
                         } else {
                             if (log) {
-                                LOGGER.log(`Command ${lsCommand} takes too long to start`, LogLevel.ERROR);
+                                LOGGER.error(`Command ${lsCommand} takes too long to start`);
                             }
                             reject(res);
                         }
                     }, humanVisibleDelay);
                 } catch (err: any) {
                     if (log) {
-                        LOGGER.log(`command ${lsCommand} executed with error: ${JSON.stringify(err)}`, LogLevel.ERROR);
+                        LOGGER.error(`command ${lsCommand} executed with error: ${JSON.stringify(err)}`);
                     }
                 }
             } else {

vscode/src/configurations/handlers.ts

@@ -18,8 +18,8 @@ import { extensions, workspace } from "vscode";
 import { builtInConfigKeys, configKeys } from "./configuration";
 import { extConstants, NODE_WINDOWS_LABEL } from "../constants";
 import * as os from 'os';
-import { globalVars, LOGGER } from "../extension";
-import { LogLevel } from "../logger";
+import { globalVars } from "../extension";
+import { LOGGER } from "../logger";
 import * as path from 'path';
 import * as fs from 'fs';
 
@@ -54,7 +54,7 @@ export const projectSearchRootsValueHandler = (): string => {
         try {
             projectSearchRoots = os.homedir() as string;
         } catch (err: any) {
-            LOGGER.log(`Failed to obtain the user home directory due to: ${err}`, LogLevel.ERROR);
+            LOGGER.error(`Failed to obtain the user home directory due to: ${err}`);
         }
         if (!projectSearchRoots) {
             projectSearchRoots = os.type() === NODE_WINDOWS_LABEL ? '%USERPROFILE%' : '$HOME';   // The launcher script may perform the env variable substitution
@@ -84,7 +84,7 @@ export const lspServerVmOptionsHandler = (): string[] => {
 }
 
 export const isDarkColorThemeHandler = (): boolean => {
-    const themeName: string = getBuiltinConfigurationValue(builtInConfigKeys.vscodeTheme);    
+    const themeName: string = getBuiltinConfigurationValue(builtInConfigKeys.vscodeTheme);
     if (!themeName) {
         return false;
     }

vscode/src/debugger/debugger.ts

@@ -24,9 +24,11 @@ import { l10n } from '../localiser';
 import { StreamDebugAdapter } from './streamDebugAdapter';
 import { globalVars } from '../extension';
 import { extCommands, nbCommands } from '../commands/commands';
+import { argumentsNode, environmentVariablesNode, vmOptionsNode, workingDirectoryNode } from '../views/runConfiguration';
+import { initializeRunConfiguration } from '../utils';
 
 export function registerDebugger(context: ExtensionContext): void {
-    let debugTrackerFactory =new NetBeansDebugAdapterTrackerFactory();
+    let debugTrackerFactory = new NetBeansDebugAdapterTrackerFactory();
     context.subscriptions.push(vscode.debug.registerDebugAdapterTrackerFactory(extConstants.COMMAND_PREFIX, debugTrackerFactory));
     let configInitialProvider = new NetBeansConfigurationInitialProvider();
     context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider(extConstants.COMMAND_PREFIX, configInitialProvider, vscode.DebugConfigurationProviderTriggerKind.Initial));
@@ -36,7 +38,12 @@ export function registerDebugger(context: ExtensionContext): void {
     context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider(extConstants.COMMAND_PREFIX, configResolver));
     context.subscriptions.push(vscode.debug.onDidTerminateDebugSession(((session) => onDidTerminateSession(session))));
     let debugDescriptionFactory = new NetBeansDebugAdapterDescriptionFactory();
-    context.subscriptions.push(vscode.debug.registerDebugAdapterDescriptorFactory(extConstants.COMMAND_PREFIX, debugDescriptionFactory));  
+    context.subscriptions.push(vscode.debug.registerDebugAdapterDescriptorFactory(extConstants.COMMAND_PREFIX, debugDescriptionFactory));
+    initializeRunConfiguration().then(initialized => {
+        if (initialized) {
+            context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider(extConstants.COMMAND_PREFIX, new RunConfigurationProvider()));
+        }
+    });
 };
 
 class NetBeansDebugAdapterTrackerFactory implements vscode.DebugAdapterTrackerFactory {
@@ -66,13 +73,13 @@ class NetBeansDebugAdapterDescriptionFactory implements vscode.DebugAdapterDescr
                     }
                 } else {
                     // resolve(new vscode.DebugAdapterServer(debugPort));
-                   const socket = net.connect(globalVars.debugPort, "127.0.0.1", () => {});
-                   socket.on("connect", () => {
-                       const adapter = new StreamDebugAdapter();
-                       socket.write(globalVars.debugHash ? globalVars.debugHash : "");
-                       adapter.connect(socket, socket);
-                       resolve(new vscode.DebugAdapterInlineImplementation(adapter));
-                   });
+                    const socket = net.connect(globalVars.debugPort, "127.0.0.1", () => { });
+                    socket.on("connect", () => {
+                        const adapter = new StreamDebugAdapter();
+                        socket.write(globalVars.debugHash ? globalVars.debugHash : "");
+                        adapter.connect(socket, socket);
+                        resolve(new vscode.DebugAdapterInlineImplementation(adapter));
+                    });
                 }
             }
             fnc();
@@ -84,26 +91,26 @@ class NetBeansDebugAdapterDescriptionFactory implements vscode.DebugAdapterDescr
 class NetBeansConfigurationInitialProvider implements vscode.DebugConfigurationProvider {
 
     provideDebugConfigurations(folder: vscode.WorkspaceFolder | undefined, token?: vscode.CancellationToken): vscode.ProviderResult<vscode.DebugConfiguration[]> {
-       return this.doProvideDebugConfigurations(folder, token);
+        return this.doProvideDebugConfigurations(folder, token);
     }
 
-    async doProvideDebugConfigurations(folder: vscode.WorkspaceFolder | undefined, _token?:  vscode.CancellationToken):  Promise<vscode.DebugConfiguration[]> {
-        let c : LanguageClient = await globalVars.clientPromise.client;
+    async doProvideDebugConfigurations(folder: vscode.WorkspaceFolder | undefined, _token?: vscode.CancellationToken): Promise<vscode.DebugConfiguration[]> {
+        let c: LanguageClient = await globalVars.clientPromise.client;
         if (!folder) {
             return [];
         }
-        var u : vscode.Uri | undefined;
+        var u: vscode.Uri | undefined;
         if (folder && folder.uri) {
             u = folder.uri;
         } else {
             u = vscode.window.activeTextEditor?.document?.uri
         }
-        let result : vscode.DebugConfiguration[] = [];
-        const configNames : string[] | null | undefined = await vscode.commands.executeCommand(nbCommands.projectConfigurations, u?.toString());
+        let result: vscode.DebugConfiguration[] = [];
+        const configNames: string[] | null | undefined = await vscode.commands.executeCommand(nbCommands.projectConfigurations, u?.toString());
         if (configNames) {
-            let first : boolean = true;
+            let first: boolean = true;
             for (let cn of configNames) {
-                let cname : string;
+                let cname: string;
 
                 if (first) {
                     // ignore the default config, comes first.
@@ -112,7 +119,7 @@ class NetBeansConfigurationInitialProvider implements vscode.DebugConfigurationP
                 } else {
                     cname = "Launch Java: " + cn;
                 }
-                const debugConfig : vscode.DebugConfiguration = {
+                const debugConfig: vscode.DebugConfiguration = {
                     name: cname,
                     type: extConstants.COMMAND_PREFIX,
                     request: "launch",
@@ -135,19 +142,19 @@ class NetBeansConfigurationDynamicProvider implements vscode.DebugConfigurationP
     }
 
     provideDebugConfigurations(folder: vscode.WorkspaceFolder | undefined, token?: vscode.CancellationToken): vscode.ProviderResult<vscode.DebugConfiguration[]> {
-       return this.doProvideDebugConfigurations(folder, this.context, this.commandValues, token);
+        return this.doProvideDebugConfigurations(folder, this.context, this.commandValues, token);
     }
 
-    async doProvideDebugConfigurations(folder: vscode.WorkspaceFolder | undefined, context: ExtensionContext, commandValues: Map<string, string>, _token?:  vscode.CancellationToken):  Promise<vscode.DebugConfiguration[]> {
-        let c : LanguageClient = await globalVars.clientPromise.client;
+    async doProvideDebugConfigurations(folder: vscode.WorkspaceFolder | undefined, context: ExtensionContext, commandValues: Map<string, string>, _token?: vscode.CancellationToken): Promise<vscode.DebugConfiguration[]> {
+        let c: LanguageClient = await globalVars.clientPromise.client;
         if (!folder) {
             return [];
         }
-        let result : vscode.DebugConfiguration[] = [];
-        const attachConnectors : DebugConnector[] | null | undefined = await vscode.commands.executeCommand(extCommands.attachDebugger);
+        let result: vscode.DebugConfiguration[] = [];
+        const attachConnectors: DebugConnector[] | null | undefined = await vscode.commands.executeCommand(extCommands.attachDebugger);
         if (attachConnectors) {
             for (let ac of attachConnectors) {
-                const debugConfig : vscode.DebugConfiguration = {
+                const debugConfig: vscode.DebugConfiguration = {
                     name: ac.name,
                     type: ac.type,
                     request: "attach",
@@ -207,6 +214,61 @@ class NetBeansConfigurationResolver implements vscode.DebugConfigurationProvider
     }
 }
 
+class RunConfigurationProvider implements vscode.DebugConfigurationProvider {
+
+    resolveDebugConfiguration(_folder: vscode.WorkspaceFolder | undefined, config: vscode.DebugConfiguration, _token?: vscode.CancellationToken): vscode.ProviderResult<vscode.DebugConfiguration> {
+        return new Promise<vscode.DebugConfiguration>(resolve => {
+            resolve(config);
+        });
+    }
+
+    resolveDebugConfigurationWithSubstitutedVariables?(_folder: vscode.WorkspaceFolder | undefined, config: vscode.DebugConfiguration, _token?: vscode.CancellationToken): vscode.ProviderResult<vscode.DebugConfiguration> {
+        return new Promise<vscode.DebugConfiguration>(resolve => {
+            const args = argumentsNode.getValue();
+            if (args) {
+                if (!config.args) {
+                    config.args = args;
+                } else {
+                    config.args = `${config.args} ${args}`;
+                }
+            }
+
+            const vmArgs = vmOptionsNode.getValue();
+            if (vmArgs) {
+                if (!config.vmArgs) {
+                    config.vmArgs = vmArgs;
+                } else {
+                    config.vmArgs = `${config.vmArgs} ${vmArgs}`;
+                }
+            }
+
+            const env = environmentVariablesNode.getValue();
+            if (env) {
+                const envs = env.split(',');
+                if (!config.env) {
+                    config.env = {};
+                }
+                for (let val of envs) {
+                    val = val.trim();
+                    const div = val.indexOf('=');
+                    if (div > 0) { // div === 0 means bad format (no ENV name)
+                        config.env[val.substring(0, div)] = val.substring(div + 1, val.length);
+                    }
+                }
+            }
+
+            const cwd = workingDirectoryNode.getValue();
+            if (cwd) {
+                config.cwd = cwd;
+            }
+
+            resolve(config);
+        });
+    }
+
+}
+
+
 function onDidTerminateSession(session: vscode.DebugSession): any {
     const config = session.configuration;
     if (config.env) {