Add Debug Interface Access (DIA) SDK COM wrappers and tests (#7)

Adds struct-based COM wrappers for the DIA SDK interfaces in the new

Microsoft.VisualStudio.Debugging.DebugInterfaceAccess namespace, following the

same pattern as the existing VS Setup interfaces (IComIID structs with a nested

[ComImport] Interface, dual NETFRAMEWORK/static IID, and delegate* vtable calls).

All 54 dia2 interfaces are covered, with vtable indices verified against dia2.h.

- Documentation is sourced from the DIA headers: IDL helpstrings drive member

  summaries, SAL annotations drive parameter docs, and csymrow.h field comments

  enrich the IDiaSymbol boolean flags.

- IEnumUnknown, PROPSPEC, and IEnumSTATPROPSTG are generated via CsWin32

  (NativeMethods.txt) and aggregated onto Madowaku; net472 IComIID polyfills are

  added for the generated COM structs.

- Adds a CLASSID class with the DiaSource, DiaSourceAlt, and DiaStackWalker CLSIDs.

- Tests load the architecture-appropriate msdia140.dll from the

  Microsoft.Diagnostics.Tracing.TraceEvent.SupportFiles package via Madowaku's

  ComClassFactory and exercise the load/session/symbol pipeline.

Author: JeremyKuhne

Directory.Packages.props

@@ -11,6 +11,7 @@
     <PackageVersion Include="Microsoft.Build" Version="17.14.8" />
     <PackageVersion Include="Microsoft.CodeAnalysis.ResxSourceGenerator" Version="5.0.0-1.25277.114" />
     <PackageVersion Include="Microsoft.CSharp" Version="4.7.0" />
+    <PackageVersion Include="Microsoft.Diagnostics.Tracing.TraceEvent.SupportFiles" Version="1.0.23" />
     <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="10.0.300" />
     <PackageVersion Include="Microsoft.Windows.CsWin32" Version="0.3.275" />
     <PackageVersion Include="MinVer" Version="7.0.0" />

vsinterop.tests/Microsoft/VisualStudio/Debugging/DebugInterfaceAccess/DiaSourceTests.cs

@@ -0,0 +1,153 @@
+// Copyright (c) 2025 Jeremy W Kuhne
+// SPDX-License-Identifier: MIT
+// See LICENSE file in the project root for full license information
+
+using Windows.Win32.Foundation;
+using Windows.Win32.System.Com;
+
+namespace Microsoft.VisualStudio.Debugging.DebugInterfaceAccess;
+
+[TestClass]
+public unsafe class DiaSourceTests
+{
+    private static string TestPdbPath => Path.ChangeExtension(typeof(DiaSourceTests).Assembly.Location, ".pdb");
+
+    [TestMethod]
+    public void CanCreateDiaSourceFactory()
+    {
+        using ComClassFactory factory = Msdia.CreateFactory(CLASSID.DiaSource);
+        Assert.AreEqual(CLASSID.DiaSource, factory.ClassId);
+    }
+
+    [TestMethod]
+    public void CanCreateIDiaDataSource()
+    {
+        using ComClassFactory factory = Msdia.CreateFactory(CLASSID.DiaSource);
+        using var dataSource = factory.CreateInstance<IDiaDataSource>();
+        Assert.IsFalse(dataSource.IsNull);
+    }
+
+    [TestMethod]
+    public void LoadDataFromPdb_NonExistentPath_Fails()
+    {
+        using ComClassFactory factory = Msdia.CreateFactory(CLASSID.DiaSource);
+        using var dataSource = factory.CreateInstance<IDiaDataSource>();
+
+        string missing = Path.Combine(AppContext.BaseDirectory, "this_file_does_not_exist.pdb");
+
+        HRESULT result;
+        fixed (char* path = missing)
+        {
+            result = dataSource.Pointer->loadDataFromPdb(path);
+        }
+
+        Assert.IsTrue(result.Failed, "Loading a missing PDB returns a failure HRESULT.");
+    }
+
+    [TestMethod]
+    public void LoadDataFromPdb_OpenSession_GlobalScopeIsExe()
+    {
+        using ComClassFactory factory = Msdia.CreateFactory(CLASSID.DiaSource);
+        using var dataSource = factory.CreateInstance<IDiaDataSource>();
+
+        LoadTestData(dataSource);
+
+        using ComScope<IDiaSession> session = default;
+        dataSource.Pointer->openSession(session).ThrowOnFailure();
+        Assert.IsFalse(session.IsNull);
+
+        using ComScope<IDiaSymbol> globalScope = default;
+        session.Pointer->get_globalScope(globalScope).ThrowOnFailure();
+        Assert.IsFalse(globalScope.IsNull);
+
+        uint symTag;
+        globalScope.Pointer->get_symTag(&symTag).ThrowOnFailure();
+        Assert.AreEqual((uint)SymTagEnum.SymTagExe, symTag);
+    }
+
+    [TestMethod]
+    public void GlobalScope_HasSymbolName()
+    {
+        using ComClassFactory factory = Msdia.CreateFactory(CLASSID.DiaSource);
+        using var dataSource = factory.CreateInstance<IDiaDataSource>();
+
+        LoadTestData(dataSource);
+
+        using ComScope<IDiaSession> session = default;
+        dataSource.Pointer->openSession(session).ThrowOnFailure();
+
+        using ComScope<IDiaSymbol> globalScope = default;
+        session.Pointer->get_globalScope(globalScope).ThrowOnFailure();
+
+        using BSTR name = default;
+        globalScope.Pointer->get_name(&name).ThrowOnFailure();
+        Assert.IsFalse(name.IsNull, "The global (exe) symbol has a name.");
+    }
+
+    [TestMethod]
+    public void FindChildren_EnumeratesCompilands()
+    {
+        using ComClassFactory factory = Msdia.CreateFactory(CLASSID.DiaSource);
+        using var dataSource = factory.CreateInstance<IDiaDataSource>();
+
+        LoadTestData(dataSource);
+
+        using ComScope<IDiaSession> session = default;
+        dataSource.Pointer->openSession(session).ThrowOnFailure();
+
+        using ComScope<IDiaSymbol> globalScope = default;
+        session.Pointer->get_globalScope(globalScope).ThrowOnFailure();
+
+        using ComScope<IDiaEnumSymbols> compilands = default;
+        globalScope.Pointer->findChildren(
+            SymTagEnum.SymTagCompiland,
+            name: default,
+            compareFlags: 0,
+            compilands).ThrowOnFailure();
+        Assert.IsFalse(compilands.IsNull);
+
+        int count;
+        compilands.Pointer->get_Count(&count).ThrowOnFailure();
+        Assert.IsTrue(count > 0, "The module has at least one compiland.");
+
+        using ComScope<IDiaSymbol> compiland = default;
+        uint fetched;
+        compilands.Pointer->Next(1, compiland, &fetched).ThrowOnFailure();
+        Assert.AreEqual(1u, fetched);
+
+        uint symTag;
+        compiland.Pointer->get_symTag(&symTag).ThrowOnFailure();
+        Assert.AreEqual((uint)SymTagEnum.SymTagCompiland, symTag);
+    }
+
+    [TestMethod]
+    public void GetEnumTables_ReturnsTables()
+    {
+        using ComClassFactory factory = Msdia.CreateFactory(CLASSID.DiaSource);
+        using var dataSource = factory.CreateInstance<IDiaDataSource>();
+
+        LoadTestData(dataSource);
+
+        using ComScope<IDiaSession> session = default;
+        dataSource.Pointer->openSession(session).ThrowOnFailure();
+
+        using ComScope<IDiaEnumTables> tables = default;
+        session.Pointer->getEnumTables(tables).ThrowOnFailure();
+        Assert.IsFalse(tables.IsNull);
+
+        int count;
+        tables.Pointer->get_Count(&count).ThrowOnFailure();
+        Assert.IsTrue(count > 0, "A session exposes at least one table.");
+    }
+
+    private static void LoadTestData(ComScope<IDiaDataSource> dataSource)
+    {
+        string pdbPath = TestPdbPath;
+        Assert.IsTrue(File.Exists(pdbPath), $"Test PDB not found at '{pdbPath}'.");
+
+        fixed (char* path = pdbPath)
+        {
+            dataSource.Pointer->loadDataFromPdb(path).ThrowOnFailure();
+        }
+    }
+}

vsinterop.tests/Microsoft/VisualStudio/Debugging/DebugInterfaceAccess/Msdia.cs

@@ -0,0 +1,45 @@
+// Copyright (c) 2025 Jeremy W Kuhne
+// SPDX-License-Identifier: MIT
+// See LICENSE file in the project root for full license information
+
+using System.Runtime.InteropServices;
+using Windows.Win32.Foundation;
+using Windows.Win32.System.Com;
+using Windows.Win32.System.LibraryLoader;
+
+namespace Microsoft.VisualStudio.Debugging.DebugInterfaceAccess;
+
+/// <summary>
+///  Loads the architecture-appropriate <c>msdia140.dll</c> (supplied by the
+///  Microsoft.Diagnostics.Tracing.TraceEvent.SupportFiles package) and creates DIA class factories from it.
+/// </summary>
+internal static class Msdia
+{
+    /// <summary>
+    ///  The full path to the <c>msdia140.dll</c> that matches the current process architecture.
+    /// </summary>
+    internal static string LibraryPath { get; } = Path.Combine(
+        AppContext.BaseDirectory,
+        "Dia",
+        RuntimeInformation.ProcessArchitecture switch
+        {
+            Architecture.X64 => "amd64",
+            Architecture.X86 => "x86",
+            Architecture.Arm64 => "arm64",
+            _ => throw new PlatformNotSupportedException(
+                $"msdia140.dll is not available for {RuntimeInformation.ProcessArchitecture}.")
+        },
+        "msdia140.dll");
+
+    // msdia140.dll has a static dependency on the Visual C++ runtime (msvcp140.dll, vcruntime140*.dll), which
+    // the package places next to it. Loading with LOAD_WITH_ALTERED_SEARCH_PATH makes Windows resolve those
+    // dependencies from the DLL's own directory rather than the application directory.
+    private static readonly Lazy<HMODULE> s_module = new(static () =>
+        HMODULE.LoadModule(LibraryPath, LOAD_LIBRARY_FLAGS.LOAD_WITH_ALTERED_SEARCH_PATH));
+
+    /// <summary>
+    ///  Creates a <see cref="ComClassFactory"/> for the given DIA class, loading <c>msdia140.dll</c> on first use.
+    /// </summary>
+    /// <param name="classId">The CLSID of the DIA coclass, for example <see cref="CLASSID.DiaSource"/>.</param>
+    internal static ComClassFactory CreateFactory(Guid classId) => new(s_module.Value, classId);
+}

vsinterop.tests/vsinterop.tests.csproj

@@ -23,8 +23,29 @@
     </PackageReference>
     <PackageReference Include="MSTest" />
     <PackageReference Include="AwesomeAssertions" />
+
+    <!--
+      Provides the native msdia140.dll (Debug Interface Access) binaries for each architecture under
+      lib/native/<arch>. We don't want the managed Dia2Lib.dll interop assembly the package also carries,
+      so all assets are excluded; GeneratePathProperty still gives us the restored package location for
+      the copy target below.
+    -->
+    <PackageReference Include="Microsoft.Diagnostics.Tracing.TraceEvent.SupportFiles" GeneratePathProperty="true" ExcludeAssets="all" />
   </ItemGroup>
 
+  <!--
+    Copy the DIA native binaries (msdia140.dll and its CRT dependencies) for every architecture into a
+    Dia/<arch> folder next to the test assembly. Tests load the architecture-appropriate copy at runtime.
+  -->
+  <Target Name="CopyDiaNativeBinaries" AfterTargets="Build">
+    <ItemGroup>
+      <_DiaNativeFile Include="$(PkgMicrosoft_Diagnostics_Tracing_TraceEvent_SupportFiles)\lib\native\**\*.dll" />
+    </ItemGroup>
+    <Copy SourceFiles="@(_DiaNativeFile)"
+          DestinationFiles="@(_DiaNativeFile->'$(OutDir)Dia\%(RecursiveDir)%(Filename)%(Extension)')"
+          SkipUnchangedFiles="true" />
+  </Target>
+
   <ItemGroup>
     <ProjectReference Include="..\vsinterop\vsinterop.csproj" AdditionalProperties="TargetFramework=$(TargetFramework)" />
   </ItemGroup>
@@ -34,11 +55,11 @@
   </ItemGroup>
 
   <ItemGroup>
-    <EditorConfigFiles Remove="N:\repos\vsinterop\vsinterop.tests\.editorconfig" />
+    <EditorConfigFiles Remove=".editorconfig" />
   </ItemGroup>
 
   <ItemGroup>
-    <None Include="N:\repos\vsinterop\vsinterop.tests\.editorconfig" />
+    <None Include=".editorconfig" />
   </ItemGroup>
 
 </Project>

vsinterop/Microsoft/VisualStudio/Debugging/DebugInterfaceAccess/CLASSID.cs

@@ -0,0 +1,44 @@
+// Copyright (c) 2025 Jeremy W Kuhne
+// SPDX-License-Identifier: MIT
+// See LICENSE file in the project root for full license information
+
+namespace Microsoft.VisualStudio.Debugging.DebugInterfaceAccess;
+
+/// <summary>
+///  Class identifiers (CLSIDs) for the Debug Interface Access (DIA) SDK coclasses exposed by msdia*.dll.
+/// </summary>
+/// <remarks>
+///  <para>
+///   Use these with <c>CoCreateInstance</c> or a class factory (for example, by loading <c>msdia140.dll</c>
+///   directly and calling <c>DllGetClassObject</c>) to create the corresponding DIA objects.
+///  </para>
+/// </remarks>
+public static class CLASSID
+{
+    /// <summary>
+    ///  CLSID of the <c>DiaSource</c> class, which provides an <see cref="IDiaDataSource"/> that allocates from
+    ///  the process heap and returns <c>BSTR</c> values that can be freed with the standard <c>SysFreeString</c>.
+    /// </summary>
+    /// <value>The CLSID <c>{E6756135-1E65-4D17-8576-610761398C3C}</c>.</value>
+    public static Guid DiaSource { get; } = new(0xe6756135, 0x1e65, 0x4d17, 0x85, 0x76, 0x61, 0x07, 0x61, 0x39, 0x8c, 0x3c);
+
+    /// <summary>
+    ///  CLSID of the <c>DiaSourceAlt</c> class, a variant of <c>DiaSource</c> that does not use the system heap.
+    /// </summary>
+    /// <remarks>
+    ///  <para>
+    ///   A process may create either <c>DiaSourceAlt</c> objects or <c>DiaSource</c> objects, but not both. When
+    ///   using <c>DiaSourceAlt</c>, all returned <c>BSTR</c> values are really <c>LPCOLESTR</c> and must be released
+    ///   with <c>LocalFree</c> rather than the usual <c>BSTR</c> routines.
+    ///  </para>
+    /// </remarks>
+    /// <value>The CLSID <c>{91904831-49CA-4766-B95C-25397E2DD6DC}</c>.</value>
+    public static Guid DiaSourceAlt { get; } = new(0x91904831, 0x49ca, 0x4766, 0xb9, 0x5c, 0x25, 0x39, 0x7e, 0x2d, 0xd6, 0xdc);
+
+    /// <summary>
+    ///  CLSID of the <c>DiaStackWalker</c> class, which provides an <see cref="IDiaStackWalker"/> for performing
+    ///  general stack walks.
+    /// </summary>
+    /// <value>The CLSID <c>{CE4A85DB-5768-475B-A4E1-C0BCA2112A6B}</c>.</value>
+    public static Guid DiaStackWalker { get; } = new(0xce4a85db, 0x5768, 0x475b, 0xa4, 0xe1, 0x0c, 0xbc, 0xa2, 0x11, 0x2a, 0x6b);
+}