Merge pull request #6658 from dpoeschl/RevertBufferClassification

Revert "Syntactically classify buffers without a workspace"

Author: dpoeschl

src/EditorFeatures/CSharpTest/Classification/SyntacticTaggerTests.cs

@@ -1,13 +1,9 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
-using System.Collections.Immutable;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Implementation.Classification;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
-using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Text;
 using Roslyn.Test.Utilities;
@@ -36,19 +32,8 @@ public async Task TestTagsChangedForEntireFile()
                     subjectBuffer,
                     workspace.GetService<IForegroundNotificationService>(),
                     AggregateAsynchronousOperationListener.CreateEmptyListener(),
-                    typeMap: null,
-                    taggerProvider: new SyntacticClassificationTaggerProvider(
-                        notificationService: null,
-                        typeMap: null,
-                        viewSupportsClassificationServiceOpt: null,
-                        associatedViewService: null,
-                        allLanguageServices: ImmutableArray<Lazy<ILanguageService, LanguageServiceMetadata>>.Empty,
-                        contentTypes: ImmutableArray<Lazy<ILanguageService, ContentTypeLanguageMetadata>>.Empty,
-                        asyncListeners: ImmutableArray<Lazy<IAsynchronousOperationListener, FeatureMetadata>>.Empty),
-                    viewSupportsClassificationServiceOpt: null,
-                    associatedViewService: null,
-                    editorClassificationService: null,
-                    languageName: null);
+                    null,
+                    new SyntacticClassificationTaggerProvider(null, null, null));
 
                 SnapshotSpan span = default(SnapshotSpan);
                 tagComputer.TagsChanged += (s, e) =>

src/EditorFeatures/Core/EditorFeatures.csproj

@@ -338,7 +338,6 @@
     <Compile Include="Implementation\Classification\ClassificationTypeDefinitions.cs" />
     <Compile Include="Implementation\Classification\ClassificationUtilities.cs" />
     <Compile Include="Implementation\Classification\IEditorClassificationService.cs" />
-    <Compile Include="Implementation\Classification\IViewSupportsClassificationService.cs" />
     <Compile Include="Implementation\Classification\SemanticClassificationTaggerProvider.cs" />
     <Compile Include="Implementation\Classification\SyntacticClassificationTaggerProvider.cs" />
     <Compile Include="Implementation\Classification\SyntacticClassificationTaggerProvider.TagComputer.cs" />

src/EditorFeatures/Core/Implementation/Classification/IViewSupportsClassificationService.cs

@@ -2,22 +2,19 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Classification;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Editor.Shared.Threading;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
-using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Internal.Log;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Text;
-using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Text.Tagging;
 using Roslyn.Utilities;
 
@@ -59,23 +56,13 @@ internal partial class TagComputer
             private ITextSnapshot _lastParsedSnapshot;
             private Document _lastParsedDocument;
 
-            private bool _isClassificationOnlyWorkspace;
             private Workspace _workspace;
             private CancellationTokenSource _reportChangeCancellationSource;
 
             private readonly IAsynchronousOperationListener _listener;
             private readonly IForegroundNotificationService _notificationService;
             private readonly ClassificationTypeMap _typeMap;
             private readonly SyntacticClassificationTaggerProvider _taggerProvider;
-            private readonly IEditorClassificationService _editorClassificationService;
-            private readonly IViewSupportsClassificationService _viewSupportsClassificationServiceOpt;
-            private readonly ITextBufferAssociatedViewService _associatedViewService;
-
-            private readonly string _languageName;
-
-            // Not all buffers with a matching content type should be tagged, but determining this
-            // can be expensive.
-            private bool? _cachedTaggableStatus;
 
             private int _taggerReferenceCount;
 
