SLVS-2430 Trigger analysis on pressed key with debounce

Author: gabriela-trutan-sonarsource

src/Integration.Vsix.UnitTests/SonarLintTagger/TaggerProviderTests.cs

@@ -31,6 +31,7 @@
 using SonarLint.VisualStudio.Integration.Vsix;
 using SonarLint.VisualStudio.Integration.Vsix.Analysis;
 using SonarLint.VisualStudio.Integration.Vsix.ErrorList;
+using SonarLint.VisualStudio.Integration.Vsix.SonarLintTagger;
 using SonarLint.VisualStudio.IssueVisualization.Editor;
 using SonarLint.VisualStudio.IssueVisualization.Editor.LanguageDetection;
 
@@ -57,6 +58,7 @@ public class TaggerProviderTests
     private IAnalyzer analyzer;
     private IInitializationProcessorFactory initializationProcessorFactory;
     private IThreadHandling threadHandling;
+    private ITaskExecutorWithDebounceFactory taskExecutorWithDebounceFactory;
 
     private static readonly AnalysisLanguage[] DetectedLanguagesJsTs = [AnalysisLanguage.TypeScript, AnalysisLanguage.Javascript];
 
@@ -90,6 +92,8 @@ public void SetUp()
 
         threadHandling = Substitute.ForPartsOf<NoOpThreadHandler>();
 
+        taskExecutorWithDebounceFactory = Substitute.For<ITaskExecutorWithDebounceFactory>();
+
         testSubject = CreateAndInitializeTestSubject();
     }
 
@@ -121,7 +125,8 @@ private static Export[] GetRequiredExports() =>
         MefTestHelpers.CreateExport<IFileTracker>(),
         MefTestHelpers.CreateExport<IAnalyzer>(),
         MefTestHelpers.CreateExport<ILogger>(),
-        MefTestHelpers.CreateExport<IInitializationProcessorFactory>()
+        MefTestHelpers.CreateExport<IInitializationProcessorFactory>(),
+        MefTestHelpers.CreateExport<ITaskExecutorWithDebounceFactory>(),
     ];
 
     #endregion MEF tests
@@ -147,6 +152,7 @@ public void CreateTagger_should_create_tracker_when_tagger_is_created()
         tagger.Should().NotBeNull();
 
         VerifyCreateIssueConsumerWasCalled(doc);
+        taskExecutorWithDebounceFactory.Received(1).Create<ITextSnapshot>(debounceMilliseconds: 1000);
     }
 
     [TestMethod]
@@ -611,7 +617,7 @@ private TaggerProvider CreateAndInitializeTestSubject()
         var taggerProvider = new TaggerProvider(
             mockSonarErrorDataSource, dummyDocumentFactoryService, serviceProvider,
             mockSonarLanguageRecognizer, mockAnalysisRequester, vsProjectInfoProvider, issueConsumerFactory, issueConsumerStorage,
-            mockTaggableBufferIndicator, mockFileTracker, analyzer, logger, initializationProcessorFactory);
+            mockTaggableBufferIndicator, mockFileTracker, analyzer, logger, initializationProcessorFactory, taskExecutorWithDebounceFactory);
         taggerProvider.InitializationProcessor.InitializeAsync().GetAwaiter().GetResult();
         return taggerProvider;
     }

src/Integration.Vsix.UnitTests/SonarLintTagger/TextBufferIssueTrackerTests.cs

@@ -56,6 +56,8 @@ public class TextBufferIssueTrackerTests
     private IIssueConsumerFactory issueConsumerFactory;
     private IIssueConsumerStorage issueConsumerStorage;
     private IIssueConsumer issueConsumer;
+    private ITaskExecutorWithDebounceFactory taskExecutorWithDebounceFactory;
+    private ITaskExecutorWithDebounce<ITextSnapshot> taskExecutorWithDebounce;
 
     [TestInitialize]
     public void SetUp()
@@ -71,6 +73,9 @@ public void SetUp()
         mockDocumentTextBuffer = CreateTextBufferMock(mockTextSnapshot);
         mockedJavascriptDocumentFooJs = CreateDocumentMock("foo.js", mockDocumentTextBuffer);
         javascriptLanguage = [AnalysisLanguage.Javascript];
