Versions.props

@@ -10,9 +10,9 @@
     <NerdbankGitVersioningVersion>3.7.112</NerdbankGitVersioningVersion>
     <NSubstituteVersion>5.3.0</NSubstituteVersion>
     <TunnelVisionLabsReferenceAssemblyAnnotatorVersion>1.0.0-alpha.160</TunnelVisionLabsReferenceAssemblyAnnotatorVersion>
-    <XunitAnalyzersVersion>1.18.0</XunitAnalyzersVersion>
-    <XunitV2Version>2.9.3-pre.7</XunitV2Version>
-    <XunitV3Version>1.0.0</XunitV3Version>
+    <XunitAnalyzersVersion>1.19.0</XunitAnalyzersVersion>
+    <XunitV2Version>2.9.3</XunitV2Version>
+    <XunitV3Version>1.0.1</XunitV3Version>
   </PropertyGroup>
 
 </Project>

src/xunit.runner.visualstudio/Constants.cs

@@ -1,6 +1,6 @@
 namespace Xunit.Runner.VisualStudio;
 
-public static class Constants
+internal static class Constants
 {
 #if NETFRAMEWORK
 	public const string ExecutorUri = "executor://xunit/VsTestRunner3/netfx/";

src/xunit.runner.visualstudio/Sinks/DiagnosticMessageSink.cs

@@ -2,7 +2,7 @@
 
 namespace Xunit.Runner.VisualStudio;
 
-public class DiagnosticMessageSink : DiagnosticEventSink
+internal class DiagnosticMessageSink : DiagnosticEventSink
 {
 	public DiagnosticMessageSink(
 		LoggerHelper log,

src/xunit.runner.visualstudio/Sinks/VsDiscoverySink.cs

@@ -15,7 +15,7 @@
 
 namespace Xunit.Runner.VisualStudio;
 
-public sealed class VsDiscoverySink : IVsDiscoverySink, IDisposable
+internal sealed class VsDiscoverySink : IVsDiscoverySink, IDisposable
 {
 	static readonly string Ellipsis = new((char)183, 3);
 	const int MaximumDisplayNameLength = 447;

src/xunit.runner.visualstudio/Sinks/VsExecutionSink.cs

@@ -14,7 +14,7 @@
 
 namespace Xunit.Runner.VisualStudio;
 
-public sealed class VsExecutionSink : TestMessageSink, IDisposable
+internal sealed class VsExecutionSink : TestMessageSink, IDisposable
 {
 	readonly Func<bool> cancelledThunk;
 	readonly LoggerHelper logger;

src/xunit.runner.visualstudio/TestPlatformContext.cs

@@ -4,7 +4,7 @@ namespace Xunit.Runner.VisualStudio;
 /// Provides contextual information on a test run/discovery based on runsettings
 /// or the invocation (execution, discovery).
 /// </summary>
-public struct TestPlatformContext
+internal struct TestPlatformContext
 {
 	/// <summary>
 	/// Indicates if the test runner is running in design mode (meaning, inside the Visual Studio IDE).

src/xunit.runner.visualstudio/Utility/AppDomainManager.cs

@@ -0,0 +1,73 @@
+#if NETFRAMEWORK
+
+using System;
+using System.IO;
+using System.Reflection;
+using System.Runtime.ExceptionServices;
+using System.Security;
+using System.Security.Permissions;
+using Xunit.Internal;
+
+namespace Xunit.Runner.VisualStudio;
+
+class AppDomainManager
+{
+	readonly AppDomain appDomain;
+
+	public AppDomainManager(string assemblyFileName)
+	{
+		Guard.ArgumentNotNullOrEmpty(assemblyFileName);
+
+		assemblyFileName = Path.GetFullPath(assemblyFileName);
+		Guard.FileExists(assemblyFileName);
+
+		var applicationBase = Path.GetDirectoryName(assemblyFileName);
+		var applicationName = Guid.NewGuid().ToString();
+		var setup = new AppDomainSetup
+		{
+			ApplicationBase = applicationBase,
+			ApplicationName = applicationName,
+			ShadowCopyFiles = "true",
+			ShadowCopyDirectories = applicationBase,
+			CachePath = Path.Combine(Path.GetTempPath(), applicationName)
+		};
+
+		appDomain = AppDomain.CreateDomain(Path.GetFileNameWithoutExtension(assemblyFileName), AppDomain.CurrentDomain.Evidence, setup, new PermissionSet(PermissionState.Unrestricted));
+	}
+
+	public TObject? CreateObject<TObject>(
+		AssemblyName assemblyName,
+		string typeName,
+		params object[] args)
+			where TObject : class
+	{
+		try
+		{
+			return appDomain.CreateInstanceAndUnwrap(assemblyName.FullName, typeName, false, BindingFlags.Default, null, args, null, null) as TObject;
+		}
+		catch (TargetInvocationException ex)
+		{
+			ExceptionDispatchInfo.Capture(ex.InnerException ?? ex).Throw();
+			return default;  // Will never reach here, but the compiler doesn't know that
+		}
+	}
+
+	public virtual void Dispose()
+	{
+		if (appDomain is not null)
+		{
+			var cachePath = appDomain.SetupInformation.CachePath;
+
+			try
+			{
+				AppDomain.Unload(appDomain);
+
+				if (cachePath is not null)
+					Directory.Delete(cachePath, true);
+			}
+			catch { }
+		}
+	}
+}
+
+#endif

src/xunit.runner.visualstudio/Utility/AssemblyExtensions.cs

@@ -1,6 +1,9 @@
+using System.Reflection;
+
+#if NETFRAMEWORK
 using System;
 using System.IO;
-using System.Reflection;
+#endif
 
 internal static class AssemblyExtensions
 {

src/xunit.runner.visualstudio/Utility/AssemblyRunInfo.cs

@@ -5,7 +5,7 @@
 
 namespace Xunit.Runner.VisualStudio;
 
-public class AssemblyRunInfo
+internal class AssemblyRunInfo
 {
 	AssemblyRunInfo(
 		LoggerHelper logger,

src/xunit.runner.visualstudio/Utility/DiaSessionWrapper.cs

@@ -0,0 +1,81 @@
+using System;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel.Navigation;
+using Xunit.Internal;
+using Xunit.Runner.Common;
+
+namespace Xunit.Runner.VisualStudio;
+
+// This class wraps DiaSession, and uses DiaSessionWrapperHelper to discover when a test is an async test
+// (since that requires special handling by DIA). The wrapper helper needs to exist in a separate AppDomain
+// so that we can do discovery without locking the assembly under test (for .NET Framework).
+class DiaSessionWrapper : IDisposable
+{
+#if NETFRAMEWORK
+	readonly AppDomainManager? appDomainManager;
+#endif
+	readonly DiaSessionWrapperHelper? helper;
+	readonly DiaSession? session;
+	readonly DiagnosticMessageSink diagnosticMessageSink;
+
+	public DiaSessionWrapper(
+		string assemblyFileName,
+		DiagnosticMessageSink diagnosticMessageSink)
+	{
+		this.diagnosticMessageSink = Guard.ArgumentNotNull(diagnosticMessageSink);
+
+		try
+		{
+			session = new DiaSession(assemblyFileName);
+		}
+		catch (Exception ex)
+		{
+			diagnosticMessageSink.OnMessage(new InternalDiagnosticMessage($"Exception creating DiaSession: {ex}"));
+		}
+
+		try
+		{
+#if NETFRAMEWORK
+			var adapterFileName = typeof(DiaSessionWrapperHelper).Assembly.GetLocalCodeBase();
+			if (adapterFileName is not null)
+			{
+				appDomainManager = new AppDomainManager(assemblyFileName);
+				helper = appDomainManager.CreateObject<DiaSessionWrapperHelper>(typeof(DiaSessionWrapperHelper).Assembly.GetName(), typeof(DiaSessionWrapperHelper).FullName!, adapterFileName);
+			}
+#else
+			helper = new DiaSessionWrapperHelper(assemblyFileName);
+#endif
+		}
+		catch (Exception ex)
+		{
+			diagnosticMessageSink.OnMessage(new DiagnosticMessage($"Exception creating DiaSessionWrapperHelper: {ex}"));
+		}
+	}
+
+	public INavigationData? GetNavigationData(
+		string typeName,
+		string methodName)
+	{
+		if (session is null || helper is null)
+			return null;
+
+		try
+		{
+			helper.Normalize(ref typeName, ref methodName);
+			return session.GetNavigationDataForMethod(typeName, methodName);
+		}
+		catch (Exception ex)
+		{
+			diagnosticMessageSink.OnMessage(new DiagnosticMessage($"Exception getting source mapping for {typeName}.{methodName}: {ex}"));
+			return null;
+		}
+	}
+
+	public void Dispose()
+	{
+		session?.Dispose();
+#if NETFRAMEWORK
+		appDomainManager?.Dispose();
+#endif
+	}
+}

src/xunit.runner.visualstudio/Utility/DiaSessionWrapperHelper.cs

@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Xunit.Internal;
+using Xunit.Sdk;
+
+namespace Xunit.Runner.VisualStudio;
+
+class DiaSessionWrapperHelper : LongLivedMarshalByRefObject
+{
+	readonly Assembly? assembly;
+	readonly Dictionary<string, Type> typeNameMap;
+
+	public DiaSessionWrapperHelper(string assemblyFileName)
+	{
+		try
+		{
+#if NETFRAMEWORK
+			assembly = Assembly.ReflectionOnlyLoadFrom(assemblyFileName);
+			var assemblyDirectory = Path.GetDirectoryName(assemblyFileName);
+
+			if (assemblyDirectory is not null)
+				AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += (sender, args) =>
+				{
+					try
+					{
+						// Try to load it normally
+						var name = AppDomain.CurrentDomain.ApplyPolicy(args.Name);
+						return Assembly.ReflectionOnlyLoad(name);
+					}
+					catch
+					{
+						try
+						{
+							// If a normal implicit load fails, try to load it from the directory that
+							// the test assembly lives in
+							return Assembly.ReflectionOnlyLoadFrom(
+								Path.Combine(
+									assemblyDirectory,
+									new AssemblyName(args.Name).Name + ".dll"
+								)
+							);
+						}
+						catch
+						{
+							// If all else fails, say we couldn't find it
+							return null;
+						}
+					}
+				};
+#else
+			assembly = Assembly.Load(new AssemblyName { Name = Path.GetFileNameWithoutExtension(assemblyFileName) });
+#endif
+		}
+		catch { }
+
+		if (assembly is not null)
+		{
+			Type?[]? types = null;
+
+			try
+			{
+				types = assembly.GetTypes();
+			}
+			catch (ReflectionTypeLoadException ex)
+			{
+				types = ex.Types;
+			}
+			catch { }  // Ignore anything other than ReflectionTypeLoadException
+
+			if (types is not null)
+				typeNameMap =
+					types
+						.WhereNotNull()
+						.Where(t => !string.IsNullOrEmpty(t.FullName))
+						.ToDictionaryIgnoringDuplicateKeys(k => k.FullName!);
+		}
+
+		typeNameMap ??= [];
+	}
+
+	public void Normalize(
+		ref string typeName,
+		ref string methodName)
+	{
+		try
+		{
+			if (assembly is null)
+				return;
+
+			if (typeNameMap.TryGetValue(typeName, out var type) && type is not null)
+			{
+				var method = type.GetMethod(methodName);
+				if (method is not null && method.DeclaringType is not null && method.DeclaringType.FullName is not null)
+				{
+					// DiaSession only ever wants you to ask for the declaring type
+					typeName = method.DeclaringType.FullName;
+
+					// See if this is an async method by looking for [AsyncStateMachine] on the method,
+					// which means we need to pass the state machine's "MoveNext" method.
+					var stateMachineType = method.GetCustomAttribute<AsyncStateMachineAttribute>()?.StateMachineType;
+					if (stateMachineType is not null && stateMachineType.FullName is not null)
+					{
+						typeName = stateMachineType.FullName;
+						methodName = "MoveNext";
+					}
+				}
+			}
+		}
+		catch { }
+	}
+}

src/xunit.runner.visualstudio/Utility/LoggerHelper.cs

@@ -6,7 +6,7 @@
 
 namespace Xunit.Runner.VisualStudio;
 
-public class LoggerHelper(IMessageLogger? logger, Stopwatch stopwatch)
+internal class LoggerHelper(IMessageLogger? logger, Stopwatch stopwatch)
 {
 	public IMessageLogger? InnerLogger { get; private set; } = logger;
 

src/xunit.runner.visualstudio/Utility/RunSettings.cs

@@ -6,7 +6,7 @@
 
 namespace Xunit.Runner.VisualStudio;
 
-public class RunSettings
+internal class RunSettings
 {
 	public AppDomainSupport? AppDomain { get; set; }
 	public string? Culture { get; set; }

src/xunit.runner.visualstudio/Utility/TestCaseFilter.cs

@@ -7,7 +7,7 @@
 
 namespace Xunit.Runner.VisualStudio;
 
-public class TestCaseFilter
+internal class TestCaseFilter
 {
 	const string DisplayNameString = "DisplayName";
 	const string FullyQualifiedNameString = "FullyQualifiedName";

src/xunit.runner.visualstudio/Utility/VisualStudioRunnerLogger.cs

@@ -2,7 +2,7 @@
 
 namespace Xunit.Runner.VisualStudio;
 
-public class VisualStudioRunnerLogger(LoggerHelper loggerHelper) :
+internal class VisualStudioRunnerLogger(LoggerHelper loggerHelper) :
 	IRunnerLogger
 {
 	static readonly object lockObject = new();