EnC analyzer constructor cleanup

tmat · tmat · commit 3f4d5a497d9c · 2024-11-22T13:03:12.000-08:00
diff --git a/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs b/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs
@@ -15,8 +15,6 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Differencing;
 using Microsoft.CodeAnalysis.EditAndContinue;
-using Microsoft.CodeAnalysis.Formatting;
-using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Collections;
@@ -26,17 +24,11 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue;
 
-internal sealed class CSharpEditAndContinueAnalyzer(Action<SyntaxNode>? testFaultInjector = null) : AbstractEditAndContinueAnalyzer(testFaultInjector)
+[ExportLanguageService(typeof(IEditAndContinueAnalyzer), LanguageNames.CSharp), Shared]
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed class CSharpEditAndContinueAnalyzer() : AbstractEditAndContinueAnalyzer
 {
-    [ExportLanguageServiceFactory(typeof(IEditAndContinueAnalyzer), LanguageNames.CSharp), Shared]
-    [method: ImportingConstructor]
-    [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-    internal sealed class Factory() : ILanguageServiceFactory
-    {
-        public ILanguageService CreateLanguageService(HostLanguageServices languageServices)
-            => new CSharpEditAndContinueAnalyzer(testFaultInjector: null);
-    }
-
     #region Syntax Analysis
 
     private enum BlockPart
diff --git a/src/Features/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs b/src/Features/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs
@@ -122,7 +122,7 @@ private static async Task<DocumentAnalysisResults> AnalyzeDocumentAsync(
         EditAndContinueCapabilities capabilities = EditAndContinueTestVerifier.Net5RuntimeCapabilities,
         ImmutableArray<ActiveStatementLineSpan> newActiveStatementSpans = default)
     {
-        var analyzer = new CSharpEditAndContinueAnalyzer();
+        var analyzer = EditAndContinueTestVerifier.CreateAnalyzer(faultInjector: null, LanguageNames.CSharp);
         var baseActiveStatements = AsyncLazy.Create(activeStatementMap ?? ActiveStatementsMap.Empty);
         var lazyCapabilities = AsyncLazy.Create(capabilities);
         return await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, newActiveStatementSpans.NullToEmpty(), lazyCapabilities, CancellationToken.None);
@@ -749,13 +749,13 @@ public async Task AnalyzeDocumentAsync_InternalError(bool outOfMemory)
         var baseActiveStatements = AsyncLazy.Create(ActiveStatementsMap.Empty);
         var capabilities = AsyncLazy.Create(EditAndContinueTestVerifier.Net5RuntimeCapabilities);
 
-        var analyzer = new CSharpEditAndContinueAnalyzer(node =>
+        var analyzer = EditAndContinueTestVerifier.CreateAnalyzer(faultInjector: node =>
         {
             if (node is CompilationUnitSyntax)
             {
                 throw outOfMemory ? new OutOfMemoryException() : new NullReferenceException("NullRef!");
             }
-        });
+        }, LanguageNames.CSharp);
 
         var result = await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, [], capabilities, CancellationToken.None);
 
diff --git a/src/Features/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestVerifier.cs b/src/Features/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestVerifier.cs
@@ -6,17 +6,13 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.Differencing;
-using Microsoft.CodeAnalysis.EditAndContinue;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests;
 
