Optimize editor taggers and solution queries

Performance improvements to reduce unnecessary work:

Tagger optimizations:
- InternalTaggerBase now forwards only the actual changed span instead
  of invalidating the entire document on token tag changes
- TokenTaggerBase.GetTags() filters tags by intersection testing,
  returning only tags overlapping the requested spans with proper
  snapshot translation
- TokenTaggerBase.OnTagsUpdated() computes minimal bounding span of
  actual changes rather than invalidating the entire document

Solution enumeration optimizations:
- GetAllProjectsAsync() and GetProjectAsync() now resolve
  IVsHierarchyItemManager once upfront and use synchronous
  FromHierarchyItem() instead of awaiting FromHierarchyAsync()
  in each iteration, eliminating repeated async/await overhead

These changes significantly reduce editor invalidation overhead and
improve responsiveness, especially in large documents and solutions.
[release]

Author: madskristensen

src/toolkit/Community.VisualStudio.Toolkit.Shared/MEF/InternalTaggerBase.cs

@@ -31,10 +31,15 @@ public InternalTaggerBase(ITagAggregator<TokenTag>? tags)
 
         private void TokenTagsChanged(object sender, TagsChangedEventArgs e)
         {
-            ITextBuffer buffer = e.Span.BufferGraph.TopBuffer;
-            SnapshotSpan span = new(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length);
+            IMappingSpan mappingSpan = e.Span;
+            NormalizedSnapshotSpanCollection spans = mappingSpan.GetSpans(mappingSpan.BufferGraph.TopBuffer.CurrentSnapshot);
 
-            TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(span));
+            if (spans.Count > 0)
+            {
+                // Forward the actual changed span instead of manufacturing a full-document span
+                SnapshotSpan changedSpan = new(spans[0].Start, spans[spans.Count - 1].End);
+                TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(changedSpan));
+            }
         }
 
         /// <inheritdoc/>

src/toolkit/Community.VisualStudio.Toolkit.Shared/MEF/TokenTaggerBase.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -58,7 +58,29 @@ private void Tokenize(bool runFirstTokenizationImmediately)
         /// <inheritdoc/>
         public IEnumerable<ITagSpan<TokenTag>> GetTags(NormalizedSnapshotSpanCollection spans)
         {
-            return TagsCache;
+            if (spans.Count == 0)
+            {
+                yield break;
+            }
+
+            List<ITagSpan<TokenTag>> cache = TagsCache;
+            ITextSnapshot requestedSnapshot = spans[0].Snapshot;
+
+            foreach (ITagSpan<TokenTag> tagSpan in cache)
+            {
+                SnapshotSpan tagSnapshotSpan = tagSpan.Span;
+
+                // Translate the tag span to the requested snapshot if needed
+                if (tagSnapshotSpan.Snapshot != requestedSnapshot)
+                {
+                    tagSnapshotSpan = tagSnapshotSpan.TranslateTo(requestedSnapshot, SpanTrackingMode.EdgeExclusive);
+                }
+
+                if (spans.IntersectsWith(tagSnapshotSpan))
+                {
+                    yield return tagSpan;
+                }
+            }
         }
 
         /// <summary>
@@ -102,9 +124,51 @@ public virtual Task<object> GetTooltipAsync(SnapshotPoint triggerPoint)
         /// <param name="tags"></param>
         protected void OnTagsUpdated(List<ITagSpan<TokenTag>> tags)
         {
+            List<ITagSpan<TokenTag>> oldTags = TagsCache;
             TagsCache = tags;
-            SnapshotSpan span = new(Buffer.CurrentSnapshot, 0, Buffer.CurrentSnapshot.Length);
-            TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(span));
+
+            if (TagsChanged == null)
+            {
+                return;
+            }
+
+            ITextSnapshot currentSnapshot = Buffer.CurrentSnapshot;
+
+            // Compute the minimal bounding span covering old and new tags
+            int minStart = int.MaxValue;
+            int maxEnd = int.MinValue;
+
+            ComputeBounds(oldTags, currentSnapshot, ref minStart, ref maxEnd);
+            ComputeBounds(tags, currentSnapshot, ref minStart, ref maxEnd);
+
+            if (minStart <= maxEnd && minStart != int.MaxValue)
+            {
+                SnapshotSpan changedSpan = new(currentSnapshot, minStart, maxEnd - minStart);
+                TagsChanged.Invoke(this, new SnapshotSpanEventArgs(changedSpan));
+            }
+        }
+
+        private static void ComputeBounds(List<ITagSpan<TokenTag>> tags, ITextSnapshot currentSnapshot, ref int minStart, ref int maxEnd)
+        {
+            foreach (ITagSpan<TokenTag> tagSpan in tags)
+            {
+                SnapshotSpan span = tagSpan.Span;
+
+                if (span.Snapshot != currentSnapshot)
+                {
+                    span = span.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive);
+                }
+
+                if (span.Start.Position < minStart)
+                {
+                    minStart = span.Start.Position;
+                }
+
+                if (span.End.Position > maxEnd)
+                {
+                    maxEnd = span.End.Position;
+                }
+            }
         }
 
         /// <inheritdoc/>

src/toolkit/Community.VisualStudio.Toolkit.Shared/Solution/Solutions.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
@@ -86,11 +86,15 @@ public async Task<IEnumerable<Project>> GetAllProjectsAsync(ProjectStateFilter f
             IVsSolution solution = await VS.Services.GetSolutionAsync();
             IEnumerable<IVsHierarchy> hierarchies = solution.GetAllProjectHierarchies(filter);
 
+            // Resolve the hierarchy item manager once instead of per-iteration
+            IVsHierarchyItemManager manager = await VS.GetMefServiceAsync<IVsHierarchyItemManager>();
+
             List<Project> list = new();
 
             foreach (IVsHierarchy hierarchy in hierarchies)
             {
-                Project? proj = await SolutionItem.FromHierarchyAsync(hierarchy, VSConstants.VSITEMID_ROOT) as Project;
+                IVsHierarchyItem hierItem = manager.GetHierarchyItem(hierarchy, VSConstants.VSITEMID_ROOT);
+                Project? proj = SolutionItem.FromHierarchyItem(hierItem) as Project;
 
                 if (proj?.Type == SolutionItemType.Project)
                 {
@@ -112,9 +116,14 @@ public async Task<IEnumerable<Project>> GetAllProjectsAsync(ProjectStateFilter f
             IVsSolution solution = await VS.Services.GetSolutionAsync();
             IEnumerable<IVsHierarchy> hierarchies = solution.GetAllProjectHierarchies(ProjectStateFilter.All);
 
+            // Resolve the hierarchy item manager once instead of per-iteration
+            IVsHierarchyItemManager manager = await VS.GetMefServiceAsync<IVsHierarchyItemManager>();
+
             foreach (IVsHierarchy hierarchy in hierarchies)
             {
-                Project? proj = await SolutionItem.FromHierarchyAsync(hierarchy, VSConstants.VSITEMID_ROOT) as Project;
+                IVsHierarchyItem hierItem = manager.GetHierarchyItem(hierarchy, VSConstants.VSITEMID_ROOT);
+                Project? proj = SolutionItem.FromHierarchyItem(hierItem) as Project;
+
                 if (proj != null)
                 {
                     if (proj.Type == SolutionItemType.Project && string.Compare(proj.Name, projectName, true) == 0)