Forced parsing to a background thread

[release]
madskristensen · Jan 2, 2022 · 44cdc00 · 44cdc00
1 parent 737d5ab
commit 44cdc00
Show file tree

Hide file tree

Showing 13 changed files with 84 additions and 83 deletions.
diff --git a/src/RestClient/Parser/Document.cs b/src/RestClient/Parser/Document.cs
@@ -11,7 +11,7 @@ public partial class Document
         protected Document(string[] lines)
         {
             _lines = lines;
-            _ = ParseAsync();
+            Parse();
         }
 
         public List<ParseItem> Items { get; private set; } = new List<ParseItem>();

diff --git a/src/RestClient/Parser/DocumentParser.cs b/src/RestClient/Parser/DocumentParser.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 
 namespace RestClient
 {
@@ -16,42 +15,45 @@ public partial class Document
         public bool IsParsing { get; private set; }
         public bool IsValid { get; private set; }
 
-        public Task ParseAsync()
+        public void Parse()
         {
             IsParsing = true;
+            var isSuccess = false;
+            var start = 0;
 
-            return Task.Run(() =>
+            try
             {
-                var start = 0;
+                List<ParseItem> tokens = new();
 
-                try
+                foreach (var line in _lines)
                 {
-                    List<ParseItem> tokens = new();
+                    IEnumerable<ParseItem>? current = ParseLine(start, line, tokens);
 
-                    foreach (var line in _lines)
+                    if (current != null)
                     {
-                        IEnumerable<ParseItem>? current = ParseLine(start, line, tokens);
+                        tokens.AddRange(current);
+                    }
 
-                        if (current != null)
-                        {
-                            tokens.AddRange(current);
-                        }
+                    start += line.Length;
+                }
 
-                        start += line.Length;
-                    }
+                Items = tokens;
 
-                    Items = tokens;
+                OrganizeItems();
+                ExpandVariables();
+                ValidateDocument();
 
-                    OrganizeItems();
-                    ExpandVariables();
-                    ValidateDocument();
-                }
-                finally
+                isSuccess = true;
+            }
+            finally
+            {
+                IsParsing = false;
+
+                if (isSuccess)
                 {
-                    IsParsing = false;
                     Parsed?.Invoke(this, EventArgs.Empty);
                 }
-            });
+            }
         }
 
         private IEnumerable<ParseItem> ParseLine(int start, string line, List<ParseItem> tokens)

