Revert "Revert "Refactoring of Active Statement tracking for OOP""

src/EditorFeatures/CSharpTest/EditAndContinue/ActiveStatementTrackingServiceTests.cs

@@ -2,11 +2,26 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
+using Microsoft.CodeAnalysis.Editor.Implementation.EditAndContinue;
+using Microsoft.CodeAnalysis.Editor.UnitTests;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.Text;
 using Roslyn.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests
 {
+    [UseExportProvider]
     public class ActiveStatementTrackingServiceTests : EditingTestBase
     {
         [Fact, WorkItem(846042, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/846042")]
@@ -125,5 +140,82 @@ static void Main(string[] args)
 
             edits.VerifyRudeDiagnostics(active);
         }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TrackingService_GetLatestSpansAsync(bool scheduleInitialTrackingBeforeOpenDoc)
+        {
+            var sourceV1 = "class C { void F() => G(1); void G(int a) => System.Console.WriteLine(1); }";
+
+            using var workspace = new TestWorkspace();
+
+            var span11 = new LinePositionSpan(new LinePosition(0, 10), new LinePosition(0, 15));
+            var span12 = new LinePositionSpan(new LinePosition(0, 20), new LinePosition(0, 25));
+            var span21 = new LinePositionSpan(new LinePosition(0, 11), new LinePosition(0, 16));
+            var span22 = new LinePositionSpan(new LinePosition(0, 21), new LinePosition(0, 26));
+
+            var encService = new MockEditAndContinueWorkspaceService();
+
+            encService.GetBaseActiveStatementSpansAsyncImpl = documentIds => ImmutableArray.Create(ImmutableArray.Create(
+                (span11, ActiveStatementFlags.IsNonLeafFrame),
+                (span12, ActiveStatementFlags.IsLeafFrame)));
+
+            encService.GetDocumentActiveStatementSpansAsyncImpl = document => ImmutableArray.Create(
+                (span21, ActiveStatementFlags.IsNonLeafFrame),
+                (span22, ActiveStatementFlags.IsLeafFrame));
+
+            var testDocument = new TestHostDocument(text: sourceV1, exportProvider: workspace.ExportProvider);
+            workspace.AddTestProject(new TestHostProject(workspace, testDocument));
+            var textBuffer = testDocument.GetTextBuffer();
+
+            var solution = workspace.CurrentSolution;
+            var project = solution.Projects.Single();
+            var document = project.Documents.Single();
+            var snapshot = textBuffer.CurrentSnapshot;
+            Assert.Same(snapshot, document.GetTextSynchronously(CancellationToken.None).FindCorrespondingEditorTextSnapshot());
+
+            var trackingSession = new ActiveStatementTrackingService.TrackingSession(workspace, encService);
+
+            if (scheduleInitialTrackingBeforeOpenDoc)
+            {
+                await trackingSession.TrackActiveSpansAsync().ConfigureAwait(false);
+
+                var spans1 = trackingSession.Test_GetTrackingSpans();
+                AssertEx.Equal(new[]
+                {
+                    $"V0 →←@[10..15): IsNonLeafFrame",
+                    $"V0 →←@[20..25): IsLeafFrame"
+                }, spans1[document.Id].Select(s => $"{s.Span}: {s.Flags}"));
+            }
+
+            var spans2 = await trackingSession.GetLatestSpansAsync(document, snapshot, CancellationToken.None).ConfigureAwait(false);
+            AssertEx.Equal(new[]
+            {
+                $"V0 →←@[11..16): IsNonLeafFrame",
+                $"V0 →←@[21..26): IsLeafFrame"
+            }, spans2.Select(s => $"{s.Span}: {s.Flags}"));
+
+            if (!scheduleInitialTrackingBeforeOpenDoc)
+            {
+                await trackingSession.TrackActiveSpansAsync().ConfigureAwait(false);
+
+                var spans1 = trackingSession.Test_GetTrackingSpans();
+                AssertEx.Equal(new[]
+                {
+                    $"V0 →←@[11..16): IsNonLeafFrame",
+                    $"V0 →←@[21..26): IsLeafFrame"
+                }, spans1[document.Id].Select(s => $"{s.Span}: {s.Flags}"));
+            }
+
+            // we are not able to determine active statements in a document:
+            encService.GetDocumentActiveStatementSpansAsyncImpl = document => default;
+
+            var spans3 = await trackingSession.GetLatestSpansAsync(document, snapshot, CancellationToken.None).ConfigureAwait(false);
+            AssertEx.Equal(new[]
+            {
+                $"V0 →←@[11..16): IsNonLeafFrame",
+                $"V0 →←@[21..26): IsLeafFrame"
+            }, spans3.Select(s => $"{s.Span}: {s.Flags}"));
+        }
     }
 }

src/EditorFeatures/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs

@@ -281,7 +281,9 @@ public static void Main()
             var oldStatementSyntax = oldSyntaxRoot.FindNode(oldStatementTextSpan);
 
             var baseActiveStatements = ImmutableArray.Create(ActiveStatementsDescription.CreateActiveStatement(ActiveStatementFlags.IsLeafFrame, oldStatementSpan, DocumentId.CreateNewId(ProjectId.CreateNewId())));
-            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newDocument, trackingService: null, CancellationToken.None);
+            var spanTracker = new TestActiveStatementSpanTracker();
+
+            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newDocument, spanTracker, CancellationToken.None);
 
             Assert.True(result.HasChanges);
             Assert.True(result.SemanticEdits[0].PreserveLocalVariables);