@@ -84,21 +71,13 @@ public TagComputer(
                 IForegroundNotificationService notificationService,
                 IAsynchronousOperationListener asyncListener,
                 ClassificationTypeMap typeMap,
-                SyntacticClassificationTaggerProvider taggerProvider,
-                IViewSupportsClassificationService viewSupportsClassificationServiceOpt,
-                ITextBufferAssociatedViewService associatedViewService,
-                IEditorClassificationService editorClassificationService,
-                string languageName)
+                SyntacticClassificationTaggerProvider taggerProvider)
             {
                 _subjectBuffer = subjectBuffer;
                 _notificationService = notificationService;
                 _listener = asyncListener;
                 _typeMap = typeMap;
                 _taggerProvider = taggerProvider;
-                _viewSupportsClassificationServiceOpt = viewSupportsClassificationServiceOpt;
-                _associatedViewService = associatedViewService;
-                _editorClassificationService = editorClassificationService;
-                _languageName = languageName;
 
                 _workQueue = new AsynchronousSerialWorkQueue(asyncListener);
                 _reportChangeCancellationSource = new CancellationTokenSource();
@@ -108,7 +87,10 @@ public TagComputer(
                 _workspaceRegistration = Workspace.GetWorkspaceRegistration(subjectBuffer.AsTextContainer());
                 _workspaceRegistration.WorkspaceChanged += OnWorkspaceRegistrationChanged;
 
-                ConnectToWorkspace(_workspaceRegistration.Workspace);
+                if (_workspaceRegistration.Workspace != null)
+                {
+                    ConnectToWorkspace(_workspaceRegistration.Workspace);
+                }
             }
 
             private void OnWorkspaceRegistrationChanged(object sender, EventArgs e)
@@ -153,92 +135,47 @@ private void ConnectToWorkspace(Workspace workspace)
                 ResetLastParsedDocument();
 
                 _workspace = workspace;
+                _workspace.WorkspaceChanged += this.OnWorkspaceChanged;
+                _workspace.DocumentOpened += this.OnDocumentOpened;
+                _workspace.DocumentActiveContextChanged += this.OnDocumentActiveContextChanged;
 
-                if (_workspace != null)
-                {
-                    _isClassificationOnlyWorkspace = false;
-                    _workspace.WorkspaceChanged += this.OnWorkspaceChanged;
-                    _workspace.DocumentOpened += this.OnDocumentOpened;
-                    _workspace.DocumentActiveContextChanged += this.OnDocumentActiveContextChanged;
-
-                    var textContainer = _subjectBuffer.AsTextContainer();
+                var textContainer = _subjectBuffer.AsTextContainer();
 
-                    var documentId = _workspace.GetDocumentIdInCurrentContext(textContainer);
-                    if (documentId != null)
-                    {
-                        var document = workspace.CurrentSolution.GetDocument(documentId);
-                        if (document != null)
-                        {
-                            EnqueueParseSnapshotTask(document);
-                            return;
-                        }
-                    }
-                }
-                else
+                var documentId = _workspace.GetDocumentIdInCurrentContext(textContainer);
+                if (documentId != null)
                 {
-                    // This buffer isn't being tracked by any workspace. In Visual Studio, this
-                    // can happen if it is not in the Running Document Table. We'll try to do
-                    // basic syntax classification based on the initial state of the snapshot.
-                    // Changes to the buffer are not observed, but initial tags will track forward.
-
-                    _isClassificationOnlyWorkspace = true;
-                    if (_languageName != null)
+                    var document = workspace.CurrentSolution.GetDocument(documentId);
+                    if (document != null)
                     {
-                        _workspace = new AdhocWorkspace();
-                        var solution = _workspace.CreateSolution(SolutionId.CreateNewId());
-                        var project = solution.AddProject(name: string.Empty, assemblyName: string.Empty, language: _languageName);
-
-                        var parsedSnapshot = _subjectBuffer.CurrentSnapshot;
-                        var document = project.AddDocument(name: string.Empty, text: _subjectBuffer.CurrentSnapshot.AsText());
-
-                        EnqueueParseSnapshotTask(document, parsedSnapshot);
-                        return;
+                        EnqueueParseSnapshotTask(document);
                     }
                 }
             }
 
             public void DisconnectFromWorkspace()
             {
-                if (_isClassificationOnlyWorkspace)
-                {
-                    _workspace.Dispose();
-                    _workspace = null;
-                    _isClassificationOnlyWorkspace = false;
-                }
-                else if (_workspace != null)
+                if (_workspace != null)
                 {
                     _workspace.WorkspaceChanged -= this.OnWorkspaceChanged;
                     _workspace.DocumentOpened -= this.OnDocumentOpened;
                     _workspace.DocumentActiveContextChanged -= this.OnDocumentActiveContextChanged;
 
                     _workspace = null;
-                }
 
-                ResetLastParsedDocument();
+                    ResetLastParsedDocument();
+                }
             }
 
             private void EnqueueParseSnapshotTask(Document newDocument)
             {
-                Contract.Assert(!_isClassificationOnlyWorkspace, "classification-only workspaces must provide the corresponding snapshot");
-
-                _workQueue.EnqueueBackgroundTask(
-                    c => this.EnqueueParseSnapshotWorkerAsync(newDocument, c),
-                    GetType() + ".EnqueueParseSnapshotTask.1",
-                    CancellationToken.None);
-            }
-
-            private void EnqueueParseSnapshotTask(Document newDocument, ITextSnapshot snapshot)
-            {
-                _workQueue.EnqueueBackgroundTask(
-                    c => this.EnqueueParseSnapshotWorkerAsync(newDocument, snapshot, c),
-                    GetType() + ".EnqueueParseSnapshotTask.1",
-                    CancellationToken.None);
+                if (newDocument != null)
+                {
+                    _workQueue.EnqueueBackgroundTask(c => this.EnqueueParseSnapshotWorkerAsync(newDocument, c), GetType() + ".EnqueueParseSnapshotTask.1", CancellationToken.None);
+                }
             }
 
             private async Task EnqueueParseSnapshotWorkerAsync(Document document, CancellationToken cancellationToken)
             {
-                Contract.Assert(!_isClassificationOnlyWorkspace, "classification-only workspaces must provide the corresponding snapshot");
-
                 // we will enqueue new one soon, cancel pending refresh right away
                 _reportChangeCancellationSource.Cancel();
 
@@ -252,14 +189,8 @@ private async Task EnqueueParseSnapshotWorkerAsync(Document document, Cancellati
                     return;
                 }
 
-                await EnqueueParseSnapshotWorkerAsync(document, snapshot, cancellationToken).ConfigureAwait(false);
-            }
-
-            private async Task EnqueueParseSnapshotWorkerAsync(Document document, ITextSnapshot snapshot, CancellationToken cancellationToken)
-            {
                 // preemptively parse file in background so that when we are called from tagger from UI thread, we have tree ready.
                 var syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
-
                 lock (_gate)
                 {
                     _lastParsedSnapshot = snapshot;
@@ -302,37 +233,26 @@ public IEnumerable<ITagSpan<IClassificationTag>> GetTags(NormalizedSnapshotSpanC
             {
                 using (Logger.LogBlock(FunctionId.Tagger_SyntacticClassification_TagComputer_GetTags, CancellationToken.None))
                 {
-                    if (!_cachedTaggableStatus.HasValue)
+                    if (spans.Count > 0 && _workspace != null)
                     {
-                        if (!_isClassificationOnlyWorkspace)
-                        {
-                            _cachedTaggableStatus = true;
-                        }
-                        else
+                        var firstSpan = spans[0];
+                        var languageServices = _workspace.Services.GetLanguageServices(firstSpan.Snapshot.ContentType);
+                        if (languageServices != null)
                         {
-                            var wpfTextViews = _associatedViewService.GetAssociatedTextViews(_subjectBuffer);
-                            if (wpfTextViews.Any())
-                            {
-                                _cachedTaggableStatus = _viewSupportsClassificationServiceOpt?.CanClassifyViews(wpfTextViews.Cast<ITextView>()) ?? true;
-                            }
-                        }
-                    }
+                            var classificationService = languageServices.GetService<IEditorClassificationService>();
 
-                    if (_cachedTaggableStatus == false)
-                    {
-                        return SpecializedCollections.EmptyEnumerable<ITagSpan<IClassificationTag>>();
-                    }
+                            if (classificationService != null)
+                            {
+                                var classifiedSpans = ClassificationUtilities.GetOrCreateClassifiedSpanList();
 
-                    if (spans.Count > 0)
-                    {
-                        var classifiedSpans = ClassificationUtilities.GetOrCreateClassifiedSpanList();
+                                foreach (var span in spans)
+                                {
+                                    AddClassifiedSpans(classificationService, span, classifiedSpans);
+                                }
 
-                        foreach (var span in spans)
-                        {
-                            AddClassifiedSpans(_editorClassificationService, span, classifiedSpans);
+                                return ClassificationUtilities.ConvertAndReturnList(_typeMap, spans[0].Snapshot, classifiedSpans);
+                            }
                         }
-
-                        return ClassificationUtilities.ConvertAndReturnList(_typeMap, spans[0].Snapshot, classifiedSpans);
                     }
 
                     return SpecializedCollections.EmptyEnumerable<ITagSpan<IClassificationTag>>();