Merge master to master-vs-deps

src/Analyzers/CSharp/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryExpressionParenthesesTests.cs

@@ -81,6 +81,20 @@ void M()
 }", new TestParameters(options: RequireArithmeticBinaryParenthesesForClarity));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryParentheses)]
+        [WorkItem(44629, "https://github.com/dotnet/roslyn/issues/44629")]
+        public async Task TestStackAlloc()
+        {
+            await TestMissingAsync(
+@"class C
+{
+    void M()
+    {
+        var span = $$(stackalloc byte[8]);
+    }
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryParentheses)]
         public async Task TestArithmeticRequiredForClarity2()
         {

src/EditorFeatures/CSharpTest/CodeActions/ConvertIfToSwitch/ConvertIfToSwitchTests.cs

@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Testing;
+using Microsoft.VisualStudio.Shell.Interop;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;
@@ -2539,5 +2540,59 @@ void M(int i)
                 CodeActionValidationMode = CodeActionValidationMode.None,
             }.RunAsync();
         }
+
+        [WorkItem(44278, "https://github.com/dotnet/roslyn/issues/44278")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertIfToSwitch)]
+        public async Task TestTopLevelStatement()
+        {
+            var source = @"
+var e = new ET1();
+
+[||]if (e == ET1.A)
+{
+}
+else if (e == ET1.C)
+{
+}
+
+enum ET1
+{
+    A,
+    B,
+    C,
+}";
+
+            var fixedSource = @"
+var e = new ET1();
+
+switch (e)
+{
+    case ET1.A:
+        break;
+    case ET1.C:
+        break;
+}
+
+enum ET1
+{
+    A,
+    B,
+    C,
+}";
+
+            var test = new VerifyCS.Test
+            {
+                TestCode = source,
+                FixedCode = fixedSource,
+                LanguageVersion = LanguageVersionExtensions.CSharp9,
+                CodeActionValidationMode = CodeActionValidationMode.None,
+            };
+
+            test.ExpectedDiagnostics.Add(
+                // error CS8805: Program using top-level statements must be an executable.
+                DiagnosticResult.CompilerError("CS8805"));
+
+            await test.RunAsync();
+        }
     }
 }

src/EditorFeatures/Core.Wpf/SymbolSearch/SymbolSearchUpdateEngineFactory.cs