@@ -326,7 +328,9 @@ public static void Main()
             var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));
 
             var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), trackingService: null, CancellationToken.None);
+            var spanTracker = new TestActiveStatementSpanTracker();
+
+            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), spanTracker, CancellationToken.None);
 
             Assert.True(result.HasChanges);
             Assert.True(result.HasChangesAndErrors);
@@ -351,7 +355,9 @@ public static void Main()
             var oldProject = workspace.CurrentSolution.Projects.Single();
             var oldDocument = oldProject.Documents.Single();
             var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, trackingService: null, CancellationToken.None);
+            var spanTracker = new TestActiveStatementSpanTracker();
+
+            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, spanTracker, CancellationToken.None);
 
             Assert.False(result.HasChanges);
             Assert.False(result.HasChangesAndErrors);
@@ -391,7 +397,9 @@ public static void Main()
             var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));
 
             var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), trackingService: null, CancellationToken.None);
+            var spanTracker = new TestActiveStatementSpanTracker();
+
+            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), spanTracker, CancellationToken.None);
 
             Assert.False(result.HasChanges);
             Assert.False(result.HasChangesAndErrors);
@@ -423,7 +431,9 @@ public static void Main()
             var documentId = oldDocument.Id;
 
             var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, trackingService: null, CancellationToken.None);
+            var spanTracker = new TestActiveStatementSpanTracker();
+
+            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, spanTracker, CancellationToken.None);
 
             Assert.False(result.HasChanges);
             Assert.False(result.HasChangesAndErrors);
@@ -473,7 +483,9 @@ public static void Main()
                 var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));
 
                 var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-                var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), trackingService: null, CancellationToken.None);
+                var spanTracker = new TestActiveStatementSpanTracker();
+
+                var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), spanTracker, CancellationToken.None);
 
                 Assert.True(result.HasChanges);
                 Assert.True(result.HasChangesAndErrors);
@@ -505,7 +517,9 @@ public static void Main()
             var documentId = oldDocument.Id;
 
             var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, trackingService: null, CancellationToken.None);
+            var spanTracker = new TestActiveStatementSpanTracker();
+
+            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, spanTracker, CancellationToken.None);
 
             Assert.False(result.HasChanges);
             Assert.False(result.HasChangesAndErrors);
@@ -547,7 +561,9 @@ public static void Main()
             var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));
 
             var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), trackingService: null, CancellationToken.None);
+            var spanTracker = new TestActiveStatementSpanTracker();
+
+            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), spanTracker, CancellationToken.None);
 
             Assert.True(result.HasChanges);
 
@@ -589,7 +605,9 @@ public static void Main(Bar x)
             var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));
 
             var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), trackingService: null, CancellationToken.None);
