Fix method ordering, xmldoc, and remove obsolete XUnit verifiers

src/Analyzers/Analyzers.csproj

@@ -9,7 +9,7 @@
     <IncludeBuildOutput>false</IncludeBuildOutput>
     <SuppressDependenciesWhenPacking>true</SuppressDependenciesWhenPacking>
     <IncludeShared>false</IncludeShared>
-    <GenerateDocumentationFile>false</GenerateDocumentationFile>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <!-- Do not publish it until it is ready to release -->
     <IsPackable>false</IsPackable>
   </PropertyGroup>

src/Analyzers/Orchestration/OrchestrationContextFixer.cs

@@ -12,7 +12,7 @@ namespace Microsoft.DurableTask.Analyzers.Orchestration;
 /// </summary>
 /// <param name="semanticModel">The Semantic Model retrieved from the Document.</param>
 /// <param name="knownTypeSymbols">Well-known types that are used by the Durable analyzers.</param>
-/// <param name="oldRoot">The root Syntax Node retrieved from the Document.</param>
+/// <param name="root">The root Syntax Node retrieved from the Document.</param>
 /// <param name="syntaxNodeWithDiagnostic">Syntax Node that contains the diagnostic.</param>
 /// <param name="taskOrchestrationContextSymbol">The 'TaskOrchestrationContext' symbol.</param>
 public readonly struct OrchestrationCodeFixContext(

src/Client/AzureManaged/DurableTaskSchedulerClientOptions.cs

@@ -53,6 +53,19 @@ public static DurableTaskSchedulerClientOptions FromConnectionString(string conn
         return FromConnectionString(new DurableTaskSchedulerConnectionString(connectionString));
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="DurableTaskSchedulerClientOptions"/> from a parsed connection string.
+    /// </summary>
+    /// <param name="connectionString">The connection string to parse.</param>
+    /// <returns>A new instance of <see cref="DurableTaskSchedulerClientOptions"/>.</returns>
+    internal static DurableTaskSchedulerClientOptions FromConnectionString(
+        DurableTaskSchedulerConnectionString connectionString) => new()
+        {
+            EndpointAddress = connectionString.Endpoint,
+            TaskHubName = connectionString.TaskHubName,
+            Credential = GetCredentialFromConnectionString(connectionString),
+        };
+
     /// <summary>
     /// Creates a gRPC channel for communicating with the Durable Task Scheduler service.
     /// </summary>
@@ -96,19 +109,6 @@ this.Credential is not null
         });
     }
 
-    /// <summary>
-    /// Creates a new instance of <see cref="DurableTaskSchedulerClientOptions"/> from a parsed connection string.
-    /// </summary>
-    /// <param name="connectionString">The connection string to parse.</param>
-    /// <returns>A new instance of <see cref="DurableTaskSchedulerClientOptions"/>.</returns>
-    internal static DurableTaskSchedulerClientOptions FromConnectionString(
-        DurableTaskSchedulerConnectionString connectionString) => new()
-        {
-            EndpointAddress = connectionString.Endpoint,
-            TaskHubName = connectionString.TaskHubName,
-            Credential = GetCredentialFromConnectionString(connectionString),
-        };
-
     static TokenCredential? GetCredentialFromConnectionString(DurableTaskSchedulerConnectionString connectionString)
     {
         string authType = connectionString.Authentication;

src/Worker/AzureManaged/DurableTaskSchedulerWorkerOptions.cs

@@ -59,6 +59,19 @@ public static DurableTaskSchedulerWorkerOptions FromConnectionString(string conn
         return FromConnectionString(new DurableTaskSchedulerConnectionString(connectionString));
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="DurableTaskSchedulerWorkerOptions"/> from a parsed connection string.
+    /// </summary>
+    /// <param name="connectionString">The connection string to parse.</param>
+    /// <returns>A new instance of <see cref="DurableTaskSchedulerWorkerOptions"/>.</returns>
+    internal static DurableTaskSchedulerWorkerOptions FromConnectionString(
+        DurableTaskSchedulerConnectionString connectionString) => new()
+        {
+            EndpointAddress = connectionString.Endpoint,
+            TaskHubName = connectionString.TaskHubName,
+            Credential = GetCredentialFromConnectionString(connectionString),
+        };
+
     /// <summary>
     /// Creates a gRPC channel for communicating with the Durable Task Scheduler service.
     /// </summary>
@@ -103,19 +116,6 @@ this.Credential is not null
         });
     }
 