+        taskExecutorWithDebounceFactory = Substitute.For<ITaskExecutorWithDebounceFactory>();
+        taskExecutorWithDebounce = Substitute.For<ITaskExecutorWithDebounce<ITextSnapshot>>();
+        taskExecutorWithDebounceFactory.Create<ITextSnapshot>(Arg.Any<double>()).Returns(taskExecutorWithDebounce);
         MockIssueConsumerFactory(mockedJavascriptDocumentFooJs, issueConsumer);
 
         testSubject = CreateTestSubject(mockedJavascriptDocumentFooJs);
@@ -98,6 +103,7 @@ public void Ctor_RegistersEventsTrackerAndFactory()
         taggerProvider.ActiveTrackersForTesting.Should().BeEquivalentTo(testSubject);
 
         mockedJavascriptDocumentFooJs.Received(1).FileActionOccurred += Arg.Any<EventHandler<TextDocumentFileActionEventArgs>>();
+        ((ITextBuffer2)mockDocumentTextBuffer).Received(1).ChangedOnBackground += Arg.Any<EventHandler<TextContentChangedEventArgs>>();
 
         // Note: the test subject isn't responsible for adding the entry to the buffer.Properties
         // - that's done by the TaggerProvider.
@@ -196,7 +202,6 @@ public void WhenFileIsLoaded_EventsAreNotRaised()
         var renamedEventHandler = Substitute.For<EventHandler<DocumentRenamedEventArgs>>();
         var savedEventHandler = Substitute.For<EventHandler<DocumentEventArgs>>();
         taggerProvider.OpenDocumentRenamed += renamedEventHandler;
-        taggerProvider.DocumentSaved += savedEventHandler;
 
         RaiseFileLoadedEvent(mockedJavascriptDocumentFooJs);
 
@@ -326,6 +331,21 @@ public void UpdateAnalysisState_CriticalException_IsNotSuppressed()
             .WithMessage("this is a test");
     }
 
+    [TestMethod]
+    public void OnTextBufferChangedOnBackground_UpdatesAnalysisState()
+    {
+        var eventHandler = SubscribeToDocumentSaved();
+        var newContent = "new content";
+        var newSnapshot = CreateTextSnapshotMock(newContent);
+        var newAnalysisSnapshot = new AnalysisSnapshot(mockedJavascriptDocumentFooJs.FilePath, newSnapshot);
+        MockTaskExecutorWithDebounce(newSnapshot);
+        CreateTestSubject(mockedJavascriptDocumentFooJs);
+
+        RaiseTextBufferChangedOnBackground(currentTextBuffer: mockDocumentTextBuffer, newSnapshot);
+
+        VerifyAnalysisStateUpdated(mockedJavascriptDocumentFooJs, newAnalysisSnapshot, eventHandler, newContent);
+    }
+
     private void SetUpIssueConsumerStorageThrows(Exception exception) => issueConsumerStorage.When(x => x.Remove(Arg.Any<string>())).Do(x => throw exception);
 
     private static void VerifySingletonManagerDoesNotExist(ITextBuffer buffer) => FindSingletonManagerInPropertyCollection(buffer).Should().BeNull();
@@ -372,21 +392,21 @@ private TaggerProvider CreateTaggerProvider()
         var analysisRequester = mockAnalysisRequester;
         var provider = new TaggerProvider(sonarErrorListDataSource, textDocumentFactoryService,
             serviceProvider, languageRecognizer, analysisRequester, vsProjectInfoProvider, issueConsumerFactory, issueConsumerStorage, Mock.Of<ITaggableBufferIndicator>(),
-            mockFileTracker, analyzer, logger, new InitializationProcessorFactory(Substitute.For<IAsyncLockFactory>(), new NoOpThreadHandler(), new TestLogger()));
+            mockFileTracker, analyzer, logger, new InitializationProcessorFactory(Substitute.For<IAsyncLockFactory>(), new NoOpThreadHandler(), new TestLogger()), taskExecutorWithDebounceFactory);
         return provider;
     }
 