diff --git a/src/RestClientVS/Commands/GoToDefinitionCommand.cs b/src/RestClientVS/Commands/GoToDefinitionCommand.cs
@@ -21,7 +21,7 @@ public bool ExecuteCommand(GoToDefinitionCommandArgs args, CommandExecutionConte
         {
             var position = args.TextView.Caret.Position.BufferPosition.Position;
 
-            Document document = RestDocument.FromTextbuffer(args.TextView.TextBuffer);
+            Document document = args.TextView.TextBuffer.GetRestDocument();
             ParseItem token = document.FindItemFromPosition(position);
 
             if (token?.Type == ItemType.Reference)

diff --git a/src/RestClientVS/Commands/SendRequestCommand.cs b/src/RestClientVS/Commands/SendRequestCommand.cs
@@ -20,7 +20,7 @@ protected override async Task ExecuteAsync(OleMenuCmdEventArgs e)
             if (docView != null)
             {
                 var position = docView.TextView.Caret.Position.BufferPosition.Position;
-                Document doc = RestDocument.FromTextbuffer(docView.TextBuffer);
+                Document doc = docView.TextBuffer.GetRestDocument();
                 Request request = doc.Requests.FirstOrDefault(r => r.Contains(position));
 
                 if (request != null)

diff --git a/src/RestClientVS/ExtensionMethods.cs b/src/RestClientVS/ExtensionMethods.cs
@@ -7,5 +7,8 @@ public static class ExtensionMethods
     {
         public static Span ToSpan(this ParseItem token) =>
             new(token.Start, token.Length);
+
+        public static RestDocument GetRestDocument(this ITextBuffer buffer) =>
+            buffer.Properties.GetOrCreateSingletonProperty(() => new RestDocument(buffer));
     }
 }
diff --git a/src/RestClientVS/Language/RestCompletionSource.cs b/src/RestClientVS/Language/RestCompletionSource.cs
@@ -44,7 +44,7 @@ public Task<CompletionContext> GetCompletionContextAsync(IAsyncCompletionSession
         {
             ITextSnapshotLine line = triggerLocation.GetContainingLine();
 
-            Document document = RestDocument.FromTextbuffer(session.TextView.TextBuffer);
+            Document document = session.TextView.TextBuffer.GetRestDocument();
             SnapshotPoint lineStart = line.Start;
             ParseItem token = GetPreviousToken(document, lineStart, out var hasEmptyLine);
 
@@ -167,7 +167,7 @@ public CompletionStartData InitializeCompletion(CompletionTrigger trigger, Snaps
                 return CompletionStartData.DoesNotParticipateInCompletion;
             }
 
-            Document document = RestDocument.FromTextbuffer(triggerLocation.Snapshot.TextBuffer);
+            Document document = triggerLocation.Snapshot.TextBuffer.GetRestDocument();
             ParseItem item = document?.FindItemFromPosition(triggerLocation.Position);
 
             if (item?.Type == ItemType.Reference)

diff --git a/src/RestClientVS/Language/RestIntratextAdornmentTagger.cs b/src/RestClientVS/Language/RestIntratextAdornmentTagger.cs
@@ -30,7 +30,7 @@ internal class RestIntratextAdornmentTagger : ITagger<IntraTextAdornmentTag>
         public RestIntratextAdornmentTagger(ITextBuffer buffer)
         {
             _buffer = buffer;
-            _document = RestDocument.FromTextbuffer(buffer);
+            _document = buffer.GetRestDocument();
         }
 
         public IEnumerable<ITagSpan<IntraTextAdornmentTag>> GetTags(NormalizedSnapshotSpanCollection spans)

diff --git a/src/RestClientVS/Language/TokenTagger.cs b/src/RestClientVS/Language/TokenTagger.cs
@@ -8,6 +8,7 @@
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Adornments;
 using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Threading;
 using Microsoft.VisualStudio.Utilities;
 using RestClient;
 
@@ -34,10 +35,15 @@ internal class TokenTagger : ITagger<TokenTag>, IDisposable
         internal TokenTagger(ITextBuffer buffer)
         {
             _buffer = buffer;
-            _document = RestDocument.FromTextbuffer(buffer);
+            _document = buffer.GetRestDocument();
             _document.Parsed += ReParse;
             _tagsCache = new Dictionary<ParseItem, ITagSpan<TokenTag>>();
-            ReParse();
+
+            ThreadHelper.JoinableTaskFactory.RunAsync(async () =>
+            {
+                await TaskScheduler.Default;
+                ReParse();
+            }).FireAndForget();
         }
 
         public IEnumerable<ITagSpan<TokenTag>> GetTags(NormalizedSnapshotSpanCollection spans)
@@ -47,26 +53,31 @@ public IEnumerable<ITagSpan<TokenTag>> GetTags(NormalizedSnapshotSpanCollection
 
         private void ReParse(object sender = null, EventArgs e = null)
         {
-            ThreadHelper.JoinableTaskFactory.StartOnIdle(() =>
-            {
-                Dictionary<ParseItem, ITagSpan<TokenTag>> list = new();
+            // Make sure this is running on a background thread.
+            ThreadHelper.ThrowIfOnUIThread();
 
-                foreach (ParseItem item in _document.Items)
-                {
-                    AddTagToList(list, item);
+            Dictionary<ParseItem, ITagSpan<TokenTag>> list = new();
 
-                    foreach (ParseItem variable in item.References)
-                    {
-                        AddTagToList(list, variable);
-                    }
+            foreach (ParseItem item in _document.Items)
+            {
+                if (_document.IsParsing)
+                {
+                    // Abort and wait for the next parse event to finish
+                    return;
                 }
 
-                _tagsCache = list;
+                AddTagToList(list, item);
+
+                foreach (ParseItem variable in item.References)
+                {
+                    AddTagToList(list, variable);
+                }
+            }
 
-                SnapshotSpan span = new(_buffer.CurrentSnapshot, 0, _buffer.CurrentSnapshot.Length);
-                TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(span));
+            _tagsCache = list;
 
-            }, VsTaskRunContext.UIThreadIdlePriority).FireAndForget();
+            SnapshotSpan span = new(_buffer.CurrentSnapshot, 0, _buffer.CurrentSnapshot.Length);
+            TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(span));
         }
 
         private void AddTagToList(Dictionary<ParseItem, ITagSpan<TokenTag>> list, ParseItem item)

diff --git a/src/RestClientVS/RestClientVS.csproj b/src/RestClientVS/RestClientVS.csproj
@@ -108,6 +108,9 @@
     <PackageReference Include="Community.VisualStudio.Toolkit.17" Version="17.0.365" ExcludeAssets="Runtime">
       <IncludeAssets>compile; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Microsoft.VisualStudio.Threading">
+      <Version>17.0.64</Version>
+    </PackageReference>
     <PackageReference Include="Microsoft.VSSDK.BuildTools" Version="17.0.5232" />
   </ItemGroup>
   <ItemGroup>

diff --git a/src/RestClientVS/RestDocument.cs b/src/RestClientVS/RestDocument.cs
@@ -1,5 +1,7 @@
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Threading;
 using RestClient;
 
 namespace RestClientVS
@@ -20,13 +22,12 @@ public RestDocument(ITextBuffer buffer)
 
             FileName = buffer.GetFileName();
 
-#pragma warning disable VSTHRD104 // Offer async methods
-            ThreadHelper.JoinableTaskFactory.Run(async () =>
+            ThreadHelper.JoinableTaskFactory.RunAsync(async () =>
             {
+                await Task.Yield();
                 Project project = await VS.Solutions.GetActiveProjectAsync();
                 ProjectName = project?.Name;
-            });
-#pragma warning restore VSTHRD104 // Offer async methods
+            }).FireAndForget();
         }
 
         private void BufferChanged(object sender, TextContentChangedEventArgs e)
@@ -35,9 +36,10 @@ private void BufferChanged(object sender, TextContentChangedEventArgs e)
             ParseAsync().FireAndForget();
         }
 
-        public static RestDocument FromTextbuffer(ITextBuffer buffer)
+        private async Task ParseAsync()
         {
-            return buffer.Properties.GetOrCreateSingletonProperty(() => new RestDocument(buffer));
+            await TaskScheduler.Default;
+            Parse();
         }
 
         public void Dispose()

diff --git a/test/RestClientTest/HttpTest.cs b/test/RestClientTest/HttpTest.cs
@@ -17,7 +17,6 @@ public class HttpTest
         public async Task SendAsync(string url)
         {
             var doc = Document.FromLines(url);
-            await doc.WaitForParsingCompleteAsync();
 
             RequestResult client = await RequestSender.SendAsync(doc.Requests.First(), TimeSpan.FromSeconds(10));
             var raw = await client.Response.ToRawStringAsync();