Merge main to main-vs-deps

src/EditorFeatures/Core.Wpf/NavigateTo/NavigateToItemDisplay.cs

@@ -53,15 +53,7 @@ private ReadOnlyCollection<DescriptionItem> CreateDescriptionItems()
             }
 
             var sourceText = document.GetTextSynchronously(CancellationToken.None);
-            var item = _searchResult.NavigableItem;
-            var spanStart = item.SourceSpan.Start;
-            if (item.IsStale && spanStart > sourceText.Length)
-            {
-                // in the case of a stale item, the span may be out of bounds of the document. Cap
-                // us to the end of the document as that's where we're going to navigate the user
-                // to.
-                spanStart = sourceText.Length;
-            }
+            var span = NavigateToUtilities.GetBoundedSpan(_searchResult.NavigableItem, sourceText);
 
             var items = new List<DescriptionItem>
                     {
@@ -79,7 +71,7 @@ private ReadOnlyCollection<DescriptionItem> CreateDescriptionItems()
                             new ReadOnlyCollection<DescriptionRun>(
                                 new[] { new DescriptionRun("Line:", bold: true) }),
                             new ReadOnlyCollection<DescriptionRun>(
-                                new[] { new DescriptionRun((sourceText.Lines.IndexOf(spanStart) + 1).ToString()) }))
+                                new[] { new DescriptionRun((sourceText.Lines.IndexOf(span.Start) + 1).ToString()) }))
                     };
 
             var summary = _searchResult.Summary;

src/EditorFeatures/Core.Wpf/NavigateTo/NavigateToItemProvider.cs