+            var spanTracker = new TestActiveStatementSpanTracker();
+
+            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), spanTracker, CancellationToken.None);
 
             Assert.True(result.HasChanges);
             Assert.True(result.HasChangesAndErrors);
@@ -640,9 +658,11 @@ public class D
 
             var result = new List<DocumentAnalysisResults>();
             var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
+            var spanTracker = new TestActiveStatementSpanTracker();
+
             foreach (var changedDocumentId in changedDocuments)
             {
-                result.Add(await analyzer.AnalyzeDocumentAsync(oldProject.GetDocument(changedDocumentId), baseActiveStatements, newProject.GetDocument(changedDocumentId), trackingService: null, CancellationToken.None));
+                result.Add(await analyzer.AnalyzeDocumentAsync(oldProject.GetDocument(changedDocumentId), baseActiveStatements, newProject.GetDocument(changedDocumentId), spanTracker, CancellationToken.None));
             }
 
             Assert.True(result.IsSingle());
@@ -688,9 +708,11 @@ public static void Main()
 
             var result = new List<DocumentAnalysisResults>();
             var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
+            var spanTracker = new TestActiveStatementSpanTracker();
+
             foreach (var changedDocumentId in changedDocuments)
             {
-                result.Add(await analyzer.AnalyzeDocumentAsync(oldProject.GetDocument(changedDocumentId), baseActiveStatements, newProject.GetDocument(changedDocumentId), trackingService: null, CancellationToken.None));
+                result.Add(await analyzer.AnalyzeDocumentAsync(oldProject.GetDocument(changedDocumentId), baseActiveStatements, newProject.GetDocument(changedDocumentId), spanTracker, CancellationToken.None));
             }
 
             Assert.True(result.IsSingle());

src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/Extensions.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#nullable enable
+
 using System.Collections.Generic;
 using Microsoft.CodeAnalysis.Differencing;
 using Microsoft.CodeAnalysis.EditAndContinue;
@@ -103,13 +105,13 @@ internal static void VerifySemantics(
 
         internal static void VerifySemantics(
             this EditScript<SyntaxNode> editScript,
-            ActiveStatementsDescription activeStatements = null,
-            TargetFramework[] targetFrameworks = null,
-            IEnumerable<string> additionalOldSources = null,
-            IEnumerable<string> additionalNewSources = null,
-            SemanticEditDescription[] expectedSemanticEdits = null,
-            DiagnosticDescription expectedDeclarationError = null,
-            RudeEditDiagnosticDescription[] expectedDiagnostics = null)
+            ActiveStatementsDescription? activeStatements = null,
+            TargetFramework[]? targetFrameworks = null,
+            IEnumerable<string>? additionalOldSources = null,
+            IEnumerable<string>? additionalNewSources = null,
+            SemanticEditDescription[]? expectedSemanticEdits = null,
+            DiagnosticDescription? expectedDeclarationError = null,
+            RudeEditDiagnosticDescription[]? expectedDiagnostics = null)
         {
             foreach (var targetFramework in targetFrameworks ?? new[] { TargetFramework.NetStandard20, TargetFramework.NetCoreApp30 })
             {

src/EditorFeatures/Core/Implementation/EditAndContinue/ActiveStatementSpanTracker.cs

@@ -0,0 +1,40 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Composition;
+using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.EditAndContinue
+{
+    internal sealed class ActiveStatementSpanTracker : IActiveStatementSpanTracker
+    {
+        [ExportWorkspaceServiceFactory(typeof(IActiveStatementSpanTracker), ServiceLayer.Editor), Shared]
+        private sealed class Factory : IWorkspaceServiceFactory
+        {
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public Factory() { }
+
+            public IWorkspaceService CreateService(HostWorkspaceServices services)
+                => new ActiveStatementSpanTracker(services);
+        }
+
+        private readonly IActiveStatementTrackingService _trackingService;
+
+        public ActiveStatementSpanTracker(HostWorkspaceServices services)
+        {
+            _trackingService = services.GetRequiredService<IActiveStatementTrackingService>();
+        }
+
+        public bool TryGetSpan(ActiveStatementId id, SourceText source, out TextSpan span)
+            => _trackingService.TryGetSpan(id, source, out span);
+    }
+}