Remove IActiveStatementSpanTracker from the MEF catalog

31a883f9 · Sam Harwell · 728187a0 · 31a883f9 · 31a883f9 · 31a883f9
21 changed file
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs
@@ -28,7 +28,7 @@ public class CSharpEditAndContinueAnalyzerTests
    {
        private static readonly IExportProviderFactory s_exportProviderFactoryWithTestActiveStatementSpanTracker =
            ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic
-                .WithPart(typeof(TestActiveStatementSpanTracker)));
+                .WithPart(typeof(TestActiveStatementSpanTrackerFactory)));

        #region Helpers

@@ -266,7 +266,6 @@ public static void Main()
    }
 }
 ";
-            var analyzer = new CSharpEditAndContinueAnalyzer();

            using var workspace = TestWorkspace.CreateCSharp(source1, exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());
            var oldSolution = workspace.CurrentSolution;
@@ -287,7 +286,8 @@ public static void Main()
            var oldStatementSyntax = oldSyntaxRoot.FindNode(oldStatementTextSpan);

            var baseActiveStatements = ImmutableArray.Create(ActiveStatementsDescription.CreateActiveStatement(ActiveStatementFlags.IsLeafFrame, oldStatementSpan, DocumentId.CreateNewId(ProjectId.CreateNewId())));
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newDocument, CancellationToken.None);

@@ -324,7 +324,6 @@ public static void Main()
    }
 }
 ";
-            var analyzer = new CSharpEditAndContinueAnalyzer();

            using var workspace = TestWorkspace.CreateCSharp(source1, exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());
            var oldSolution = workspace.CurrentSolution;
@@ -334,7 +333,8 @@ public static void Main()
            var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));

            var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None);

@@ -355,13 +355,13 @@ public static void Main()
    }
 }
 ";
-            var analyzer = new CSharpEditAndContinueAnalyzer();

            using var workspace = TestWorkspace.CreateCSharp(source, exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());
            var oldProject = workspace.CurrentSolution.Projects.Single();
            var oldDocument = oldProject.Documents.Single();
            var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, CancellationToken.None);

@@ -391,7 +391,6 @@ public static void Main()
    }
 }
 ";
-            var analyzer = new CSharpEditAndContinueAnalyzer();

            using var workspace = TestWorkspace.CreateCSharp(source1, exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());

@@ -403,7 +402,8 @@ public static void Main()
            var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));

            var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None);

@@ -424,7 +424,6 @@ public static void Main()
    }
 }
 ";
-            var analyzer = new CSharpEditAndContinueAnalyzer();
            var experimentalFeatures = new Dictionary<string, string>(); // no experimental features to enable
            var experimental = TestOptions.Regular.WithFeatures(experimentalFeatures);

@@ -437,7 +436,8 @@ public static void Main()
            var documentId = oldDocument.Id;

            var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, CancellationToken.None);

@@ -473,7 +473,6 @@ public static void Main()
    }
 }
 ";
-                var analyzer = new CSharpEditAndContinueAnalyzer();

                var featuresToEnable = new Dictionary<string, string>() { { feature, "enabled" } };
                var experimental = TestOptions.Regular.WithFeatures(featuresToEnable);
@@ -489,7 +488,8 @@ public static void Main()
                var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));

                var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-                var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+                var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+                var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

                var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None);

@@ -513,7 +513,6 @@ public static void Main()
    }
 }
 ";
-            var analyzer = new CSharpEditAndContinueAnalyzer();

            using var workspace = TestWorkspace.CreateCSharp(source, exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());

@@ -523,7 +522,8 @@ public static void Main()
            var documentId = oldDocument.Id;

            var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, CancellationToken.None);

@@ -555,7 +555,6 @@ public static void Main()
    }
 }
 ";
-            var analyzer = new CSharpEditAndContinueAnalyzer();

            using var workspace = TestWorkspace.CreateCSharp(source1, exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());

@@ -567,7 +566,8 @@ public static void Main()
            var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));

            var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None);

@@ -599,7 +599,6 @@ public static void Main(Bar x)
    }
 }
 ";
-            var analyzer = new CSharpEditAndContinueAnalyzer();

            using var workspace = TestWorkspace.CreateCSharp(source1, exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());

@@ -611,7 +610,8 @@ public static void Main(Bar x)
            var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));

            var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

            var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None);

@@ -642,7 +642,6 @@ public class D
    }
 }
 ";
-            var analyzer = new CSharpEditAndContinueAnalyzer();

            using var workspace = TestWorkspace.CreateCSharp(source1, exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());
            // fork the solution to introduce a change