@@ -31,11 +31,8 @@ public static async Task<ISymbolSearchUpdateEngine> CreateEngineAsync(
             if (client != null)
             {
                 var callbackObject = new CallbackObject(logService, progressService);
-                var session = await client.TryCreateKeepAliveSessionAsync(WellKnownServiceHubService.RemoteSymbolSearchUpdateEngine, callbackObject, cancellationToken).ConfigureAwait(false);
-                if (session != null)
-                {
-                    return new RemoteUpdateEngine(workspace, session);
-                }
+                var session = await client.CreateConnectionAsync(WellKnownServiceHubService.RemoteSymbolSearchUpdateEngine, callbackObject, cancellationToken).ConfigureAwait(false);
+                return new RemoteUpdateEngine(workspace, session);
             }
 
             // Couldn't go out of proc.  Just do everything inside the current process.
@@ -47,11 +44,11 @@ private sealed partial class RemoteUpdateEngine : ISymbolSearchUpdateEngine
             private readonly SemaphoreSlim _gate = new SemaphoreSlim(initialCount: 1);
 
             private readonly Workspace _workspace;
-            private readonly KeepAliveSession _session;
+            private readonly RemoteServiceConnection _session;
 
             public RemoteUpdateEngine(
                 Workspace workspace,
-                KeepAliveSession session)
+                RemoteServiceConnection session)
             {
                 _workspace = workspace;
                 _session = session;

src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindImplementations.cs

@@ -52,7 +52,7 @@ public static async Task FindImplementationsAsync(
                 // the 'progress' parameter which will then update the UI.
                 var serverCallback = new FindUsagesServerCallback(solution, context);
 
-                var success = await client.TryRunRemoteAsync(
+                await client.RunRemoteAsync(
                     WellKnownServiceHubService.CodeAnalysis,
                     nameof(IRemoteFindUsagesService.FindImplementationsAsync),
                     solution,
@@ -62,14 +62,13 @@ public static async Task FindImplementationsAsync(
                     },
                     serverCallback,
                     cancellationToken).ConfigureAwait(false);
-
-                if (success)
-                    return;
             }
-
-            // Couldn't effectively search in OOP. Perform the search in-process.
-            await FindImplementationsInCurrentProcessAsync(
-                symbol, project, context).ConfigureAwait(false);
+            else
+            {
+                // Couldn't effectively search in OOP. Perform the search in-process.
+                await FindImplementationsInCurrentProcessAsync(
+                    symbol, project, context).ConfigureAwait(false);
+            }
         }
 
         private static async Task FindImplementationsInCurrentProcessAsync(

src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs

@@ -149,7 +149,7 @@ public static async Task FindReferencesAsync(
                 // the 'progress' parameter which will then update the UI.
                 var serverCallback = new FindUsagesServerCallback(solution, context);
 
-                var success = await client.TryRunRemoteAsync(
+                await client.RunRemoteAsync(
                     WellKnownServiceHubService.CodeAnalysis,
                     nameof(IRemoteFindUsagesService.FindReferencesAsync),
                     solution,
@@ -160,14 +160,13 @@ public static async Task FindReferencesAsync(
                     },
                     serverCallback,
                     cancellationToken).ConfigureAwait(false);
-
-                if (success)
-                    return;
             }
-
-            // Couldn't effectively search in OOP. Perform the search in-process.
-            await FindReferencesInCurrentProcessAsync(
-                context, symbol, project, options).ConfigureAwait(false);
+            else
+            {
+                // Couldn't effectively search in OOP. Perform the search in-process.
+                await FindReferencesInCurrentProcessAsync(
+                    context, symbol, project, options).ConfigureAwait(false);
+            }
         }
 
         private static Task FindReferencesInCurrentProcessAsync(

src/EditorFeatures/TestUtilities/Remote/InProcRemostHostClient.cs

@@ -25,6 +25,7 @@ namespace Roslyn.Test.Utilities.Remote
 {
     internal sealed class InProcRemoteHostClient : RemoteHostClient, IRemoteHostServiceCallback
     {
+        private readonly HostWorkspaceServices _services;
         private readonly InProcRemoteServices _inprocServices;
         private readonly RemoteEndPoint _endPoint;
 
@@ -34,7 +35,7 @@ public static async Task<RemoteHostClient> CreateAsync(HostWorkspaceServices ser
 
             var remoteHostStream = await inprocServices.RequestServiceAsync(WellKnownServiceHubService.RemoteHost).ConfigureAwait(false);
 
-            var clientId = CreateClientId(Process.GetCurrentProcess().Id.ToString());
+            var clientId = $"InProc ({Guid.NewGuid()})";
             var instance = new InProcRemoteHostClient(clientId, services, inprocServices, remoteHostStream);
 
             // make sure connection is done right
@@ -58,9 +59,9 @@ private InProcRemoteHostClient(
             HostWorkspaceServices services,
             InProcRemoteServices inprocServices,
             Stream stream)
-            : base(services)
         {
             ClientId = clientId;
+            _services = services;
 
             _inprocServices = inprocServices;
 
@@ -76,14 +77,15 @@ public Task GetAssetsAsync(int scopeId, Checksum[] checksums, string pipeName, C
             => RemoteEndPoint.WriteDataToNamedPipeAsync(
                 pipeName,
                 (scopeId, checksums),
-                (writer, data, cancellationToken) => RemoteHostAssetSerialization.WriteDataAsync(writer, RemotableDataService, data.scopeId, data.checksums, cancellationToken),
+                (writer, data, cancellationToken) => RemoteHostAssetSerialization.WriteDataAsync(
+                    writer, _services.GetRequiredService<IRemotableDataService>(), data.scopeId, data.checksums, cancellationToken),
                 cancellationToken);
 
         /// <summary>
         /// Remote API.
         /// </summary>
         public Task<bool> IsExperimentEnabledAsync(string experimentName, CancellationToken cancellationToken)
-            => Task.FromResult(Services.GetRequiredService<IExperimentationService>().IsExperimentEnabled(experimentName));
+            => Task.FromResult(_services.GetRequiredService<IExperimentationService>().IsExperimentEnabled(experimentName));
 
         public AssetStorage AssetStorage => _inprocServices.AssetStorage;
 
@@ -95,14 +97,13 @@ public Task<Stream> RequestServiceAsync(RemoteServiceName serviceName)
 
         public override string ClientId { get; }
 
-        protected override async Task<Connection?> TryCreateConnectionAsync(
-            RemoteServiceName serviceName, object? callbackTarget, CancellationToken cancellationToken)
+        public override async Task<RemoteServiceConnection> CreateConnectionAsync(RemoteServiceName serviceName, object? callbackTarget, CancellationToken cancellationToken)
         {
             // get stream from service hub to communicate service specific information 
             // this is what consumer actually use to communicate information
             var serviceStream = await _inprocServices.RequestServiceAsync(serviceName).ConfigureAwait(false);
 
-            return new JsonRpcConnection(Services, _inprocServices.Logger, callbackTarget, serviceStream);
+            return new JsonRpcConnection(_services, _inprocServices.Logger, callbackTarget, serviceStream, poolReclamation: null);
         }
 
         public override void Dispose()

src/EditorFeatures/TestUtilities/Roslyn.Services.Test.Utilities.csproj

@@ -62,6 +62,9 @@
     <Compile Include="..\..\VisualStudio\Core\Def\Implementation\Remote\JsonRpcConnection.cs">
       <Link>Remote\JsonRpcConnection.cs</Link>
     </Compile>
+    <Compile Include="..\..\VisualStudio\Core\Def\Implementation\Remote\IPooledConnectionReclamation.cs">
+      <Link>Remote\IPooledConnectionReclamation.cs</Link>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests" />

src/Features/Core/Portable/AddImport/AbstractAddImportFeatureService.cs

@@ -59,7 +59,7 @@ public async Task<ImmutableArray<AddImportFixData>> GetFixesAsync(
             {
                 var callbackTarget = new RemoteSymbolSearchService(symbolSearchService);
 
-                var result = await client.TryRunRemoteAsync<IList<AddImportFixData>>(
+                var result = await client.RunRemoteAsync<IList<AddImportFixData>>(
                     WellKnownServiceHubService.CodeAnalysis,
                     nameof(IRemoteAddImportFeatureService.GetFixesAsync),
                     document.Project.Solution,
@@ -76,10 +76,7 @@ public async Task<ImmutableArray<AddImportFixData>> GetFixesAsync(
                     callbackTarget,
                     cancellationToken).ConfigureAwait(false);
 
-                if (result.HasValue)
-                {
-                    return result.Value.ToImmutableArray();
-                }
+                return result.ToImmutableArray();
             }
 
             return await GetFixesInCurrentProcessAsync(

src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ExtensionMethodImportCompletionHelper.cs

@@ -44,18 +44,15 @@ public static async Task<ImmutableArray<SerializableImportCompletionItem>> GetUn
                 var client = await RemoteHostClient.TryGetClientAsync(project, cancellationToken).ConfigureAwait(false);
                 if (client != null)
                 {
-                    var result = await client.TryRunRemoteAsync<(IList<SerializableImportCompletionItem> items, StatisticCounter counter)>(
+                    var result = await client.RunRemoteAsync<(IList<SerializableImportCompletionItem> items, StatisticCounter counter)>(
                         WellKnownServiceHubService.CodeAnalysis,
                         nameof(IRemoteExtensionMethodImportCompletionService.GetUnimportedExtensionMethodsAsync),
                         project.Solution,
                         new object[] { document.Id, position, SymbolKey.CreateString(receiverTypeSymbol), namespaceInScope.ToArray(), forceIndexCreation },
                         callbackTarget: null,
                         cancellationToken).ConfigureAwait(false);
 
-                    if (result.HasValue)
-                    {
-                        return (result.Value.items.ToImmutableArray(), result.Value.counter);
-                    }
+                    return (result.items.ToImmutableArray(), result.counter);
                 }
 
                 return await GetUnimportedExtensionMethodsInCurrentProcessAsync(document, position, receiverTypeSymbol, namespaceInScope, forceIndexCreation, cancellationToken).ConfigureAwait(false);

src/Features/Core/Portable/ConvertIfToSwitch/AbstractConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs

@@ -52,7 +52,7 @@ private async Task<Document> UpdateDocumentAsync(
 
             var nodesToRemove = sections.Skip(1).Select(s => s.SyntaxToRemove).Where(s => s.Parent == ifStatement.Parent);
             root = root.RemoveNodes(nodesToRemove, SyntaxRemoveOptions.KeepNoTrivia);
-            root = root.ReplaceNode(root.FindNode(ifSpan), @switch);
+            root = root.ReplaceNode(root.FindNode(ifSpan, getInnermostNodeForTie: true), @switch);
             return document.WithSyntaxRoot(root);
         }
 

src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs

@@ -167,7 +167,7 @@ public async Task<Solution> ConvertToStructAsync(
                 var client = await RemoteHostClient.TryGetClientAsync(solution.Workspace, cancellationToken).ConfigureAwait(false);
                 if (client != null)
                 {
-                    var resultOpt = await client.TryRunRemoteAsync<SerializableConvertTupleToStructResult>(
+                    var result = await client.RunRemoteAsync<SerializableConvertTupleToStructResult>(
                         WellKnownServiceHubService.CodeAnalysis,
                         nameof(IRemoteConvertTupleToStructCodeRefactoringProvider.ConvertToStructAsync),
                         solution,
@@ -180,14 +180,11 @@ public async Task<Solution> ConvertToStructAsync(
                         callbackTarget: null,
                         cancellationToken).ConfigureAwait(false);
 
-                    if (resultOpt.HasValue)
-                    {
-                        var result = resultOpt.Value;
-                        var resultSolution = await RemoteUtilities.UpdateSolutionAsync(
-                            solution, result.DocumentTextChanges, cancellationToken).ConfigureAwait(false);
-                        return await AddRenameTokenAsync(
-                            resultSolution, result.RenamedToken, cancellationToken).ConfigureAwait(false);
-                    }
+                    var resultSolution = await RemoteUtilities.UpdateSolutionAsync(
+                        solution, result.DocumentTextChanges, cancellationToken).ConfigureAwait(false);
+
+                    return await AddRenameTokenAsync(
+                        resultSolution, result.RenamedToken, cancellationToken).ConfigureAwait(false);
                 }
             }
 

src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs

@@ -91,7 +91,7 @@ private async Task FireAndForgetReportAnalyzerPerformanceAsync(Project project,
 
                 try
                 {
-                    _ = await client.TryRunRemoteAsync(
+                    await client.RunRemoteAsync(
                         WellKnownServiceHubService.CodeAnalysis,
                         nameof(IRemoteDiagnosticAnalyzerService.ReportAnalyzerPerformance),
                         solution: null,
@@ -128,16 +128,14 @@ private static async Task<DiagnosticAnalysisResultMap<DiagnosticAnalyzer, Diagno
                     forcedAnalysis, analyzerDriver.AnalysisOptions.ReportSuppressedDiagnostics, analyzerDriver.AnalysisOptions.LogAnalyzerExecutionTime,
                     project.Id, analyzerMap.Keys.ToArray());
 
-                var result = await client.TryRunRemoteAsync(
+                return await client.RunRemoteAsync(
                     WellKnownServiceHubService.CodeAnalysis,
                     nameof(IRemoteDiagnosticAnalyzerService.CalculateDiagnosticsAsync),
                     solution,
                     new object[] { argument },
                     callbackTarget: null,
                     (s, c) => ReadCompilerAnalysisResultAsync(s, analyzerMap, project, c),
                     cancellationToken).ConfigureAwait(false);
-
-                return result.HasValue ? result.Value : DiagnosticAnalysisResultMap<DiagnosticAnalyzer, DiagnosticAnalysisResult>.Empty;
             }
 
             private static async Task<DiagnosticAnalysisResultMap<DiagnosticAnalyzer, DiagnosticAnalysisResult>> ReadCompilerAnalysisResultAsync(Stream stream, Dictionary<string, DiagnosticAnalyzer> analyzerMap, Project project, CancellationToken cancellationToken)

src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_IncrementalAnalyzer.cs

@@ -545,7 +545,7 @@ private async Task ReportAnalyzerPerformanceAsync(Document document, Compilation
                     return;
                 }
 
-                _ = await client.TryRunRemoteAsync(
+                await client.RunRemoteAsync(
                     WellKnownServiceHubService.CodeAnalysis,
                     nameof(IRemoteDiagnosticAnalyzerService.ReportAnalyzerPerformance),
                     solution: null,

src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs

@@ -30,7 +30,7 @@ public async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync
             var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false);
             if (client != null)
             {
-                var result = await client.TryRunRemoteAsync<IList<SerializableDocumentHighlights>>(
+                var result = await client.RunRemoteAsync<IList<SerializableDocumentHighlights>>(
                     WellKnownServiceHubService.CodeAnalysis,
                     nameof(IRemoteDocumentHighlights.GetDocumentHighlightsAsync),
                     solution,
@@ -43,10 +43,7 @@ public async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync
                     callbackTarget: null,
                     cancellationToken).ConfigureAwait(false);
 
-                if (result.HasValue)
-                {
-                    return result.Value.SelectAsArray(h => h.Rehydrate(solution));
-                }
+                return result.SelectAsArray(h => h.Rehydrate(solution));
             }
 
             return await GetDocumentHighlightsInCurrentProcessAsync(