Revert diagnostic worker changes.

OmniSharp · Oct 14, 2020 · c610d51 · c610d51
1 parent 4046da8
commit c610d51
Show file tree

Hide file tree

Showing 8 changed files with 181 additions and 229 deletions.
diff --git a/src/OmniSharp.Roslyn.CSharp/Services/Refactoring/V2/CachingCodeFixProviderForProjects.cs b/src/OmniSharp.Roslyn.CSharp/Services/Refactoring/V2/CachingCodeFixProviderForProjects.cs
@@ -41,14 +41,16 @@ public CachingCodeFixProviderForProjects(ILoggerFactory loggerFactory, OmniSharp
             };
         }
 
-        public ImmutableArray<CodeFixProvider> GetAllCodeFixesForProject(Project project)
+        public ImmutableArray<CodeFixProvider> GetAllCodeFixesForProject(ProjectId projectId)
         {
-            if (_cache.ContainsKey(project.Id))
-                return _cache[project.Id];
+            if (_cache.ContainsKey(projectId))
+                return _cache[projectId];
+
+            var project = _workspace.CurrentSolution.GetProject(projectId);
 
             if (project == null)
             {
-                _cache.TryRemove(project.Id, out _);
+                _cache.TryRemove(projectId, out _);
                 return ImmutableArray<CodeFixProvider>.Empty;
             }
 

diff --git a/src/OmniSharp.Roslyn.CSharp/Workers/Diagnostics/AnalyzerWorkQueue.cs b/src/OmniSharp.Roslyn.CSharp/Workers/Diagnostics/AnalyzerWorkQueue.cs
@@ -17,8 +17,8 @@ public Queue(TimeSpan throttling)
                 Throttling = throttling;
             }
 
-            public ImmutableHashSet<Document> WorkWaitingToExecute { get; set; } = ImmutableHashSet<Document>.Empty;
-            public ImmutableHashSet<Document> WorkExecuting { get; set; } = ImmutableHashSet<Document>.Empty;
+            public ImmutableHashSet<DocumentId> WorkWaitingToExecute { get; set; } = ImmutableHashSet<DocumentId>.Empty;
+            public ImmutableHashSet<DocumentId> WorkExecuting { get; set; } = ImmutableHashSet<DocumentId>.Empty;
             public DateTime LastThrottlingBegan { get; set; } = DateTime.UtcNow;
             public TimeSpan Throttling { get; }
             public CancellationTokenSource WorkPendingToken { get; set; }
@@ -44,7 +44,7 @@ public AnalyzerWorkQueue(ILoggerFactory loggerFactory, int timeoutForPendingWork
             _maximumDelayWhenWaitingForResults = timeoutForPendingWorkMs;
         }
 
-        public void PutWork(IReadOnlyCollection<Document> documents, AnalyzerWorkType workType)
+        public void PutWork(IReadOnlyCollection<DocumentId> documentIds, AnalyzerWorkType workType)
         {
             lock (_queueLock)
             {
@@ -56,21 +56,21 @@ public void PutWork(IReadOnlyCollection<Document> documents, AnalyzerWorkType wo
                 if (queue.WorkPendingToken == null)
                     queue.WorkPendingToken = new CancellationTokenSource();
 
-                queue.WorkWaitingToExecute = queue.WorkWaitingToExecute.Union(documents);
+                queue.WorkWaitingToExecute = queue.WorkWaitingToExecute.Union(documentIds);
             }
         }
 
-        public IReadOnlyCollection<Document> TakeWork(AnalyzerWorkType workType)
+        public IReadOnlyCollection<DocumentId> TakeWork(AnalyzerWorkType workType)
         {
             lock (_queueLock)
             {
                 var queue = _queues[workType];
 
                 if (IsThrottlingActive(queue) || queue.WorkWaitingToExecute.IsEmpty)
-                    return ImmutableHashSet<Document>.Empty;
+                    return ImmutableHashSet<DocumentId>.Empty;
 
                 queue.WorkExecuting = queue.WorkWaitingToExecute;
-                queue.WorkWaitingToExecute = ImmutableHashSet<Document>.Empty;
+                queue.WorkWaitingToExecute = ImmutableHashSet<DocumentId>.Empty;
                 return queue.WorkExecuting;
             }
         }
@@ -84,12 +84,12 @@ public void WorkComplete(AnalyzerWorkType workType)
         {
             lock (_queueLock)
             {
-                if (_queues[workType].WorkExecuting.IsEmpty)
+                if(_queues[workType].WorkExecuting.IsEmpty)
                     return;
 
                 _queues[workType].WorkPendingToken?.Cancel();
                 _queues[workType].WorkPendingToken = null;
-                _queues[workType].WorkExecuting = ImmutableHashSet<Document>.Empty;
+                _queues[workType].WorkExecuting = ImmutableHashSet<DocumentId>.Empty;
             }
         }
 
@@ -107,9 +107,15 @@ public Task WaitForegroundWorkComplete()
                 .ContinueWith(task => LogTimeouts(task));
         }
 
