Merge branch 'asyncNavigation4' into asyncNavigation5

src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs

@@ -208,8 +208,6 @@ public CSharpOperationFactory(SemanticModel semanticModel)
                 case BoundKind.TupleLiteral:
                 case BoundKind.ConvertedTupleLiteral:
                     return CreateBoundTupleOperation((BoundTupleExpression)boundNode);
-                case BoundKind.UnconvertedInterpolatedString:
-                    throw ExceptionUtilities.Unreachable;
                 case BoundKind.InterpolatedString:
                     return CreateBoundInterpolatedStringExpressionOperation((BoundInterpolatedString)boundNode);
                 case BoundKind.StringInsert:
@@ -218,8 +216,6 @@ public CSharpOperationFactory(SemanticModel semanticModel)
                     return CreateBoundLocalFunctionStatementOperation((BoundLocalFunctionStatement)boundNode);
                 case BoundKind.AnonymousObjectCreationExpression:
                     return CreateBoundAnonymousObjectCreationExpressionOperation((BoundAnonymousObjectCreationExpression)boundNode);
-                case BoundKind.AnonymousPropertyDeclaration:
-                    throw ExceptionUtilities.Unreachable;
                 case BoundKind.ConstantPattern:
                     return CreateBoundConstantPatternOperation((BoundConstantPattern)boundNode);
                 case BoundKind.DeclarationPattern:
@@ -268,10 +264,6 @@ public CSharpOperationFactory(SemanticModel semanticModel)
                     return CreateRangeExpressionOperation((BoundRangeExpression)boundNode);
                 case BoundKind.SwitchSection:
                     return CreateBoundSwitchSectionOperation((BoundSwitchSection)boundNode);
-                case BoundKind.UnconvertedConditionalOperator:
-                    throw ExceptionUtilities.Unreachable;
-                case BoundKind.UnconvertedSwitchExpression:
-                    throw ExceptionUtilities.Unreachable;
                 case BoundKind.ConvertedSwitchExpression:
                     return CreateBoundSwitchExpressionOperation((BoundConvertedSwitchExpression)boundNode);
                 case BoundKind.SwitchExpressionArm:
@@ -326,6 +318,10 @@ public CSharpOperationFactory(SemanticModel semanticModel)
                         _ => null
                     };
                     return new NoneOperation(children, _semanticModel, boundNode.Syntax, type: type, constantValue, isImplicit: isImplicit);
+                case BoundKind.UnconvertedInterpolatedString:
+                case BoundKind.UnconvertedConditionalOperator:
+                case BoundKind.UnconvertedSwitchExpression:
+                case BoundKind.AnonymousPropertyDeclaration:
                 default:
                     // If you're hitting this because the IOperation test hook has failed, see
                     // <roslyn-root>/docs/Compilers/IOperation Test Hook.md for instructions on how to fix.
@@ -849,7 +845,7 @@ private IOperation CreateBoundObjectInitializerMemberOperation(BoundObjectInitia
 
                     return new PropertyReferenceOperation(property.GetPublicSymbol(), arguments, createReceiver(), _semanticModel, syntax, type, isImplicit);
                 default:
-                    throw ExceptionUtilities.Unreachable;
+                    throw ExceptionUtilities.UnexpectedValue(memberSymbol.Kind);
             }
 
             IOperation? createReceiver() => memberSymbol?.IsStatic == true ?

src/EditorFeatures/Core.Wpf/Interactive/InteractiveDocumentNavigationService.cs

@@ -26,10 +26,8 @@ public InteractiveDocumentNavigationService(IThreadingContext threadingContext)
             _threadingContext = threadingContext;
         }
 
-        public Task<bool> CanNavigateToSpanAsync(Workspace workspace, DocumentId documentId, TextSpan textSpan, CancellationToken cancellationToken)
-        {
-            return SpecializedTasks.True;
-        }
+        public Task<bool> CanNavigateToSpanAsync(Workspace workspace, DocumentId documentId, TextSpan textSpan, bool allowInvalidSpan, CancellationToken cancellationToken)
+            => SpecializedTasks.True;
 
         public Task<bool> CanNavigateToLineAndOffsetAsync(Workspace workspace, DocumentId documentId, int lineNumber, int offset, CancellationToken cancellationToken)
             => SpecializedTasks.False;
