Merge pull request #45004 from sharwell/use-mef-2

Use IActiveStatementSpanTrackerFactory through MEF

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);

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

@@ -18,7 +18,10 @@ namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests
 {
     public abstract class EditingTestBase : CSharpTestBase
     {
-        internal static readonly CSharpEditAndContinueAnalyzer Analyzer = new CSharpEditAndContinueAnalyzer();
+        internal static CSharpEditAndContinueAnalyzer CreateAnalyzer()
+        {
+            return new CSharpEditAndContinueAnalyzer(new TestActiveStatementSpanTracker());
+        }
 
         internal enum MethodKind
         {
@@ -43,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)
         {
@@ -72,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);
@@ -88,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)
@@ -141,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

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

@@ -20,7 +20,7 @@ internal static void VerifyUnchangedDocument(
             string source,
             ActiveStatementsDescription description)
         {
-            CSharpEditAndContinueTestHelpers.Instance.VerifyUnchangedDocument(
+            CSharpEditAndContinueTestHelpers.CreateInstance().VerifyUnchangedDocument(
                 ActiveStatementsDescription.ClearTags(source),
                 description.OldStatements,
                 description.OldTrackingSpans,
@@ -41,7 +41,7 @@ internal static void VerifyRudeDiagnostics(
             ActiveStatementsDescription description,
             params RudeEditDiagnosticDescription[] expectedDiagnostics)
         {
-            CSharpEditAndContinueTestHelpers.Instance.VerifyRudeDiagnostics(
+            CSharpEditAndContinueTestHelpers.CreateInstance().VerifyRudeDiagnostics(
                 editScript,
                 description,
                 expectedDiagnostics);
@@ -53,7 +53,7 @@ internal static void VerifyLineEdits(
             IEnumerable<string> expectedNodeUpdates,
             params RudeEditDiagnosticDescription[] expectedDiagnostics)
         {
-            CSharpEditAndContinueTestHelpers.Instance.VerifyLineEdits(
+            CSharpEditAndContinueTestHelpers.CreateInstance().VerifyLineEdits(
                 editScript,
                 expectedLineEdits,
                 expectedNodeUpdates,

src/EditorFeatures/CSharpTest/EditAndContinue/StatementEditingTests.cs

@@ -8377,7 +8377,7 @@ static IEnumerable<int> F()
 ";
             var edits = GetTopEdits(src1, src2);
 
-            CSharpEditAndContinueTestHelpers.Instance40.VerifySemantics(
+            CSharpEditAndContinueTestHelpers.CreateInstance40().VerifySemantics(
                 edits,
                 ActiveStatementsDescription.Empty,
                 null,
@@ -8417,7 +8417,7 @@ static IEnumerable<int> F()
 ";
             var edits = GetTopEdits(src1, src2);
 
-            CSharpEditAndContinueTestHelpers.Instance40.VerifySemantics(
+            CSharpEditAndContinueTestHelpers.CreateInstance40().VerifySemantics(
                 edits,
                 ActiveStatementsDescription.Empty,
                 null,

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

@@ -0,0 +1,57 @@
+// 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.EditAndContinue;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.EditAndContinue
+{
+    internal sealed class ActiveStatementSpanTrackerFactory : IActiveStatementSpanTrackerFactory
+    {
+        [ExportWorkspaceServiceFactory(typeof(IActiveStatementSpanTracker), ServiceLayer.Editor), Shared]
+        private sealed class Factory : IWorkspaceServiceFactory
+        {
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public Factory() { }
+
+            [Obsolete(MefConstruction.FactoryMethodMessage, error: true)]
+            public IWorkspaceService CreateService(HostWorkspaceServices services)
+                => new ActiveStatementSpanTrackerFactory(services);
+        }
+
+        private readonly IActiveStatementSpanTracker _tracker;
+
+        [Obsolete(MefConstruction.FactoryMethodMessage, error: true)]
+        public ActiveStatementSpanTrackerFactory(HostWorkspaceServices services)
+        {
+            _tracker = new Tracker(services.GetRequiredService<IActiveStatementTrackingService>());
+        }
+
+        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);
+        }
+    }
+}