-    /// <summary>
-    /// Creates a new instance of <see cref="DurableTaskSchedulerWorkerOptions"/> from a parsed connection string.
-    /// </summary>
-    /// <param name="connectionString">The connection string to parse.</param>
-    /// <returns>A new instance of <see cref="DurableTaskSchedulerWorkerOptions"/>.</returns>
-    internal static DurableTaskSchedulerWorkerOptions FromConnectionString(
-        DurableTaskSchedulerConnectionString connectionString) => new()
-        {
-            EndpointAddress = connectionString.Endpoint,
-            TaskHubName = connectionString.TaskHubName,
-            Credential = GetCredentialFromConnectionString(connectionString),
-        };
-
     static TokenCredential? GetCredentialFromConnectionString(DurableTaskSchedulerConnectionString connectionString)
     {
         string authType = connectionString.Authentication;

test/Analyzers.Tests/Analyzers.Tests.csproj

@@ -2,8 +2,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis" Version="4.9.2" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.XUnit" Version="1.1.1" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.XUnit" Version="1.1.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing" Version="1.1.2" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing" Version="1.1.2" />
   </ItemGroup>
 
   <ItemGroup>

test/Analyzers.Tests/Orchestration/DateTimeOrchestrationAnalyzerTests.cs

@@ -367,7 +367,11 @@ static DateTime MyRunAsync(TaskOrchestrationContext context)
 
         DiagnosticResult expected = BuildDiagnostic().WithLocation(0).WithArguments("MyRunAsync", "System.DateTime.Now", "MyRun");
 
-        await VerifyCS.VerifyDurableTaskCodeFixAsync(code, expected, fix);
+        await VerifyCS.VerifyDurableTaskCodeFixAsync(code, expected, fix, test =>
+        {
+            // TODO: CodeFixBehaviors.SkipLocalDiagnosticCheck is failing this test. This is apparently a bad analyzer practice.
+            test.CodeFixTestBehaviors |= CodeFixTestBehaviors.SkipLocalDiagnosticCheck;
+        });
     }
 
 

test/Analyzers.Tests/Verifiers/CSharpAnalyzerVerifier.cs

@@ -5,7 +5,6 @@
 using Microsoft.CodeAnalysis.CSharp.Testing;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
 
 namespace Microsoft.DurableTask.Analyzers.Tests.Verifiers;
 
@@ -14,15 +13,15 @@ public static partial class CSharpAnalyzerVerifier<TAnalyzer>
 {
     /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.Diagnostic()"/>
     public static DiagnosticResult Diagnostic()
-        => CSharpAnalyzerVerifier<TAnalyzer, XUnitVerifier>.Diagnostic();
+        => CSharpAnalyzerVerifier<TAnalyzer, DefaultVerifier>.Diagnostic();
 
     /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.Diagnostic(string)"/>
     public static DiagnosticResult Diagnostic(string diagnosticId)
-        => CSharpAnalyzerVerifier<TAnalyzer, XUnitVerifier>.Diagnostic(diagnosticId);
+        => CSharpAnalyzerVerifier<TAnalyzer, DefaultVerifier>.Diagnostic(diagnosticId);
 
     /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.Diagnostic(DiagnosticDescriptor)"/>
     public static DiagnosticResult Diagnostic(DiagnosticDescriptor descriptor)
-        => CSharpAnalyzerVerifier<TAnalyzer, XUnitVerifier>.Diagnostic(descriptor);
+        => CSharpAnalyzerVerifier<TAnalyzer, DefaultVerifier>.Diagnostic(descriptor);
 
     /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.VerifyAnalyzerAsync(string, DiagnosticResult[])"/>
     public static async Task VerifyAnalyzerAsync(string source, params DiagnosticResult[] expected)
@@ -36,7 +35,7 @@ public static async Task VerifyAnalyzerAsync(string source, params DiagnosticRes
         await test.RunAsync(CancellationToken.None);
     }
 
-    public class Test : CSharpAnalyzerTest<TAnalyzer, XUnitVerifier>
+    public class Test : CSharpAnalyzerTest<TAnalyzer, DefaultVerifier>
     {
     }
 }

test/Analyzers.Tests/Verifiers/CSharpCodeFixVerifier.Durable.cs

@@ -13,26 +13,30 @@ public static Task VerifyDurableTaskAnalyzerAsync(string source, params Diagnost
         return VerifyDurableTaskAnalyzerAsync(source, null, expected);
     }
 
-    public static async Task VerifyDurableTaskAnalyzerAsync(string source, Action<Test>? configureTest = null, params DiagnosticResult[] expected)
+    public static async Task VerifyDurableTaskAnalyzerAsync(
+        string source, Action<Test>? configureTest = null, params DiagnosticResult[] expected)
     {
         await RunAsync(expected, new Test()
         {
             TestCode = source,
         }, configureTest);
     }
 
