Merge pull request #4584 from CyrusNajmabadi/usingTaggers

Place taggers in using blocks in tests.

src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource_ReferenceCounting.cs

@@ -19,9 +19,11 @@ private partial class TagSource
                 {
 #if DEBUG
                     Contract.Fail($@"Should have been disposed!
+DataSource-StackTrace:
+{_dataSource.StackTrace}
 
-{_stackTrace}
-");
+StackTrace:
+{_stackTrace}");
 #else
                     Contract.Fail($@"Should have been disposed! Try running in Debug to get the allocation callstack");
 #endif

src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.cs

 // 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.Collections.Generic;
-using System.Linq;
+#if DEBUG
+using System.Diagnostics;
+#endif
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
@@ -67,12 +69,20 @@ internal abstract partial class AbstractAsynchronousTaggerProvider<TTag> where T
         protected virtual IEnumerable<Option<bool>> Options => SpecializedCollections.EmptyEnumerable<Option<bool>>();
         protected virtual IEnumerable<PerLanguageOption<bool>> PerLanguageOptions => SpecializedCollections.EmptyEnumerable<PerLanguageOption<bool>>();
 
+#if DEBUG
+        public readonly string StackTrace;
+#endif
+
         protected AbstractAsynchronousTaggerProvider(
             IAsynchronousOperationListener asyncListener,
             IForegroundNotificationService notificationService)
         {
-            this._asyncListener = asyncListener;
-            this._notificationService = notificationService;
+            _asyncListener = asyncListener;
+            _notificationService = notificationService;
+
+#if DEBUG
+            StackTrace = new StackTrace().ToString();
+#endif
         }
 
         private TagSource CreateTagSource(ITextView textViewOpt, ITextBuffer subjectBuffer)

src/EditorFeatures/Test/Diagnostics/DiagnosticTagSourceTests.cs

@@ -46,36 +46,38 @@ public void Test_TagSourceDiffer()
                     workspace.Services.GetService<IOptionService>(), diagnosticService,
                     workspace.GetService<IForegroundNotificationService>(), listeners);
                 var tagger = provider.CreateTagger<IErrorTag>(workspace.Documents.First().GetTextBuffer());
+                using (var disposable = tagger as IDisposable)
+                {
 
-                var service = workspace.Services.GetService<ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
-                var incrementalAnalyzers = ImmutableArray.Create(analyzerService.CreateIncrementalAnalyzer(workspace));
+                    var service = workspace.Services.GetService<ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
+                    var incrementalAnalyzers = ImmutableArray.Create(analyzerService.CreateIncrementalAnalyzer(workspace));
 
-                // test first update
-                service.WaitUntilCompletion_ForTestingPurposesOnly(workspace, incrementalAnalyzers);
+                    // test first update
+                    service.WaitUntilCompletion_ForTestingPurposesOnly(workspace, incrementalAnalyzers);
 
-                listener.CreateWaitTask().PumpingWait();
+                    listener.CreateWaitTask().PumpingWait();
 
-                var snapshot = workspace.Documents.First().GetTextBuffer().CurrentSnapshot;
-                var spans = tagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(snapshot, 0, snapshot.Length))).ToList();
-                Assert.True(spans.First().Span.Contains(new Span(0, 1)));
+                    var snapshot = workspace.Documents.First().GetTextBuffer().CurrentSnapshot;
+                    var spans = tagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(snapshot, 0, snapshot.Length))).ToList();
+                    Assert.True(spans.First().Span.Contains(new Span(0, 1)));
 
-                // test second update
-                analyzer.ChangeSeverity();
+                    // test second update
+                    analyzer.ChangeSeverity();
 
-                var document = workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id);
-                var text = document.GetTextAsync().Result;
-                workspace.TryApplyChanges(document.WithText(text.WithChanges(new TextChange(new TextSpan(text.Length - 1, 1), string.Empty))).Project.Solution);
+                    var document = workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id);
+                    var text = document.GetTextAsync().Result;
+                    workspace.TryApplyChanges(document.WithText(text.WithChanges(new TextChange(new TextSpan(text.Length - 1, 1), string.Empty))).Project.Solution);
 
-                service.WaitUntilCompletion_ForTestingPurposesOnly(workspace, incrementalAnalyzers);
+                    service.WaitUntilCompletion_ForTestingPurposesOnly(workspace, incrementalAnalyzers);
 
-                listener.CreateWaitTask().PumpingWait();
+                    listener.CreateWaitTask().PumpingWait();
 
