Add Rust hosting package and VS Code debugger wiring

Aspire-Core.slnf

@@ -32,6 +32,7 @@
       "src\\Aspire.Hosting.JavaScript\\Aspire.Hosting.JavaScript.csproj",
       "src\\Aspire.Hosting.PostgreSQL\\Aspire.Hosting.PostgreSQL.csproj",
       "src\\Aspire.Hosting.Python\\Aspire.Hosting.Python.csproj",
+      "src\\Aspire.Hosting.Rust\\Aspire.Hosting.Rust.csproj",
       "src\\Aspire.Hosting.RabbitMQ\\Aspire.Hosting.RabbitMQ.csproj",
       "src\\Aspire.Hosting.Redis\\Aspire.Hosting.Redis.csproj",
       "src\\Aspire.Hosting.SqlServer\\Aspire.Hosting.SqlServer.csproj",
@@ -58,6 +59,7 @@
       "tests\\Aspire.Hosting.EntityFrameworkCore.Tests\\Aspire.Hosting.EntityFrameworkCore.Tests.csproj",
       "tests\\Aspire.Hosting.Testing.Tests\\Aspire.Hosting.Testing.Tests.csproj",
       "tests\\Aspire.Hosting.Tests\\Aspire.Hosting.Tests.csproj",
+      "tests\\Aspire.Hosting.Rust.Tests\\Aspire.Hosting.Rust.Tests.csproj",
       "tests\\Aspire.TestUtilities\\Aspire.TestUtilities.csproj",
       "tests\\TestingAppHost1\\TestingAppHost1.AppHost\\TestingAppHost1.AppHost.csproj",
       "tests\\TestingAppHost1\\TestingAppHost1.MyWebApp\\TestingAppHost1.MyWebApp.csproj",

Aspire.slnx

@@ -73,6 +73,7 @@
     <Project Path="src/Aspire.Hosting.Orleans/Aspire.Hosting.Orleans.csproj" />
     <Project Path="src/Aspire.Hosting.PostgreSQL/Aspire.Hosting.PostgreSQL.csproj" />
     <Project Path="src/Aspire.Hosting.Python/Aspire.Hosting.Python.csproj" />
+    <Project Path="src/Aspire.Hosting.Rust/Aspire.Hosting.Rust.csproj" />
     <Project Path="src/Aspire.Hosting.Qdrant/Aspire.Hosting.Qdrant.csproj" />
     <Project Path="src/Aspire.Hosting.RabbitMQ/Aspire.Hosting.RabbitMQ.csproj" />
     <Project Path="src/Aspire.Hosting.Radius/Aspire.Hosting.Radius.csproj" />
@@ -547,6 +548,7 @@
     <Project Path="tests/Aspire.Hosting.Orleans.Tests/Aspire.Hosting.Orleans.Tests.csproj" />
     <Project Path="tests/Aspire.Hosting.PostgreSQL.Tests/Aspire.Hosting.PostgreSQL.Tests.csproj" />
     <Project Path="tests/Aspire.Hosting.Python.Tests/Aspire.Hosting.Python.Tests.csproj" />
+    <Project Path="tests/Aspire.Hosting.Rust.Tests/Aspire.Hosting.Rust.Tests.csproj" />
     <Project Path="tests/Aspire.Hosting.Qdrant.Tests/Aspire.Hosting.Qdrant.Tests.csproj" />
     <Project Path="tests/Aspire.Hosting.RabbitMQ.Tests/Aspire.Hosting.RabbitMQ.Tests.csproj" />
     <Project Path="tests/Aspire.Hosting.Radius.Tests/Aspire.Hosting.Radius.Tests.csproj" />

extension/src/capabilities.ts

@@ -15,6 +15,11 @@ export type Capability =
     | 'ms-python.python' // Older AppHost versions used this extension identifier instead of python
     | 'go' // Support for running Go projects
     | 'golang.go' // Older AppHost versions used this extension identifier instead of go
+    | 'cppvsdbg' // C++ debugger adapter type used for Rust debugging on Windows
+    | 'cppdbg' // C++ debugger adapter type fallback
+    | 'rust' // Support for running Rust projects
+    | 'rust-lang.rust-analyzer' // Rust Analyzer extension identifier
+    | 'vadimcn.vscode-lldb' // CodeLLDB extension identifier
     | 'node' // Support for running Node.js projects
     | 'bun' // Support for running Bun projects
     | 'oven.bun-vscode' // Bun debug adapter extension identifier
@@ -24,12 +29,42 @@ export type Capability =
     | 'azure-functions'; // Support for running Azure Functions projects
 
 export type Capabilities = Capability[];