-    public static Task VerifyDurableTaskCodeFixAsync(string source, DiagnosticResult expected, string fixedSource)
+    public static Task VerifyDurableTaskCodeFixAsync(
+        string source, DiagnosticResult expected, string fixedSource, Action<Test>? configureTest = null)
     {
-        return VerifyDurableTaskCodeFixAsync(source, [expected], fixedSource);
+        return VerifyDurableTaskCodeFixAsync(source, [expected], fixedSource, configureTest);
     }
 
-    public static async Task VerifyDurableTaskCodeFixAsync(string source, DiagnosticResult[] expected, string fixedSource)
+    public static async Task VerifyDurableTaskCodeFixAsync(
+        string source, DiagnosticResult[] expected, string fixedSource, Action<Test>? configureTest = null)
     {
         await RunAsync(expected, new Test()
         {
             TestCode = source,
             FixedCode = fixedSource,
-        });
+        },
+        configureTest);
     }
 
     static async Task RunAsync(DiagnosticResult[] expected, Test test, Action<Test>? configureTest = null)

test/Analyzers.Tests/Verifiers/CSharpCodeFixVerifier.cs

@@ -6,7 +6,6 @@
 using Microsoft.CodeAnalysis.CSharp.Testing;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
 
 namespace Microsoft.DurableTask.Analyzers.Tests.Verifiers;
 
@@ -16,15 +15,15 @@ public static partial class CSharpCodeFixVerifier<TAnalyzer, TCodeFix>
 {
     /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.Diagnostic()"/>
     public static DiagnosticResult Diagnostic()
-        => CSharpCodeFixVerifier<TAnalyzer, TCodeFix, XUnitVerifier>.Diagnostic();
+        => CSharpCodeFixVerifier<TAnalyzer, TCodeFix, DefaultVerifier>.Diagnostic();
 
     /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.Diagnostic(string)"/>
     public static DiagnosticResult Diagnostic(string diagnosticId)
-        => CSharpCodeFixVerifier<TAnalyzer, TCodeFix, XUnitVerifier>.Diagnostic(diagnosticId);
+        => CSharpCodeFixVerifier<TAnalyzer, TCodeFix, DefaultVerifier>.Diagnostic(diagnosticId);
 
     /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.Diagnostic(DiagnosticDescriptor)"/>
     public static DiagnosticResult Diagnostic(DiagnosticDescriptor descriptor)
-        => CSharpCodeFixVerifier<TAnalyzer, TCodeFix, XUnitVerifier>.Diagnostic(descriptor);
+        => CSharpCodeFixVerifier<TAnalyzer, TCodeFix, DefaultVerifier>.Diagnostic(descriptor);
 
     /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.VerifyAnalyzerAsync(string, DiagnosticResult[])"/>
     public static async Task VerifyAnalyzerAsync(string source, params DiagnosticResult[] expected)
@@ -59,7 +58,7 @@ public static async Task VerifyCodeFixAsync(string source, DiagnosticResult[] ex
         await test.RunAsync(CancellationToken.None);
     }
 
-    public class Test : CSharpCodeFixTest<TAnalyzer, TCodeFix, XUnitVerifier>
+    public class Test : CSharpCodeFixTest<TAnalyzer, TCodeFix, DefaultVerifier>
     {
     }
 }

test/Generators.Tests/Generators.Tests.csproj

@@ -5,7 +5,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.SourceGenerators.Testing.XUnit" Version="1.1.*" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.SourceGenerators.Testing" Version="1.1.2" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.9.0" PrivateAssets="all" />
     <PackageReference Include="Microsoft.CodeAnalysis.Common" Version="3.9.0" PrivateAssets="all" />
     <PackageReference Include="Microsoft.CodeAnalysis" Version="3.9.0" PrivateAssets="all" />

test/Generators.Tests/Utils/CSharpSourceGeneratorVerifier.cs

@@ -6,14 +6,13 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Testing;
 using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
 
 namespace Microsoft.DurableTask.Generators.Tests.Utils;
 
 // Mostly copy/pasted from the Microsoft Source Generators testing documentation
 public static class CSharpSourceGeneratorVerifier<TSourceGenerator> where TSourceGenerator : ISourceGenerator, new()
 {
-    public class Test : CSharpSourceGeneratorTest<TSourceGenerator, XUnitVerifier>
+    public class Test : CSharpSourceGeneratorTest<TSourceGenerator, DefaultVerifier>
     {
         public Test()
         {