Implement report issue command for prerelease extension

package.json

@@ -141,6 +141,7 @@
     "typescript": "4.6.3",
     "unzipper": "0.10.11",
     "vsce": "2.9.2",
+    "vscode-uri": "^3.0.7",
     "webpack": "5.76.0",
     "webpack-cli": "4.6.0"
   },
@@ -1677,8 +1678,7 @@
       {
         "command": "csharp.reportIssue",
         "title": "Report an issue",
-        "category": "CSharp",
-        "enablement": "config.dotnet.server.useOmnisharp"
+        "category": "CSharp"
       },
       {
         "command": "csharp.showDecompilationTerms",

src/coreclr-debug/activate.ts

@@ -11,7 +11,7 @@ import { PlatformInformation } from '../shared/platform';
 import { DebuggerPrerequisiteWarning, DebuggerPrerequisiteFailure, DebuggerNotInstalledFailure } from '../omnisharp/loggingEvents';
 import { EventStream } from '../EventStream';
 import { getRuntimeDependencyPackageWithId } from '../tools/RuntimeDependencyPackageUtils';
-import { getDotnetInfo } from '../utils/getDotnetInfo';
+import { getDotnetInfo } from '../shared/utils/getDotnetInfo';
 import { Options } from '../shared/options';
 import { RemoteAttachPicker } from '../features/processPicker';
 import CompositeDisposable from '../CompositeDisposable';

src/coreclr-debug/util.ts

@@ -8,7 +8,7 @@ import * as fs from 'fs';
 import * as semver from 'semver';
 import * as os from 'os';
 import { PlatformInformation } from '../shared/platform';
-import { getDotnetInfo, DotnetInfo } from '../utils/getDotnetInfo';
+import { getDotnetInfo, DotnetInfo } from '../shared/utils/getDotnetInfo';
 
 const MINIMUM_SUPPORTED_DOTNET_CLI: string = '1.0.0';
 
@@ -127,6 +127,10 @@ export function getTargetArchitecture(platformInfo: PlatformInformation, launchJ
     }
 
     // Otherwise, look at the runtime ID.
+    if (!dotnetInfo.RuntimeId) {
+        throw new Error(`Unable to determine RuntimeId. Please set 'targetArchitecture' in your launch.json configuration.`);
+    }
+
     if (dotnetInfo.RuntimeId.includes('arm64'))
     {
         return 'arm64';

src/features/commands.ts

@@ -18,9 +18,9 @@ import { EventStream } from '../EventStream';
 import { PlatformInformation } from '../shared/platform';
 import CompositeDisposable from '../CompositeDisposable';
 import OptionProvider from '../shared/observers/OptionProvider';
-import reportIssue from './reportIssue';
+import reportIssue from '../shared/reportIssue';
 import { IHostExecutableResolver } from '../shared/constants/IHostExecutableResolver';
-import { getDotnetInfo } from '../utils/getDotnetInfo';
+import { getDotnetInfo } from '../shared/utils/getDotnetInfo';
 import { getDecompilationAuthorization, resetDecompilationAuthorization } from '../omnisharp/decompilationPrompt';
 import { IWorkspaceDebugInformationProvider } from '../shared/IWorkspaceDebugInformationProvider';
 
@@ -47,7 +47,7 @@ export default function registerCommands(
     // Register command for generating tasks.json and launch.json assets.
     disposable.add(vscode.commands.registerCommand('dotnet.generateAssets', async (selectedIndex) => generateAssets(workspaceInformationProvider, selectedIndex)));
 
-    disposable.add(vscode.commands.registerCommand('csharp.reportIssue', async () => reportIssue(vscode, context.extension.packageJSON.version, eventStream, getDotnetInfo, platformInfo.isValidPlatformForMono(), optionProvider.GetLatestOptions(), dotnetResolver, monoResolver)));
+    disposable.add(vscode.commands.registerCommand('csharp.reportIssue', async () => reportIssue(vscode, context.extension.packageJSON.version, getDotnetInfo, platformInfo.isValidPlatformForMono(), optionProvider.GetLatestOptions(), dotnetResolver, monoResolver)));
 
     disposable.add(vscode.commands.registerCommand('csharp.showDecompilationTerms', async () => showDecompilationTerms(context, server, optionProvider)));
 

src/lsptoolshost/commands.ts

@@ -8,8 +8,12 @@ import { UriConverter } from './uriConverter';
 import * as languageClient from 'vscode-languageclient/node';
 import { RoslynLanguageServer } from './roslynLanguageServer';
 import { createLaunchTargetForSolution } from '../shared/LaunchTarget';
+import reportIssue from '../shared/reportIssue';
+import { getDotnetInfo } from '../shared/utils/getDotnetInfo';
+import OptionProvider from '../shared/observers/OptionProvider';
+import { IHostExecutableResolver } from '../shared/constants/IHostExecutableResolver';
 
-export function registerCommands(context: vscode.ExtensionContext, languageServer: RoslynLanguageServer) {
+export function registerCommands(context: vscode.ExtensionContext, languageServer: RoslynLanguageServer, optionProvider: OptionProvider, hostExecutableResolver: IHostExecutableResolver) {
     // It is very important to be careful about the types used as parameters for these command callbacks.
     // If the arguments are coming from the server as json, it is NOT appropriate to use type definitions
     // from the normal vscode API (e.g. vscode.Location) as input parameters.
@@ -23,6 +27,7 @@ export function registerCommands(context: vscode.ExtensionContext, languageServe
     context.subscriptions.push(vscode.commands.registerCommand('roslyn.client.completionComplexEdit', completionComplexEdit));
     context.subscriptions.push(vscode.commands.registerCommand('dotnet.restartServer', async () => restartServer(languageServer)));
     context.subscriptions.push(vscode.commands.registerCommand('dotnet.openSolution', async () => openSolution(languageServer)));
+    context.subscriptions.push(vscode.commands.registerCommand('csharp.reportIssue', async () => reportIssue(vscode, context.extension.packageJSON.version, getDotnetInfo, /*shouldIncludeMonoInfo:*/ false, optionProvider.GetLatestOptions(), hostExecutableResolver)));
 }
 
 /**

src/lsptoolshost/dotnetRuntimeExtensionResolver.ts

@@ -0,0 +1,104 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as path from 'path';
+import * as vscode from 'vscode';
+import { HostExecutableInformation } from "../shared/constants/HostExecutableInformation";
+import { IHostExecutableResolver } from "../shared/constants/IHostExecutableResolver";
+import { PlatformInformation } from "../shared/platform";
+import { Options } from "../shared/options";
+import { existsSync } from 'fs';
+import { CSharpExtensionId } from '../constants/CSharpExtensionId';
+
+export const DotNetRuntimeVersion = '7.0';
+
+interface IDotnetAcquireResult {
+    dotnetPath: string;
+}
+
+/**
+ * Resolves the dotnet runtime for a server executable from given options and the dotnet runtime VSCode extension.
+ */
+export class DotnetRuntimeExtensionResolver implements IHostExecutableResolver {
+    constructor(
+        private platformInfo: PlatformInformation,
+        /**
+         * This is a function instead of a string because the server path can change while the extension is active (when the option changes).
+         */
+        private getServerPath: (options: Options, platform: PlatformInformation) => string) { }
+
+    private hostInfo: HostExecutableInformation | undefined;
+
+    async getHostExecutableInfo(options: Options): Promise<HostExecutableInformation> {
+        let dotnetRuntimePath = options.commonOptions.dotnetPath;
+        const serverPath = this.getServerPath(options, this.platformInfo);
+        if (!dotnetRuntimePath) {
+            let dotnetInfo = await this.acquireDotNetProcessDependencies(serverPath);
+            dotnetRuntimePath = path.dirname(dotnetInfo.path);
+        }
+
+        const dotnetExecutableName = this.platformInfo.isWindows() ? 'dotnet.exe' : 'dotnet';
+        const dotnetExecutablePath = path.join(dotnetRuntimePath, dotnetExecutableName);
+        if (!existsSync(dotnetExecutablePath)) {
+            throw new Error(`Cannot find dotnet path '${dotnetExecutablePath}'`);
+        }
+
+        return {
+            version: "", /* We don't need to know the version - we've already downloaded the correct one */
+            path: dotnetExecutablePath,
+            env: process.env,
+        };
+    }
+
+    /**
+     * Acquires the .NET runtime if it is not already present.
+     * @returns The path to the .NET runtime
+     */
+    private async acquireRuntime(): Promise<HostExecutableInformation> {
+        if (this.hostInfo) {
+            return this.hostInfo;
+        }
+
+        let status = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet.acquireStatus', {
+            version: DotNetRuntimeVersion,
+            requestingExtensionId: CSharpExtensionId,
+        });
+        if (status === undefined) {
+            await vscode.commands.executeCommand('dotnet.showAcquisitionLog');
+
+            status = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet.acquire', {
+                version: DotNetRuntimeVersion,
+                requestingExtensionId: CSharpExtensionId,
+            });
+            if (!status?.dotnetPath) {
+                throw new Error('Could not resolve the dotnet path!');
+            }
+        }
+
+        return (this.hostInfo = {
+            version: DotNetRuntimeVersion,
+            path: status.dotnetPath,
+            env: process.env
+        });
+    }
+
+    /**
+     * Acquires the .NET runtime and any other dependencies required to spawn a particular .NET executable.
+     * @param path The path to the entrypoint assembly. Typically a .dll.
+     * @returns The path to the `dotnet` command to use to spawn the process.
+     */
+    private async acquireDotNetProcessDependencies(path: string) {
+        const dotnetPath = await this.acquireRuntime();
+
+        const args = [path];
+        // This will install any missing Linux dependencies.
+        await vscode.commands.executeCommand('dotnet.ensureDotnetDependencies', { command: dotnetPath, arguments: args });
+
+        return dotnetPath;
+    }
+}
+
+
+