+export type RustDebugAdapterType = 'cppvsdbg' | 'cppdbg' | 'lldb' | 'codelldb';
 
 function isExtensionInstalled(extensionId: string): boolean {
     const extension = vscode.extensions.getExtension(extensionId);
     return !!extension;
 }
 
+function hasDebuggerType(debuggerType: RustDebugAdapterType): boolean {
+    return vscode.extensions.all.some((extension) => {
+        const debuggers = (extension.packageJSON as { contributes?: { debuggers?: Array<{ type?: string }> } }).contributes?.debuggers;
+        return Array.isArray(debuggers) && debuggers.some(entry => entry.type === debuggerType);
+    });
+}
+
+export function getRustDebugAdapterType(): RustDebugAdapterType | undefined {
+    if (process.platform === 'win32') {
+        if (hasDebuggerType('cppvsdbg')) {
+            return 'cppvsdbg';
+        }
+
+        if (hasDebuggerType('cppdbg')) {
+            return 'cppdbg';
+        }
+    }
+
+    if (hasDebuggerType('lldb') || isExtensionInstalled("vadimcn.vscode-lldb")) {
+        return 'lldb';
+    }
+
+    if (hasDebuggerType('codelldb')) {
+        return 'codelldb';
+    }
+
+    return undefined;
+}
+
 export function isCsDevKitInstalled() {
     return isExtensionInstalled("ms-dotnettools.csdevkit");
 }
@@ -46,6 +81,10 @@ export function isGoInstalled() {
     return isExtensionInstalled("golang.go");
 }
 
+export function isRustInstalled() {
+    return getRustDebugAdapterType() !== undefined;
+}
+
 export function isAzureFunctionsExtensionInstalled() {
     return isExtensionInstalled("ms-azuretools.vscode-azurefunctions");
 }
@@ -92,6 +131,18 @@ export function getSupportedCapabilities(): Capabilities {
         capabilities.push("golang.go");
     }
 
+    if (isRustInstalled()) {
+        capabilities.push("rust");
+
+        if (isExtensionInstalled("rust-lang.rust-analyzer")) {
+            capabilities.push("rust-lang.rust-analyzer");
+        }
+
+        if (isExtensionInstalled("vadimcn.vscode-lldb")) {
+            capabilities.push("vadimcn.vscode-lldb");
+        }
+    }
+
     if (isNodeInstalled()) {
         capabilities.push("node");
         capabilities.push("browser");

extension/src/dcp/types.ts

@@ -56,6 +56,21 @@ export function isGoLaunchConfiguration(obj: any): obj is GoLaunchConfiguration
     return obj && obj.type === 'go';
 }
 
