Don't push non-intersecting nodes/tokens to the classification stack

src/Workspaces/Core/Portable/Classification/SyntaxClassification/AbstractSyntaxClassificationService.Worker.cs

@@ -29,6 +29,7 @@ private readonly ref struct Worker
         private readonly ClassificationOptions _options;
 
         private static readonly ObjectPool<SegmentedList<ClassifiedSpan>> s_listPool = new(() => []);
+        private static readonly ObjectPool<Stack<SyntaxNodeOrToken>> s_stackPool = new(() => new(), trimOnFree: false);
 
         private Worker(
             SemanticModel semanticModel,
@@ -49,7 +50,7 @@ private Worker(
 
             // get one from pool
             _set = SharedPools.Default<SegmentedHashSet<ClassifiedSpan>>().AllocateAndClear();
-            _pendingNodes = SharedPools.Default<Stack<SyntaxNodeOrToken>>().AllocateAndClear();
+            _pendingNodes = s_stackPool.Allocate();
         }
 
         internal static void Classify(
@@ -77,8 +78,8 @@ public void Dispose()
             // threshold simply with a single classified screen.  This allows reuse of those sets without causing
             // lots of garbage.
             _set.Clear();
+            s_stackPool.ClearAndFree(_pendingNodes);
             SharedPools.Default<SegmentedHashSet<ClassifiedSpan>>().Free(_set);
-            SharedPools.Default<Stack<SyntaxNodeOrToken>>().ClearAndFree(this._pendingNodes);
         }
 
         private void AddClassification(TextSpan textSpan, string type)
@@ -100,29 +101,23 @@ private void ProcessNodes()
             {
                 _cancellationToken.ThrowIfCancellationRequested();
 
-                if (nodeOrToken.FullSpan.IntersectsWith(_textSpan))
-                {
-                    ClassifyNodeOrToken(nodeOrToken);
+                ClassifyNodeOrToken(nodeOrToken);
 
-                    foreach (var child in nodeOrToken.ChildNodesAndTokens())
-                    {
+                foreach (var child in nodeOrToken.ChildNodesAndTokens())
+                {
+                    // Only push children that intersect the span we're classifying.  This way we keep the stack size small.
+                    if (child.FullSpan.IntersectsWith(_textSpan))
                         _pendingNodes.Push(child);
-                    }
                 }
             }
         }
 
         private void ClassifyNodeOrToken(SyntaxNodeOrToken nodeOrToken)
         {
-            var node = nodeOrToken.AsNode();
-            if (node != null)
-            {
+            if (nodeOrToken.AsNode(out var node))
                 ClassifyNode(node);
-            }
             else
-            {
                 ClassifyToken(nodeOrToken.AsToken());
-            }
         }
 
         private void ClassifyNode(SyntaxNode syntax)
@@ -149,9 +144,7 @@ private void AddClassifications(SegmentedList<ClassifiedSpan> classifications)
         private void AddClassification(ClassifiedSpan classification)
         {
             if (classification.ClassificationType != null)
-            {
                 AddClassification(classification.TextSpan, classification.ClassificationType);
-            }
         }
 
         private void ClassifyToken(SyntaxToken syntax)
@@ -179,10 +172,8 @@ private void ClassifyStructuredTrivia(SyntaxTriviaList triviaList)
             {
                 _cancellationToken.ThrowIfCancellationRequested();
 
-                if (trivia.HasStructure)
-                {
+                if (trivia.HasStructure && trivia.FullSpan.IntersectsWith(_textSpan))
                     _pendingNodes.Push(trivia.GetStructure());
-                }
             }
         }
     }

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/ObjectPools/Extensions.cs

@@ -204,7 +204,7 @@ public static void ClearAndFree<T>(this ObjectPool<Stack<T>> pool, Stack<T> set)
         var count = set.Count;
         set.Clear();
 
-        if (count > Threshold)
+        if (count > Threshold && pool.TrimOnFree)
         {
             set.TrimExcess();
         }