-    private static ITextSnapshot CreateTextSnapshotMock()
+    private static ITextSnapshot CreateTextSnapshotMock(string content = TextContent)
     {
         var textSnapshot = Substitute.For<ITextSnapshot>();
-        textSnapshot.GetText().Returns(TextContent);
+        textSnapshot.GetText().Returns(content);
         return textSnapshot;
     }
 
     private static ITextBuffer CreateTextBufferMock(ITextSnapshot textSnapshot)
     {
         // Text buffer with a properties collection and current snapshot
-        var mockTextBuffer = Substitute.For<ITextBuffer>();
+        var mockTextBuffer = Substitute.For<ITextBuffer2>();
 
         var dummyProperties = new PropertyCollection();
         mockTextBuffer.Properties.Returns(dummyProperties);
@@ -446,12 +466,51 @@ private TextBufferIssueTracker CreateTestSubject(ITextDocument textDocument)
     private TextBufferIssueTracker CreateTestSubject(ITextDocument textDocument, ILogger logger) =>
         new(taggerProvider,
             textDocument, javascriptLanguage,
-            mockSonarErrorDataSource, vsProjectInfoProvider, issueConsumerFactory, issueConsumerStorage, logger);
+            mockSonarErrorDataSource, vsProjectInfoProvider, issueConsumerFactory, issueConsumerStorage, taskExecutorWithDebounce, logger);
 
     private void ClearIssueConsumerCalls()
     {
         issueConsumerStorage.ClearReceivedCalls();
         issueConsumerFactory.ClearReceivedCalls();
         vsProjectInfoProvider.ClearReceivedCalls();
     }
+
+    private static void RaiseTextBufferChangedOnBackground(ITextBuffer currentTextBuffer, ITextSnapshot newTextSnapshot)
+    {
+        var args = new TextContentChangedEventArgs(Substitute.For<ITextSnapshot>(), newTextSnapshot, EditOptions.DefaultMinimalChange, null);
+        ((ITextBuffer2)currentTextBuffer).ChangedOnBackground += Raise.EventWith(null, args);
+    }
+
+    private EventHandler<DocumentEventArgs> SubscribeToDocumentSaved()
+    {
+        var eventHandler = Substitute.For<EventHandler<DocumentEventArgs>>();
+        taggerProvider.DocumentUpdated += eventHandler;
+        return eventHandler;
+    }
+
+    private void MockTaskExecutorWithDebounce(ITextSnapshot newSnapshot) =>
+        taskExecutorWithDebounce.When(x => x.DebounceAsync(Arg.Is<ITextSnapshot>(x => x == newSnapshot), Arg.Any<Action<ITextSnapshot>>())).Do(callInfo =>
+        {
+            var action = callInfo.Arg<Action<ITextSnapshot>>();
+            action(newSnapshot);
+        });
+
+    private void VerifyAnalysisStateUpdated(
+        ITextDocument textDocument,
+        AnalysisSnapshot newAnalysisSnapshot,
+        EventHandler<DocumentEventArgs> eventHandler,
+        string newContent)
+    {
+        issueConsumerStorage.Received().Remove(textDocument.FilePath);
+        vsProjectInfoProvider.Received().GetDocumentProjectInfo(newAnalysisSnapshot.FilePath);
+        issueConsumerFactory.Received().Create(textDocument, newAnalysisSnapshot.FilePath, newAnalysisSnapshot.TextSnapshot, Arg.Any<string>(), Arg.Any<Guid>(),
+            Arg.Any<SnapshotChangedHandler>());
+        issueConsumerStorage.Received().Set(textDocument.FilePath, Arg.Any<IIssueConsumer>());
+        issueConsumer.Received().SetIssues(textDocument.FilePath, []);
+        issueConsumer.Received().SetHotspots(textDocument.FilePath, []);
+        eventHandler.Received().Invoke(taggerProvider,
+            Arg.Is<DocumentEventArgs>(x => x.Document.FullPath == textDocument.FilePath
+                                           && x.Document.DetectedLanguages == javascriptLanguage
+                                           && x.Content == newContent));
+    }
 }

