SLVS-2430 Trigger analysis on pressed key with debounce (#6402)

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(debounceMilliseconds: TimeSpan.FromMilliseconds(500));
     }
 
     [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/TaskExecutorWithDebounceFactoryTest.cs

@@ -0,0 +1,55 @@
+/*
+ * SonarLint for Visual Studio
+ * Copyright (C) 2016-2025 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using SonarLint.VisualStudio.Core.Synchronization;
+using SonarLint.VisualStudio.Integration.Vsix.SonarLintTagger;
+
+namespace SonarLint.VisualStudio.Integration.UnitTests.SonarLintTagger;
+
+[TestClass]
+public class TaskExecutorWithDebounceFactoryTest
+{
+    private TaskExecutorWithDebounceFactory testSubject;
+    private IAsyncLockFactory asyncLockFactory;
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        asyncLockFactory = Substitute.For<IAsyncLockFactory>();
+        testSubject = new TaskExecutorWithDebounceFactory(asyncLockFactory);
+    }
+
+    [TestMethod]
+    public void MefCtor_CheckIsExported() =>
+        MefTestHelpers.CheckTypeCanBeImported<TaskExecutorWithDebounceFactory, ITaskExecutorWithDebounceFactory>(
+            MefTestHelpers.CreateExport<IAsyncLockFactory>());
+
+    [TestMethod]
+    public void MefCtor_CheckIsSingleton() => MefTestHelpers.CheckIsSingletonMefComponent<TaskExecutorWithDebounceFactory>();
+
+    [TestMethod]
+    public void Create_ShouldReturnInstance()
+    {
+        var result = testSubject.Create(TimeSpan.FromMilliseconds(1));
+
+        result.Should().NotBeNull();
+        result.Should().BeOfType<TaskExecutorWithDebounce>();
+    }
+}

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

@@ -0,0 +1,89 @@
+/*
+ * SonarLint for Visual Studio
+ * Copyright (C) 2016-2025 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using Microsoft.VisualStudio.Threading;
+using SonarLint.VisualStudio.Core.Synchronization;
+using SonarLint.VisualStudio.Integration.TestInfrastructure;
+using SonarLint.VisualStudio.Integration.Vsix.SonarLintTagger;
+
+namespace SonarLint.VisualStudio.Integration.UnitTests.SonarLintTagger;
+
+[TestClass]
+public class TaskExecutorWithDebounceTest
+{
+    private readonly TimeSpan debounceTimeInMs = TimeSpan.FromMilliseconds(100);
+    private IAsyncLock asyncLock;
+    private IAsyncLockFactory asyncLockFactory;
+    private TaskExecutorWithDebounce testSubject;
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        asyncLockFactory = Substitute.For<IAsyncLockFactory>();
+        asyncLock = Substitute.For<IAsyncLock>();
+        asyncLockFactory.Create().Returns(asyncLock);
+        testSubject = new TaskExecutorWithDebounce(asyncLockFactory, debounceTimeInMs);
+    }
+
+    [TestMethod]
+    public async Task DebounceAsync_ExecutesTaskWithDebounce()
+    {
+        var currentState = new TestData { Value = 1 };
+        var tcs = new TaskCompletionSource<int>();
+        var stopwatch = Stopwatch.StartNew();
+
+        testSubject.DebounceAsync(() =>
+        {
+            UpdateState(currentState, 2, tcs);
+            stopwatch.Stop();
+        }).Forget();
+        await tcs.Task;
+
+        asyncLock.Received(1).AcquireAsync().IgnoreAwaitForAssert();
+        currentState.Value.Should().Be(2);
+        stopwatch.ElapsedMilliseconds.Should().BeGreaterOrEqualTo(debounceTimeInMs.Milliseconds);
+    }
+
+    [TestMethod]
+    public async Task DebounceAsync_MultipleTimes_UpdatesWithLatestState()
+    {
+        var currentState = new TestData { Value = 1 };
+        var tcs = new TaskCompletionSource<int>();
+
+        testSubject.DebounceAsync(() => UpdateState(currentState, 2)).Forget();
+        testSubject.DebounceAsync(() => UpdateState(currentState, 3)).Forget();
+        testSubject.DebounceAsync(() => UpdateState(currentState, 4, tcs)).Forget();
+        await tcs.Task;
+
+        asyncLock.Received(3).AcquireAsync().IgnoreAwaitForAssert();
+        currentState.Value.Should().Be(4);
+    }
+
+    private static void UpdateState(TestData date, int newValue, TaskCompletionSource<int> taskCompletionSource = null)
+    {
+        date.Value = newValue;
+        taskCompletionSource?.SetResult(1);
+    }
+
+    private record TestData
+    {
+        public int Value { get; set; }
+    }
+}

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 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>();
+        taskExecutorWithDebounceFactory.Create(Arg.Any<TimeSpan>()).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.
@@ -150,6 +156,7 @@ public void Dispose_CleansUpEventsAndRegistrations()
         taggerProvider.ActiveTrackersForTesting.Should().BeEmpty();
 
         mockedJavascriptDocumentFooJs.Received(1).FileActionOccurred -= Arg.Any<EventHandler<TextDocumentFileActionEventArgs>>();
+        ((ITextBuffer2)mockDocumentTextBuffer).Received(1).ChangedOnBackground -= Arg.Any<EventHandler<TextContentChangedEventArgs>>();
     }
 
     [TestMethod]
@@ -196,7 +203,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 +332,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();
+        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 +393,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 +467,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() =>
+        taskExecutorWithDebounce.When(x => x.DebounceAsync(Arg.Any<Action>())).Do(callInfo =>
+        {
+            var action = callInfo.Arg<Action>();
+            action();
+        });
+
+    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));
+    }
 }