@@ -664,7 +663,8 @@ public class D

            var result = new List<DocumentAnalysisResults>();
            var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

            foreach (var changedDocumentId in changedDocuments)
            {
@@ -692,7 +692,6 @@ public static void Main()
 ";
            var source2 = @"
 ";
-            var analyzer = new CSharpEditAndContinueAnalyzer();

            using var workspace = TestWorkspace.CreateCSharp(source1, exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());

@@ -714,7 +713,8 @@ public static void Main()

            var result = new List<DocumentAnalysisResults>();
            var baseActiveStatements = ImmutableArray.Create<ActiveStatement>();
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);

            foreach (var changedDocumentId in changedDocuments)
            {

--- a/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestHelpers.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestHelpers.cs
@@ -19,20 +19,20 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.EditAndContinue
 {
    internal sealed class CSharpEditAndContinueTestHelpers : EditAndContinueTestHelpers
    {
+        private readonly CSharpEditAndContinueAnalyzer _analyzer = new CSharpEditAndContinueAnalyzer(new TestActiveStatementSpanTracker());
+
        private readonly ImmutableArray<MetadataReference> _fxReferences;

-        internal static CSharpEditAndContinueTestHelpers Instance
+        internal static CSharpEditAndContinueTestHelpers CreateInstance()
            => new CSharpEditAndContinueTestHelpers(TargetFramework.Mscorlib46Extended);

-        internal static CSharpEditAndContinueTestHelpers Instance40
+        internal static CSharpEditAndContinueTestHelpers CreateInstance40()
            => new CSharpEditAndContinueTestHelpers(TargetFramework.Mscorlib40AndSystemCore);

-        private static readonly CSharpEditAndContinueAnalyzer s_analyzer = new CSharpEditAndContinueAnalyzer();
-
        public CSharpEditAndContinueTestHelpers(TargetFramework targetFramework)
            => _fxReferences = TargetFrameworkUtil.GetReferences(targetFramework);

-        public override AbstractEditAndContinueAnalyzer Analyzer => s_analyzer;
+        public override AbstractEditAndContinueAnalyzer Analyzer => _analyzer;

        public override Compilation CreateLibraryCompilation(string name, IEnumerable<SyntaxTree> trees)
            => CSharpCompilation.Create("New", trees, _fxReferences, TestOptions.UnsafeReleaseDll);

--- a/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs
@@ -11,16 +11,17 @@
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.EditAndContinue;
 using Microsoft.CodeAnalysis.Emit;
-using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
 using Xunit;

 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests
 {
-    [UseExportProvider]
    public abstract class EditingTestBase : CSharpTestBase
    {
-        internal static readonly CSharpEditAndContinueAnalyzer Analyzer = new CSharpEditAndContinueAnalyzer();
+        internal static CSharpEditAndContinueAnalyzer CreateAnalyzer()
+        {
+            return new CSharpEditAndContinueAnalyzer(new TestActiveStatementSpanTracker());
+        }

        internal enum MethodKind
        {
@@ -45,7 +46,7 @@ internal static SemanticEditDescription SemanticEdit(SemanticEditKind kind, Func
            => new SemanticEditDescription(kind, symbolProvider, null, preserveLocalVariables);

        private static SyntaxTree ParseSource(string source)
-            => CSharpEditAndContinueTestHelpers.Instance.ParseText(ActiveStatementsDescription.ClearTags(source));
+            => CSharpEditAndContinueTestHelpers.CreateInstance().ParseText(ActiveStatementsDescription.ClearTags(source));

        internal static EditScript<SyntaxNode> GetTopEdits(string src1, string src2)
        {
@@ -74,7 +75,7 @@ internal static Match<SyntaxNode> GetMethodMatch(string src1, string src2, Metho
            var m2 = MakeMethodBody(src2, kind);

            var diagnostics = new List<RudeEditDiagnostic>();
-            var match = Analyzer.GetTestAccessor().ComputeBodyMatch(m1, m2, Array.Empty<AbstractEditAndContinueAnalyzer.ActiveNode>(), diagnostics, out var oldHasStateMachineSuspensionPoint, out var newHasStateMachineSuspensionPoint);
+            var match = CreateAnalyzer().GetTestAccessor().ComputeBodyMatch(m1, m2, Array.Empty<AbstractEditAndContinueAnalyzer.ActiveNode>(), diagnostics, out var oldHasStateMachineSuspensionPoint, out var newHasStateMachineSuspensionPoint);
            var needsSyntaxMap = oldHasStateMachineSuspensionPoint && newHasStateMachineSuspensionPoint;

            Assert.Equal(kind != MethodKind.Regular && kind != MethodKind.ConstructorWithParameters, needsSyntaxMap);
@@ -90,7 +91,7 @@ internal static Match<SyntaxNode> GetMethodMatch(string src1, string src2, Metho
        internal static IEnumerable<KeyValuePair<SyntaxNode, SyntaxNode>> GetMethodMatches(string src1, string src2, MethodKind kind = MethodKind.Regular)
        {
            var methodMatch = GetMethodMatch(src1, src2, kind);
-            return EditAndContinueTestHelpers.GetMethodMatches(Analyzer, methodMatch);
+            return EditAndContinueTestHelpers.GetMethodMatches(CreateAnalyzer(), methodMatch);
        }

        public static MatchingPairs ToMatchingPairs(Match<SyntaxNode> match)
@@ -143,7 +144,7 @@ internal static void VerifyPreserveLocalVariables(EditScript<SyntaxNode> edits,
            var body2 = ((MethodDeclarationSyntax)SyntaxFactory.SyntaxTree(decl2).GetRoot()).Body;

            var diagnostics = new List<RudeEditDiagnostic>();
-            var match = Analyzer.GetTestAccessor().ComputeBodyMatch(body1, body2, Array.Empty<AbstractEditAndContinueAnalyzer.ActiveNode>(), diagnostics, out var oldHasStateMachineSuspensionPoint, out var newHasStateMachineSuspensionPoint);
+            var match = CreateAnalyzer().GetTestAccessor().ComputeBodyMatch(body1, body2, Array.Empty<AbstractEditAndContinueAnalyzer.ActiveNode>(), diagnostics, out var oldHasStateMachineSuspensionPoint, out var newHasStateMachineSuspensionPoint);
            var needsSyntaxMap = oldHasStateMachineSuspensionPoint && newHasStateMachineSuspensionPoint;

            // Active methods are detected to preserve local variables for variable mapping and

--- a/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/Extensions.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/Extensions.cs
@@ -9,25 +9,18 @@
 using Microsoft.CodeAnalysis.EditAndContinue;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.EditAndContinue;
-using Microsoft.CodeAnalysis.Editor.UnitTests;
-using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Test.Utilities;
-using Microsoft.VisualStudio.Composition;
 using Roslyn.Test.Utilities;

 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests
 {
    internal static class Extensions
    {
-        private static readonly IExportProviderFactory s_exportProviderFactoryWithTestActiveStatementSpanTracker =
-            ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic
-                .WithPart(typeof(TestActiveStatementSpanTracker)));
-
        internal static void VerifyUnchangedDocument(
            string source,
            ActiveStatementsDescription description)
        {
-            CSharpEditAndContinueTestHelpers.Instance.VerifyUnchangedDocument(
+            CSharpEditAndContinueTestHelpers.CreateInstance().VerifyUnchangedDocument(
                ActiveStatementsDescription.ClearTags(source),
                description.OldStatements,
                description.OldTrackingSpans,
@@ -48,7 +41,7 @@ internal static class Extensions
            ActiveStatementsDescription description,
            params RudeEditDiagnosticDescription[] expectedDiagnostics)
        {
-            CSharpEditAndContinueTestHelpers.Instance.VerifyRudeDiagnostics(
+            CSharpEditAndContinueTestHelpers.CreateInstance().VerifyRudeDiagnostics(
                editScript,
                description,
                expectedDiagnostics);
@@ -60,7 +53,7 @@ internal static class Extensions
            IEnumerable<string> expectedNodeUpdates,
            params RudeEditDiagnosticDescription[] expectedDiagnostics)
        {
-            CSharpEditAndContinueTestHelpers.Instance.VerifyLineEdits(
+            CSharpEditAndContinueTestHelpers.CreateInstance().VerifyLineEdits(
                editScript,
                expectedLineEdits,
                expectedNodeUpdates,
@@ -120,11 +113,9 @@ internal static class Extensions
            DiagnosticDescription? expectedDeclarationError = null,
            RudeEditDiagnosticDescription[]? expectedDiagnostics = null)
        {
-            using var workspace = TestWorkspace.CreateCSharp("", exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());
            foreach (var targetFramework in targetFrameworks ?? new[] { TargetFramework.NetStandard20, TargetFramework.NetCoreApp30 })
            {
                new CSharpEditAndContinueTestHelpers(targetFramework).VerifySemantics(
-                    workspace,
                    editScript,
                    activeStatements,
                    additionalOldSources,

--- a/src/EditorFeatures/CSharpTest/EditAndContinue/StatementEditingTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/StatementEditingTests.cs
@@ -2,14 +2,12 @@
 // 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.Generic;
 using System.IO;
 using Microsoft.CodeAnalysis.EditAndContinue;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.EditAndContinue;
-using Microsoft.CodeAnalysis.Editor.UnitTests;
-using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Test.Utilities;
-using Microsoft.VisualStudio.Composition;
 using Roslyn.Test.Utilities;
 using Xunit;

@@ -17,10 +15,6 @@ namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests
 {
    public class StatementEditingTests : EditingTestBase
    {
-        private static readonly IExportProviderFactory s_exportProviderFactoryWithTestActiveStatementSpanTracker =
-            ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic
-                .WithPart(typeof(TestActiveStatementSpanTracker)));
-
        #region Strings

        [Fact]
@@ -8382,12 +8376,9 @@ static IEnumerable<int> F()
    }
 }
 ";
-
-            using var workspace = TestWorkspace.CreateCSharp("", exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());
            var edits = GetTopEdits(src1, src2);

-            CSharpEditAndContinueTestHelpers.Instance40.VerifySemantics(
-                workspace,
+            CSharpEditAndContinueTestHelpers.CreateInstance40().VerifySemantics(
                edits,
                ActiveStatementsDescription.Empty,
                null,
@@ -8425,12 +8416,9 @@ static IEnumerable<int> F()
    }
 }
 ";
-
-            using var workspace = TestWorkspace.CreateCSharp("", exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());
            var edits = GetTopEdits(src1, src2);

-            CSharpEditAndContinueTestHelpers.Instance40.VerifySemantics(
-                workspace,
+            CSharpEditAndContinueTestHelpers.CreateInstance40().VerifySemantics(
                edits,
                ActiveStatementsDescription.Empty,
                null,

--- a/src/EditorFeatures/Core/Implementation/EditAndContinue/ActiveStatementSpanTracker.cs
+++ b/src/EditorFeatures/Core/Implementation/EditAndContinue/ActiveStatementSpanTracker.cs
@@ -13,7 +13,7 @@

 namespace Microsoft.CodeAnalysis.Editor.Implementation.EditAndContinue
 {
-    internal sealed class ActiveStatementSpanTracker : IActiveStatementSpanTracker
+    internal sealed class ActiveStatementSpanTrackerFactory : IActiveStatementSpanTrackerFactory
    {
        [ExportWorkspaceServiceFactory(typeof(IActiveStatementSpanTracker), ServiceLayer.Editor), Shared]
        private sealed class Factory : IWorkspaceServiceFactory
@@ -24,18 +24,34 @@ private sealed class Factory : IWorkspaceServiceFactory

            [Obsolete(MefConstruction.FactoryMethodMessage, error: true)]
            public IWorkspaceService CreateService(HostWorkspaceServices services)
-                => new ActiveStatementSpanTracker(services);
+                => new ActiveStatementSpanTrackerFactory(services);
        }

-        private readonly IActiveStatementTrackingService _trackingService;
+        private readonly IActiveStatementSpanTracker _tracker;

        [Obsolete(MefConstruction.FactoryMethodMessage, error: true)]
-        public ActiveStatementSpanTracker(HostWorkspaceServices services)
+        public ActiveStatementSpanTrackerFactory(HostWorkspaceServices services)
        {
-            _trackingService = services.GetRequiredService<IActiveStatementTrackingService>();
+            _tracker = new Tracker(services.GetRequiredService<IActiveStatementTrackingService>());
        }

-        public bool TryGetSpan(ActiveStatementId id, SourceText source, out TextSpan span)
-            => _trackingService.TryGetSpan(id, source, out span);
+        public IActiveStatementSpanTracker GetOrCreateActiveStatementSpanTracker()
+        {
+            return _tracker;
+        }
+
+        private sealed class Tracker : IActiveStatementSpanTracker
+        {
+            private readonly IActiveStatementTrackingService _trackingService;
+
+            [Obsolete(MefConstruction.FactoryMethodMessage, error: true)]
+            public Tracker(IActiveStatementTrackingService activeStatementTrackingService)
+            {
+                _trackingService = activeStatementTrackingService;
+            }
+
+            public bool TryGetSpan(ActiveStatementId id, SourceText source, out TextSpan span)
+                => _trackingService.TryGetSpan(id, source, out span);
+        }
    }
 }
--- a/src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs
+++ b/src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs
@@ -36,7 +36,7 @@ public sealed class EditAndContinueWorkspaceServiceTests : TestBase
    {
        private static readonly IExportProviderFactory s_exportProviderFactoryWithTestActiveStatementSpanTracker =
            ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic
-                .WithPart(typeof(TestActiveStatementSpanTracker)));
+                .WithPart(typeof(TestActiveStatementSpanTrackerFactory)));

        private static readonly ActiveStatementProvider s_noActiveStatements =
            cancellationToken => Task.FromResult(ImmutableArray<ActiveStatementDebugInfo>.Empty);
@@ -72,7 +72,7 @@ public EditAndContinueWorkspaceServiceTests()

        private EditAndContinueWorkspaceService CreateEditAndContinueService(Workspace workspace)
        {
-            Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());

            return new EditAndContinueWorkspaceService(
                workspace,
@@ -199,7 +199,7 @@ private static TextSpan GetSpan(string str, string substr)
        public async Task RunMode_ProjectThatDoesNotSupportEnC()
        {
            var exportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory(
-                TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithPart(typeof(DummyLanguageService)).WithPart(typeof(TestActiveStatementSpanTracker)));
+                TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithPart(typeof(DummyLanguageService)).WithPart(typeof(TestActiveStatementSpanTrackerFactory)));

            using var workspace = new TestWorkspace(exportProvider: exportProviderFactory.CreateExportProvider());
            var solution = workspace.CurrentSolution;
@@ -508,7 +508,7 @@ public async Task RunMode_DifferentDocumentWithSameContent()
        public async Task BreakMode_ProjectThatDoesNotSupportEnC()
        {
            var exportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory(
-                TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithPart(typeof(DummyLanguageService)).WithPart(typeof(TestActiveStatementSpanTracker)));
+                TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithPart(typeof(DummyLanguageService)).WithPart(typeof(TestActiveStatementSpanTrackerFactory)));

            using (var workspace = new TestWorkspace(exportProvider: exportProviderFactory.CreateExportProvider()))
            {
@@ -2325,7 +2325,7 @@ public async Task ActiveStatements()
            var activeLineSpan21 = sourceTextV2.Lines.GetLinePositionSpan(activeSpan21);
            var activeLineSpan22 = sourceTextV2.Lines.GetLinePositionSpan(activeSpan22);

-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
            spanTracker.Spans = new Dictionary<DocumentId, TextSpan?[]>
            {
                { documentId, new TextSpan?[] { activeSpan11, activeSpan12 } }
@@ -2442,7 +2442,7 @@ public async Task ActiveStatements_SyntaxErrorOrOutOfSyncDocument(bool isOutOfSy
            var activeLineSpan21 = sourceTextV2.Lines.GetLinePositionSpan(activeSpan21);
            var activeLineSpan22 = sourceTextV2.Lines.GetLinePositionSpan(activeSpan22);

-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
            spanTracker.Spans = new Dictionary<DocumentId, TextSpan?[]>
            {
                { documentId, new TextSpan?[] { activeSpan11, activeSpan12 } }
@@ -2510,7 +2510,7 @@ public async Task ActiveStatements_SyntaxErrorOrOutOfSyncDocument(bool isOutOfSy
        public async Task ActiveStatements_ForeignDocument()
        {
            var exportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory(
-                TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithPart(typeof(DummyLanguageService)).WithPart(typeof(TestActiveStatementSpanTracker)));
+                TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithPart(typeof(DummyLanguageService)).WithPart(typeof(TestActiveStatementSpanTrackerFactory)));

            using var workspace = new TestWorkspace(exportProvider: exportProviderFactory.CreateExportProvider());
            var solution = workspace.CurrentSolution;

--- a/src/EditorFeatures/Test/EditAndContinue/EditSessionActiveStatementsTests.cs
+++ b/src/EditorFeatures/Test/EditAndContinue/EditSessionActiveStatementsTests.cs
@@ -91,7 +91,7 @@ private sealed class Validator
                CommittedSolution.DocumentState initialState = CommittedSolution.DocumentState.MatchesBuildOutput)
            {
                var exportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory(
-                TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithPart(typeof(CSharpEditAndContinueAnalyzer)).WithPart(typeof(DummyLanguageService)).WithPart(typeof(TestActiveStatementSpanTracker)));
+                TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithPart(typeof(CSharpEditAndContinueAnalyzer.Factory)).WithPart(typeof(DummyLanguageService)).WithPart(typeof(TestActiveStatementSpanTrackerFactory)));

                var exportProvider = exportProviderFactory.CreateExportProvider();

@@ -116,7 +116,7 @@ private sealed class Validator

                debuggingSession.Test_SetNonRemappableRegions(nonRemappableRegions ?? ImmutableDictionary<ActiveMethodId, ImmutableArray<NonRemappableRegion>>.Empty);

-                Assert.IsType<TestActiveStatementSpanTracker>(Workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+                Assert.IsType<TestActiveStatementSpanTracker>(Workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());

                var telemetry = new EditSessionTelemetry();
                EditSession = new EditSession(debuggingSession, telemetry, cancellationToken => Task.FromResult(activeStatements), mockDebuggeModuleProvider.Object);

--- a/src/EditorFeatures/TestUtilities/EditAndContinue/EditAndContinueTestHelpers.cs
+++ b/src/EditorFeatures/TestUtilities/EditAndContinue/EditAndContinueTestHelpers.cs
@@ -44,8 +44,8 @@ internal abstract class EditAndContinueTestHelpers

            var documentId = DocumentId.CreateNewId(ProjectId.CreateNewId("TestEnCProject"), "TestEnCDocument");

-            var spanTracker = new TestActiveStatementSpanTracker(
-                (trackingSpans != null) ? new Dictionary<DocumentId, TextSpan?[]> { { documentId, trackingSpans } } : null);
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(Analyzer.GetTestAccessor().ActiveStatementSpanTracker);
+            spanTracker.Spans = (trackingSpans != null) ? new Dictionary<DocumentId, TextSpan?[]> { { documentId, trackingSpans } } : null;

            var actualNewActiveStatements = new ActiveStatement[oldActiveStatements.Length];
            var actualNewExceptionRegions = new ImmutableArray<LinePositionSpan>[oldActiveStatements.Length];
@@ -94,8 +94,8 @@ internal abstract class EditAndContinueTestHelpers

            var documentId = DocumentId.CreateNewId(ProjectId.CreateNewId("TestEnCProject"), "TestEnCDocument");

-            var spanTracker = new TestActiveStatementSpanTracker(
-                (description.OldTrackingSpans != null) ? new Dictionary<DocumentId, TextSpan?[]> { { documentId, description.OldTrackingSpans } } : null);
+            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(Analyzer.GetTestAccessor().ActiveStatementSpanTracker);
+            spanTracker.Spans = (description.OldTrackingSpans != null) ? new Dictionary<DocumentId, TextSpan?[]> { { documentId, description.OldTrackingSpans } } : null;

            Analyzer.GetTestAccessor().AnalyzeSyntax(
                editScript,
@@ -103,7 +103,6 @@ internal abstract class EditAndContinueTestHelpers
                oldText,
                newText,
                documentId,
-                spanTracker,
                oldActiveStatements.AsImmutable(),
                actualNewActiveStatements,
                actualNewExceptionRegions,
@@ -183,7 +182,6 @@ internal abstract class EditAndContinueTestHelpers
        }

        internal void VerifySemantics(
-            Workspace workspace,
            EditScript<SyntaxNode> editScript,
            ActiveStatementsDescription? activeStatements = null,
            IEnumerable<string>? additionalOldSources = null,
@@ -230,7 +228,7 @@ internal abstract class EditAndContinueTestHelpers
            var actualLineEdits = new List<LineChange>();
            var actualSemanticEdits = new List<SemanticEdit>();
            var diagnostics = new List<RudeEditDiagnostic>();
-            var spanTracker = Assert.IsType<TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService<IActiveStatementSpanTracker>());
+            Assert.IsType<TestActiveStatementSpanTracker>(Analyzer.GetTestAccessor().ActiveStatementSpanTracker);
            var documentId = DocumentId.CreateNewId(ProjectId.CreateNewId());

            var actualNewActiveStatements = new ActiveStatement[activeStatements.OldStatements.Length];
@@ -242,7 +240,6 @@ internal abstract class EditAndContinueTestHelpers
                oldText,
                newText,
                documentId,
-                spanTracker,
                oldActiveStatements,
                actualNewActiveStatements,
                actualNewExceptionRegions,

--- a/src/EditorFeatures/TestUtilities/EditAndContinue/TestActiveStatementSpanTracker.cs
+++ b/src/EditorFeatures/TestUtilities/EditAndContinue/TestActiveStatementSpanTracker.cs
@@ -4,29 +4,15 @@

 #nullable enable

-using System;
 using System.Collections.Generic;
-using System.Composition;
-using System.Diagnostics.CodeAnalysis;
-using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Text;

 namespace Microsoft.CodeAnalysis.EditAndContinue.UnitTests
 {
-    [ExportWorkspaceService(typeof(IActiveStatementSpanTracker), ServiceLayer.Host)]
-    [Shared]
-    [PartNotDiscoverable]
    internal class TestActiveStatementSpanTracker : IActiveStatementSpanTracker
    {
        public Dictionary<DocumentId, TextSpan?[]>? Spans;

-        [ImportingConstructor]
-        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public TestActiveStatementSpanTracker()
-        {
-        }
-
-        [SuppressMessage("RoslynDiagnosticsReliability", "RS0034:Exported parts should be marked with 'ImportingConstructorAttribute'", Justification = "Used incorrectly by test code")]
        public TestActiveStatementSpanTracker(Dictionary<DocumentId, TextSpan?[]>? spans = null)
        {
            Spans = spans;

--- a/src/EditorFeatures/TestUtilities/EditAndContinue/TestActiveStatementSpanTrackerFactory.cs
+++ b/src/EditorFeatures/TestUtilities/EditAndContinue/TestActiveStatementSpanTrackerFactory.cs
+// 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.Composition;
+using Microsoft.CodeAnalysis.Host.Mef;
+
+namespace Microsoft.CodeAnalysis.EditAndContinue.UnitTests
+{
+    [ExportWorkspaceService(typeof(IActiveStatementSpanTrackerFactory), ServiceLayer.Host)]
+    [Shared]
+    [PartNotDiscoverable]
+    internal class TestActiveStatementSpanTrackerFactory : IActiveStatementSpanTrackerFactory
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public TestActiveStatementSpanTrackerFactory()
+        {
+            ActiveStatementSpanTracker = new TestActiveStatementSpanTracker();
+        }
+
+        public TestActiveStatementSpanTracker ActiveStatementSpanTracker { get; }
+
+        IActiveStatementSpanTracker IActiveStatementSpanTrackerFactory.GetOrCreateActiveStatementSpanTracker()
+            => ActiveStatementSpanTracker;
+    }
+}
--- a/src/EditorFeatures/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb
+++ b/src/EditorFeatures/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb
@@ -12,11 +12,12 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax

 Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests

-    <UseExportProvider>
    Public MustInherit Class EditingTestBase
        Inherits BasicTestBase

-        Friend Shared ReadOnly Analyzer As VisualBasicEditAndContinueAnalyzer = New VisualBasicEditAndContinueAnalyzer()
+        Friend Shared Function CreateAnalyzer() As VisualBasicEditAndContinueAnalyzer
+            Return New VisualBasicEditAndContinueAnalyzer(New TestActiveStatementSpanTracker())
+        End Function

        Public Enum StateMachineKind
            None
@@ -38,7 +39,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests
        End Function

        Private Shared Function ParseSource(source As String, Optional options As ParseOptions = Nothing) As SyntaxTree
-            Return VisualBasicEditAndContinueTestHelpers.Instance.ParseText(ActiveStatementsDescription.ClearTags(source))
+            Return VisualBasicEditAndContinueTestHelpers.CreateInstance().ParseText(ActiveStatementsDescription.ClearTags(source))
        End Function

        Friend Shared Function GetTopEdits(src1 As String, src2 As String) As EditScript(Of SyntaxNode)
@@ -64,7 +65,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests
            Dim diagnostics = New List(Of RudeEditDiagnostic)()

            Dim oldHasStateMachineSuspensionPoint = False, newHasStateMachineSuspensionPoint = False
-            Dim match = Analyzer.GetTestAccessor().ComputeBodyMatch(m1, m2, Array.Empty(Of AbstractEditAndContinueAnalyzer.ActiveNode)(), diagnostics, oldHasStateMachineSuspensionPoint, newHasStateMachineSuspensionPoint)
+            Dim match = CreateAnalyzer().GetTestAccessor().ComputeBodyMatch(m1, m2, Array.Empty(Of AbstractEditAndContinueAnalyzer.ActiveNode)(), diagnostics, oldHasStateMachineSuspensionPoint, newHasStateMachineSuspensionPoint)
            Dim needsSyntaxMap = oldHasStateMachineSuspensionPoint AndAlso newHasStateMachineSuspensionPoint

            Assert.Equal(stateMachine <> StateMachineKind.None, needsSyntaxMap)
@@ -80,7 +81,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests
                                                src2 As String,
                                                Optional stateMachine As StateMachineKind = StateMachineKind.None) As IEnumerable(Of KeyValuePair(Of SyntaxNode, SyntaxNode))
            Dim methodMatch = GetMethodMatch(src1, src2, stateMachine)
-            Return EditAndContinueTestHelpers.GetMethodMatches(Analyzer, methodMatch)
+            Return EditAndContinueTestHelpers.GetMethodMatches(CreateAnalyzer(), methodMatch)
        End Function

        Public Shared Function ToMatchingPairs(match As Match(Of SyntaxNode)) As MatchingPairs

--- a/src/EditorFeatures/VisualBasicTest/EditAndContinue/Helpers/Extensions.vb
+++ b/src/EditorFeatures/VisualBasicTest/EditAndContinue/Helpers/Extensions.vb
@@ -6,24 +6,18 @@ Imports System.Runtime.CompilerServices
 Imports Microsoft.CodeAnalysis.Differencing
 Imports Microsoft.CodeAnalysis.EditAndContinue
 Imports Microsoft.CodeAnalysis.EditAndContinue.UnitTests
-Imports Microsoft.CodeAnalysis.Editor.UnitTests
-Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EditAndContinue
-Imports Microsoft.VisualStudio.Composition
+Imports Microsoft.CodeAnalysis.Test.Utilities

 Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests

    Friend Module Extensions

-        Private ReadOnly s_exportProviderFactoryWithTestActiveStatementSpanTracker As IExportProviderFactory =
-            ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic _
-                .WithPart(GetType(TestActiveStatementSpanTracker)))
-
        Friend Sub VerifyUnchangedDocument(
            source As String,
            description As ActiveStatementsDescription)

-            VisualBasicEditAndContinueTestHelpers.Instance.VerifyUnchangedDocument(
+            VisualBasicEditAndContinueTestHelpers.CreateInstance().VerifyUnchangedDocument(
                ActiveStatementsDescription.ClearTags(source),
                description.OldStatements,
                description.OldTrackingSpans,
@@ -42,7 +36,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests
        Friend Sub VerifyRudeDiagnostics(editScript As EditScript(Of SyntaxNode),
                                         description As ActiveStatementsDescription,
                                         ParamArray expectedDiagnostics As RudeEditDiagnosticDescription())
-            VisualBasicEditAndContinueTestHelpers.Instance.VerifyRudeDiagnostics(editScript, description, expectedDiagnostics)
+            VisualBasicEditAndContinueTestHelpers.CreateInstance().VerifyRudeDiagnostics(editScript, description, expectedDiagnostics)
        End Sub

        <Extension>
@@ -50,7 +44,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests
                                   expectedLineEdits As IEnumerable(Of LineChange),
                                   expectedNodeUpdates As IEnumerable(Of String),
                                   ParamArray expectedDiagnostics As RudeEditDiagnosticDescription())
-            VisualBasicEditAndContinueTestHelpers.Instance.VerifyLineEdits(editScript, expectedLineEdits, expectedNodeUpdates, expectedDiagnostics)
+            VisualBasicEditAndContinueTestHelpers.CreateInstance().VerifyLineEdits(editScript, expectedLineEdits, expectedNodeUpdates, expectedDiagnostics)
        End Sub

        <Extension>
@@ -101,17 +95,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests
                                   expectedSemanticEdits As SemanticEditDescription(),
                                   expectedDeclarationError As DiagnosticDescription,
                                   ParamArray expectedDiagnostics As RudeEditDiagnosticDescription())
-            Using workspace = TestWorkspace.CreateVisualBasic("", exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
-                VisualBasicEditAndContinueTestHelpers.Instance.VerifySemantics(
-                    workspace,
-                    editScript,
-                    activeStatements,
-                    additionalOldSources,
-                    additionalNewSources,
-                    expectedSemanticEdits,
-                    expectedDeclarationError,
-                    expectedDiagnostics)
-            End Using
+            VisualBasicEditAndContinueTestHelpers.CreateInstance().VerifySemantics(
+                editScript,
+                activeStatements,
+                additionalOldSources,
+                additionalNewSources,
+                expectedSemanticEdits,
+                expectedDeclarationError,
+                expectedDiagnostics)
        End Sub
    End Module
 End Namespace
--- a/src/EditorFeatures/VisualBasicTest/EditAndContinue/Helpers/VisualBasicEditAndContinueTestHelpers.vb
+++ b/src/EditorFeatures/VisualBasicTest/EditAndContinue/Helpers/VisualBasicEditAndContinueTestHelpers.vb
@@ -14,18 +14,24 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EditAndContinue
    Friend NotInheritable Class VisualBasicEditAndContinueTestHelpers
        Inherits EditAndContinueTestHelpers

-        Private ReadOnly _fxReferences As ImmutableArray(Of PortableExecutableReference)
+        Private ReadOnly _analyzer As VisualBasicEditAndContinueAnalyzer = New VisualBasicEditAndContinueAnalyzer(New TestActiveStatementSpanTracker())

-        Friend Shared ReadOnly Instance As VisualBasicEditAndContinueTestHelpers = New VisualBasicEditAndContinueTestHelpers(
-            ImmutableArray.Create(TestReferences.NetFx.v4_0_30319_17626.mscorlib, TestReferences.NetFx.v4_0_30319.System, TestReferences.NetFx.v4_0_30319.System_Core))
+        Private ReadOnly _fxReferences As ImmutableArray(Of PortableExecutableReference)

-        Friend Shared ReadOnly Instance40 As VisualBasicEditAndContinueTestHelpers = New VisualBasicEditAndContinueTestHelpers(
-            ImmutableArray.Create(TestReferences.NetFx.v4_0_30319.mscorlib, TestReferences.NetFx.v4_0_30319.System_Core))
+        Friend Shared Function CreateInstance() As VisualBasicEditAndContinueTestHelpers
+            Return New VisualBasicEditAndContinueTestHelpers(
+                ImmutableArray.Create(TestReferences.NetFx.v4_0_30319_17626.mscorlib, TestReferences.NetFx.v4_0_30319.System, TestReferences.NetFx.v4_0_30319.System_Core))
+        End Function

-        Friend Shared ReadOnly InstanceMinAsync As VisualBasicEditAndContinueTestHelpers = New VisualBasicEditAndContinueTestHelpers(
-            ImmutableArray.Create(TestReferences.NetFx.Minimal.mincorlib, TestReferences.NetFx.Minimal.minasync))
+        Friend Shared Function CreateInstance40() As VisualBasicEditAndContinueTestHelpers
+            Return New VisualBasicEditAndContinueTestHelpers(
+                ImmutableArray.Create(TestReferences.NetFx.v4_0_30319.mscorlib, TestReferences.NetFx.v4_0_30319.System_Core))
+        End Function

-        Private Shared ReadOnly s_analyzer As VisualBasicEditAndContinueAnalyzer = New VisualBasicEditAndContinueAnalyzer()
+        Friend Shared Function CreateInstanceMinAsync() As VisualBasicEditAndContinueTestHelpers
+            Return New VisualBasicEditAndContinueTestHelpers(
+                ImmutableArray.Create(TestReferences.NetFx.Minimal.mincorlib, TestReferences.NetFx.Minimal.minasync))
+        End Function

        Sub New(fxReferences As ImmutableArray(Of PortableExecutableReference))
            _fxReferences = fxReferences
@@ -33,7 +39,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EditAndContinue

        Public Overrides ReadOnly Property Analyzer As AbstractEditAndContinueAnalyzer
            Get
-                Return s_analyzer
+                Return _analyzer
            End Get
        End Property


--- a/src/EditorFeatures/VisualBasicTest/EditAndContinue/RudeEditStatementTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/EditAndContinue/RudeEditStatementTests.vb
@@ -4,21 +4,14 @@

 Imports Microsoft.CodeAnalysis.EditAndContinue
 Imports Microsoft.CodeAnalysis.EditAndContinue.UnitTests
-Imports Microsoft.CodeAnalysis.Editor.UnitTests
-Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EditAndContinue
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
-Imports Microsoft.VisualStudio.Composition

 Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests

    Public Class RudeEditStatementTests
        Inherits EditingTestBase

-        Private Shared ReadOnly s_exportProviderFactoryWithTestActiveStatementSpanTracker As IExportProviderFactory =
-            ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic _
-                .WithPart(GetType(TestActiveStatementSpanTracker)))
-
 #Region "Matching"

        <Fact>
@@ -6017,20 +6010,15 @@ Class C
    End Function
 End Class
 "
-
-            Using workspace = TestWorkspace.CreateVisualBasic("", exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
-                Dim edits = GetTopEdits(src1, src2)
-                VisualBasicEditAndContinueTestHelpers.Instance40.VerifySemantics(
-                    workspace,
-                    editScript:=edits,
-                    activeStatements:=ActiveStatementsDescription.Empty,
-                    additionalOldSources:=Nothing,
-                    additionalNewSources:=Nothing,
-                    expectedSemanticEdits:=Nothing,
-                    expectedDiagnostics:={Diagnostic(RudeEditKind.UpdatingStateMachineMethodMissingAttribute, "Shared Iterator Function F()", "System.Runtime.CompilerServices.IteratorStateMachineAttribute")},
-                    expectedDeclarationError:=Nothing)
-            End Using
-
+            Dim edits = GetTopEdits(src1, src2)
+            VisualBasicEditAndContinueTestHelpers.CreateInstance40().VerifySemantics(
+                editScript:=edits,
+                activeStatements:=ActiveStatementsDescription.Empty,
+                additionalOldSources:=Nothing,
+                additionalNewSources:=Nothing,
+                expectedSemanticEdits:=Nothing,
+                expectedDiagnostics:={Diagnostic(RudeEditKind.UpdatingStateMachineMethodMissingAttribute, "Shared Iterator Function F()", "System.Runtime.CompilerServices.IteratorStateMachineAttribute")},
+                expectedDeclarationError:=Nothing)
        End Sub

        <Fact>
@@ -6053,18 +6041,15 @@ Class C
    End Function
 End Class
 "
-            Using workspace = TestWorkspace.CreateVisualBasic("", exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
-                Dim edits = GetTopEdits(src1, src2)
-                VisualBasicEditAndContinueTestHelpers.Instance40.VerifySemantics(
-                    workspace,
-                    editScript:=edits,
-                    activeStatements:=ActiveStatementsDescription.Empty,
-                    additionalOldSources:=Nothing,
-                    additionalNewSources:=Nothing,
-                    expectedSemanticEdits:=Nothing,
-                    expectedDiagnostics:=Nothing,
-                    expectedDeclarationError:=Nothing)
-            End Using
+            Dim edits = GetTopEdits(src1, src2)
+            VisualBasicEditAndContinueTestHelpers.CreateInstance40().VerifySemantics(
+                editScript:=edits,
+                activeStatements:=ActiveStatementsDescription.Empty,
+                additionalOldSources:=Nothing,
+                additionalNewSources:=Nothing,
+                expectedSemanticEdits:=Nothing,
+                expectedDiagnostics:=Nothing,
+                expectedDeclarationError:=Nothing)
        End Sub

 #End Region
@@ -6143,19 +6128,15 @@ Class C
    End Function
 End Class
 "
-
-            Using workspace = TestWorkspace.CreateVisualBasic("", exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
-                Dim edits = GetTopEdits(src1, src2)
-                VisualBasicEditAndContinueTestHelpers.InstanceMinAsync.VerifySemantics(
-                    workspace,
-                    editScript:=edits,
-                    activeStatements:=ActiveStatementsDescription.Empty,
-                    additionalOldSources:=Nothing,
-                    additionalNewSources:=Nothing,
-                    expectedSemanticEdits:=Nothing,
-                    expectedDiagnostics:={Diagnostic(RudeEditKind.UpdatingStateMachineMethodMissingAttribute, "Shared Async Function F()", "System.Runtime.CompilerServices.AsyncStateMachineAttribute")},
-                    expectedDeclarationError:=Nothing)
-            End Using
+            Dim edits = GetTopEdits(src1, src2)
+            VisualBasicEditAndContinueTestHelpers.CreateInstanceMinAsync().VerifySemantics(
+                editScript:=edits,
+                activeStatements:=ActiveStatementsDescription.Empty,
+                additionalOldSources:=Nothing,
+                additionalNewSources:=Nothing,
+                expectedSemanticEdits:=Nothing,
+                expectedDiagnostics:={Diagnostic(RudeEditKind.UpdatingStateMachineMethodMissingAttribute, "Shared Async Function F()", "System.Runtime.CompilerServices.AsyncStateMachineAttribute")},
+                expectedDeclarationError:=Nothing)
        End Sub

        <Fact>
@@ -6179,17 +6160,14 @@ Class C
    End Function
 End Class
 "
-            Using workspace = TestWorkspace.CreateVisualBasic("", exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
-                Dim edits = GetTopEdits(src1, src2)
-                VisualBasicEditAndContinueTestHelpers.InstanceMinAsync.VerifySemantics(
-                    workspace,
-                    edits,
-                    ActiveStatementsDescription.Empty,
-                    Nothing,
-                    Nothing,
-                    Nothing,
-                    Nothing)
-            End Using
+            Dim edits = GetTopEdits(src1, src2)
+            VisualBasicEditAndContinueTestHelpers.CreateInstanceMinAsync().VerifySemantics(
+                edits,
+                ActiveStatementsDescription.Empty,
+                Nothing,
+                Nothing,
+                Nothing,
+                Nothing)
        End Sub
 #End Region
    End Class

--- a/src/EditorFeatures/VisualBasicTest/EditAndContinue/VisualBasicEditAndContinueAnalyzerTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/EditAndContinue/VisualBasicEditAndContinueAnalyzerTests.vb
@@ -19,7 +19,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests

        Private Shared ReadOnly s_exportProviderFactoryWithTestActiveStatementSpanTracker As IExportProviderFactory =
            ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic _
-                .WithPart(GetType(TestActiveStatementSpanTracker)))
+                .WithPart(GetType(TestActiveStatementSpanTrackerFactory)))

 #Region "Helpers"
        Private Shared Sub TestSpans(source As String, hasLabel As Func(Of SyntaxNode, Boolean))
@@ -446,7 +446,6 @@ Class C
    End Sub
 End Class
 "
-            Dim analyzer = New VisualBasicEditAndContinueAnalyzer()

            Using workspace = TestWorkspace.CreateVisualBasic(source1, exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())

@@ -468,7 +467,8 @@ End Class
                Dim oldStatementSpan = oldText.Lines.GetLinePositionSpan(oldStatementTextSpan)
                Dim oldStatementSyntax = oldSyntaxRoot.FindNode(oldStatementTextSpan)

-                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTracker)())
+                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTrackerFactory)().GetOrCreateActiveStatementSpanTracker())
+                Dim analyzer = New VisualBasicEditAndContinueAnalyzer(activeStatementSpanTracker)
                Dim baseActiveStatements = ImmutableArray.Create(ActiveStatementsDescription.CreateActiveStatement(ActiveStatementFlags.IsLeafFrame, oldStatementSpan, DocumentId.CreateNewId(ProjectId.CreateNewId())))
                Dim result = Await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newDocument, CancellationToken.None)

@@ -495,12 +495,12 @@ Class C
 End Class
 "

-            Dim analyzer = New VisualBasicEditAndContinueAnalyzer()
            Using workspace = TestWorkspace.CreateVisualBasic(source, exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
                Dim oldProject = workspace.CurrentSolution.Projects.Single()
                Dim oldDocument = oldProject.Documents.Single()
                Dim baseActiveStatements = ImmutableArray.Create(Of ActiveStatement)()
-                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTracker)())
+                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTrackerFactory)().GetOrCreateActiveStatementSpanTracker())
+                Dim analyzer = New VisualBasicEditAndContinueAnalyzer(activeStatementSpanTracker)
                Dim result = Await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, CancellationToken.None)

                Assert.False(result.HasChanges)
@@ -526,17 +526,17 @@ Class C
 End Class
 "

-            Dim analyzer = New VisualBasicEditAndContinueAnalyzer()
            Using workspace = TestWorkspace.CreateVisualBasic(source1, exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
                Dim oldProject = workspace.CurrentSolution.Projects.Single()
                Dim oldDocument = oldProject.Documents.Single()
                Dim documentId = oldDocument.Id
                Dim oldSolution = workspace.CurrentSolution
                Dim newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2))
-                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTracker)())
+                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTrackerFactory)().GetOrCreateActiveStatementSpanTracker())
+                Dim analyzer = New VisualBasicEditAndContinueAnalyzer(activeStatementSpanTracker)

                Dim baseActiveStatements = ImmutableArray.Create(Of ActiveStatement)()
-                Dim result = Await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None)
+                Dim result = Await Analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None)

                Assert.False(result.HasChanges)
                Assert.False(result.HasChangesAndErrors)
@@ -555,12 +555,12 @@ Class C
 End Class
 "

-            Dim analyzer = New VisualBasicEditAndContinueAnalyzer()
            Using workspace = TestWorkspace.CreateVisualBasic(source, exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
                Dim oldProject = workspace.CurrentSolution.Projects.Single()
                Dim oldDocument = oldProject.Documents.Single()
                Dim baseActiveStatements = ImmutableArray.Create(Of ActiveStatement)()
-                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTracker)())
+                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTrackerFactory)().GetOrCreateActiveStatementSpanTracker())
+                Dim analyzer = New VisualBasicEditAndContinueAnalyzer(activeStatementSpanTracker)
                Dim result = Await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, oldDocument, CancellationToken.None)

                Assert.False(result.HasChanges)
@@ -588,17 +588,17 @@ Class C
 End Class
 "

-            Dim analyzer = New VisualBasicEditAndContinueAnalyzer()
            Using workspace = TestWorkspace.CreateVisualBasic(source1, exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
                Dim oldProject = workspace.CurrentSolution.Projects.Single()
                Dim oldDocument = oldProject.Documents.Single()
                Dim documentId = oldDocument.Id
                Dim oldSolution = workspace.CurrentSolution
                Dim newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2))
-                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTracker)())
+                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTrackerFactory)().GetOrCreateActiveStatementSpanTracker())
+                Dim analyzer = New VisualBasicEditAndContinueAnalyzer(activeStatementSpanTracker)

                Dim baseActiveStatements = ImmutableArray.Create(Of ActiveStatement)()
-                Dim result = Await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None)
+                Dim result = Await Analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None)

                ' no declaration errors (error in method body is only reported when emitting)
                Assert.False(result.HasChangesAndErrors)
