Problem

Multiple test files in the F# compiler integration tests hard-coded reliance on the VS170COMNTOOLS (VS 2022) environment variable with a fallback to VSAPPIDDIR. On machines lacking a VS2022 installation, these tests would throw immediately with failwith, preventing any test execution:

// Old problematic code in 3 different files
if String.IsNullOrEmpty vsvar then 
    failwith "VS170COMNTOOLS and VSAPPIDDIR environment variables not found."

This affected:

• vsintegration/tests/UnitTests/AssemblyResolver.fs
• vsintegration/tests/FSharp.Editor.Tests/Helpers/AssemblyResolver.fs
• vsintegration/tests/Salsa/VsMocks.fs

Solution

This PR implements a centralized, robust Visual Studio installation discovery mechanism that gracefully handles missing VS installations instead of failing hard.

New VSInstallDiscovery.fs Helper

Created vsintegration/tests/TestHelpers/VSInstallDiscovery.fs with a comprehensive discovery strategy:

1. FSHARP_VS_INSTALL_DIR - Explicit root override for testing
2. VSAPPIDDIR - Derive parent directory if points to IDE folder
3. VS*COMNTOOLS - Highest version among any VS environment variables (VS170COMNTOOLS, VS160COMNTOOLS, etc.)
4. vswhere.exe - Query Visual Studio installer when available

Graceful Fallback Behavior

Instead of throwing exceptions, the system now:

• Logs clear messages about VS availability: "[FSharp Tests] No Visual Studio installation found"
• Continues test execution with reduced functionality
• Provides no-op assembly resolvers when VS assemblies aren't available
• Returns IDisposable for proper cleanup

API Design

// Simple boolean check
let HasVisualStudio: bool

// Root installation path (empty string if not found)  
let VSRoot: string

// Get existing VS assembly probing paths
let getVSProbingPaths(): string list

// Register assembly resolver with proper cleanup
let addVSAssemblyResolver(): IDisposable

Code Consolidation

All three existing assembly resolver files now use the centralized helper, eliminating ~150 lines of duplicated logic.

Testing

Comprehensive testing confirms:

• ✅ Tests no longer fail when VS2022 is absent
• ✅ Proper precedence order is respected
• ✅ Environment variable pattern matching works correctly
• ✅ Assembly resolution gracefully degrades when VS is missing
• ✅ Existing behavior preserved when VS is properly installed

Benefits

• Reliability: Tests can run in CI/CD environments without VS installation
• Maintainability: Single source of truth for VS discovery logic
• Flexibility: Support for multiple VS versions and testing scenarios
• Robustness: Graceful degradation instead of hard failures

This pull request was created as a result of the following prompt from Copilot chat.

Implement robust Visual Studio installation discovery for integration/editor tests so they no longer hard-fail when VS2022 (VS170COMNTOOLS) is absent, and consolidate duplicated assembly resolver logic.

Context / Motivation:
Currently multiple test files (vsintegration/tests/UnitTests/AssemblyResolver.fs, vsintegration/tests/FSharp.Editor.Tests/Helpers/AssemblyResolver.fs, vsintegration/tests/Salsa/VsMocks.fs) hard-code reliance on the VS170COMNTOOLS (VS 2022) environment variable (with a fallback to VSAPPIDDIR). On machines lacking a VS2022 installation these tests throw immediately (failwith), preventing partial test execution or graceful skipping. We want to:

1. Provide a generalized discovery mechanism supporting older/newer VS versions and absence of VS entirely.
2. Allow an override via an environment variable.
3. Fall back to vswhere.exe when explicit environment variables are missing.
4. Remove duplication of resolver code across the three places.
5. Avoid throwing if no VS installation can be found; instead register no-op or reduced probing and log a single line.
6. (Optional but included) Provide a convenient predicate/values for future conditional test skipping.

Scope of Changes:
Add new helper file: vsintegration/tests/TestHelpers/VSInstallDiscovery.fs containing logic:

• tryLocateVSRoot():
  Order of precedence:
  a. FSHARP_VS_INSTALL_DIR (explicit root override)
  b. VSAPPIDDIR (derive parent directory if points to IDE folder)
  c. Highest version among any environment variables matching pattern VS*COMNTOOLS (e.g. VS170COMNTOOLS, VS160COMNTOOLS, etc.)
  d. vswhere.exe invocation (-latest -products * -requires Microsoft.Component.MSBuild -property installationPath)
• Expose HasVisualStudio (bool), VSRoot (string), getVSProbingPaths(), addVSAssemblyResolver() returning IDisposable.

Refactor existing files to use helper:

• Replace contents of vsintegration/tests/UnitTests/AssemblyResolver.fs so it simply imports helper and registers resolver.
• Replace vsintegration/tests/FSharp.Editor.Tests/Helpers/AssemblyResolver.fs similarly.
• Modify vsintegration/tests/Salsa/VsMocks.fs: remove duplicate vsInstallDir logic, call helper; only attempt to compose VS editor assemblies if HasVisualStudio is true; otherwise log a message (non-fatal). Missing optional assemblies log warnings instead of failwith.

Non-Goals / Not Included:

• Automatic skipping of tests (we only enable graceful absence). We leave future ability to annotate tests.
• Changing any production (non-test) code.
• Adjusting build scripts.

Acceptance Criteria:

• Building solution without VS170COMNTOOLS set no longer throws failwith during test discovery/startup.
• Tests that do not require VS editor assemblies still run.
• Setting FSHARP_VS_INSTALL_DIR to a valid root (parent of Common7\IDE) enables probing as before.
• If multiple VS*COMNTOOLS variables exist, the highest numeric version root is selected.
• If vswhere exists and finds an installation, that path works even without COMNTOOLS variables.
• Code duplication removed; new helper centralizes logic.

Implementation Details (proposed code skeleton):
File: vsintegration/tests/TestHelpers/VSInstallDiscovery.fs

namespace FSharp.TestHelpers
open System
open System.IO
open System.Collections
open System.Diagnostics
[<AutoOpen>]
module VSInstallDiscovery =
  let tryLocateVSRoot () = (* precedence logic as described *)
  let HasVisualStudio, VSRoot = match tryLocateVSRoot() with | Some r -> true, r | None -> false, ""
  let getVSProbingPaths () = (* build filtered existing directories *)
  let addVSAssemblyResolver () = (* register AssemblyResolve if paths available, else log *)

Update the three existing files to use addVSAssemblyResolver. Provide logging messages prefixed with "[FSharp Tests]".

Testing Instructions:

1. Unset VS170COMNTOOLS and ensure no VS installed path is on machine; run relevant test projects; confirm no immediate failwith.
2. Set FSHARP_VS_INSTALL_DIR to a mock path lacking expected assemblies; verify graceful log and continued run.
3. On a machine with VS2022 developer prompt (VS170COMNTOOLS set), confirm behavior unchanged and assemblies load.
4. (Optional) Temporarily add a VS160COMNTOOLS variable with different path and remove VS170COMNTOOLS to confirm highest-version selection when multiple present.

Risks / Mitigations:

• Potential silent missing assemblies causing NullReference exceptions later. Mitigate by clear initial log message when no VS installation found.
• vswhere invocation timeout: limited to quick call; if it fails we ignore.

No other repository files should be affected.

💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click here to start the survey.