-internal sealed class CSharpEditAndContinueTestVerifier(Action<SyntaxNode>? faultInjector = null) : EditAndContinueTestVerifier
+internal sealed class CSharpEditAndContinueTestVerifier(Action<SyntaxNode>? faultInjector = null) : EditAndContinueTestVerifier(faultInjector)
 {
-    private readonly CSharpEditAndContinueAnalyzer _analyzer = new(faultInjector);
-
-    public override AbstractEditAndContinueAnalyzer Analyzer => _analyzer;
     public override string LanguageName => LanguageNames.CSharp;
     public override string ProjectFileExtension => ".csproj";
     public override TreeComparer<SyntaxNode> TopSyntaxComparer => SyntaxComparer.TopLevel;
diff --git a/src/Features/CSharpTest/EditAndContinue/Helpers/EditAndContinueValidation.cs b/src/Features/CSharpTest/EditAndContinue/Helpers/EditAndContinueValidation.cs
@@ -2,9 +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.
 
-using Microsoft.CodeAnalysis.Differencing;
-using Microsoft.CodeAnalysis.EditAndContinue;
 using Microsoft.CodeAnalysis.Contracts.EditAndContinue;
+using Microsoft.CodeAnalysis.EditAndContinue;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
 using Roslyn.Test.Utilities;
 using Xunit;
diff --git a/src/Features/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs b/src/Features/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs
@@ -17,6 +17,8 @@
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 using Xunit;
+using Microsoft.CodeAnalysis.Host.Mef;
+using System.Linq;
 
 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests;
 
@@ -27,11 +29,6 @@ public abstract class EditingTestBase : CSharpTestBase
 namespace System.Runtime.CompilerServices { class CreateNewOnMetadataUpdateAttribute : Attribute {} }
 ";
 
-    internal static CSharpEditAndContinueAnalyzer CreateAnalyzer()
-    {
-        return new CSharpEditAndContinueAnalyzer(testFaultInjector: null);
-    }
-
     internal enum MethodKind
     {
         Regular,
@@ -184,7 +181,8 @@ 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 EditAndContinueTestVerifier.GetMethodMatches(CreateAnalyzer(), methodMatch);
+        var analyzer = EditAndContinueTestVerifier.CreateAnalyzer(faultInjector: null, LanguageNames.CSharp);
+        return EditAndContinueTestVerifier.GetMethodMatches(analyzer, methodMatch);
     }
 
     public static MatchingPairs ToMatchingPairs(Match<SyntaxNode> match)
diff --git a/src/Features/CSharpTest/EditAndContinue/StatementMatchingTests.cs b/src/Features/CSharpTest/EditAndContinue/StatementMatchingTests.cs
@@ -7,11 +7,13 @@
 using System.Collections.Generic;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests;
 
+[UseExportProvider]
 public class StatementMatchingTests : EditingTestBase
 {
     #region Known Matches
diff --git a/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs b/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
@@ -69,12 +69,7 @@ internal abstract class AbstractEditAndContinueAnalyzer : IEditAndContinueAnalyz
                 SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
 
     // used by tests to validate correct handlign of unexpected exceptions
-    private readonly Action<SyntaxNode>? _testFaultInjector;
-
-    protected AbstractEditAndContinueAnalyzer(Action<SyntaxNode>? testFaultInjector)
-    {
-        _testFaultInjector = testFaultInjector;
-    }
+    private Action<SyntaxNode>? _testFaultInjector;
 
     private static TraceLog Log
         => EditAndContinueService.AnalysisLog;
@@ -6779,19 +6774,23 @@ private static bool HasGetHashCodeSignature(IMethodSymbol method)
     internal TestAccessor GetTestAccessor()
         => new(this);
 
-    internal readonly struct TestAccessor(AbstractEditAndContinueAnalyzer abstractEditAndContinueAnalyzer)
+    internal readonly struct TestAccessor(AbstractEditAndContinueAnalyzer analyzer)
     {
-        private readonly AbstractEditAndContinueAnalyzer _abstractEditAndContinueAnalyzer = abstractEditAndContinueAnalyzer;
+        internal Action<SyntaxNode>? FaultInjector
+        {
+            get => analyzer._testFaultInjector = FaultInjector;
+            set => analyzer._testFaultInjector = value;
+        }
 
         internal void ReportTopLevelSyntacticRudeEdits(ArrayBuilder<RudeEditDiagnostic> diagnostics, EditScript<SyntaxNode> syntacticEdits, Dictionary<SyntaxNode, EditKind> editMap)
-            => _abstractEditAndContinueAnalyzer.ReportTopLevelSyntacticRudeEdits(diagnostics, syntacticEdits, editMap);
+            => analyzer.ReportTopLevelSyntacticRudeEdits(diagnostics, syntacticEdits, editMap);
 
         internal DeclarationBodyMap IncludeLambdaBodyMaps(
             DeclarationBodyMap bodyMap,
             ArrayBuilder<ActiveNode> memberBodyActiveNodes,
             ref Dictionary<LambdaBody, LambdaInfo>? lazyActiveOrMatchedLambdas)
         {
-            return _abstractEditAndContinueAnalyzer.IncludeLambdaBodyMaps(bodyMap, memberBodyActiveNodes, ref lazyActiveOrMatchedLambdas);
+            return analyzer.IncludeLambdaBodyMaps(bodyMap, memberBodyActiveNodes, ref lazyActiveOrMatchedLambdas);
         }
     }
 
diff --git a/src/Features/TestUtilities/EditAndContinue/EditAndContinueTestVerifier.cs b/src/Features/TestUtilities/EditAndContinue/EditAndContinueTestVerifier.cs
@@ -18,6 +18,7 @@
 using Roslyn.Utilities;
 using Xunit;
 using static Microsoft.CodeAnalysis.EditAndContinue.AbstractEditAndContinueAnalyzer;
+using Microsoft.CodeAnalysis.Host.Mef;
 
 namespace Microsoft.CodeAnalysis.EditAndContinue.UnitTests
 {
@@ -44,14 +45,27 @@ internal abstract class EditAndContinueTestVerifier
             EditAndContinueCapabilities.GenericUpdateMethod |
             EditAndContinueCapabilities.GenericAddFieldToExistingType;
 
-        public abstract AbstractEditAndContinueAnalyzer Analyzer { get; }
+        public AbstractEditAndContinueAnalyzer Analyzer { get; }
+
+        protected EditAndContinueTestVerifier(Action<SyntaxNode>? faultInjector)
+        {
+            Analyzer = CreateAnalyzer(faultInjector, LanguageName);
+        }
 
         public abstract ImmutableArray<SyntaxNode> GetDeclarators(ISymbol method);
         public abstract string LanguageName { get; }
         public abstract string ProjectFileExtension { get; }
         public abstract TreeComparer<SyntaxNode> TopSyntaxComparer { get; }
         public abstract string? TryGetResource(string keyword);
 
+        internal static AbstractEditAndContinueAnalyzer CreateAnalyzer(Action<SyntaxNode>? faultInjector, string languageName)
+        {
+            var exportProvider = FeaturesTestCompositions.Features.ExportProviderFactory.CreateExportProvider();
+            var analyzer = (AbstractEditAndContinueAnalyzer)exportProvider.GetExports<IEditAndContinueAnalyzer, LanguageMetadata>().Single(e => e.Metadata.Language == languageName).Value;
+            analyzer.GetTestAccessor().FaultInjector = faultInjector;
+            return analyzer;
+        }
+
         private void VerifyDocumentActiveStatementsAndExceptionRegions(
             ActiveStatementsDescription description,
             SyntaxTree oldTree,
diff --git a/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb b/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb
@@ -16,26 +16,13 @@ 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
 
-        <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(testFaultInjector:=Nothing)
-            End Function
-        End Class
-
-        ' Public for testing purposes
-        Public Sub New(Optional testFaultInjector As Action(Of SyntaxNode) = Nothing)
-            MyBase.New(testFaultInjector)
+        <ImportingConstructor>
+        <Obsolete(MefConstruction.ImportingConstructorMessage, True)>
+        Public Sub New()
         End Sub
 
 #Region "Syntax Analysis"
diff --git a/src/Features/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb b/src/Features/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb
@@ -28,11 +28,6 @@ Namespace System.Runtime.CompilerServices
     End Class
 End Namespace
 "
-
-        Friend Shared Function CreateAnalyzer() As VisualBasicEditAndContinueAnalyzer
-            Return New VisualBasicEditAndContinueAnalyzer()
-        End Function
-
         Public Enum MethodKind
             Regular
             Async
@@ -249,7 +244,8 @@ End Namespace
                                                 src2 As String,
                                                 Optional kind As MethodKind = MethodKind.Regular) As IEnumerable(Of KeyValuePair(Of SyntaxNode, SyntaxNode))
             Dim methodMatch = GetMethodMatch(src1, src2, kind)
-            Return EditAndContinueTestVerifier.GetMethodMatches(CreateAnalyzer(), methodMatch)
+            Dim analyzer = EditAndContinueTestVerifier.CreateAnalyzer(faultInjector:=Nothing, LanguageNames.VisualBasic)
+            Return EditAndContinueTestVerifier.GetMethodMatches(analyzer, methodMatch)
         End Function
 
         Public Shared Function ToMatchingPairs(match As Match(Of SyntaxNode)) As MatchingPairs
diff --git a/src/Features/VisualBasicTest/EditAndContinue/Helpers/VisualBasicEditAndContinueTestVerifier.vb b/src/Features/VisualBasicTest/EditAndContinue/Helpers/VisualBasicEditAndContinueTestVerifier.vb
@@ -3,30 +3,21 @@
 ' See the LICENSE file in the project root for more information.
 
 Imports System.Collections.Immutable
-Imports Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
-Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
-Imports Microsoft.CodeAnalysis.EditAndContinue
-Imports Microsoft.CodeAnalysis.EditAndContinue.UnitTests
 Imports Microsoft.CodeAnalysis.Differencing
+Imports Microsoft.CodeAnalysis.EditAndContinue.UnitTests
+Imports Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
 Imports Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests
+Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EditAndContinue
 
     Friend NotInheritable Class VisualBasicEditAndContinueTestVerifier
         Inherits EditAndContinueTestVerifier
 
-        Private ReadOnly _analyzer As VisualBasicEditAndContinueAnalyzer
-
-        Public Sub New(Optional faultInjector As Action(Of SyntaxNode) = Nothing)
-            _analyzer = New VisualBasicEditAndContinueAnalyzer(faultInjector)
+        Public Sub New()
+            MyBase.New(faultInjector:=Nothing)
         End Sub
 
-        Public Overrides ReadOnly Property Analyzer As AbstractEditAndContinueAnalyzer
-            Get
-                Return _analyzer
-            End Get
-        End Property
-
         Public Overrides ReadOnly Property LanguageName As String
             Get
                 Return LanguageNames.VisualBasic
diff --git a/src/Features/VisualBasicTest/EditAndContinue/VisualBasicEditAndContinueAnalyzerTests.vb b/src/Features/VisualBasicTest/EditAndContinue/VisualBasicEditAndContinueAnalyzerTests.vb
@@ -120,7 +120,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests
         End Sub
 
         Private Shared Async Function AnalyzeDocumentAsync(oldProject As Project, newDocument As Document, Optional activeStatementMap As ActiveStatementsMap = Nothing) As Task(Of DocumentAnalysisResults)
-            Dim analyzer = New VisualBasicEditAndContinueAnalyzer()
+            Dim analyzer = EditAndContinueTestVerifier.CreateAnalyzer(faultInjector:=Nothing, LanguageNames.VisualBasic)
             Dim baseActiveStatements = AsyncLazy.Create(If(activeStatementMap, ActiveStatementsMap.Empty))
             Dim capabilities = AsyncLazy.Create(EditAndContinueTestVerifier.Net5RuntimeCapabilities)
             Return Await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, ImmutableArray(Of ActiveStatementLineSpan).Empty, capabilities, CancellationToken.None)

Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ private static async Task<DocumentAnalysisResults> AnalyzeDocumentAsync(`
`122`	`122`	`EditAndContinueCapabilities capabilities = EditAndContinueTestVerifier.Net5RuntimeCapabilities,`
`123`	`123`	`ImmutableArray<ActiveStatementLineSpan> newActiveStatementSpans = default)`
`124`	`124`	`{`
`125`		`- var analyzer = new CSharpEditAndContinueAnalyzer();`
	`125`	`+ var analyzer = EditAndContinueTestVerifier.CreateAnalyzer(faultInjector: null, LanguageNames.CSharp);`
`126`	`126`	`var baseActiveStatements = AsyncLazy.Create(activeStatementMap ?? ActiveStatementsMap.Empty);`
`127`	`127`	`var lazyCapabilities = AsyncLazy.Create(capabilities);`
`128`	`128`	`return await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, newActiveStatementSpans.NullToEmpty(), lazyCapabilities, CancellationToken.None);`
`@@ -749,13 +749,13 @@ public async Task AnalyzeDocumentAsync_InternalError(bool outOfMemory)`
`749`	`749`	`var baseActiveStatements = AsyncLazy.Create(ActiveStatementsMap.Empty);`
`750`	`750`	`var capabilities = AsyncLazy.Create(EditAndContinueTestVerifier.Net5RuntimeCapabilities);`
`751`	`751`
`752`		`- var analyzer = new CSharpEditAndContinueAnalyzer(node =>`
	`752`	`+ var analyzer = EditAndContinueTestVerifier.CreateAnalyzer(faultInjector: node =>`
`753`	`753`	`{`
`754`	`754`	`if (node is CompilationUnitSyntax)`
`755`	`755`	`{`
`756`	`756`	`throw outOfMemory ? new OutOfMemoryException() : new NullReferenceException("NullRef!");`
`757`	`757`	`}`
`758`		`- });`
	`758`	`+ }, LanguageNames.CSharp);`
`759`	`759`
`760`	`760`	`var result = await analyzer.AnalyzeDocumentAsync(oldProject, baseActiveStatements, newDocument, [], capabilities, CancellationToken.None);`
`761`	`761`