Merge remote-tracking branch 'upstream/main' into eslint

Author: dibarbet

package-lock.json

@@ -6,6 +6,7 @@
   "displayName": "C#",
   "author": "Microsoft Corporation",
   "license": "SEE LICENSE IN RuntimeLicenses/license.txt",
+  "qna": "https://github.com/dotnet/vscode-csharp/issues",
   "icon": "images/csharpIcon.png",
   "preview": false,
   "bugs": {
@@ -35,7 +36,7 @@
     }
   },
   "defaults": {
-    "roslyn": "4.7.0-3.23316.4",
+    "roslyn": "4.7.0-3.23326.2",
     "omniSharp": "1.39.6",
     "razor": "7.0.0-preview.23275.2"
   },
@@ -150,6 +151,7 @@
     "typescript": "^5.1.3",
     "unzipper": "0.10.11",
     "vsce": "2.9.2",
+    "vscode-uri": "^3.0.7",
     "webpack": "5.76.0",
     "webpack-cli": "4.6.0"
   },
@@ -1686,8 +1688,7 @@
       {
         "command": "csharp.reportIssue",
         "title": "Report an issue",
-        "category": "CSharp",
-        "enablement": "config.dotnet.server.useOmnisharp"
+        "category": "CSharp"
       },
       {
         "command": "csharp.showDecompilationTerms",

package.json

@@ -15,7 +15,7 @@ import {
 } 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/constants/IGetDotnetInfo.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 = '1.0.0';
 
@@ -133,6 +133,12 @@ export function getTargetArchitecture(
     }
 
     // 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';
     } else if (dotnetInfo.RuntimeId.includes('x64')) {

src/coreclrDebug/activate.ts

@@ -24,9 +24,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';
 
@@ -79,7 +79,6 @@ export default function registerCommands(
             reportIssue(
                 vscode,
                 context.extension.packageJSON.version,
-                eventStream,
                 getDotnetInfo,
                 platformInfo.isValidPlatformForMono(),
                 optionProvider.GetLatestOptions(),

src/coreclrDebug/util.ts

@@ -8,8 +8,17 @@ 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.
@@ -29,6 +38,18 @@ export function registerCommands(context: vscode.ExtensionContext, languageServe
     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/features/commands.ts

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------------------------
+ *  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) {
+            const 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;
+    }
+}