Better progress reporting

src/LanguageServer/Impl/Definitions/ILogger.cs

@@ -19,5 +19,6 @@
 namespace Microsoft.Python.LanguageServer {
     public interface ILogger {
         void TraceMessage(IFormattable message);
+        void TraceMessage(string message);
     }
 }

src/LanguageServer/Impl/Implementation/AnalysisProgressReporter.cs

@@ -0,0 +1,85 @@
+// Python Tools for Visual Studio
+// Copyright(c) Microsoft Corporation
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the License); you may not use
+// this file except in compliance with the License. You may obtain a copy of the
+// License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY
+// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+// MERCHANTABLITY OR NON-INFRINGEMENT.
+//
+// See the Apache Version 2.0 License for specific language governing
+// permissions and limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.PythonTools.Analysis.Infrastructure;
+
+namespace Microsoft.Python.LanguageServer.Implementation {
+    sealed class AnalysisProgressReporter : IDisposable {
+        private readonly DisposableBag _disposables = new DisposableBag(nameof(AnalysisProgressReporter));
+        private readonly Dictionary<Uri, int> _activeAnalysis = new Dictionary<Uri, int>();
+        private readonly IProgressService _progressService;
+        private readonly ILogger _logger;
+        private readonly Server _server;
+        private readonly object _lock = new object();
+        private IProgress _progress;
+
+        public AnalysisProgressReporter(Server server, IProgressService progressService, ILogger logger) {
+            _progressService = progressService;
+            _logger = logger;
+
+            _server = server;
+            _server.OnAnalysisQueued += OnAnalysisQueued;
+            _server.OnAnalysisComplete += OnAnalysisComplete;
+            _disposables
+                .Add(() => _server.OnAnalysisQueued -= OnAnalysisQueued)
+                .Add(() => _server.OnAnalysisComplete -= OnAnalysisComplete)
+                .Add(() => _progress?.Dispose());
+        }
+
+        public void Dispose() {
+            _disposables.TryDispose();
+        }
+
+        private void OnAnalysisQueued(object sender, AnalysisQueuedEventArgs e) {
+            lock (_lock) {
+                if (_activeAnalysis.ContainsKey(e.uri)) {
+                    _activeAnalysis[e.uri]++;
+                } else {
+                    _activeAnalysis[e.uri] = 1;
+                }
+                UpdateProgressMessage();
+            }
+        }
+        private void OnAnalysisComplete(object sender, AnalysisCompleteEventArgs e) {
+            lock (_lock) {
+                if (_activeAnalysis.TryGetValue(e.uri, out var count)) {
+                    if (count > 1) {
+                        _activeAnalysis[e.uri]--;
+                    } else {
+                        _activeAnalysis.Remove(e.uri);
+                    }
+                } else {
+                    _logger.TraceMessage($"Analysis completed for {e.uri} that is not in the dictionary.");
+                }
+                UpdateProgressMessage();
+            }
+        }
+
+        private void UpdateProgressMessage() {
+            if(_activeAnalysis.Count > 0) {
+                _progress = _progress ?? _progressService.BeginProgress();
+                _progress.Report(_activeAnalysis.Count == 1
+                    ? Resources.AnalysisProgress_SingleItemRemaining
+                    : Resources.AnalysisProgress_MultipleItemsRemaining.FormatInvariant(_activeAnalysis.Count)).DoNotWait();
+            } else {
+                _progress?.Dispose();
+                _progress = null;
+            }
+        }
+    }
+}

src/LanguageServer/Impl/Implementation/Server.cs

