Merge the new UnitTesting solution crawler into Main

eng/targets/Services.props

@@ -30,6 +30,7 @@
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.CodeLensReferences" ClassName="Microsoft.CodeAnalysis.Remote.RemoteCodeLensReferencesService+Factory" />
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.DesignerAttributeDiscovery" ClassName="Microsoft.CodeAnalysis.Remote.RemoteDesignerAttributeDiscoveryService+Factory" />
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.ProjectTelemetry" ClassName="Microsoft.CodeAnalysis.Remote.RemoteProjectTelemetryService+Factory" />
+    <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.LegacySolutionEventsAggregation" ClassName="Microsoft.CodeAnalysis.Remote.RemoteLegacySolutionEventsAggregationService+Factory" />
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.SymbolSearchUpdate" ClassName="Microsoft.CodeAnalysis.Remote.RemoteSymbolSearchUpdateService+Factory" />
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.TaskList" ClassName="Microsoft.CodeAnalysis.Remote.RemoteTaskListService+Factory" />
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.EditAndContinue" ClassName="Microsoft.CodeAnalysis.EditAndContinue.RemoteEditAndContinueService+Factory" />

src/EditorFeatures/Core/SolutionEvents/HostLegacySolutionEventsWorkspaceEventListener.cs

@@ -0,0 +1,104 @@
+// 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.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Collections;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Remote;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.CodeAnalysis.SolutionCrawler;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.LegacySolutionEvents
+{
+    [ExportEventListener(WellKnownEventListeners.Workspace, WorkspaceKind.Host), Shared]
+    internal sealed partial class HostLegacySolutionEventsWorkspaceEventListener : IEventListener<object>
+    {
+        private readonly IGlobalOptionService _globalOptions;
+        private readonly IThreadingContext _threadingContext;
+        private readonly AsyncBatchingWorkQueue<WorkspaceChangeEventArgs> _eventQueue;
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public HostLegacySolutionEventsWorkspaceEventListener(
+            IGlobalOptionService globalOptions,
+            IThreadingContext threadingContext,
+            IAsynchronousOperationListenerProvider listenerProvider)
+        {
+            _globalOptions = globalOptions;
+            _threadingContext = threadingContext;
+            _eventQueue = new AsyncBatchingWorkQueue<WorkspaceChangeEventArgs>(
+                DelayTimeSpan.Short,
+                ProcessWorkspaceChangeEventsAsync,
+                listenerProvider.GetListener(FeatureAttribute.SolutionCrawlerUnitTesting),
+                _threadingContext.DisposalToken);
+        }
+
+        public void StartListening(Workspace workspace, object? serviceOpt)
+        {
+            if (_globalOptions.GetOption(SolutionCrawlerRegistrationService.EnableSolutionCrawler))
+            {
+                workspace.WorkspaceChanged += OnWorkspaceChanged;
+                _threadingContext.DisposalToken.Register(() =>
+                {
+                    workspace.WorkspaceChanged -= OnWorkspaceChanged;
+                });
+            }
+        }
+
+        private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs e)
+            => _eventQueue.AddWork(e);
+
+        private async ValueTask ProcessWorkspaceChangeEventsAsync(ImmutableSegmentedList<WorkspaceChangeEventArgs> events, CancellationToken cancellationToken)
+        {
+            if (events.IsEmpty)
+                return;
+
+            var workspace = events[0].OldSolution.Workspace;
+            Contract.ThrowIfTrue(events.Any(e => e.OldSolution.Workspace != workspace || e.NewSolution.Workspace != workspace));
+
+            var client = await RemoteHostClient.TryGetClientAsync(workspace, cancellationToken).ConfigureAwait(false);
+
+            if (client is null)
+            {
+                var aggregationService = workspace.Services.GetRequiredService<ILegacySolutionEventsAggregationService>();
+                var shouldReport = aggregationService.ShouldReportChanges(workspace.Services.SolutionServices);
+                if (!shouldReport)
+                    return;
+
+                foreach (var args in events)
+                    await aggregationService.OnWorkspaceChangedAsync(args, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                // Notifying OOP of workspace events can be expensive (there may be a lot of them, and they involve
+                // syncing over entire solution snapshots).  As such, do not bother to do this if the remote side says
+                // that it's not interested in the events.  This will happen, for example, when the unittesting
+                // Test-Explorer window has not been shown yet, and so the unit testing system will not have registered
+                // an incremental analyzer with us.
+                var shouldReport = await client.TryInvokeAsync<IRemoteLegacySolutionEventsAggregationService, bool>(
+                    (service, cancellationToken) => service.ShouldReportChangesAsync(cancellationToken),
+                    cancellationToken).ConfigureAwait(false);
+                if (!shouldReport.HasValue || !shouldReport.Value)
+                    return;
+
+                foreach (var args in events)
+                {
+                    await client.TryInvokeAsync<IRemoteLegacySolutionEventsAggregationService>(
+                        args.OldSolution, args.NewSolution,
+                        (service, oldSolutionChecksum, newSolutionChecksum, cancellationToken) =>
+                            service.OnWorkspaceChangedAsync(oldSolutionChecksum, newSolutionChecksum, args.Kind, args.ProjectId, args.DocumentId, cancellationToken),
+                        cancellationToken).ConfigureAwait(false);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.ExternalAccess.UnitTesting.SolutionCrawler;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.UnitTesting.Api
+{
+    internal interface INewUnitTestingIncrementalAnalyzerImplementation
+    {
+#if false // Not used in unit testing crawling
+        // Task NewSolutionSnapshotAsync(Solution solution, CancellationToken cancellationToken);
+        // Task DocumentOpenAsync(Document document, CancellationToken cancellationToken);
+        // Task DocumentCloseAsync(Document document, CancellationToken cancellationToken);
+        // Task DocumentResetAsync(Document document, CancellationToken cancellationToken);
+        // void RemoveProject(ProjectId projectId);
+
+        // [Obsolete]
+        // bool NeedsReanalysisOnOptionChanged(object sender, UnitTestingOptionChangedEventArgsWrapper e);
+
+        Task AnalyzeSyntaxAsync(Document document, UnitTestingInvocationReasons reasons, CancellationToken cancellationToken);
+#endif
+
+        Task AnalyzeDocumentAsync(
+            Document document,
+#if false // Not used in unit testing crawling
+            SyntaxNode bodyOpt,
+#endif
+            UnitTestingInvocationReasons reasons,
+            CancellationToken cancellationToken);
+
+        Task AnalyzeProjectAsync(
+            Project project,
+#if false // Not used in unit testing crawling
+            bool semanticsChanged,
+#endif
+            UnitTestingInvocationReasons reasons,
+            CancellationToken cancellationToken);
+
+        void RemoveDocument(DocumentId documentId);
+    }
+}

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

@@ -0,0 +1,11 @@
+// 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.
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.UnitTesting.Api
+{
+    internal interface INewUnitTestingIncrementalAnalyzerProviderImplementation
+    {
+        INewUnitTestingIncrementalAnalyzerImplementation CreateIncrementalAnalyzer();
+    }
+}

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

@@ -0,0 +1,116 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.ExternalAccess.UnitTesting.Api;
+using Microsoft.CodeAnalysis.ExternalAccess.UnitTesting.SolutionCrawler;
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.UnitTesting.Api;
+
+internal sealed partial class NewUnitTestingIncrementalAnalyzerProvider
+{
+    private sealed class NewUnitTestingIncrementalAnalyzer : IUnitTestingIncrementalAnalyzer
+    {
+        private readonly INewUnitTestingIncrementalAnalyzerImplementation _implementation;
+
+        public NewUnitTestingIncrementalAnalyzer(INewUnitTestingIncrementalAnalyzerImplementation implementation)
+            => _implementation = implementation;
+
+        public Task AnalyzeDocumentAsync(
+            Document document,
+#if false // Not used in unit testing crawling
+            SyntaxNode bodyOpt,
+#endif
+            UnitTestingInvocationReasons reasons,
+            CancellationToken cancellationToken)
+        {
+            return _implementation.AnalyzeDocumentAsync(
+                document,
+#if false // Not used in unit testing crawling
+                bodyOpt,
+#endif
+                reasons,
+                cancellationToken);
+        }
+
+        public Task AnalyzeProjectAsync(
+            Project project,
+#if false // Not used in unit testing crawling
+            bool semanticsChanged,
+#endif
+            UnitTestingInvocationReasons reasons,
+            CancellationToken cancellationToken)
+        {
+            return _implementation.AnalyzeProjectAsync(
+                project,
+#if false // Not used in unit testing crawling
+                semanticsChanged,
+#endif
+                reasons,
+                cancellationToken);
+        }
+
+#if false // Not used in unit testing crawling
+        public Task AnalyzeSyntaxAsync(Document document, UnitTestingInvocationReasons reasons, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public Task DocumentCloseAsync(Document document, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public Task DocumentOpenAsync(Document document, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public Task DocumentResetAsync(Document document, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public Task ActiveDocumentSwitchedAsync(TextDocument document, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public Task NewSolutionSnapshotAsync(Solution solution, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+#endif
+
+        public Task RemoveDocumentAsync(DocumentId documentId, CancellationToken cancellationToken)
+        {
+            _implementation.RemoveDocument(documentId);
+            return Task.CompletedTask;
+        }
+
+#if false // Not used in unit testing crawling
+        public Task RemoveProjectAsync(ProjectId projectId, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public Task NonSourceDocumentOpenAsync(TextDocument textDocument, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public Task NonSourceDocumentCloseAsync(TextDocument textDocument, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public Task NonSourceDocumentResetAsync(TextDocument textDocument, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public Task AnalyzeNonSourceDocumentAsync(TextDocument textDocument, UnitTestingInvocationReasons reasons, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public void LogAnalyzerCountSummary()
+        {
+        }
+
+        /// <summary>
+        /// Order all incremental analyzers below DiagnosticIncrementalAnalyzer
+        /// </summary>
+        public int Priority => 1;
+
+        // Unit testing incremental analyzer only supports full solution analysis scope.
+        // In future, we should add a separate option to allow users to configure background analysis scope for unit testing.
+        public static BackgroundAnalysisScope GetBackgroundAnalysisScope(OptionSet _) => BackgroundAnalysisScope.FullSolution;
+
+        public void Shutdown()
+        {
+        }
+#endif
+    }
+}

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

@@ -0,0 +1,64 @@
+// 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 Microsoft.CodeAnalysis.ExternalAccess.UnitTesting.SolutionCrawler;
+using Microsoft.CodeAnalysis.Host;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.UnitTesting.Api;
+
+internal sealed partial class NewUnitTestingIncrementalAnalyzerProvider : IUnitTestingIncrementalAnalyzerProvider
+{
+    private readonly string? _workspaceKind;
+    private readonly SolutionServices _services;
+    private readonly INewUnitTestingIncrementalAnalyzerProviderImplementation _incrementalAnalyzerProvider;
+
+    private IUnitTestingIncrementalAnalyzer? _lazyAnalyzer;
+
+    private NewUnitTestingIncrementalAnalyzerProvider(
+        string? workspaceKind,
+        SolutionServices services,
+        INewUnitTestingIncrementalAnalyzerProviderImplementation incrementalAnalyzerProvider)
+    {
+        _workspaceKind = workspaceKind;
+        _services = services;
+        _incrementalAnalyzerProvider = incrementalAnalyzerProvider;
+    }
+
+    // NOTE: We're currently expecting the analyzer to be singleton, so that
+    //       analyzers returned when calling this method twice would pass a reference equality check.
+    //       One instance should be created by SolutionCrawler, another one by us, when calling the
+    //       UnitTestingSolutionCrawlerServiceAccessor.Reanalyze method.
+    public IUnitTestingIncrementalAnalyzer CreateIncrementalAnalyzer()
+        => _lazyAnalyzer ??= new NewUnitTestingIncrementalAnalyzer(_incrementalAnalyzerProvider.CreateIncrementalAnalyzer());
+
+    public void Reanalyze()
+    {
+        var solutionCrawlerService = _services.GetService<IUnitTestingSolutionCrawlerService>();
+        solutionCrawlerService?.Reanalyze(
+            _workspaceKind, _services, this.CreateIncrementalAnalyzer(), projectIds: null, documentIds: null, highPriority: false);
+    }
+
+    public static NewUnitTestingIncrementalAnalyzerProvider? TryRegister(string? workspaceKind, SolutionServices services, string analyzerName, INewUnitTestingIncrementalAnalyzerProviderImplementation provider)
+    {
+        Contract.ThrowIfNull(workspaceKind);
+        var solutionCrawlerRegistrationService = services.GetService<IUnitTestingSolutionCrawlerRegistrationService>();
+        if (solutionCrawlerRegistrationService == null)
+        {
+            return null;
+        }
+
+        var analyzerProvider = new NewUnitTestingIncrementalAnalyzerProvider(workspaceKind, services, provider);
+
+        var metadata = new UnitTestingIncrementalAnalyzerProviderMetadata(
+            analyzerName,
+#if false // Not used in unit testing crawling
+            highPriorityForActiveFile: false,
+#endif
+            new[] { workspaceKind });
+
+        solutionCrawlerRegistrationService.AddAnalyzerProvider(analyzerProvider, metadata);
+        return analyzerProvider;
+    }
+}