@@ -623,16 +623,16 @@ Class C
 End Class
 "

-            Dim analyzer = New VisualBasicEditAndContinueAnalyzer()
            Using workspace = TestWorkspace.CreateVisualBasic(source1, exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
                Dim oldSolution = workspace.CurrentSolution
                Dim oldProject = oldSolution.Projects.Single()
                Dim documentId = oldProject.Documents.Single().Id
                Dim newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2))
-                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTracker)())
+                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTrackerFactory)().GetOrCreateActiveStatementSpanTracker())
+                Dim analyzer = New VisualBasicEditAndContinueAnalyzer(activeStatementSpanTracker)

                Dim baseActiveStatements = ImmutableArray.Create(Of ActiveStatement)()
-                Dim result = Await analyzer.AnalyzeDocumentAsync(oldSolution.GetDocument(documentId), baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None)
+                Dim result = Await Analyzer.AnalyzeDocumentAsync(oldSolution.GetDocument(documentId), baseActiveStatements, newSolution.GetDocument(documentId), CancellationToken.None)

                Assert.True(result.HasChanges)
                Assert.True(result.HasChangesAndErrors)
@@ -656,7 +656,7 @@ Class C
 End Class
 </text>.Value

-            Dim analyzer = New VisualBasicEditAndContinueAnalyzer()
+            Dim analyzer = New VisualBasicEditAndContinueAnalyzer(New TestActiveStatementSpanTracker())
            Dim root = SyntaxFactory.ParseCompilationUnit(source)

            Assert.Null(analyzer.FindMemberDeclaration(root, Integer.MaxValue))
