Merge remote-tracking branch 'origin/remove_vscode_disposable' into remove_vscode_disposable

Author: akshita31

src/features/commands.ts

@@ -46,7 +46,7 @@ export default function registerCommands(server: OmniSharpServer, eventStream: E
     let d7 = vscode.commands.registerCommand('dotnet.generateAssets', async () => generateAssets(server));
 
     // Register command for remote process picker for attach
-    let d8 = vscode.commands.registerCommand('csharp.listRemoteProcess', async (args) => RemoteAttachPicker.ShowAttachEntries(args));
+    let d8 = vscode.commands.registerCommand('csharp.listRemoteProcess', async (args) => RemoteAttachPicker.ShowAttachEntries(args, platformInfo));
 
     // Register command for adapter executable command.
     let d9 = vscode.commands.registerCommand('csharp.coreclrAdapterExecutableCommand', async (args) => getAdapterExecutionCommand(platformInfo, eventStream));

src/features/processPicker.ts

@@ -191,7 +191,7 @@ export class RemoteAttachPicker {
         return args.map(arg => this.quoteArg(arg)).join(" ");
     }
 
-    public static async ShowAttachEntries(args: any): Promise<string> {
+    public static async ShowAttachEntries(args: any, platformInfo: PlatformInformation): Promise<string> {
         // Create remote attach output channel for errors.
         if (!RemoteAttachPicker._channel) {
             RemoteAttachPicker._channel = vscode.window.createOutputChannel('remote-attach');
@@ -216,7 +216,7 @@ export class RemoteAttachPicker {
             let pipeTransport = this.getPipeTransportOptions(args.pipeTransport, os.platform());
 
             return RemoteAttachPicker.createPipeCmd(pipeTransport.pipeProgram, pipeTransport.pipeArgs, pipeTransport.quoteArgs)
-                .then(async pipeCmd => RemoteAttachPicker.getRemoteOSAndProcesses(pipeCmd))
+                .then(async pipeCmd => RemoteAttachPicker.getRemoteOSAndProcesses(pipeCmd, platformInfo))
                 .then(processes => {
                     let attachPickOptions: vscode.QuickPickOptions = {
                         matchOnDescription: true,
@@ -229,10 +229,10 @@ export class RemoteAttachPicker {
         }
     }
 
-    public static async getRemoteOSAndProcesses(pipeCmd: string): Promise<AttachItem[]> {
+    public static async getRemoteOSAndProcesses(pipeCmd: string, platformInfo: PlatformInformation): Promise<AttachItem[]> {
         const scriptPath = path.join(getExtensionPath(), 'scripts', 'remoteProcessPickerScript');
 
-        return execChildProcessAndOutputErrorToChannel(`${pipeCmd} < ${scriptPath}`, null, RemoteAttachPicker._channel).then(output => {
+        return execChildProcessAndOutputErrorToChannel(`${pipeCmd} < ${scriptPath}`, null, RemoteAttachPicker._channel, platformInfo).then(output => {
             // OS will be on first line
             // Processess will follow if listed
             let lines = output.split(/\r?\n/);
@@ -504,23 +504,21 @@ async function execChildProcess(process: string, workingDirectory: string): Prom
 // VSCode cannot find the path "c:\windows\system32\bash.exe" as bash.exe is only available on 64bit OS. 
 // It can be invoked from "c:\windows\sysnative\bash.exe", so adding "c:\windows\sysnative" to path if we identify
 // VSCode is running in windows and doesn't have it in the path.
-async function GetSysNativePathIfNeeded(): Promise<NodeJS.ProcessEnv> {
-    return PlatformInformation.GetCurrent().then(platformInfo => {
-        let env = process.env;
-        if (platformInfo.isWindows() && platformInfo.architecture === "x86_64") {
-            let sysnative: String = process.env.WINDIR + "\\sysnative";
-            env.Path = process.env.PATH + ";" + sysnative;
-        }
+async function GetSysNativePathIfNeeded(platformInfo: PlatformInformation): Promise<NodeJS.ProcessEnv> {
+    let env = process.env;
+    if (platformInfo.isWindows() && platformInfo.architecture === "x86_64") {
+        let sysnative: String = process.env.WINDIR + "\\sysnative";
+        env.Path = process.env.PATH + ";" + sysnative;
+    }
 
-        return env;
-    });
+    return env;
 }
 
-async function execChildProcessAndOutputErrorToChannel(process: string, workingDirectory: string, channel: vscode.OutputChannel): Promise<string> {
+async function execChildProcessAndOutputErrorToChannel(process: string, workingDirectory: string, channel: vscode.OutputChannel, platformInfo: PlatformInformation): Promise<string> {
     channel.appendLine(`Executing: ${process}`);
 
     return new Promise<string>(async (resolve, reject) => {
-        return GetSysNativePathIfNeeded().then(newEnv => {
+        return GetSysNativePathIfNeeded(platformInfo).then(newEnv => {
             child_process.exec(process, { cwd: workingDirectory, env: newEnv, maxBuffer: 500 * 1024 }, (error: Error, stdout: string, stderr: string) => {
                 let channelOutput = "";
 

src/omnisharp/launcher.ts

@@ -204,9 +204,9 @@ export interface LaunchResult {
     monoVersion?: string;
 }
 
-export async function launchOmniSharp(cwd: string, args: string[], launchInfo: LaunchInfo): Promise<LaunchResult> {
+export async function launchOmniSharp(cwd: string, args: string[], launchInfo: LaunchInfo, platformInfo: PlatformInformation): Promise<LaunchResult> {
     return new Promise<LaunchResult>((resolve, reject) => {
-        launch(cwd, args, launchInfo)
+        launch(cwd, args, launchInfo, platformInfo)
             .then(result => {
                 // async error - when target not not ENEOT
                 result.process.on('error', err => {
@@ -222,8 +222,7 @@ export async function launchOmniSharp(cwd: string, args: string[], launchInfo: L
     });
 }
 
-async function launch(cwd: string, args: string[], launchInfo: LaunchInfo): Promise<LaunchResult> {
-    const platformInfo = await PlatformInformation.GetCurrent();
+async function launch(cwd: string, args: string[], launchInfo: LaunchInfo, platformInfo: PlatformInformation): Promise<LaunchResult> {
     const options = Options.Read();
 
     if (options.useEditorFormattingSettings) {
@@ -323,7 +322,7 @@ function launchNixMono(launchPath: string, monoVersion: string, cwd: string, arg
     return {
         process,
         command: launchPath,
-        monoVersion, 
+        monoVersion,
     };
 }
 

src/omnisharp/server.ts

@@ -88,20 +88,15 @@ export class OmniSharpServer {
     private _options: Options;
 
     private _omnisharpManager: OmnisharpManager;
-    private eventStream: EventStream;
     private updateProjectDebouncer = new Subject<ObservableEvents.ProjectModified>();
     private firstUpdateProject: boolean;
-    private vscode: vscode;
 
-    constructor(vscode: vscode, networkSettingsProvider: NetworkSettingsProvider, eventStream: EventStream, packageJSON: any, platformInfo: PlatformInformation) {
-        this.eventStream = eventStream;
-        this.vscode = vscode;
+    constructor(private vscode: vscode, networkSettingsProvider: NetworkSettingsProvider, private eventStream: EventStream, packageJSON: any, private platformInfo: PlatformInformation) {
         this._requestQueue = new RequestQueueCollection(this.eventStream, 8, request => this._makeRequest(request));
         let downloader = new OmnisharpDownloader(networkSettingsProvider, this.eventStream, packageJSON, platformInfo);
         this._omnisharpManager = new OmnisharpManager(downloader, platformInfo);
         this.updateProjectDebouncer.debounceTime(1500).subscribe((event) => { this.updateProjectInfo(); });
         this.firstUpdateProject = true;
-
     }
 
     public isRunning(): boolean {
@@ -326,7 +321,7 @@ export class OmniSharpServer {
         this._fireEvent(Events.BeforeServerStart, solutionPath);
 
         try {
-            let launchResult = await launchOmniSharp(cwd, args, launchInfo);
+            let launchResult = await launchOmniSharp(cwd, args, launchInfo, this.platformInfo);
             this.eventStream.post(new ObservableEvents.OmnisharpLaunch(launchResult.monoVersion, launchResult.command, launchResult.process.pid));
 
             this._serverProcess = launchResult.process;