refactor: fix PR comments

Author: Anakael

src/OmniSharp.Abstractions/Eventing/IEventEmitter.cs

@@ -1,7 +1,10 @@
+using System.Threading;
+using System.Threading.Tasks;
+
 namespace OmniSharp.Eventing
 {
     public interface IEventEmitter
     {
-        void Emit(string kind, object args);
+        ValueTask EmitAsync(string kind, object args, CancellationToken cancellationToken = default);
     }
-}
+}

src/OmniSharp.Abstractions/Eventing/IEventEmitterExtensions.cs

@@ -1,56 +1,60 @@
 using System;
 using System.Collections.Generic;
 using OmniSharp.Models.Events;
-using OmniSharp;
 using OmniSharp.Models;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace OmniSharp.Eventing
 {
     public static class IEventEmitterExtensions
     {
-        public static void Error(this IEventEmitter emitter, Exception ex, string fileName = null)
-        {
-            emitter.Emit(
+        public static ValueTask ErrorAsync(this IEventEmitter emitter, Exception ex, string fileName = null, CancellationToken cancellationToken = default) =>
+            emitter.EmitAsync(
                 EventTypes.Error,
-                new ErrorMessage { FileName = fileName, Text = ex.ToString() });
-        }
+                new ErrorMessage { FileName = fileName, Text = ex.ToString() },
+                cancellationToken);
 
-        public static void RestoreStarted(this IEventEmitter emitter, string projectPath)
-        {
-            emitter.Emit(
+        public static ValueTask RestoreStartedAsync(this IEventEmitter emitter, string projectPath, CancellationToken cancellationToken = default) =>
+            emitter.EmitAsync(
                 EventTypes.PackageRestoreStarted,
-                new PackageRestoreMessage { FileName = projectPath });
-        }
+                new PackageRestoreMessage { FileName = projectPath },
+                cancellationToken);
 
-        public static void RestoreFinished(this IEventEmitter emitter, string projectPath, bool succeeded)
-        {
-            emitter.Emit(
+        public static ValueTask RestoreFinishedAsync(this IEventEmitter emitter, string projectPath, bool succeeded, CancellationToken cancellationToken = default) =>
+            emitter.EmitAsync(
                 EventTypes.PackageRestoreFinished,
                 new PackageRestoreMessage
                 {
                     FileName = projectPath,
                     Succeeded = succeeded
-                });
-        }
+                },
+                cancellationToken);
 
-        public static void UnresolvedDepdendencies(this IEventEmitter emitter, string projectFilePath, IEnumerable<PackageDependency> unresolvedDependencies)
-        {
-            emitter.Emit(
+        public static ValueTask UnresolvedDependenciesAsync(this IEventEmitter emitter, string projectFilePath, IEnumerable<PackageDependency> unresolvedDependencies, CancellationToken cancellationToken = default) =>
+            emitter.EmitAsync(
                 EventTypes.UnresolvedDependencies,
                 new UnresolvedDependenciesMessage
                 {
                     FileName = projectFilePath,
                     UnresolvedDependencies = unresolvedDependencies
-                });
-        }
+                },
+                cancellationToken);
 
-        public static void ProjectLoadingStarted(this IEventEmitter emitter, string projectPath) =>
-            emitter.Emit(
+        public static ValueTask ProjectLoadingStartedAsync(this IEventEmitter emitter, string projectPath, CancellationToken cancellationToken = default) =>
+            emitter.EmitAsync(
                     EventTypes.ProjectLoadingStarted,
-                    projectPath);
+                    projectPath,
+                    cancellationToken);
+
+        public static ValueTask ProjectLoadingFinishedAsync(this IEventEmitter emitter, string projectPath, CancellationToken cancellationToken = default) =>
+            emitter.EmitAsync(
+                    EventTypes.ProjectLoadingFinished,
+                    projectPath,
+                    cancellationToken);
 
-        public static void ProjectInformation(this IEventEmitter emitter,
+        public static async Task ProjectInformationAsync(this IEventEmitter emitter,
                                               HashedString projectId,
                                               HashedString sessionId,
                                               int outputKind,
@@ -61,7 +65,7 @@ public static void ProjectInformation(this IEventEmitter emitter,
                                               IEnumerable<HashedString> fileExtensions,
                                               IEnumerable<int> fileCounts,
                                               bool sdkStyleProject,
-                                              string projectFilePath)
+                                              CancellationToken cancellationToken = default)
         {
             var projectConfiguration = new ProjectConfigurationMessage()
             {
@@ -74,13 +78,13 @@ public static void ProjectInformation(this IEventEmitter emitter,
                 References = references.Select(hashed => hashed.Value),
                 FileExtensions = fileExtensions.Select(hashed => hashed.Value),
                 FileCounts = fileCounts,
-                SdkStyleProject = sdkStyleProject,
-                ProjectFilePath = projectFilePath
+                SdkStyleProject = sdkStyleProject
             };
 
-            emitter.Emit(
+            await emitter.EmitAsync(
                 EventTypes.ProjectConfiguration,
-                projectConfiguration);
+                projectConfiguration,
+                cancellationToken);
         }
     }
 }

src/OmniSharp.Abstractions/Models/Events/EventTypes.cs

