feat: implement analyzer and code fixer for identifying and fixing when a sync flag is not propagated correctly.

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenOuterMethodHasNoSyncParam.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetCoreAsync(int id, bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync()
+  {
+    return await _dataService.GetCoreAsync(17);
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsHardcodedFalse.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetCoreAsync(int id, bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await {|#0:_dataService.GetCoreAsync(17, false)|};
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsHardcodedFalse_Fixed.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetCoreAsync(int id, bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await _dataService.GetCoreAsync(17, sync);
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsNotLastTargetParameter.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetDataAsync(int id, bool sync = false, bool useCache = true);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await {|#0:_dataService.GetDataAsync(17)|};
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsNotLastTargetParameter_Fixed.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetDataAsync(int id, bool sync = false, bool useCache = true);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await _dataService.GetDataAsync(17, sync);
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsOmitted.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetCoreAsync(int id, bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await {|#0:_dataService.GetCoreAsync(17)|};
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsOmitted_CustomName.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetMoreDataAsync(bool runSynchronously = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool runSynchronously)
+  {
+    return await {|#0:_dataService.GetMoreDataAsync()|};
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsOmitted_CustomName_Fixed.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetMoreDataAsync(bool runSynchronously = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool runSynchronously)
+  {
+    return await _dataService.GetMoreDataAsync(runSynchronously);
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsOmitted_Fixed.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetCoreAsync(int id, bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await _dataService.GetCoreAsync(17, sync);
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsOmitted_MultipleAwaits.cs

@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetDataAsync(bool sync = false);
+  Task<string> GetMoreDataAsync(bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    var a = await _dataService.GetDataAsync(sync);
+    var b = await {|#0:_dataService.GetMoreDataAsync()|};
+    return a + b;
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsOmitted_MultipleAwaits_Fixed.cs

@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetDataAsync(bool sync = false);
+  Task<string> GetMoreDataAsync(bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    var a = await _dataService.GetDataAsync(sync);
+    var b = await _dataService.GetMoreDataAsync(sync);
+    return a + b;
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsPassedAsNamed.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetCoreAsync(int id, bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await _dataService.GetCoreAsync(id: 17, sync: sync);
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsPassedAsNamedHardcoded.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetCoreAsync(int id, bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await {|#0:_dataService.GetCoreAsync(17, sync: false)|};
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsPassedAsNamedHardcoded_Fixed.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetCoreAsync(int id, bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await _dataService.GetCoreAsync(17, sync: sync);
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsPassedCorrectly.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetCoreAsync(int id, bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await _dataService.GetCoreAsync(17, sync);
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenSyncIsPassedPositionally.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+public interface IDataService
+{
+  Task<string> GetCoreAsync(int id, bool sync = false);
+}
+
+public class BusinessLogic
+{
+  private readonly IDataService _dataService;
+  public BusinessLogic(IDataService dataService) { _dataService = dataService; }
+
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    return await _dataService.GetCoreAsync(17, sync);
+  }
+}

tests/StevanFreeborn.AsyncSyncFlagAnalyzer.Tests/TestData/WhenTargetHasNoSyncParam.cs

@@ -0,0 +1,10 @@
+using System.Threading.Tasks;
+
+public class BusinessLogic
+{
+  private async Task<string> GetFrobCoreAsync(bool sync)
+  {
+    await Task.Delay(100);
+    return "done";
+  }
+}