Have code refactoring tests run in OOP mode by default

src/EditorFeatures/CSharpTest/CodeActions/InitializeParameter/AddParameterCheckTests.cs

@@ -7,7 +7,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.InitializeParameter;
-using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Testing;
@@ -18,6 +17,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.InitializeParameter
 {
     using VerifyCS = CSharpCodeRefactoringVerifier<CSharpAddParameterCheckCodeRefactoringProvider>;
 
+    [UseExportProvider]
     [Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
     public class AddParameterCheckTests
     {

src/EditorFeatures/CSharpTest/CodeActions/InlineMethod/CSharpInlineMethodTests.cs

@@ -14,6 +14,7 @@
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.InlineMethod
 {
+    [UseExportProvider]
     [Trait(Traits.Feature, Traits.Features.CodeActionsInlineMethod)]
     public class CSharpInlineMethodTests
     {

src/EditorFeatures/VisualBasicTest/CodeActions/InlineMethod/VisualBasicInlineMethodTests.vb

@@ -7,9 +7,10 @@ Imports Microsoft.CodeAnalysis.Testing
 Imports Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.InlineTemporary
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.InlineMethod
-
+    <UseExportProvider>
     <Trait(Traits.Feature, Traits.Features.CodeActionsInlineMethod)>
     Public Class VisualBasicInlineMethodTests
+        <UseExportProvider>
         Private Class TestVerifier
             Inherits VisualBasicCodeRefactoringVerifier(Of VisualBasicInlineMethodRefactoringProvider).Test
             Private Const Marker As String = "##"

src/Features/CSharpTest/AddDebuggerDisplay/AddDebuggerDisplayTests.cs

@@ -4,15 +4,17 @@
 
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.AddDebuggerDisplay;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Testing;
 using Xunit;
-using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeRefactoringVerifier<
-    Microsoft.CodeAnalysis.CSharp.AddDebuggerDisplay.CSharpAddDebuggerDisplayCodeRefactoringProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.AddDebuggerDisplay
 {
+    using VerifyCS = CSharpCodeRefactoringVerifier<CSharpAddDebuggerDisplayCodeRefactoringProvider>;
+
+    [UseExportProvider]
     [Trait(Traits.Feature, Traits.Features.CodeActionsAddDebuggerDisplay)]
     public sealed class AddDebuggerDisplayTests
     {

src/Features/CSharpTest/ConvertCast/ConvertDirectCastToTryCastTests.cs

@@ -14,6 +14,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertConversionOperat
 {
     using VerifyCS = CSharpCodeRefactoringVerifier<CSharpConvertDirectCastToTryCastCodeRefactoringProvider>;
 
+    [UseExportProvider]
     [Trait(Traits.Feature, Traits.Features.ConvertCast)]
     public class ConvertDirectCastToTryCastTests
     {

src/Features/CSharpTest/ConvertCast/ConvertTryCastToDirectCastTests.cs

@@ -14,6 +14,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertConversionOperat
 {
     using VerifyCS = CSharpCodeRefactoringVerifier<CSharpConvertTryCastToDirectCastCodeRefactoringProvider>;
 
+    [UseExportProvider]
     [Trait(Traits.Feature, Traits.Features.ConvertCast)]
     public class ConvertTryCastToDirectCastTests
     {

src/Features/CSharpTest/ConvertIfToSwitch/ConvertIfToSwitchTests.cs

@@ -16,6 +16,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeActions.ConvertIfTo
 {
     using VerifyCS = CSharpCodeRefactoringVerifier<CSharpConvertIfToSwitchCodeRefactoringProvider>;
 
+    [UseExportProvider]
     [Trait(Traits.Feature, Traits.Features.CodeActionsConvertIfToSwitch)]
     public class ConvertIfToSwitchTests
     {

src/Features/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs

@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.ConvertNamespace;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Testing;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -17,6 +18,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertNamespace
 {
     using VerifyCS = CSharpCodeRefactoringVerifier<ConvertNamespaceCodeRefactoringProvider>;
 
+    [UseExportProvider]
     public class ConvertNamespaceRefactoringTests
     {
         public static IEnumerable<object[]> EndOfDocumentSequences

src/Features/CSharpTest/ConvertPrimaryToRegularConstructor/ConvertPrimaryToRegularConstructorTests.cs

@@ -6,13 +6,15 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.ConvertPrimaryToRegularConstructor;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Testing;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertPrimaryToRegularConstructor;
 
 using VerifyCS = CSharpCodeRefactoringVerifier<ConvertPrimaryToRegularConstructorCodeRefactoringProvider>;
 
+[UseExportProvider]
 public class ConvertPrimaryToRegularConstructorTests
 {
     private const string FieldNamesCamelCaseWithFieldUnderscorePrefixEditorConfig = """

src/Features/CSharpTest/ConvertProgram/ConvertToProgramMainRefactoringTests.cs

@@ -8,13 +8,15 @@
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.ConvertProgram;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Testing;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertProgram
 {
     using VerifyCS = CSharpCodeRefactoringVerifier<ConvertToProgramMainCodeRefactoringProvider>;
 
+    [UseExportProvider]
     public class ConvertToProgramMainRefactoringTests
     {
         [Fact]

src/Features/CSharpTest/ConvertProgram/ConvertToTopLevelStatementsRefactoringTests.cs

@@ -8,13 +8,15 @@
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.ConvertProgram;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Testing;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertProgram
 {
     using VerifyCS = CSharpCodeRefactoringVerifier<ConvertToTopLevelStatementsCodeRefactoringProvider>;
 
+    [UseExportProvider]
     public class ConvertToTopLevelStatementsRefactoringTests
     {
         [Fact]

src/Features/CSharpTest/ConvertToInterpolatedString/ConvertConcatenationToInterpolatedStringTests.cs

@@ -15,6 +15,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertToInterpolatedSt
 
 using VerifyCS = CSharpCodeRefactoringVerifier<CSharpConvertConcatenationToInterpolatedStringRefactoringProvider>;
 
+[UseExportProvider]
 [Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)]
 public class ConvertConcatenationToInterpolatedStringTests
 {

src/Features/CSharpTest/ConvertToRawString/ConvertInterpolatedStringToRawStringTests.cs

@@ -14,6 +14,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertToRawString;
 using VerifyCS = CSharpCodeRefactoringVerifier<
     ConvertStringToRawStringCodeRefactoringProvider>;
 
+[UseExportProvider]
 [Trait(Traits.Feature, Traits.Features.CodeActionsConvertToRawString)]
 public class ConvertInterpolatedStringToRawStringTests
 {

src/Features/CSharpTest/ConvertToRawString/ConvertRegularStringToRawStringTests.cs

@@ -14,6 +14,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertToRawString
     using VerifyCS = CSharpCodeRefactoringVerifier<
         ConvertStringToRawStringCodeRefactoringProvider>;
 
+    [UseExportProvider]
     [Trait(Traits.Feature, Traits.Features.CodeActionsConvertToRawString)]
     public class ConvertRegularStringToRawStringTests
     {

src/Features/CSharpTest/ConvertTupleToStruct/ConvertTupleToStructTests.cs

@@ -10,12 +10,10 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.ConvertTupleToStruct;
-using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.NamingStyles;
 using Microsoft.CodeAnalysis.Remote.Testing;
-using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Testing;
 using Roslyn.Test.Utilities;

src/Features/CSharpTest/EnableNullable/EnableNullableTests.cs

@@ -9,15 +9,19 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.CodeRefactorings.EnableNullable;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Testing;
 using Roslyn.Utilities;
 using Xunit;
-using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeRefactoringVerifier<
-    Microsoft.CodeAnalysis.CSharp.CodeRefactorings.EnableNullable.EnableNullableCodeRefactoringProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeActions.EnableNullable
 {
+    using VerifyCS = CSharpCodeRefactoringVerifier<EnableNullableCodeRefactoringProvider>;
+
+    [UseExportProvider]
     public class EnableNullableTests
     {
         private static readonly Func<Solution, ProjectId, Solution> s_enableNullableInFixedSolution =

src/Features/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs

@@ -22,6 +22,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.GenerateDefaultConstruc
     using VerifyRefactoring = CSharpCodeRefactoringVerifier<
         GenerateDefaultConstructorsCodeRefactoringProvider>;
 
+    [UseExportProvider]
     public class GenerateDefaultConstructorsTests
     {
         private static async Task TestRefactoringAsync(string source, string fixedSource, int index = 0)

src/Features/CSharpTest/GenerateFromMembers/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersTests.cs

@@ -14,6 +14,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.GenerateFromMembers.Add
 {
     using VerifyCS = CSharpCodeRefactoringVerifier<AddConstructorParametersFromMembersCodeRefactoringProvider>;
 
+    [UseExportProvider]
     [Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)]
     public class AddConstructorParametersFromMembersTests
     {

src/Features/CSharpTest/ReplaceConditionalWithStatements/ReplaceConditionalWithStatementsTests.cs

@@ -2,19 +2,17 @@
 // 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;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.ReplaceConditionalWithStatements;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ReplaceConditionalWithStatements;
 
 using VerifyCS = CSharpCodeRefactoringVerifier<CSharpReplaceConditionalWithStatementsCodeRefactoringProvider>;
 
+[UseExportProvider]
 public class ReplaceConditionalWithStatementsTests
 {
     [Fact]

src/Features/CSharpTest/UseNamedArguments/UseNamedArgumentsTests.cs

@@ -15,6 +15,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseNamedArguments
 {
     using VerifyCS = CSharpCodeRefactoringVerifier<CSharpUseNamedArgumentsCodeRefactoringProvider>;
 
+    [UseExportProvider]
     [Trait(Traits.Feature, Traits.Features.CodeActionsUseNamedArguments)]
     public class UseNamedArgumentsTests
     {

src/Features/CSharpTest/UseRecursivePatterns/UseRecursivePatternsRefactoringTests.cs

@@ -14,6 +14,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.UseRec
 {
     using VerifyCS = CSharpCodeRefactoringVerifier<UseRecursivePatternsCodeRefactoringProvider>;
 
+    [UseExportProvider]
     [Trait(Traits.Feature, Traits.Features.CodeActionsUseRecursivePatterns)]
     public class UseRecursivePatternsRefactoringTests
     {

src/Features/DiagnosticsTestUtilities/CodeActions/CSharpCodeRefactoringVerifier`1+Test.cs

@@ -118,9 +118,9 @@ protected override CodeRefactoringContext CreateCodeRefactoringContext(Document
                 => new CodeRefactoringContext(document, span, (action, textSpan) => registerRefactoring(action), _sharedState.CodeActionOptions, cancellationToken);
 
             /// <summary>
-            /// The <see cref="TestHost"/> we want this test to run in.  Defaults to <see cref="TestHost.InProcess"/> if unspecified.
+            /// The <see cref="TestHost"/> we want this test to run in.  Defaults to <see cref="TestHost.OutOfProcess"/> if unspecified.
             /// </summary>
-            public TestHost TestHost { get; set; } = TestHost.InProcess;
+            public TestHost TestHost { get; set; } = TestHost.OutOfProcess;
 
             private static readonly TestComposition s_editorFeaturesOOPComposition = FeaturesTestCompositions.Features.WithTestHostParts(TestHost.OutOfProcess);
 

src/Features/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeRefactoringVerifier`1+Test.cs

@@ -104,9 +104,10 @@ protected override CodeRefactoringContext CreateCodeRefactoringContext(Document
                 => new CodeRefactoringContext(document, span, (action, textSpan) => registerRefactoring(action), _sharedState.CodeActionOptions, cancellationToken);
 
             /// <summary>
-            /// The <see cref="TestHost"/> we want this test to run in.  Defaults to <see cref="TestHost.InProcess"/> if unspecified.
+            /// The <see cref="TestHost"/> we want this test to run in.  Defaults to <see cref="TestHost.OutOfProcess"/>
+            /// if unspecified.
             /// </summary>
-            public TestHost TestHost { get; set; } = TestHost.InProcess;
+            public TestHost TestHost { get; set; } = TestHost.OutOfProcess;
 
             private static readonly TestComposition s_editorFeaturesOOPComposition = FeaturesTestCompositions.Features.WithTestHostParts(TestHost.OutOfProcess);
 

src/Features/VisualBasicTest/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersTests.vb

@@ -8,6 +8,7 @@ Imports VerifyVB = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.VisualBas
     Microsoft.CodeAnalysis.AddConstructorParametersFromMembers.AddConstructorParametersFromMembersCodeRefactoringProvider)
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.AddConstructorParametersFromMembers
+    <UseExportProvider>
     <Trait(Traits.Feature, Traits.Features.CodeActionsAddConstructorParametersFromMembers)>
     Public Class AddConstructorParametersFromMembersTests
         <Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530592")>

src/Features/VisualBasicTest/AddDebuggerDisplay/AddDebuggerDisplayTests.vb

@@ -6,7 +6,7 @@ Imports VerifyVB = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.VisualBas
     Microsoft.CodeAnalysis.VisualBasic.AddDebuggerDisplay.VisualBasicAddDebuggerDisplayCodeRefactoringProvider)
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.AddDebuggerDisplay
-
+    <UseExportProvider>
     <Trait(Traits.Feature, Traits.Features.CodeActionsAddDebuggerDisplay)>
     Public NotInheritable Class AddDebuggerDisplayTests
         <Fact>

src/Features/VisualBasicTest/ConvertCast/ConvertDirectCastToTryCastTests.vb

@@ -7,9 +7,9 @@ Imports VerifyVB = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.VisualBas
     Microsoft.CodeAnalysis.VisualBasic.ConvertCast.VisualBasicConvertDirectCastToTryCastCodeRefactoringProvider)
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ConvertCast
+    <UseExportProvider>
     <Trait(Traits.Feature, Traits.Features.ConvertCast)>
     Public Class ConvertDirectCastToTryCastTests
-
         <Fact>
         Public Async Function ConvertFromDirectCastToTryCast() As Task
             Dim markup = "

src/Features/VisualBasicTest/ConvertCast/ConvertTryCastToDirectCastTests.vb

@@ -6,9 +6,9 @@ Imports VerifyVB = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.VisualBas
     Microsoft.CodeAnalysis.VisualBasic.ConvertConversionOperators.VisualBasicConvertTryCastToDirectCastCodeRefactoringProvider)
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ConvertCast
+    <UseExportProvider>
     <Trait(Traits.Feature, Traits.Features.ConvertCast)>
     Public Class ConvertTryCastToDirectCastTests
-
         <Fact>
         Public Async Function ConvertFromTryCastToDirectCast() As Task
             Dim markup =

src/Features/VisualBasicTest/ConvertToInterpolatedString/ConvertConcatenationToInterpolatedStringTests.vb

@@ -6,6 +6,7 @@ Imports VerifyVB = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.VisualBas
     Microsoft.CodeAnalysis.VisualBasic.ConvertToInterpolatedString.VisualBasicConvertConcatenationToInterpolatedStringRefactoringProvider)
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ConvertToInterpolatedString
+    <UseExportProvider>
     <Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)>
     Public Class ConvertConcatenationToInterpolatedStringTests
         <Fact>

src/Features/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb

@@ -13,11 +13,12 @@ Imports VerifyRefactoring = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.
         Microsoft.CodeAnalysis.GenerateDefaultConstructors.GenerateDefaultConstructorsCodeRefactoringProvider)
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.GenerateDefaultConstructors
+    <UseExportProvider>
     Public Class GenerateDefaultConstructorsTests
 
         Private Shared Async Function TestRefactoringAsync(source As String, fixedSource As String, Optional index As Integer = 0) As Task
             Await TestRefactoringOnlyAsync(source, fixedSource, index)
-            await TestCodeFixMissingAsync(source)
+            Await TestCodeFixMissingAsync(source)
         End Function
 
         Private Shared Async Function TestRefactoringOnlyAsync(source As String, fixedSource As String, Optional index As Integer = 0) As Task

src/Features/VisualBasicTest/IntroduceParameter/IntroduceParameterTests.vb

@@ -11,6 +11,7 @@ Imports VerifyVB = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.VisualBas
     Microsoft.CodeAnalysis.VisualBasic.IntroduceParameter.VisualBasicIntroduceParameterCodeRefactoringProvider)
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.IntroduceParameter
+    <UseExportProvider>
     <Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceParameter)>
     Public Class IntroduceParameterTests
         <Fact>

src/Features/VisualBasicTest/ReplaceConditionalWithStatements/ReplaceConditionalWithStatementsTests.vb

@@ -15,7 +15,7 @@ Imports VerifyVB = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.VisualBas
     Microsoft.CodeAnalysis.VisualBasic.ReplaceConditionalWithStatements.VisualBasicReplaceConditionalWithStatementsCodeRefactoringProvider)
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ReplaceConditionalWithStatements
-
+    <UseExportProvider>
     Public Class ReplaceConditionalWithStatementsTests
         <Fact>
         Public Async Function TestAssignment_ObjectType() As Task

src/Workspaces/Core/Portable/Serialization/SerializerService_Reference.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Reflection.Metadata;
 using System.Threading;
@@ -37,6 +38,12 @@ private static bool TryGetAnalyzerImageReferenceGuid(AnalyzerImageReference imag
             return s_analyzerImageReferenceMap.TryGetValue(imageReference, out guid);
     }
 
+    private static bool TryGetAnalyzerImageReferenceFromGuid(Guid guid, [NotNullWhen(true)] out AnalyzerImageReference? imageReference)
+    {
+        lock (s_analyzerImageReferenceMapGate)
+            return s_analyzerImageReferenceMap.TryGetKey(guid, out imageReference);
+    }
+
     public static Checksum CreateChecksum(MetadataReference reference, CancellationToken cancellationToken)
     {
         if (reference is PortableExecutableReference portable)
@@ -145,11 +152,8 @@ public virtual AnalyzerReference ReadAnalyzerReferenceFrom(ObjectReader reader,
 
             case nameof(AnalyzerImageReference):
                 var guid = reader.ReadGuid();
-                lock (s_analyzerImageReferenceMapGate)
-                {
-                    Contract.ThrowIfFalse(s_analyzerImageReferenceMap.TryGetKey(guid, out var analyzerImageReference));
-                    return analyzerImageReference;
-                }
+                Contract.ThrowIfFalse(TryGetAnalyzerImageReferenceFromGuid(guid, out var analyzerImageReference));
+                return analyzerImageReference;
         }
 
         throw ExceptionUtilities.UnexpectedValue(type);