@@ -41,22 +41,7 @@ public NavigateToItemProvider(
         ISet<string> INavigateToItemProvider2.KindsProvided => KindsProvided;
 
         public ImmutableHashSet<string> KindsProvided
-        {
-            get
-            {
-                var result = ImmutableHashSet.Create<string>(StringComparer.Ordinal);
-                foreach (var project in _workspace.CurrentSolution.Projects)
-                {
-                    var navigateToSearchService = project.GetLanguageService<INavigateToSearchService>();
-                    if (navigateToSearchService != null)
-                    {
-                        result = result.Union(navigateToSearchService.KindsProvided);
-                    }
-                }
-
-                return result;
-            }
-        }
+            => NavigateToUtilities.GetKindsProvided(_workspace.CurrentSolution);
 
         public bool CanFilter
         {

src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs

@@ -3682,7 +3682,7 @@ public async Task UnitTestingHotReloadServiceTest()
 
             var hotReload = new UnitTestingHotReloadService(workspace.Services);
 
-            await hotReload.StartSessionAsync(solution, CancellationToken.None);
+            await hotReload.StartSessionAsync(solution, ImmutableArray.Create("Baseline", "AddDefinitionToExistingType", "NewTypeDefinition"), CancellationToken.None);
 
             var sessionId = hotReload.GetTestAccessor().SessionId;
             var session = encService.GetTestAccessor().GetDebuggingSession(sessionId);
@@ -3694,13 +3694,13 @@ public async Task UnitTestingHotReloadServiceTest()
 
             solution = solution.WithDocumentText(documentIdA, SourceText.From(source2, Encoding.UTF8));
 
-            var result = await hotReload.EmitSolutionUpdateAsync(solution, CancellationToken.None);
+            var result = await hotReload.EmitSolutionUpdateAsync(solution, true, CancellationToken.None);
             Assert.Empty(result.diagnostics);
             Assert.Equal(1, result.updates.Length);
 
             solution = solution.WithDocumentText(documentIdA, SourceText.From(source3, Encoding.UTF8));
 
-            result = await hotReload.EmitSolutionUpdateAsync(solution, CancellationToken.None);
+            result = await hotReload.EmitSolutionUpdateAsync(solution, true, CancellationToken.None);
             AssertEx.Equal(
                 new[] { "ENC0020: " + string.Format(FeaturesResources.Renaming_0_will_prevent_the_debug_session_from_continuing, FeaturesResources.method) },
                 result.diagnostics.Select(d => $"{d.Id}: {d.GetMessage()}"));

src/Features/Core/Portable/Common/GlyphExtensions.cs

@@ -208,7 +208,7 @@ private static Glyph GetGlyph(string tag, ImmutableArray<string> allTags)
             return Glyph.None;
         }
 
-        private static Accessibility GetAccessibility(ImmutableArray<string> tags)
+        public static Accessibility GetAccessibility(ImmutableArray<string> tags)
         {
             foreach (var tag in tags)
             {

src/Features/Core/Portable/ExternalAccess/UnitTesting/API/UnitTestingHotReloadService.cs

@@ -19,17 +19,21 @@ internal sealed class UnitTestingHotReloadService
     {
         private sealed class DebuggerService : IManagedEditAndContinueDebuggerService
         {
-            public static readonly DebuggerService Instance = new();
+            private readonly ImmutableArray<string> _capabilities;
+
+            public DebuggerService(ImmutableArray<string> capabilities)
+            {
+                _capabilities = capabilities;
+            }
 
             public Task<ImmutableArray<ManagedActiveStatementDebugInfo>> GetActiveStatementsAsync(CancellationToken cancellationToken)
                 => Task.FromResult(ImmutableArray<ManagedActiveStatementDebugInfo>.Empty);
 
             public Task<ManagedEditAndContinueAvailability> GetAvailabilityAsync(Guid module, CancellationToken cancellationToken)
                 => Task.FromResult(new ManagedEditAndContinueAvailability(ManagedEditAndContinueAvailabilityStatus.Available));
 
-            // TODO: get capabilities from the runtime
             public Task<ImmutableArray<string>> GetCapabilitiesAsync(CancellationToken cancellationToken)
-                => Task.FromResult(ImmutableArray.Create("Baseline", "AddDefinitionToExistingType", "NewTypeDefinition"));
+                => Task.FromResult(_capabilities);
 
             public Task PrepareModuleForUpdateAsync(Guid module, CancellationToken cancellationToken)
                 => Task.CompletedTask;
@@ -64,24 +68,27 @@ public UnitTestingHotReloadService(HostWorkspaceServices services)
         /// Starts the watcher.
         /// </summary>
         /// <param name="solution">Solution that represents sources that match the built binaries on disk.</param>
+        /// <param name="capabilities">Array of capabilities retrieved from the runtime to dictate supported rude edits.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
-        public async Task StartSessionAsync(Solution solution, CancellationToken cancellationToken)
+        public async Task StartSessionAsync(Solution solution, ImmutableArray<string> capabilities, CancellationToken cancellationToken)
         {
-            var newSessionId = await _encService.StartDebuggingSessionAsync(solution, DebuggerService.Instance, captureMatchingDocuments: true, reportDiagnostics: false, cancellationToken).ConfigureAwait(false);
+            var newSessionId = await _encService.StartDebuggingSessionAsync(solution, new DebuggerService(capabilities), captureMatchingDocuments: true, reportDiagnostics: false, cancellationToken).ConfigureAwait(false);
             Contract.ThrowIfFalse(_sessionId == default, "Session already started");
             _sessionId = newSessionId;
         }
 
         /// <summary>
-        /// Emits updates for all projects that differ between the given <paramref name="solution"/> snapshot and the one given to the previous successful call or 
-        /// the one passed to <see cref="StartSessionAsync(Solution, CancellationToken)"/> for the first invocation.
+        /// Emits updates for all projects that differ between the given <paramref name="solution"/> snapshot and the one given to the previous successful call 
+        /// where <paramref name="commitUpdates"/> was `true` or the one passed to <see cref="StartSessionAsync(Solution, ImmutableArray{string}, CancellationToken)"/>
+        /// for the first invocation.
         /// </summary>
         /// <param name="solution">Solution snapshot.</param>
+        /// <param name="commitUpdates">commits changes if true, discards if false</param>
         /// <param name="cancellationToken">Cancellation token.</param>
         /// <returns>
         /// Updates (one for each changed project) and Rude Edit diagnostics. Does not include syntax or semantic diagnostics.
         /// </returns>
-        public async Task<(ImmutableArray<Update> updates, ImmutableArray<Diagnostic> diagnostics)> EmitSolutionUpdateAsync(Solution solution, CancellationToken cancellationToken)
+        public async Task<(ImmutableArray<Update> updates, ImmutableArray<Diagnostic> diagnostics)> EmitSolutionUpdateAsync(Solution solution, bool commitUpdates, CancellationToken cancellationToken)
         {
             var sessionId = _sessionId;
             Contract.ThrowIfFalse(sessionId != default, "Session has not started");
@@ -90,7 +97,14 @@ public async Task StartSessionAsync(Solution solution, CancellationToken cancell
 
             if (results.ModuleUpdates.Status == ManagedModuleUpdateStatus.Ready)
             {
-                _encService.CommitSolutionUpdate(sessionId, out _);
+                if (commitUpdates)
+                {
+                    _encService.CommitSolutionUpdate(sessionId, out _);
+                }
+                else
+                {
+                    _encService.DiscardSolutionUpdate(sessionId);
+                }
             }
 
             var updates = results.ModuleUpdates.Updates.SelectAsArray(

src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj

@@ -46,6 +46,7 @@
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.Orchestrator" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.VisualStudio.TestWindow.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.VisualBasic.EditorFeatures" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.VisualBasic.Features" />
     <InternalsVisibleTo Include="Roslyn.Hosting.Diagnostics" />

src/Features/Core/Portable/NavigateTo/NavigateToUtilities.cs

@@ -0,0 +1,45 @@
+// 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.
+
+using System;
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Navigation;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.NavigateTo
+{
+    internal static class NavigateToUtilities
+    {
+        public static ImmutableHashSet<string> GetKindsProvided(Solution solution)
+        {
+            var result = ImmutableHashSet.CreateBuilder<string>(StringComparer.Ordinal);
+            foreach (var project in solution.Projects)
+            {
+                var navigateToSearchService = project.GetLanguageService<INavigateToSearchService>();
+                if (navigateToSearchService != null)
+                    result.UnionWith(navigateToSearchService.KindsProvided);
+            }
+
+            return result.ToImmutable();
+        }
+
+        public static TextSpan GetBoundedSpan(INavigableItem item, SourceText sourceText)
+        {
+            var spanStart = item.SourceSpan.Start;
+            var spanEnd = item.SourceSpan.End;
+            if (item.IsStale)
+            {
+                // in the case of a stale item, the span may be out of bounds of the document. Cap
+                // us to the end of the document as that's where we're going to navigate the user
+                // to.
+                spanStart = spanStart > sourceText.Length ? sourceText.Length : spanStart;
+                spanEnd = spanEnd > sourceText.Length ? sourceText.Length : spanEnd;
+            }
+
+            return TextSpan.FromBounds(spanStart, spanEnd);
+        }
+    }
+}