+export interface RustCargoLaunchTarget {
+    args?: string[];
+    filter?: string;
+}
+
+export interface RustLaunchConfiguration extends ExecutableLaunchConfiguration {
+    type: "rust";
+    cargo?: RustCargoLaunchTarget;
+    working_directory?: string;
+}
+
+export function isRustLaunchConfiguration(obj: any): obj is RustLaunchConfiguration {
+    return obj && obj.type === 'rust';
+}
+
 export interface JavaScriptRuntimeLaunchConfiguration extends ExecutableLaunchConfiguration {
     type: "node" | "bun";
     script_path?: string;

extension/src/debugger/debuggerExtensions.ts

@@ -4,12 +4,13 @@ import { debugProject, runProject } from "../loc/strings";
 import { getEnvironmentWithoutE2EBridgeVariables, mergeEnvs } from "../utils/environment";
 import { extensionLogOutputChannel } from "../utils/logging";
 import { projectDebuggerExtension } from "./languages/dotnet";
-import { isAzureFunctionsExtensionInstalled, isBunInstalled, isCsharpInstalled, isGoInstalled, isMauiInstalled, isPythonInstalled } from '../capabilities';
+import { isAzureFunctionsExtensionInstalled, isBunInstalled, isCsharpInstalled, isGoInstalled, isMauiInstalled, isPythonInstalled, isRustInstalled } from '../capabilities';
 import { pythonDebuggerExtension } from "./languages/python";
 import { nodeDebuggerExtension } from "./languages/node";
 import { browserDebuggerExtension } from "./languages/browser";
 import { azureFunctionsDebuggerExtension } from "./languages/azureFunctions";
 import { goDebuggerExtension } from "./languages/go";
+import { rustDebuggerExtension } from "./languages/rust";
 import { bunDebuggerExtension } from "./languages/bun";
 import { mauiDebuggerExtension } from "./languages/maui";
 import { isDirectory } from "../utils/io";
@@ -89,6 +90,10 @@ export function getResourceDebuggerExtensions(): ResourceDebuggerExtension[] {
         extensions.push(goDebuggerExtension);
     }
 
+    if (isRustInstalled()) {
+        extensions.push(rustDebuggerExtension);
+    }
+
     extensions.push(nodeDebuggerExtension);
     extensions.push(browserDebuggerExtension);
 

extension/src/debugger/languages/rust.ts

@@ -0,0 +1,83 @@
+import * as path from 'path';
+import * as vscode from 'vscode';
+import { getRustDebugAdapterType } from "../../capabilities";
+import { AspireResourceExtendedDebugConfiguration, ExecutableLaunchConfiguration, RustLaunchConfiguration, isRustLaunchConfiguration } from "../../dcp/types";
+import { invalidLaunchConfiguration, rustDisplayName, rustLabel } from "../../loc/strings";
+import { extensionLogOutputChannel } from "../../utils/logging";
+import { ResourceDebuggerExtension } from "../debuggerExtensions";
+
+const defaultRustDebugAdapter = getRustDebugAdapterType() ?? 'codelldb';
+
+function getProjectFile(launchConfig: ExecutableLaunchConfiguration): string {
+    if (isRustLaunchConfiguration(launchConfig) && launchConfig.working_directory) {
+        return launchConfig.working_directory;
+    }
+
+    throw new Error(invalidLaunchConfiguration(JSON.stringify(launchConfig)));
+}
+
+function createCargoConfiguration(launchConfig: RustLaunchConfiguration): { args: string[]; filter?: string } | undefined {
+    if (!launchConfig.cargo) {
+        return undefined;
+    }
+
+    return {
+        args: launchConfig.cargo.args ?? [],
+        ...(launchConfig.cargo.filter ? { filter: launchConfig.cargo.filter } : {})
+    };
+}
+
+function getRustBinaryPath(launchConfig: RustLaunchConfiguration): string {
+    const workingDirectory = launchConfig.working_directory ?? '.';
+    const binaryName = launchConfig.cargo?.filter ?? path.basename(workingDirectory);
+    const executableName = process.platform === 'win32'
+        ? `${binaryName}.exe`
+        : binaryName;
+
+    return path.join(workingDirectory, 'target', 'debug', executableName);
+}
+
+export const rustDebuggerExtension: ResourceDebuggerExtension = {
+    resourceType: 'rust',
+    debugAdapter: defaultRustDebugAdapter,
+    extensionId: null,
+    getDisplayName: (launchConfiguration: ExecutableLaunchConfiguration) => {
+        if (isRustLaunchConfiguration(launchConfiguration) && launchConfiguration.working_directory) {
+            return rustDisplayName(vscode.workspace.asRelativePath(launchConfiguration.working_directory));
+        }
+
+        return rustLabel;
+    },
+    getSupportedFileTypes: () => ['.rs'],
+    getProjectFile: (launchConfig) => getProjectFile(launchConfig),
+    createDebugSessionConfigurationCallback: async (launchConfig, args, _env, launchOptions, debugConfiguration: AspireResourceExtendedDebugConfiguration): Promise<void> => {
+        if (!isRustLaunchConfiguration(launchConfig)) {
+            extensionLogOutputChannel.info(`The resource type was not rust for ${JSON.stringify(launchConfig)}`);
+            throw new Error(invalidLaunchConfiguration(JSON.stringify(launchConfig)));
+        }
+
+        const debugAdapter = getRustDebugAdapterType();
+        if (debugAdapter === undefined) {
+            throw new Error(invalidLaunchConfiguration(JSON.stringify(launchConfig)));
+        }
+
+        debugConfiguration.type = debugAdapter;
+        debugConfiguration.request = 'launch';
+        debugConfiguration.noDebug = !launchOptions.debug;
+        debugConfiguration.cwd = launchConfig.working_directory;
+        debugConfiguration.args = args ?? [];
+
+        if (debugAdapter === 'cppvsdbg' || debugAdapter === 'cppdbg') {
+            debugConfiguration.program = getRustBinaryPath(launchConfig);
+            delete debugConfiguration.cargo;
+            return;
+        }
+
+        const cargo = createCargoConfiguration(launchConfig);
+        if (cargo) {
+            debugConfiguration.cargo = cargo;
+        }
+
+        delete debugConfiguration.program;
+    }
+};

extension/src/loc/strings.ts

@@ -148,6 +148,8 @@ export const browserDisplayName = (url: string) => vscode.l10n.t('Browser: {0}',
 export const browserLabel = vscode.l10n.t('Browser');
 export const goDisplayName = (program: string) => `Go: ${program}`;
 export const goLabel = 'Go';
+export const rustDisplayName = (program: string) => vscode.l10n.t('Rust: {0}', program);
+export const rustLabel = vscode.l10n.t('Rust');
 export const bunDisplayName = (script: string) => `Bun: ${script}`;
 export const bunLabel = 'Bun';
 export const nodeDisplayName = (script: string) => `Node.js: ${script}`;

extension/src/test/rustDebugger.test.ts

@@ -0,0 +1,114 @@
+import * as assert from 'assert';
+import * as path from 'path';
+import * as sinon from 'sinon';
+import * as vscode from 'vscode';
+import { getSupportedCapabilities } from '../capabilities';
+import { AspireDebugSession } from '../debugger/AspireDebugSession';
+import { getResourceDebuggerExtensions } from '../debugger/debuggerExtensions';
+import { rustDebuggerExtension } from '../debugger/languages/rust';
+import { AspireResourceExtendedDebugConfiguration, RustLaunchConfiguration } from '../dcp/types';
+
+suite('Rust Debugger Extension Tests', () => {
+    const fakeAspireDebugSession = {} as AspireDebugSession;
+
+    teardown(() => sinon.restore());
+
+    test('advertises Rust support when a Rust debugger extension is installed', () => {
+        sinon.stub(vscode.extensions, 'getExtension').returns(undefined);
+        sinon.stub(vscode.extensions, 'all').value([{
+            packageJSON: {
+                contributes: {
+                    debuggers: [{ type: 'codelldb' }]
+                }
+            }
+        } as unknown as vscode.Extension<unknown>]);
+
+        const capabilities = getSupportedCapabilities();
+        assert.ok(capabilities.includes('rust'));
+        assert.ok(getResourceDebuggerExtensions().some(extension => extension.resourceType === 'rust'));
+    });
+
+    test('configures VS Code Rust debugger with cargo metadata', async () => {
+        sinon.stub(vscode.extensions, 'getExtension').returns(undefined);
+        sinon.stub(vscode.extensions, 'all').value([{
+            packageJSON: {
+                contributes: {
+                    debuggers: [{ type: 'codelldb' }]
+                }
+            }
+        } as unknown as vscode.Extension<unknown>]);
+
+        const launchConfig: RustLaunchConfiguration = {
+            type: 'rust',
+            working_directory: '/workspace/rust-app',
+            cargo: {
+                args: ['build', '--release'],
+                filter: 'rust-app'
+            }
+        };
+        const debugConfig = createDebugConfig();
+
+        await rustDebuggerExtension.createDebugSessionConfigurationCallback!(
+            launchConfig,
+            ['--port', '8080'],
+            [],
+            { debug: true, runId: '1', debugSessionId: '1', isApphost: false, debugSession: fakeAspireDebugSession },
+            debugConfig);
+
+        assert.ok(['cppvsdbg', 'cppdbg', 'codelldb', 'lldb'].includes(debugConfig.type));
+        assert.strictEqual(debugConfig.request, 'launch');
+        assert.strictEqual(debugConfig.cwd, '/workspace/rust-app');
+        assert.deepStrictEqual(debugConfig.args, ['--port', '8080']);
+        if (debugConfig.type === 'cppvsdbg' || debugConfig.type === 'cppdbg') {
+            assert.strictEqual(debugConfig.cargo, undefined);
+            const expectedExecutable = process.platform === 'win32' ? 'rust-app.exe' : 'rust-app';
+            assert.strictEqual(debugConfig.program, path.join('/workspace/rust-app', 'target', 'debug', expectedExecutable));
+        }
+        else {
+            assert.deepStrictEqual(debugConfig.cargo, { args: ['build', '--release'], filter: 'rust-app' });
+            assert.strictEqual(debugConfig.program, undefined);
+        }
+        assert.strictEqual(debugConfig.noDebug, false);
+    });
+
+    test('sets noDebug when launch option disables debugging', async () => {
+        sinon.stub(vscode.extensions, 'getExtension').returns(undefined);
+        sinon.stub(vscode.extensions, 'all').value([{
+            packageJSON: {
+                contributes: {
+                    debuggers: [{ type: 'lldb' }]
+                }
+            }
+        } as unknown as vscode.Extension<unknown>]);
+
+        const launchConfig: RustLaunchConfiguration = {
+            type: 'rust',
+            working_directory: '/workspace/rust-app',
+            cargo: {
+                args: ['build']
+            }
+        };
+        const debugConfig = createDebugConfig();
+
+        await rustDebuggerExtension.createDebugSessionConfigurationCallback!(
+            launchConfig,
+            [],
+            [],
+            { debug: false, runId: '1', debugSessionId: '1', isApphost: false, debugSession: fakeAspireDebugSession },
+            debugConfig);
+
+        assert.strictEqual(debugConfig.noDebug, true);
+    });
+});
+
+function createDebugConfig(): AspireResourceExtendedDebugConfiguration {
+    return {
+        runId: '1',
+        debugSessionId: '1',
+        type: 'rust',
+        name: 'Rust',
+        request: 'launch',
+        program: '/workspace/rust-app',
+        args: []
+    };
+}