@@ -123,11 +123,14 @@ private void Analysis_UnhandledException(object sender, UnhandledExceptionEventA
 
         public void Dispose() => _disposableBag.TryDispose();
 
-        public void TraceMessage(IFormattable message) {
+        #region ILogger
+        public void TraceMessage(IFormattable message) => TraceMessage(message.ToString());
+        public void TraceMessage(string message) {
             if (_traceLogging) {
-                LogMessage(MessageType.Log, message.ToString());
+                LogMessage(MessageType.Log, message);
             }
         }
+        #endregion
 
         #region Client message handling
         internal InitializeResult GetInitializeResult() => new InitializeResult {

src/LanguageServer/Impl/LanguageServer.cs

@@ -43,31 +43,30 @@ public sealed partial class LanguageServer: IDisposable {
         private IServiceContainer _services;
         private IUIService _ui;
         private ITelemetryService _telemetry;
-        private IProgressService _progress;
 
         private JsonRpc _rpc;
         private bool _filesLoaded;
         private Task _progressReportingTask;
         private PathsWatcher _pathsWatcher;
         private IdleTimeTracker _idleTimeTracker;
+        private AnalysisProgressReporter _analysisProgressReporter;
 
         public CancellationToken Start(IServiceContainer services, JsonRpc rpc) {
             _services = services;
             _ui = services.GetService<IUIService>();
             _telemetry = services.GetService<ITelemetryService>();
-            _progress = services.GetService<IProgressService>();
-
             _rpc = rpc;
 
+            var progress = services.GetService<IProgressService>();
+            _analysisProgressReporter = new AnalysisProgressReporter(_server, progress, _server);
+
             _server.OnLogMessage += OnLogMessage;
             _server.OnShowMessage += OnShowMessage;
             _server.OnTelemetry += OnTelemetry;
             _server.OnPublishDiagnostics += OnPublishDiagnostics;
             _server.OnApplyWorkspaceEdit += OnApplyWorkspaceEdit;
             _server.OnRegisterCapability += OnRegisterCapability;
             _server.OnUnregisterCapability += OnUnregisterCapability;
-            _server.OnAnalysisQueued += OnAnalysisQueued;
-            _server.OnAnalysisComplete += OnAnalysisComplete;
 
             _disposables
                 .Add(() => _server.OnLogMessage -= OnLogMessage)
@@ -77,40 +76,14 @@ public CancellationToken Start(IServiceContainer services, JsonRpc rpc) {
                 .Add(() => _server.OnApplyWorkspaceEdit -= OnApplyWorkspaceEdit)
                 .Add(() => _server.OnRegisterCapability -= OnRegisterCapability)
                 .Add(() => _server.OnUnregisterCapability -= OnUnregisterCapability)
-                .Add(() => _server.OnAnalysisQueued -= OnAnalysisQueued)
-                .Add(() => _server.OnAnalysisComplete -= OnAnalysisComplete)
-                .Add(_prioritizer);
+                .Add(_prioritizer)
+                .Add(_analysisProgressReporter)
+                .Add(() => _pathsWatcher?.Dispose());
 
             return _sessionTokenSource.Token;
         }
 
-        private void OnAnalysisQueued(object sender, AnalysisQueuedEventArgs e) => HandleAnalysisQueueEvent();
-        private void OnAnalysisComplete(object sender, AnalysisCompleteEventArgs e) => HandleAnalysisQueueEvent();
-
-        private void HandleAnalysisQueueEvent()
-            => _progressReportingTask = _progressReportingTask ?? ProgressWorker();
-
-        private async Task ProgressWorker() {
-            await Task.Delay(1000);
-
-            var remaining = _server.EstimateRemainingWork();
-            if (remaining > 0) {
-                using (var p = _progress.BeginProgress()) {
-                    while (remaining > 0) {
-                        var items = remaining > 1 ? "items" : "item";
-                        // TODO: in localization this needs to be two different messages 
-                        // since not all languages allow sentence construction.
-                        await p.Report($"Analyzing workspace, {remaining} {items} remaining...");
-                        await Task.Delay(100);
-                        remaining = _server.EstimateRemainingWork();
-                    }
-                }
-            }
-            _progressReportingTask = null;
-        }
-
         public void Dispose() {
-            _pathsWatcher?.Dispose();
             _disposables.TryDispose();
             _server.Dispose();
         }

src/LanguageServer/Impl/Resources.resx

@@ -117,6 +117,12 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="AnalysisProgress_MultipleItemsRemaining" xml:space="preserve">
+    <value>Analyzing workspace, {0} items remaining...</value>
+  </data>
+  <data name="AnalysisProgress_SingleItemRemaining" xml:space="preserve">
+    <value>Analyzing workspace, 1 item remaining...</value>
+  </data>
   <data name="RenameVariable_CannotRename" xml:space="preserve">
     <value>Cannot rename</value>
   </data>

src/LanguageServer/Impl/Services/UIService.cs

@@ -63,7 +63,8 @@ public Task LogMessage(string message, MessageType messageType) {
         public Task SetStatusBarMessage(string message) 
             => _rpc.NotifyWithParameterObjectAsync("window/setStatusBarMessage", message);
 
-        public void TraceMessage(IFormattable message) => LogMessage(message.ToString(), MessageType.Info);
+        public void TraceMessage(string message) => LogMessage(message.ToString(), MessageType.Info);
+        public void TraceMessage(IFormattable message) => TraceMessage(message.ToString());
 
         public void SetLogLevel(MessageType logLevel) => _logLevel = logLevel;
     }