-        public void QueueDocumentForeground(Document document)
+        public bool TryPromote(DocumentId id)
         {
-            PutWork(new[] { document }, AnalyzerWorkType.Foreground);
+            if (_queues[AnalyzerWorkType.Background].WorkWaitingToExecute.Contains(id) || _queues[AnalyzerWorkType.Background].WorkExecuting.Contains(id))
+            {
+                PutWork(new[] { id }, AnalyzerWorkType.Foreground);
+                return true;
+            }
+
+            return false;
         }
 
         private void LogTimeouts(Task task)

diff --git a/src/OmniSharp.Roslyn.CSharp/Workers/Diagnostics/CSharpDiagnosticWorker.cs b/src/OmniSharp.Roslyn.CSharp/Workers/Diagnostics/CSharpDiagnosticWorker.cs
@@ -145,25 +145,14 @@ public async Task<ImmutableArray<DocumentDiagnostics>> GetDiagnostics(ImmutableA
                         .Select(docPath => _workspace.GetDocumentsFromFullProjectModelAsync(docPath)))
                 ).SelectMany(s => s);
 
-            return await GetDiagnostics(documents);
-        }
-
-        public Task<ImmutableArray<DocumentDiagnostics>> GetDiagnostics(ImmutableArray<Document> documents)
-        {
-            return GetDiagnostics((IEnumerable<Document>)documents);
-        }
-
-        private async Task<ImmutableArray<DocumentDiagnostics>> GetDiagnostics(IEnumerable<Document> documents)
-        {
-            var results = new List<DocumentDiagnostics>();
             foreach (var document in documents)
             {
                 if(document?.Project?.Name == null)
                     continue;
 
                 var projectName = document.Project.Name;
                 var diagnostics = await GetDiagnosticsForDocument(document, projectName);
-                results.Add(new DocumentDiagnostics(document, diagnostics));
+                results.Add(new DocumentDiagnostics(document.Id, document.FilePath, document.Project.Id, document.Project.Name, diagnostics));
             }
 
             return results.ToImmutableArray();
@@ -185,18 +174,18 @@ private static async Task<ImmutableArray<Diagnostic>> GetDiagnosticsForDocument(
             }
         }
 
-        public ImmutableArray<Document> QueueDocumentsForDiagnostics()
+        public ImmutableArray<DocumentId> QueueDocumentsForDiagnostics()
         {
-            var documents = _workspace.CurrentSolution.Projects.SelectMany(x => x.Documents).ToImmutableArray();
+            var documents = _workspace.CurrentSolution.Projects.SelectMany(x => x.Documents);
             QueueForDiagnosis(documents.Select(x => x.FilePath).ToImmutableArray());
-            return documents;
+            return documents.Select(x => x.Id).ToImmutableArray();
         }
 
-        public ImmutableArray<Document> QueueDocumentsForDiagnostics(ImmutableArray<ProjectId> projectIds)
+        public ImmutableArray<DocumentId> QueueDocumentsForDiagnostics(ImmutableArray<ProjectId> projectIds)
         {
-            var documents = projectIds.SelectMany(projectId => _workspace.CurrentSolution.GetProject(projectId).Documents).ToImmutableArray();
+            var documents = projectIds.SelectMany(projectId => _workspace.CurrentSolution.GetProject(projectId).Documents);
             QueueForDiagnosis(documents.Select(x => x.FilePath).ToImmutableArray());
-            return documents;
+            return documents.Select(x => x.Id).ToImmutableArray();
         }
 
         public Task<ImmutableArray<DocumentDiagnostics>> GetAllDiagnosticsAsync()