@@ -3,6 +3,7 @@ namespace OmniSharp.Models.Events
     public static class EventTypes
     {
         public const string ProjectLoadingStarted = nameof(ProjectLoadingStarted);
+        public const string ProjectLoadingFinished = nameof(ProjectLoadingFinished);
         public const string ProjectAdded = nameof(ProjectAdded);
         public const string ProjectChanged = nameof(ProjectChanged);
         public const string ProjectRemoved = nameof(ProjectRemoved);

src/OmniSharp.Abstractions/Models/Events/ProjectConfigurationMessage.cs

@@ -15,6 +15,5 @@ public class ProjectConfigurationMessage
         public IEnumerable<string> FileExtensions { get; set; }
         public IEnumerable<int> FileCounts { get; set; }
         public bool SdkStyleProject { get; set; }
-        public string ProjectFilePath { get; set; }
     }
 }

src/OmniSharp.DotNetTest/Services/BaseTestService.cs

@@ -1,4 +1,6 @@
-using Microsoft.Extensions.Logging;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 using OmniSharp.Eventing;
 using OmniSharp.Services;
 
@@ -19,11 +21,11 @@ protected BaseTestService(OmniSharpWorkspace workspace, IDotNetCliService dotNet
             LoggerFactory = loggerFactory;
         }
 
-        protected TestManager CreateTestManager(string fileName, bool noBuild)
+        protected async Task<TestManager> CreateTestManagerAsync(string fileName, bool noBuild, CancellationToken cancellationToken = default)
         {
             var document = Workspace.GetDocument(fileName);
 
-            return TestManager.Start(document.Project, DotNetCli, EventEmitter, LoggerFactory, noBuild);
+            return await TestManager.Start(document.Project, DotNetCli, EventEmitter, LoggerFactory, noBuild, cancellationToken);
         }
     }
 }

src/OmniSharp.DotNetTest/Services/BaseTestService`2.cs

@@ -22,7 +22,7 @@ protected BaseTestService(OmniSharpWorkspace workspace, IDotNetCliService dotNet
 
         public async Task<TResponse> Handle(TRequest request)
         {
-            using (var testManager = CreateTestManager(request.FileName, request.NoBuild))
+            using (var testManager = await CreateTestManagerAsync(request.FileName, request.NoBuild))
             {
                 return await HandleRequest(request, testManager);
             }

src/OmniSharp.DotNetTest/Services/DebugTestClassService.cs

@@ -25,7 +25,7 @@ public DebugTestClassService(DebugSessionManager debugSessionManager, OmniSharpW
 
         public async Task<DebugTestGetStartInfoResponse> Handle(DebugTestClassGetStartInfoRequest request)
         {
-            var testManager = CreateTestManager(request.FileName, request.NoBuild);
+            var testManager = await CreateTestManagerAsync(request.FileName, request.NoBuild);
             _debugSessionManager.StartSession(testManager);
 
             return await _debugSessionManager.DebugGetStartInfoAsync(request.MethodNames, request.RunSettings, request.TestFrameworkName, request.TargetFrameworkVersion, CancellationToken.None);

src/OmniSharp.DotNetTest/Services/DebugTestService.cs

@@ -29,14 +29,14 @@ public DebugTestService(DebugSessionManager debugSessionManager, OmniSharpWorksp
             _debugSessionManager = debugSessionManager;
         }
 
-        public Task<DebugTestGetStartInfoResponse> Handle(DebugTestGetStartInfoRequest request)
+        public async Task<DebugTestGetStartInfoResponse> Handle(DebugTestGetStartInfoRequest request)
         {
-            var testManager = CreateTestManager(request.FileName, request.NoBuild);
+            var testManager = await CreateTestManagerAsync(request.FileName, request.NoBuild);
             if (testManager.IsConnected)
             {
                 //only if the test manager connected successfully, shall we proceed with the request
                 _debugSessionManager.StartSession(testManager);
-                return _debugSessionManager.DebugGetStartInfoAsync(request.MethodName, request.RunSettings, request.TestFrameworkName, request.TargetFrameworkVersion, CancellationToken.None);
+                return await _debugSessionManager.DebugGetStartInfoAsync(request.MethodName, request.RunSettings, request.TestFrameworkName, request.TargetFrameworkVersion, CancellationToken.None);
             }
 
             throw new InvalidOperationException("The debugger could not be started");

src/OmniSharp.DotNetTest/Services/DebugTestsInContextService.cs

@@ -40,7 +40,7 @@ public async Task<DebugTestGetStartInfoResponse> Handle(DebugTestsInContextGetSt
                 };
             }
 
-            var testManager = TestManager.Create(document.Project, DotNetCli, EventEmitter, LoggerFactory);
+            var testManager = await TestManager.CreateAsync(document.Project, DotNetCli, EventEmitter, LoggerFactory);
 
             var (methodNames, testFramework) = await testManager.GetContextTestMethodNames(request.Line, request.Column, document, CancellationToken.None);
 

src/OmniSharp.DotNetTest/Services/RunTestsInContextService.cs

@@ -34,7 +34,7 @@ public async Task<RunTestResponse> Handle(RunTestsInContextRequest request)
                 };
             }
 
-            using var testManager = TestManager.Create(document.Project, DotNetCli, EventEmitter, LoggerFactory);
+            using var testManager = await TestManager.CreateAsync(document.Project, DotNetCli, EventEmitter, LoggerFactory);
 
             var (methodNames, testFramework) = await testManager.GetContextTestMethodNames(request.Line, request.Column, document, CancellationToken.None);