-                snapshot = workspace.Documents.First().GetTextBuffer().CurrentSnapshot;
-                spans = tagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(snapshot, 0, snapshot.Length))).ToList();
-                Assert.True(spans.First().Span.Contains(new Span(0, 1)));
+                    snapshot = workspace.Documents.First().GetTextBuffer().CurrentSnapshot;
+                    spans = tagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(snapshot, 0, snapshot.Length))).ToList();
+                    Assert.True(spans.First().Span.Contains(new Span(0, 1)));
 
-                ((IDisposable)tagger).Dispose();
-                registrationService.Unregister(workspace);
+                    registrationService.Unregister(workspace);
+                }
             }
         }
 

src/EditorFeatures/Test/Preview/PreviewWorkspaceTests.cs

@@ -238,34 +238,35 @@ public void TestPreviewDiagnosticTaggerInPreviewPane()
                 var leftBuffer = diffView.LeftView.BufferGraph.GetTextBuffers(t => t.ContentType.IsOfType(ContentTypeNames.CSharpContentType)).First();
                 var leftProvider = new DiagnosticsSquiggleTaggerProvider(optionsService, diagnosticService, foregroundService, listeners);
                 var leftTagger = leftProvider.CreateTagger<IErrorTag>(leftBuffer);
-
-                var rightBuffer = diffView.RightView.BufferGraph.GetTextBuffers(t => t.ContentType.IsOfType(ContentTypeNames.CSharpContentType)).First();
-                var rightProvider = new DiagnosticsSquiggleTaggerProvider(optionsService, diagnosticService, foregroundService, listeners);
-                var rightTagger = rightProvider.CreateTagger<IErrorTag>(rightBuffer);
-
-                // wait up to 20 seconds for diagnostics
-                taskSource.Task.Wait(20000);
-                if (!taskSource.Task.IsCompleted)
+                using (var leftDisposable = leftTagger as IDisposable)
                 {
-                    // something is wrong
-                    FatalError.Report(new System.Exception("not finished after 20 seconds"));
+                    var rightBuffer = diffView.RightView.BufferGraph.GetTextBuffers(t => t.ContentType.IsOfType(ContentTypeNames.CSharpContentType)).First();
+                    var rightProvider = new DiagnosticsSquiggleTaggerProvider(optionsService, diagnosticService, foregroundService, listeners);
+                    var rightTagger = rightProvider.CreateTagger<IErrorTag>(rightBuffer);
+                    using (var rightDisposable = rightTagger as IDisposable)
+                    {
+                        // wait up to 20 seconds for diagnostics
+                        taskSource.Task.Wait(20000);
+                        if (!taskSource.Task.IsCompleted)
+                        {
+                            // something is wrong
+                            FatalError.Report(new System.Exception("not finished after 20 seconds"));
+                        }
+
+                        // wait taggers
+                        waiter.CreateWaitTask().PumpingWait();
+
+                        // check left buffer
+                        var leftSnapshot = leftBuffer.CurrentSnapshot;
+                        var leftSpans = leftTagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(leftSnapshot, 0, leftSnapshot.Length))).ToList();
+                        Assert.Equal(1, leftSpans.Count);
+
+                        // check right buffer
+                        var rightSnapshot = rightBuffer.CurrentSnapshot;
+                        var rightSpans = rightTagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(rightSnapshot, 0, rightSnapshot.Length))).ToList();
+                        Assert.Equal(0, rightSpans.Count);
+                    }
                 }
-
-                // wait taggers
-                waiter.CreateWaitTask().PumpingWait();
-
-                // check left buffer
-                var leftSnapshot = leftBuffer.CurrentSnapshot;
-                var leftSpans = leftTagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(leftSnapshot, 0, leftSnapshot.Length))).ToList();
-                Assert.Equal(1, leftSpans.Count);
-
-                // check right buffer
-                var rightSnapshot = rightBuffer.CurrentSnapshot;
-                var rightSpans = rightTagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(rightSnapshot, 0, rightSnapshot.Length))).ToList();
-                Assert.Equal(0, rightSpans.Count);
-
-                ((IDisposable)leftTagger).Dispose();
-                ((IDisposable)rightTagger).Dispose();
             }
         }
 

src/EditorFeatures/Test/Squiggles/AbstractSquiggleProducerTests.cs

@@ -47,19 +47,20 @@ public static class SquiggleUtilities
             var foregroundService = workspace.GetService<IForegroundNotificationService>();
             var taggerProvider = new DiagnosticsSquiggleTaggerProvider(optionsService, diagnosticService, foregroundService, listeners);
             var tagger = taggerProvider.CreateTagger<IErrorTag>(buffer);