src/Integration.Vsix/SonarLintTagger/TaggerProvider.cs

@@ -53,6 +53,7 @@ namespace SonarLint.VisualStudio.Integration.Vsix;
 [PartCreationPolicy(CreationPolicy.Shared)]
 internal sealed class TaggerProvider : ITaggerProvider, IRequireInitialization, IDocumentTracker, IDisposable
 {
+    private const double DebounceMilliseconds = 1000;
     internal static readonly Type SingletonManagerPropertyCollectionKey = typeof(SingletonDisposableTaggerManager<IErrorTag>);
     private readonly IAnalyzer analyzer;
     private readonly IFileTracker fileTracker;
@@ -64,6 +65,7 @@ internal sealed class TaggerProvider : ITaggerProvider, IRequireInitialization,
     private readonly ISonarLanguageRecognizer languageRecognizer;
     private readonly IAnalysisRequester analysisRequester;
     private readonly ILogger logger;
+    private readonly ITaskExecutorWithDebounceFactory taskExecutorWithDebounceFactory;
 
     private readonly object reanalysisLockObject = new();
 
@@ -94,7 +96,8 @@ internal TaggerProvider(
         IFileTracker fileTracker,
         IAnalyzer analyzer,
         ILogger logger,
-        IInitializationProcessorFactory initializationProcessorFactory)
+        IInitializationProcessorFactory initializationProcessorFactory,
+        ITaskExecutorWithDebounceFactory taskExecutorWithDebounceFactory)
     {
         this.sonarErrorDataSource = sonarErrorDataSource;
         this.textDocumentFactoryService = textDocumentFactoryService;
@@ -107,6 +110,7 @@ internal TaggerProvider(
         this.fileTracker = fileTracker;
         this.analyzer = analyzer;
         this.logger = logger;
+        this.taskExecutorWithDebounceFactory = taskExecutorWithDebounceFactory;
 
         InitializationProcessor = initializationProcessorFactory.CreateAndStart<TaggerProvider>(
             [],
@@ -216,6 +220,7 @@ private TextBufferIssueTracker InternalCreateTextBufferIssueTracker(ITextDocumen
             vsProjectInfoProvider,
             issueConsumerFactory,
             issueConsumerStorage,
+            taskExecutorWithDebounceFactory.Create<ITextSnapshot>(DebounceMilliseconds),
             logger);
 
     #endregion IViewTaggerProvider members

src/Integration.Vsix/SonarLintTagger/TextBufferIssueTracker.cs

@@ -20,6 +20,7 @@
 
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Threading;
 using SonarLint.VisualStudio.Core;
 using SonarLint.VisualStudio.Core.Analysis;
 using SonarLint.VisualStudio.Integration.Vsix.Analysis;
@@ -48,10 +49,12 @@ internal sealed class TextBufferIssueTracker : IIssueTracker, ITagger<IErrorTag>
     private readonly ITextDocument document;
     private readonly IIssueConsumerFactory issueConsumerFactory;
     private readonly IIssueConsumerStorage issueConsumerStorage;
+    private readonly ITaskExecutorWithDebounce<ITextSnapshot> taskExecutorWithDebounce;
     private readonly ILogger logger;
     private readonly ISonarErrorListDataSource sonarErrorDataSource;
     private readonly ITextBuffer textBuffer;
     private readonly IVsProjectInfoProvider vsProjectInfoProvider;
+
     internal /* for testing */ TaggerProvider Provider { get; }
     internal /* for testing */ IssuesSnapshotFactory Factory { get; }
 
@@ -63,6 +66,7 @@ public TextBufferIssueTracker(
         IVsProjectInfoProvider vsProjectInfoProvider,
         IIssueConsumerFactory issueConsumerFactory,
         IIssueConsumerStorage issueConsumerStorage,
+        ITaskExecutorWithDebounce<ITextSnapshot> taskExecutorWithDebounce,
         ILogger logger)
     {
         Provider = provider;
@@ -72,6 +76,7 @@ public TextBufferIssueTracker(
         this.vsProjectInfoProvider = vsProjectInfoProvider;
         this.issueConsumerFactory = issueConsumerFactory;
         this.issueConsumerStorage = issueConsumerStorage;
+        this.taskExecutorWithDebounce = taskExecutorWithDebounce;
         this.logger = logger;
         logger.ForContext(nameof(TextBufferIssueTracker));
 
@@ -81,6 +86,10 @@ public TextBufferIssueTracker(
         Factory = new IssuesSnapshotFactory(LastAnalysisFilePath);
 
         document.FileActionOccurred += SafeOnFileActionOccurred;
+        if (textBuffer is ITextBuffer2 textBuffer2)
+        {
+            textBuffer2.ChangedOnBackground += TextBuffer_OnChangedOnBackground;
+        }
 
         sonarErrorDataSource.AddFactory(Factory);
         Provider.AddIssueTracker(this);
@@ -91,18 +100,7 @@ public TextBufferIssueTracker(
     public string LastAnalysisFilePath { get; private set; }
     public IEnumerable<AnalysisLanguage> DetectedLanguages { get; }
 
-    public void UpdateAnalysisState()
-    {
-        try
-        {
-            RemoveIssueConsumer(LastAnalysisFilePath);
-            InitializeAnalysisState();
-        }
-        catch (Exception ex) when (!ErrorHandler.IsCriticalException(ex))
-        {
-            logger.WriteLine(Strings.Analysis_ErrorUpdatingAnalysisState, ex);
-        }
-    }
+    public void UpdateAnalysisState() => RefreshAnalysisState();
 
     public string GetText() => document.TextBuffer.CurrentSnapshot.GetText();
 
@@ -151,6 +149,19 @@ private void SafeOnFileActionOccurred(object sender, TextDocumentFileActionEvent
         }
     }
 
+    private void RefreshAnalysisState(ITextSnapshot newTextSnapshot = null)
+    {
+        try
+        {
+            RemoveIssueConsumer(LastAnalysisFilePath);
+            InitializeAnalysisState(newTextSnapshot);
+        }
+        catch (Exception ex) when (!ErrorHandler.IsCriticalException(ex))
+        {
+            logger.WriteLine(Strings.Analysis_ErrorUpdatingAnalysisState, ex);
+        }
+    }
+
     private void SnapToNewSnapshot(IIssuesSnapshot newSnapshot)
     {
         // Tell our factory to snap to a new snapshot.
@@ -159,11 +170,11 @@ private void SnapToNewSnapshot(IIssuesSnapshot newSnapshot)
         sonarErrorDataSource.RefreshErrorList(Factory);
     }
 
-    private AnalysisSnapshot GetAnalysisSnapshot() => new(LastAnalysisFilePath, document.TextBuffer.CurrentSnapshot);
+    private AnalysisSnapshot GetAnalysisSnapshot(ITextSnapshot newTextSnapshot = null) => new(LastAnalysisFilePath, newTextSnapshot ?? document.TextBuffer.CurrentSnapshot);
 
-    private void InitializeAnalysisState()
+    private void InitializeAnalysisState(ITextSnapshot newTextSnapshot = null)
     {
-        var analysisSnapshot = GetAnalysisSnapshot();
+        var analysisSnapshot = GetAnalysisSnapshot(newTextSnapshot);
         CreateIssueConsumer(analysisSnapshot);
     }
 
@@ -182,4 +193,11 @@ private static void ClearErrorList(string filePath, IIssueConsumer issueConsumer
         issueConsumer.SetIssues(filePath, []);
         issueConsumer.SetHotspots(filePath, []);
     }
+
+    private void TextBuffer_OnChangedOnBackground(object sender, TextContentChangedEventArgs e) =>
+        taskExecutorWithDebounce.DebounceAsync(e.After, textSnapshot =>
+        {
+            RefreshAnalysisState(textSnapshot);
+            Provider.OnDocumentUpdated(document.FilePath, textSnapshot.GetText(), DetectedLanguages);
+        }).Forget();
 }