@@ -675,7 +675,6 @@ End Class
 Private Class D
 End Class
 "
-            Dim analyzer = New VisualBasicEditAndContinueAnalyzer()

            Using workspace = TestWorkspace.CreateVisualBasic(source1, exportProvider:=s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider())
                ' fork the solution to introduce a change
@@ -695,7 +694,8 @@ End Class

                Dim changedDocuments = changes.GetChangedDocuments().Concat(changes.GetAddedDocuments())

-                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTracker)())
+                Dim activeStatementSpanTracker = Assert.IsType(Of TestActiveStatementSpanTracker)(workspace.Services.GetRequiredService(Of IActiveStatementSpanTrackerFactory)().GetOrCreateActiveStatementSpanTracker())
+                Dim analyzer = New VisualBasicEditAndContinueAnalyzer(activeStatementSpanTracker)
                Dim result = New List(Of DocumentAnalysisResults)()
                Dim baseActiveStatements = ImmutableArray.Create(Of ActiveStatement)()
                For Each changedDocumentId In changedDocuments

--- a/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs
+++ b/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs
@@ -15,6 +15,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Differencing;
 using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
@@ -24,12 +25,26 @@

 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue
 {
-    [ExportLanguageService(typeof(IEditAndContinueAnalyzer), LanguageNames.CSharp), Shared]
    internal sealed class CSharpEditAndContinueAnalyzer : AbstractEditAndContinueAnalyzer
    {
-        [ImportingConstructor]
-        [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
-        public CSharpEditAndContinueAnalyzer()
+        [ExportLanguageServiceFactory(typeof(IEditAndContinueAnalyzer), LanguageNames.CSharp), Shared]
+        internal sealed class Factory : ILanguageServiceFactory
+        {
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public Factory()
+            {
+            }
+
+            public ILanguageService CreateLanguageService(HostLanguageServices languageServices)
+            {
+                return new CSharpEditAndContinueAnalyzer(languageServices.WorkspaceServices.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
+            }
+        }
+
+        // Public for testing purposes
+        public CSharpEditAndContinueAnalyzer(IActiveStatementSpanTracker activeStatementSpanTracker)
+            : base(activeStatementSpanTracker)
        {
        }


--- a/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
+++ b/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
@@ -28,6 +28,13 @@ internal abstract class AbstractEditAndContinueAnalyzer : IEditAndContinueAnalyz
    {
        internal const int DefaultStatementPart = 0;

+        private readonly IActiveStatementSpanTracker _activeStatementSpanTracker;
+
+        protected AbstractEditAndContinueAnalyzer(IActiveStatementSpanTracker activeStatementSpanTracker)
+        {
+            _activeStatementSpanTracker = activeStatementSpanTracker;
+        }
+
        internal abstract bool ExperimentalFeaturesEnabled(SyntaxTree tree);

        /// <summary>
@@ -375,6 +382,8 @@ protected virtual string GetSuspensionPointDisplayName(SyntaxNode node, EditKind
            Debug.Assert(document.SupportsSyntaxTree);
            Debug.Assert(document.SupportsSemanticModel);

+            Debug.Assert(document.Project.Solution.Workspace.Services.GetRequiredService<IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker() == _activeStatementSpanTracker);
+
            try
            {
                cancellationToken.ThrowIfCancellationRequested();
@@ -479,15 +488,12 @@ protected virtual string GetSuspensionPointDisplayName(SyntaxNode node, EditKind
                var syntacticEdits = topMatch.GetTreeEdits();
                var editMap = BuildEditMap(syntacticEdits);

-                var activeStatementSpanTracker = document.Project.Solution.Workspace.Services.GetRequiredService<IActiveStatementSpanTracker>();
-
                AnalyzeSyntax(
                    syntacticEdits,
                    editMap,
                    oldText,
                    newText,
                    document.Id,
-                    activeStatementSpanTracker,
                    baseActiveStatements,
                    newActiveStatements,
                    newExceptionRegions,
@@ -640,7 +646,6 @@ private static bool ReportFatalErrorAnalyzeDocumentAsync(ImmutableArray<ActiveSt
            SourceText oldText,
            SourceText newText,
            DocumentId documentId,
-            IActiveStatementSpanTracker activeStatementSpanTracker,
            ImmutableArray<ActiveStatement> oldActiveStatements,
            [Out] ActiveStatement[] newActiveStatements,
            [Out] ImmutableArray<LinePositionSpan>[] newExceptionRegions,
@@ -655,11 +660,11 @@ private static bool ReportFatalErrorAnalyzeDocumentAsync(ImmutableArray<ActiveSt
            {
                var edit = script.Edits[i];

-                AnalyzeUpdatedActiveMethodBodies(script, i, editMap, oldText, newText, documentId, activeStatementSpanTracker, oldActiveStatements, newActiveStatements, newExceptionRegions, updatedMethods, diagnostics);
+                AnalyzeUpdatedActiveMethodBodies(script, i, editMap, oldText, newText, documentId, oldActiveStatements, newActiveStatements, newExceptionRegions, updatedMethods, diagnostics);
                ReportSyntacticRudeEdits(diagnostics, script.Match, edit, editMap);
            }

-            UpdateUneditedSpans(diagnostics, script.Match, oldText, newText, documentId, activeStatementSpanTracker, oldActiveStatements, newActiveStatements, newExceptionRegions);
+            UpdateUneditedSpans(diagnostics, script.Match, oldText, newText, documentId, oldActiveStatements, newActiveStatements, newExceptionRegions);

            Debug.Assert(newActiveStatements.All(a => a != null));
        }
@@ -670,7 +675,6 @@ private static bool ReportFatalErrorAnalyzeDocumentAsync(ImmutableArray<ActiveSt
            SourceText oldText,
            SourceText newText,
            DocumentId documentId,
-            IActiveStatementSpanTracker activeStatementSpanTracker,
            ImmutableArray<ActiveStatement> oldActiveStatements,
            [In, Out] ActiveStatement[] newActiveStatements,
            [In, Out] ImmutableArray<LinePositionSpan>[] newExceptionRegions)
@@ -686,7 +690,7 @@ private static bool ReportFatalErrorAnalyzeDocumentAsync(ImmutableArray<ActiveSt
                if (newActiveStatements[i] == null)
                {
                    Contract.ThrowIfFalse(newExceptionRegions[i].IsDefault);
-                    var isTracked = activeStatementSpanTracker.TryGetSpan(new ActiveStatementId(documentId, i), newText, out var trackedSpan);
+                    var isTracked = _activeStatementSpanTracker.TryGetSpan(new ActiveStatementId(documentId, i), newText, out var trackedSpan);
                    if (!TryGetTextSpan(oldText.Lines, oldActiveStatements[i].Span, out var oldStatementSpan))
                    {
                        DocumentAnalysisResults.Log.Write("Invalid active statement span: [{0}..{1})", oldStatementSpan.Start, oldStatementSpan.End);
@@ -916,7 +920,6 @@ public LambdaInfo WithMatch(Match<SyntaxNode> match, SyntaxNode newLambdaBody)
            SourceText oldText,
            SourceText newText,
            DocumentId documentId,
-            IActiveStatementSpanTracker activeStatementSpanTracker,
            ImmutableArray<ActiveStatement> oldActiveStatements,
            [Out] ActiveStatement[] newActiveStatements,
            [Out] ImmutableArray<LinePositionSpan>[] newExceptionRegions,
@@ -1018,7 +1021,7 @@ public LambdaInfo WithMatch(Match<SyntaxNode> match, SyntaxNode newLambdaBody)
                // Tracking spans corresponding to the active statements from the tracking service.
                // We seed the method body matching algorithm with tracking spans (unless they were deleted)
                // to get precise matching.
-                var isTracked = activeStatementSpanTracker.TryGetSpan(new ActiveStatementId(documentId, ordinal), newText, out var trackedSpan);
+                var isTracked = _activeStatementSpanTracker.TryGetSpan(new ActiveStatementId(documentId, ordinal), newText, out var trackedSpan);

                if (isTracked)
                {
@@ -3854,20 +3857,22 @@ internal TestAccessor GetTestAccessor()
            public TestAccessor(AbstractEditAndContinueAnalyzer abstractEditAndContinueAnalyzer)
                => _abstractEditAndContinueAnalyzer = abstractEditAndContinueAnalyzer;

+            internal ref readonly IActiveStatementSpanTracker ActiveStatementSpanTracker
+                => ref _abstractEditAndContinueAnalyzer._activeStatementSpanTracker;
+
            internal void AnalyzeSyntax(
                EditScript<SyntaxNode> script,
                Dictionary<SyntaxNode, EditKind> editMap,
                SourceText oldText,
                SourceText newText,
                DocumentId documentId,
-                IActiveStatementSpanTracker activeStatementSpanTracker,
                ImmutableArray<ActiveStatement> oldActiveStatements,
                [Out] ActiveStatement[] newActiveStatements,
                [Out] ImmutableArray<LinePositionSpan>[] newExceptionRegions,
                [Out] List<UpdatedMemberInfo> updatedMethods,
                [Out] List<RudeEditDiagnostic> diagnostics)
            {
-                _abstractEditAndContinueAnalyzer.AnalyzeSyntax(script, editMap, oldText, newText, documentId, activeStatementSpanTracker, oldActiveStatements, newActiveStatements, newExceptionRegions, updatedMethods, diagnostics);
+                _abstractEditAndContinueAnalyzer.AnalyzeSyntax(script, editMap, oldText, newText, documentId, oldActiveStatements, newActiveStatements, newExceptionRegions, updatedMethods, diagnostics);
            }

            internal void AnalyzeUnchangedDocument(

--- a/src/Features/Core/Portable/EditAndContinue/IActiveStatementSpanTracker.cs
+++ b/src/Features/Core/Portable/EditAndContinue/IActiveStatementSpanTracker.cs
@@ -4,12 +4,11 @@

 #nullable enable

-using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Text;

 namespace Microsoft.CodeAnalysis.EditAndContinue
 {
-    internal interface IActiveStatementSpanTracker : IWorkspaceService
+    internal interface IActiveStatementSpanTracker
    {
        bool TryGetSpan(ActiveStatementId id, SourceText source, out TextSpan span);
    }

--- a/src/Features/Core/Portable/EditAndContinue/IActiveStatementSpanTrackerFactory.cs
+++ b/src/Features/Core/Portable/EditAndContinue/IActiveStatementSpanTrackerFactory.cs
+// 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.
+
+using Microsoft.CodeAnalysis.Host;
+
+namespace Microsoft.CodeAnalysis.EditAndContinue
+{
+    internal interface IActiveStatementSpanTrackerFactory : IWorkspaceService
+    {
+        IActiveStatementSpanTracker GetOrCreateActiveStatementSpanTracker();
+    }
+}
--- a/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb
+++ b/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb
@@ -4,23 +4,36 @@

 Imports System.Collections.Immutable
 Imports System.Composition
-Imports System.Diagnostics.CodeAnalysis
 Imports System.Runtime.InteropServices
 Imports System.Threading
 Imports Microsoft.CodeAnalysis.Differencing
 Imports Microsoft.CodeAnalysis.EditAndContinue
+Imports Microsoft.CodeAnalysis.Host
 Imports Microsoft.CodeAnalysis.Host.Mef
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax

 Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
-    <ExportLanguageService(GetType(IEditAndContinueAnalyzer), LanguageNames.VisualBasic), [Shared]>
    Friend NotInheritable Class VisualBasicEditAndContinueAnalyzer
        Inherits AbstractEditAndContinueAnalyzer

-        <ImportingConstructor>
-        <SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification:="Used in test code: https://github.com/dotnet/roslyn/issues/42814")>
-        Public Sub New()
+        <ExportLanguageServiceFactory(GetType(IEditAndContinueAnalyzer), LanguageNames.VisualBasic), [Shared]>
+        Private NotInheritable Class Factory
+            Implements ILanguageServiceFactory
+
+            <ImportingConstructor>
+            <Obsolete(MefConstruction.ImportingConstructorMessage, True)>
+            Public Sub New()
+            End Sub
+
+            Public Function CreateLanguageService(languageServices As HostLanguageServices) As ILanguageService Implements ILanguageServiceFactory.CreateLanguageService
+                Return New VisualBasicEditAndContinueAnalyzer(languageServices.WorkspaceServices.GetRequiredService(Of IActiveStatementSpanTrackerFactory)().GetOrCreateActiveStatementSpanTracker())
+            End Function
+        End Class
+
+        ' Public for testing purposes
+        Public Sub New(activeStatementSpanTracker As IActiveStatementSpanTracker)
+            MyBase.New(activeStatementSpanTracker)
        End Sub

 #Region "Syntax Analysis"
@@ -511,7 +524,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                Dim rightDeclaration = DirectCast(GetSymbolSyntax(rightProperty, cancellationToken), PropertyStatementSyntax)

                rightInitializer = rightDeclaration.Initializer
-            ElseIf leftInitializer.Parent.Parent.IsKind(SyntaxKind.FieldDeclaration)
+            ElseIf leftInitializer.Parent.Parent.IsKind(SyntaxKind.FieldDeclaration) Then
                ' field initializer or AsNewClause
                Dim leftDeclarator = DirectCast(leftInitializer.Parent, VariableDeclaratorSyntax)