+            using (var disposable = tagger as IDisposable)
+            {
+                var service = workspace.Services.GetService<ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
+                service.WaitUntilCompletion_ForTestingPurposesOnly(workspace, ImmutableArray.Create(analyzerService.CreateIncrementalAnalyzer(workspace)));
 
-            var service = workspace.Services.GetService<ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
-            service.WaitUntilCompletion_ForTestingPurposesOnly(workspace, ImmutableArray.Create(analyzerService.CreateIncrementalAnalyzer(workspace)));
-
-            listener.CreateWaitTask().PumpingWait();
+                listener.CreateWaitTask().PumpingWait();
 
-            var snapshot = buffer.CurrentSnapshot;
-            var spans = tagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(snapshot, 0, snapshot.Length))).ToList();
+                var snapshot = buffer.CurrentSnapshot;
+                var spans = tagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(snapshot, 0, snapshot.Length))).ToList();
 
-            ((IDisposable)tagger).Dispose();
-            registrationService.Unregister(workspace);
+                registrationService.Unregister(workspace);
 
-            return spans;
+                return spans;
+            }
         }
     }
 
@@ -89,17 +90,17 @@ internal static IList<ITagSpan<IErrorTag>> GetErrorsFromUpdateSource(TestWorkspa
             var buffer = document.GetTextBuffer();
             var provider = new DiagnosticsSquiggleTaggerProvider(optionsService, diagnosticService, foregroundService, listeners);
             var tagger = provider.CreateTagger<IErrorTag>(buffer);
+            using (var disposable = tagger as IDisposable)
+            {
+                source.RaiseDiagnosticsUpdated(updateArgs);
 
-            source.RaiseDiagnosticsUpdated(updateArgs);
-
-            listener.CreateWaitTask().PumpingWait();
-
-            var snapshot = buffer.CurrentSnapshot;
-            var spans = tagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(snapshot, 0, snapshot.Length))).ToImmutableArray();
+                listener.CreateWaitTask().PumpingWait();
 
-            ((IDisposable)tagger).Dispose();
+                var snapshot = buffer.CurrentSnapshot;
+                var spans = tagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(snapshot, 0, snapshot.Length))).ToImmutableArray();
 
-            return spans;
+                return spans;
+            }
         }
 
         internal static DiagnosticData CreateDiagnosticData(TestWorkspace workspace, TestHostDocument document, TextSpan span)

src/Test/Utilities/Portable/TestBase.cs

@@ -586,6 +586,6 @@ protected static string NormalizeDiagnosticString(string inputString)
             return inputString;
         }
 
-        #endregion
+#endregion
     }
 }

src/VisualStudio/Core/Test/Diagnostics/MiscDiagnosticUpdateSourceTests.vb

@@ -42,19 +42,18 @@ class 123 { }
                 Dim foregroundService = workspace.GetService(Of IForegroundNotificationService)()
                 Dim provider = New DiagnosticsSquiggleTaggerProvider(optionsService, diagnosticService, foregroundService, listeners)
                 Dim tagger = provider.CreateTagger(Of IErrorTag)(buffer)
+                Using disposable = TryCast(tagger, IDisposable)
+                    Dim analyzer = miscService.CreateIncrementalAnalyzer(workspace)
+                    analyzer.AnalyzeSyntaxAsync(workspace.CurrentSolution.Projects.First().Documents.First(), CancellationToken.None).PumpingWait()
 
-                Dim analyzer = miscService.CreateIncrementalAnalyzer(workspace)
-                analyzer.AnalyzeSyntaxAsync(workspace.CurrentSolution.Projects.First().Documents.First(), CancellationToken.None).PumpingWait()
-
-                listener.CreateWaitTask().PumpingWait()
-
-                Dim snapshot = buffer.CurrentSnapshot
-                Dim spans = tagger.GetTags(New NormalizedSnapshotSpanCollection(New SnapshotSpan(snapshot, 0, snapshot.Length))).ToImmutableArray()
+                    listener.CreateWaitTask().PumpingWait()
 
-                Assert.True(spans.Count() > 0)
-                Assert.True(spans.All(Function(s) s.Span.Length > 0))
+                    Dim snapshot = buffer.CurrentSnapshot
+                    Dim spans = tagger.GetTags(New NormalizedSnapshotSpanCollection(New SnapshotSpan(snapshot, 0, snapshot.Length))).ToImmutableArray()
 
-                DirectCast(tagger, IDisposable).Dispose()
+                    Assert.True(spans.Count() > 0)
+                    Assert.True(spans.All(Function(s) s.Span.Length > 0))
+                End Using
             End Using
         End Sub