@@ -90,9 +88,9 @@ public Task<bool> CanNavigateToPositionAsync(Workspace workspace, DocumentId doc
         }
 
         public Task<INavigableLocation?> GetLocationForLineAndOffsetAsync(Workspace workspace, DocumentId documentId, int lineNumber, int offset, NavigationOptions options, CancellationToken cancellationToken)
-            => throw new NotSupportedException();
+            => SpecializedTasks.Null<INavigableLocation>();
 
         public Task<INavigableLocation?> GetLocationForPositionAsync(Workspace workspace, DocumentId documentId, int position, int virtualSpace, NavigationOptions options, CancellationToken cancellationToken)
-            => throw new NotSupportedException();
+            => SpecializedTasks.Null<INavigableLocation>();
     }
 }

src/EditorFeatures/Core/Extensibility/NavigationBar/AbstractEditorNavigationBarItemService.cs

@@ -50,12 +50,13 @@ protected async Task NavigateToSymbolItemAsync(
         protected async Task NavigateToPositionAsync(Workspace workspace, DocumentId documentId, int position, int virtualSpace, CancellationToken cancellationToken)
         {
             var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>();
-            if (await navigationService.CanNavigateToPositionAsync(workspace, documentId, position, virtualSpace, cancellationToken).ConfigureAwait(false))
+            var location = await navigationService.GetLocationForPositionAsync(
+                workspace, documentId, position, virtualSpace, NavigationOptions.Default, cancellationToken).ConfigureAwait(false);
+
+            if (location != null)
             {
-                var location = await navigationService.GetLocationForPositionAsync(
-                    workspace, documentId, position, virtualSpace, NavigationOptions.Default, cancellationToken).ConfigureAwait(false);
-                if (location != null)
-                    await location.NavigateToAsync(cancellationToken).ConfigureAwait(false);
+                await location.NavigateToAsync(cancellationToken).ConfigureAwait(false);
+                return;
             }
             else
             {

src/EditorFeatures/Core/Implementation/CodeActions/CodeActionEditHandlerService.cs

@@ -172,8 +172,7 @@ public async Task<bool> ApplyAsync(
                 {
                     // Come back to the UI thread after processing the operations so we can commit the transaction
                     applied = await ProcessOperationsAsync(
-                        workspace, operations, progressTracker,
-                        cancellationToken).ConfigureAwait(true);
+                        workspace, operations, progressTracker, cancellationToken).ConfigureAwait(true);
                 }
                 catch (Exception ex) when (FatalError.ReportAndPropagateUnlessCanceled(ex, cancellationToken))
                 {
@@ -185,7 +184,7 @@ public async Task<bool> ApplyAsync(
 
             var updatedSolution = operations.OfType<ApplyChangesOperation>().FirstOrDefault()?.ChangedSolution ?? oldSolution;
             await TryNavigateToLocationOrStartRenameSessionAsync(
-                workspace, oldSolution, updatedSolution, cancellationToken).ConfigureAwait(false);
+                workspace, operations, oldSolution, updatedSolution, cancellationToken).ConfigureAwait(false);
             return applied;
         }
 
@@ -289,43 +288,54 @@ private async Task<bool> ProcessOperationsAsync(
             return applied;
         }
 
-        private async Task TryNavigateToLocationOrStartRenameSessionAsync(Workspace workspace, Solution oldSolution, Solution newSolution, CancellationToken cancellationToken)
+        private async Task TryNavigateToLocationOrStartRenameSessionAsync(
+            Workspace workspace,
+            ImmutableArray<CodeActionOperation> operations,
+            Solution oldSolution,
+            Solution newSolution,
+            CancellationToken cancellationToken)
         {
+            var navigationOperation = operations.OfType<DocumentNavigationOperation>().FirstOrDefault();
+            if (navigationOperation != null && workspace.CanOpenDocuments)
+            {
+                var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>();
+                var location = await navigationService.GetLocationForPositionAsync(
+                    workspace, navigationOperation.DocumentId, navigationOperation.Position, cancellationToken).ConfigureAwait(false);
+                if (location != null)
+                    await location.NavigateToAsync(cancellationToken).ConfigureAwait(false);
+                return;
+            }
+
             var changedDocuments = newSolution.GetChangedDocuments(oldSolution);
             foreach (var documentId in changedDocuments)
             {
                 var document = newSolution.GetRequiredDocument(documentId);
                 if (!document.SupportsSyntaxTree)
-                {
                     continue;
-                }
 
                 var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-                var navigationTokenOpt = root.GetAnnotatedTokens(NavigationAnnotation.Kind)
-                                             .FirstOrNull();
-                if (navigationTokenOpt.HasValue)
+                var navigationToken = root.GetAnnotatedTokens(NavigationAnnotation.Kind).FirstOrNull();
+                if (navigationToken.HasValue)
                 {
                     var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>();
                     var location = await navigationService.GetLocationForPositionAsync(
-                        workspace, documentId, navigationTokenOpt.Value.SpanStart, cancellationToken).ConfigureAwait(false);
+                        workspace, documentId, navigationToken.Value.SpanStart, cancellationToken).ConfigureAwait(false);
                     if (location != null)
                         await location.NavigateToAsync(cancellationToken).ConfigureAwait(false);
                     return;
                 }
 
-                var renameTokenOpt = root.GetAnnotatedTokens(RenameAnnotation.Kind)
-                                         .FirstOrNull();
-
-                if (renameTokenOpt.HasValue)
+                var renameToken = root.GetAnnotatedTokens(RenameAnnotation.Kind).FirstOrNull();
+                if (renameToken.HasValue)
                 {
                     // It's possible that the workspace's current solution is not the same as
                     // newSolution. This can happen if the workspace host performs other edits
                     // during ApplyChanges, such as in the Venus scenario where indentation and
                     // formatting can happen. To work around this, we create a SyntaxPath to the
                     // rename token in the newSolution and resolve it to the current solution.
 
-                    var pathToRenameToken = new SyntaxPath(renameTokenOpt.Value);
+                    var pathToRenameToken = new SyntaxPath(renameToken.Value);
                     var latestDocument = workspace.CurrentSolution.GetDocument(documentId);
                     if (latestDocument != null)
                     {

src/EditorFeatures/TestUtilities2/Utilities/GoToHelpers/MockDocumentNavigationService.vb

@@ -36,7 +36,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Utilities.GoToHelpers
             Return If(_canNavigateToPosition, SpecializedTasks.True, SpecializedTasks.False)
         End Function
 
-        Public Function CanNavigateToSpanAsync(workspace As Workspace, documentId As DocumentId, textSpan As TextSpan, cancellationToken As CancellationToken) As Task(Of Boolean) Implements IDocumentNavigationService.CanNavigateToSpanAsync
+        Public Function CanNavigateToSpanAsync(workspace As Workspace, documentId As DocumentId, textSpan As TextSpan, allowInvalidSpan As Boolean, cancellationToken As CancellationToken) As Task(Of Boolean) Implements IDocumentNavigationService.CanNavigateToSpanAsync
             Return If(_canNavigateToSpan, SpecializedTasks.True, SpecializedTasks.False)
         End Function
 

src/EditorFeatures/TestUtilities2/Utilities/MockDocumentNavigationServiceProvider.vb

@@ -63,7 +63,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Utilities
                 Return If(CanNavigateToPositionReturnValue, SpecializedTasks.True, SpecializedTasks.False)
             End Function
 
-            Public Function CanNavigateToSpanAsync(workspace As Workspace, documentId As DocumentId, textSpan As TextSpan, cancellationToken As CancellationToken) As Task(Of Boolean) Implements IDocumentNavigationService.CanNavigateToSpanAsync
+            Public Function CanNavigateToSpanAsync(workspace As Workspace, documentId As DocumentId, textSpan As TextSpan, allowInvalidSpan As Boolean, cancellationToken As CancellationToken) As Task(Of Boolean) Implements IDocumentNavigationService.CanNavigateToSpanAsync
                 Me.ProvidedDocumentId = documentId
                 Me.ProvidedTextSpan = textSpan
 

src/Features/Core/Portable/Common/NavigationOperation.cs → src/Features/Core/Portable/Common/DocumentNavigationOperation.cs

@@ -2,12 +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.
 
-#nullable disable
-
 using System;
 using System.Threading;
-using Microsoft.CodeAnalysis.Navigation;
-using Microsoft.CodeAnalysis.Shared.Utilities;
 
 namespace Microsoft.CodeAnalysis.CodeActions
 {
@@ -21,30 +17,18 @@ namespace Microsoft.CodeAnalysis.CodeActions
     /// </summary>
     public class DocumentNavigationOperation : CodeActionOperation
     {
-        private readonly DocumentId _documentId;
-        private readonly int _position;
+        internal DocumentId DocumentId { get; }
+        internal int Position { get; }
 
         public DocumentNavigationOperation(DocumentId documentId, int position = 0)
         {
-            _documentId = documentId ?? throw new ArgumentNullException(nameof(documentId));
-            _position = position;
+            DocumentId = documentId ?? throw new ArgumentNullException(nameof(documentId));
+            Position = position;
         }
 
         public override void Apply(Workspace workspace, CancellationToken cancellationToken)
         {
-            if (workspace.CanOpenDocuments)
-            {
-                var navigationService = workspace.Services.GetService<IDocumentNavigationService>();
-                var threadingService = workspace.Services.GetService<IWorkspaceThreadingServiceProvider>();
-
-                threadingService.Service.Run(async () =>
-                {
-                    var location = await navigationService.GetLocationForPositionAsync(
-                        workspace, _documentId, _position, cancellationToken).ConfigureAwait(false);
-                    return location != null &&
-                        await location.NavigateToAsync(cancellationToken).ConfigureAwait(false);
-                });
-            }
+            // Intentionally empty.  Handling of this operation is special cased in CodeActionEditHandlerService.cs 
         }
     }
 }

src/Features/Core/Portable/Navigation/DefaultDocumentNavigationService.cs

@@ -11,7 +11,7 @@ namespace Microsoft.CodeAnalysis.Navigation
 {
     internal sealed class DefaultDocumentNavigationService : IDocumentNavigationService
     {
-        public Task<bool> CanNavigateToSpanAsync(Workspace workspace, DocumentId documentId, TextSpan textSpan, CancellationToken cancellationToken)
+        public Task<bool> CanNavigateToSpanAsync(Workspace workspace, DocumentId documentId, TextSpan textSpan, bool allowInvalidSpan, CancellationToken cancellationToken)
             => SpecializedTasks.False;
 
         public Task<bool> CanNavigateToLineAndOffsetAsync(Workspace workspace, DocumentId documentId, int lineNumber, int offset, CancellationToken cancellationToken)

src/Features/Core/Portable/Navigation/IDocumentNavigationService.cs

@@ -15,7 +15,7 @@ internal interface IDocumentNavigationService : IWorkspaceService
         /// Determines whether it is possible to navigate to the given position in the specified document.
         /// </summary>
         /// <remarks>Legal to call from any thread.</remarks>
-        Task<bool> CanNavigateToSpanAsync(Workspace workspace, DocumentId documentId, TextSpan textSpan, CancellationToken cancellationToken);
+        Task<bool> CanNavigateToSpanAsync(Workspace workspace, DocumentId documentId, TextSpan textSpan, bool allowInvalidSpan, CancellationToken cancellationToken);
 
         /// <summary>
         /// Determines whether it is possible to navigate to the given line/offset in the specified document.
@@ -34,6 +34,9 @@ internal interface IDocumentNavigationService : IWorkspaceService
 
     internal static class IDocumentNavigationServiceExtensions
     {
+        public static Task<bool> CanNavigateToSpanAsync(this IDocumentNavigationService service, Workspace workspace, DocumentId documentId, TextSpan textSpan, CancellationToken cancellationToken)
+            => service.CanNavigateToSpanAsync(workspace, documentId, textSpan, allowInvalidSpan: false, cancellationToken);
+
         public static Task<bool> CanNavigateToPositionAsync(this IDocumentNavigationService service, Workspace workspace, DocumentId documentId, int position, CancellationToken cancellationToken)
             => service.CanNavigateToPositionAsync(workspace, documentId, position, virtualSpace: 0, cancellationToken);