Enable regenerating the runsettings file for a particular configuration so OmniSharp will run tests against the correct runtime.

Refactor OutputConfiguration into a separate file from userPrompts.

Fixes #8 as best as possible.

This still depends on either the PATH and DOTNET_ROOT being set to the correct folder (like how the -vs flag on the dotnet/runtime build.cmd script has), a global SDK being installed with a new enough version, or dotnet/vscode-csharp#4738 being implemented.

Author: jkoritzinsky

.editorconfig

@@ -0,0 +1,2 @@
+[*.cs]
+dotnet_diagnostic.VSTHRD200.severity = none

.vscode/launch.json

@@ -22,6 +22,17 @@
 			"type": "coreclr",
 			"request": "attach"
 		},
+		{
+			"name": "Launch Assistant Server",
+			"type": "coreclr",
+			"request": "launch",
+			"preLaunchTask": "Server - Single Build",
+			"program": "${workspaceFolder}/out/server/AssistantServer.dll",
+			"args": [],
+			"cwd": "${workspaceFolder}/out",
+			"stopAtEntry": true,
+			"console": "internalConsole",
+		},
 		{
 			"name": "Extension Tests",
 			"type": "extensionHost",
@@ -36,4 +47,4 @@
 			"preLaunchTask": "${defaultBuildTask}"
 		}
 	]
-}
+}

.vscode/tasks.json

@@ -41,6 +41,7 @@
 			}
 		},
 		{
+			"label": "Server - Single Build",
 			"type": "npm",
 			"script": "publish-server",
 			"problemMatcher": "$msCompile",

package.json

@@ -18,8 +18,9 @@
 		"Other"
 	],
 	"activationEvents": [
-		"onCommand:dotnet-runtime-test-assistant.importSettingsFromDevContainer",
 		"onCommand:dotnet-runtime-test-assistant.startServerIfNotStarted",
+		"onCommand:dotnet-runtime-test-assistant.importSettingsFromDevContainer",
+		"onCommand:dotnet-runtime-test-assistant.configureRunSettingsFileForTestRun",
 		"onDebugResolve:rt-runtimetest",
 		"onDebugDynamicConfigurations:rt-runtimetest",
 		"onDebugResolve:rt-cg2corelib",
@@ -39,6 +40,10 @@
 			{
 				"command": "dotnet-runtime-test-assistant.importSettingsFromDevContainer",
 				"title": "DN/RT-Test: Import settings from .devcontainer file"
+			},
+			{
+				"command": "dotnet-runtime-test-assistant.configureRunSettingsFileForTestRun",
+				"title": "DN/RT-Test: Configure the .runsettings file for running tests in VSCode"
 			}
 		],
 		"debuggers": [

src/commands.ts

@@ -1,8 +1,9 @@
 import path = require('path');
 import * as vscode from 'vscode';
 import { parse } from 'jsonc-parser';
-import { getRuntimeWorkspaceFolder } from './userPrompts';
+import { getRuntimeWorkspaceFolder, promptUserForTargetConfiguration } from './userPrompts';
 import { readFile } from 'fs/promises';
+import { tryCreateVsCodeRunSettings } from './server';
 
 // Import settings from the devcontainer configuration file into the local .vscode/settings.json file
 // if the setting is not already specified.
@@ -26,4 +27,21 @@ export async function importSettingsFromDevContainer() {
             }
         }
     }
+}
+
+export async function configureRunSettingsFileForTestRun() {
+    const workspace = await getRuntimeWorkspaceFolder();
+    if (!workspace) {
+        return;
+    }
+    const configuration = await promptUserForTargetConfiguration({ promptPrefix: 'Libraries Test Host', showChecked: false, defaultConfiguration: 'Debug' });
+    if (!configuration) {
+        return;
+    }
+    const success = await tryCreateVsCodeRunSettings(path.join(workspace.fsPath, 'src', 'libraries', 'pretest.proj'), configuration);
+    if (success) {
+        vscode.window.showInformationMessage('Regenerated the runsettings file for running .NET tests');
+    } else {
+        vscode.window.showErrorMessage('Unable to regenerate runsettings file. Check the dotnet-runtime-assistant-server log output for details');
+    }
 }

src/extension.ts

@@ -4,13 +4,14 @@ import * as crossgen2CoreLibTestProvider from './providers/crossgen2-corelib';
 import * as crossgen2TestProvider from './providers/crossgen2';
 import * as libsNativeTestProvider from './providers/libs-native';
 import { setServerPathFromExtensionContext, getOrStartServerConnection } from './server';
-import { importSettingsFromDevContainer } from './commands';
+import { configureRunSettingsFileForTestRun, importSettingsFromDevContainer } from './commands';
 
 // this method is called when your extension is activated
 // your extension is activated the very first time the command is executed
 export function activate(context: vscode.ExtensionContext) {
 	context.subscriptions.push(vscode.commands.registerCommand('dotnet-runtime-test-assistant.startServerIfNotStarted', getOrStartServerConnection));
 	context.subscriptions.push(vscode.commands.registerCommand('dotnet-runtime-test-assistant.importSettingsFromDevContainer', importSettingsFromDevContainer));
+	context.subscriptions.push(vscode.commands.registerCommand('dotnet-runtime-test-assistant.configureRunSettingsFileForTestRun', configureRunSettingsFileForTestRun));
 
 	context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider(runtimeTestProvider.DEBUG_CONFIGURATION_TYPE, runtimeTestProvider, vscode.DebugConfigurationProviderTriggerKind.Dynamic));
 	context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider(runtimeTestProvider.DEBUG_CONFIGURATION_TYPE, runtimeTestProvider));

src/helpers.ts

@@ -1,7 +1,7 @@
 
 import * as path from 'path';
 import { DebugConfiguration, Uri } from 'vscode';
-import { OutputConfiguration } from './userPrompts';
+import { OutputConfiguration } from './outputConfiguration';
 
 export function transformEnvBlock(env: { [key: string]: string }): { key: string, value: string }[] {
     let result = [];

src/outputConfiguration.ts

@@ -0,0 +1,2 @@
+
+export type OutputConfiguration = { os: string; arch: string; configuration: string; };

src/providers/crossgen2-corelib.ts

@@ -2,13 +2,13 @@ import * as path from 'path';
 import * as vscode from 'vscode';
 import * as userPrompts from '../userPrompts';
 import { DebugConfigurationBase, getCoreClrOutputRootPath } from '../helpers';
+import { OutputConfiguration } from '../outputConfiguration';
 
 type DebugConfigurationType = 'rt-cg2corelib';
 
-export const DEBUG_CONFIGURATION_TYPE : DebugConfigurationType = 'rt-cg2corelib';
+export const DEBUG_CONFIGURATION_TYPE: DebugConfigurationType = 'rt-cg2corelib';
 
-interface Crossgen2CoreLibConfiguration extends DebugConfigurationBase
-{
+interface Crossgen2CoreLibConfiguration extends DebugConfigurationBase {
     type: DebugConfigurationType;
     separateConfig?: boolean;
 }
@@ -19,8 +19,8 @@ function isCrossgen2CoreLibConfiguration(debugConfiguration: vscode.DebugConfigu
 
 export function transformConfigForCoreLib(debugConfiguration: Crossgen2CoreLibConfiguration, crossgenBuildCoreClrBin: string, corelibBuildCoreClrBin: string, targetArch: string) {
     return {
-        name : debugConfiguration.name,
-        type : 'coreclr',
+        name: debugConfiguration.name,
+        type: 'coreclr',
         request: 'launch',
         program: path.join(crossgenBuildCoreClrBin, 'crossgen2', 'crossgen2.dll'),
         args: [
@@ -51,8 +51,8 @@ export async function resolveDebugConfiguration(folder: vscode.WorkspaceFolder |
         if (!folder) {
             return undefined;
         }
-        let crossgen2Config: userPrompts.OutputConfiguration | undefined;
-        let corelibConfig: userPrompts.OutputConfiguration | undefined;
+        let crossgen2Config: OutputConfiguration | undefined;
+        let corelibConfig: OutputConfiguration | undefined;
         if (debugConfiguration.separateConfig) {
             crossgen2Config = await userPrompts.promptUserForTargetConfiguration({ promptPrefix: 'Crossgen2', showChecked: true, defaultConfiguration: 'Debug' });
             if (crossgen2Config) {

src/providers/crossgen2.ts

@@ -6,6 +6,7 @@ import { copyFile, writeFile, mkdir } from 'fs/promises';
 import { promisify } from 'util';
 import { glob } from 'glob';
 import { existsSync } from 'fs';
+import { OutputConfiguration } from '../outputConfiguration';
 
 type DebugConfigurationType = 'rt-cg2rt';
 
@@ -81,8 +82,8 @@ export async function resolveDebugConfiguration(folder: vscode.WorkspaceFolder |
         if (!folder) {
             return undefined;
         }
-        let crossgen2Config: userPrompts.OutputConfiguration | undefined;
-        let testConfig: userPrompts.OutputConfiguration | undefined;
+        let crossgen2Config: OutputConfiguration | undefined;
+        let testConfig: OutputConfiguration | undefined;
         if (debugConfiguration.separateConfig) {
             crossgen2Config = await userPrompts.promptUserForTargetConfiguration({ promptPrefix: 'Crossgen2', showChecked: true, defaultConfiguration: 'Debug' });
             if (crossgen2Config) {

src/server.ts

@@ -5,7 +5,8 @@ import * as path from 'path';
 import { getRuntimeWorkspaceFolder } from './userPrompts';
 import * as os from 'os';
 import log from './log';
-import { RequestType2 } from 'vscode-jsonrpc/node';
+import { RequestType2, RequestType4 } from 'vscode-jsonrpc/node';
+import { OutputConfiguration } from './outputConfiguration';
 
 export function setServerPathFromExtensionContext(context: vscode.ExtensionContext) {
     serverPath = path.join(context.extensionUri.fsPath, 'out', 'server', 'AssistantServer.dll');
@@ -38,7 +39,7 @@ export async function getOrStartServerConnection(): Promise<rpc.MessageConnectio
     log(`starting server process at path: '${serverPath}'`);
     let serverProc = cp.spawn(
         path.join(runtimeWorkspaceFolder.fsPath, `dotnet${getDotnetScriptExtension()}`),
-        [ serverPath ]);
+        [serverPath]);
     serverProc.stderr.setEncoding('utf8');
     serverProc.stderr.on('data', data => {
         serverLog.append(data.toString());
@@ -61,27 +62,37 @@ export async function getOrStartServerConnection(): Promise<rpc.MessageConnectio
     return currentServerConnection;
 }
 
-namespace Protocol {
+namespace GetProjectProperties {
+    export const method = 'GetProjectProperties';
 
-    export namespace GetProjectProperties {
-        export const method = 'GetProjectProperties';
+    type Response<TProperties extends string[]> = {
+        [key in TProperties[number]]: string;
+    };
 
-        type Response<TProperties extends string[]> = {
-            [key in TProperties[number]]: string;
-        };
-
-        export function getRequestType<TProperties extends string[]>() {
-            return new RequestType2<string, TProperties, Response<TProperties>, void>(method);
-        }
+    export function getRequestType<TProperties extends string[]>() {
+        return new RequestType2<string, TProperties, Response<TProperties>, void>(method);
     }
 }
 
 export async function getProjectProperties<TProperty extends string>(projectFilePath: string, ...properties: TProperty[]) {
+    log(`Getting the following properties defined in the project file at '${projectFilePath}': ${properties}`);
     const serverConnection = await getOrStartServerConnection();
-    return await serverConnection.sendRequest(Protocol.GetProjectProperties.getRequestType<TProperty[]>(), projectFilePath,  properties);
+    return await serverConnection.sendRequest(GetProjectProperties.getRequestType<TProperty[]>(), projectFilePath, properties);
 }
 
 export async function getNetCoreAppCurrentProperty() {
     const runtimeWorkspaceFolder = await getRuntimeWorkspaceFolder();
     return (await getProjectProperties(path.join(runtimeWorkspaceFolder!.fsPath, 'Build.proj'), 'NetCoreAppCurrent')).NetCoreAppCurrent;
 }
+
+namespace TryCreateVsCodeRunSettings {
+    export const method = 'TryCreateVsCodeRunSettings';
+
+    export const type = new RequestType4<string, string, string, string, boolean, void>(method);
+}
+
+export async function tryCreateVsCodeRunSettings(preTestProjectPath: string, configuration: OutputConfiguration) {
+    log(`Regenerating the vscode RunSettings file for the provided configuration '${configuration.os}-${configuration.configuration}-${configuration.arch}'`);
+    const serverConnection = await getOrStartServerConnection();
+    return await serverConnection.sendRequest(TryCreateVsCodeRunSettings.type, preTestProjectPath, configuration.os, configuration.arch, configuration.configuration);
+}

src/server/Log.cs

@@ -24,4 +24,11 @@ internal static partial class Log
         Message = "Getting properties '{properties}' from project file '{projectFile}'."
     )]
     public static partial void GetProjectProperties(this ILogger logger, string projectFile, string[] properties);
+
+    [LoggerMessage(
+        EventId = 3,
+        Level = LogLevel.Information,
+        Message = "MSBuild: {message}"
+    )]
+    public static partial void LogMSBuildOutput(this ILogger logger, string message);
 }

src/server/MSBuildLocatorRegistration.cs

@@ -0,0 +1,13 @@
+using Microsoft.Build.Locator;
+
+namespace AssistantServer;
+
+internal static class MSBuildLocatorRegistration
+{
+    static MSBuildLocatorRegistration()
+    {
+        MSBuildLocator.RegisterInstance(MSBuildLocator.QueryVisualStudioInstances(new VisualStudioInstanceQueryOptions { DiscoveryTypes = DiscoveryType.DotNetSdk }).First());
+    }
+
+    public static void Register() { }
+}

src/server/MSBuildRunner.cs

@@ -1,41 +1,61 @@
-using Microsoft.Build.Construction;
-using Microsoft.Build.Evaluation;
+using Microsoft.Build.Evaluation;
+using Microsoft.Build.Execution;
 using Microsoft.Build.Locator;
+using Microsoft.Build.Logging;
 using Microsoft.Extensions.Logging;
+using MSBuildLoggerVerbosity = Microsoft.Build.Framework.LoggerVerbosity;
 
 namespace AssistantServer;
 
 internal sealed partial class MSBuildRunner
 {
+    private readonly ProjectCollection projectCollection;
+    private readonly BuildManager buildManager;
     private readonly ILogger logger;
 
     public MSBuildRunner(ILogger logger)
     {
         this.logger = logger;
-    }
-
-    static MSBuildRunner()
-    {
-        MSBuildLocator.RegisterInstance(MSBuildLocator.QueryVisualStudioInstances(new VisualStudioInstanceQueryOptions { DiscoveryTypes = DiscoveryType.DotNetSdk }).First());
+        projectCollection = new ProjectCollection();
+        // Forward the MSBuild logging through our logging mechanism
+        projectCollection.RegisterLogger(new ConsoleLogger(MSBuildLoggerVerbosity.Normal, line => logger.LogMSBuildOutput(line), _ => { }, () => { }));
+        buildManager = new BuildManager("AssistantServer");
+        buildManager.BeginBuild(new BuildParameters(projectCollection));
     }
 
     public string[] GetProjectTargetFrameworks(string projectPath)
     {
         logger.GetProjectTargetFrameworks(projectPath);
-        var project = new Project(ProjectRootElement.Open(projectPath));
+        var project = projectCollection.LoadProject(projectPath);
         var targetFrameworks = project.GetPropertyValue("TargetFrameworks");
         return !string.IsNullOrEmpty(targetFrameworks) ? targetFrameworks.Split(';') : new string[] { project.GetPropertyValue("TargetFramework") };
     }
 
     public Dictionary<string, string> GetProjectProperties(string projectPath, string[] properties)
     {
         logger.GetProjectProperties(projectPath, properties);
-        var project = new Project(ProjectRootElement.Open(projectPath));
+        var project = projectCollection.LoadProject(projectPath);
         Dictionary<string, string> results = new();
         foreach (var property in properties)
         {
             results[property] = project.GetPropertyValue(property);
         }
         return results;
     }
+
+    public bool TryCreateVsCodeRunSettings(string preTestProject, string operatingSystem, string architecture, string configuration)
+    {
+        var projectInstance = buildManager.GetProjectInstanceForBuild(
+            projectCollection.LoadProject(preTestProject, new Dictionary<string, string>
+            {
+                { "TargetOS", operatingSystem },
+                { "TargetArchitecture", architecture },
+                { "Configuration", configuration },
+                { "CreateVsCodeRunSettingsFile", "true" }
+            },
+            projectCollection.DefaultToolsVersion));
+        var submission = buildManager.BuildRequest(new BuildRequestData(projectInstance, new[] { "GenerateRunSettingsFile" }));
+
+        return submission.OverallResult == BuildResultCode.Success;
+    }
 }

src/server/RpcService.cs

@@ -17,6 +17,7 @@ protected override Task ExecuteAsync(CancellationToken stoppingToken)
     {
         logger.Startup(Environment.ProcessId);
 
+        MSBuildLocatorRegistration.Register();
         var rpc = JsonRpc.Attach(Console.OpenStandardOutput(), Console.OpenStandardInput(), new MSBuildRunner(logger));
 
         stoppingToken.Register(() => rpc.Dispose());