Reduce allocations in the C# lexer ctor (#76544)

* Attempt to reduce allocations in the C# lexer ctor

The lexer ctor shows as about 0.5% of all allocations over the lifetime of the RoslynCodeAnalysisProcess in the csharp editing speedometer tests.

There was already the concept of the LexerCache which had some pooling usage in it. This PR moves a couple other members to it to allow for their pooling.

Author: ToddGrun

src/Compilers/CSharp/Portable/Parser/Lexer.cs

@@ -89,6 +89,10 @@ internal sealed partial class Lexer : AbstractLexer
         private DocumentationCommentParser? _xmlParser;
         private DirectiveParser? _directiveParser;
 
+        private SyntaxListBuilder _leadingTriviaCache;
+        private SyntaxListBuilder _trailingTriviaCache;
+        private SyntaxListBuilder? _directiveTriviaCache;
+
         internal struct TokenInfo
         {
             // scanned values
@@ -116,11 +120,15 @@ public Lexer(SourceText text, CSharpParseOptions options, bool allowPreprocessor
             Debug.Assert(options != null);
 
             _options = options;
-            _builder = new StringBuilder();
-            _identBuffer = new char[32];
-            _cache = new LexerCache();
             _allowPreprocessorDirectives = allowPreprocessorDirectives;
             _interpolationFollowedByColon = interpolationFollowedByColon;
+
+            // Obtain pooled items
+            _cache = LexerCache.GetInstance();
+            _builder = _cache.StringBuilder;
+            _identBuffer = _cache.IdentBuffer;
+            _leadingTriviaCache = _cache.LeadingTriviaCache;
+            _trailingTriviaCache = _cache.TrailingTriviaCache;
         }
 
         public override void Dispose()
@@ -281,10 +289,6 @@ public SyntaxToken Lex(LexerMode mode)
             }
         }
 
-        private SyntaxListBuilder _leadingTriviaCache = new SyntaxListBuilder(10);
-        private SyntaxListBuilder _trailingTriviaCache = new SyntaxListBuilder(10);
-        private SyntaxListBuilder? _directiveTriviaCache;
-
         private static int GetFullWidth(SyntaxListBuilder? builder)
         {
             int width = 0;

src/Compilers/CSharp/Portable/Parser/LexerCache.cs

@@ -5,17 +5,16 @@
 // #define COLLECT_STATS
 
 using System;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.PooledObjects;
-using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.Syntax.InternalSyntax;
 using Roslyn.Utilities;
-using System.Text;
 
 namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax
 {
-    internal partial class LexerCache
+    internal class LexerCache
     {
+        private static readonly ObjectPool<LexerCache> s_lexerCachePool = new ObjectPool<LexerCache>(() => new LexerCache());
+
         private static readonly ObjectPool<CachingIdentityFactory<string, SyntaxKind>> s_keywordKindPool =
             CachingIdentityFactory<string, SyntaxKind>.CreatePool(
                             512,
@@ -30,23 +29,144 @@ internal partial class LexerCache
                                 return kind;
                             });
 
-        private readonly TextKeyedCache<SyntaxTrivia> _triviaMap;
-        private readonly TextKeyedCache<SyntaxToken> _tokenMap;
-        private readonly CachingIdentityFactory<string, SyntaxKind> _keywordKindMap;
+        private TextKeyedCache<SyntaxTrivia>? _triviaMap;
+        private TextKeyedCache<SyntaxToken>? _tokenMap;
+        private CachingIdentityFactory<string, SyntaxKind>? _keywordKindMap;
         internal const int MaxKeywordLength = 10;
 
-        internal LexerCache()
+        private PooledStringBuilder? _stringBuilder;
+        private readonly char[] _identBuffer;
+        private SyntaxListBuilder? _leadingTriviaCache;
+        private SyntaxListBuilder? _trailingTriviaCache;
+
+        private const int LeadingTriviaCacheInitialCapacity = 128;
+        private const int TrailingTriviaCacheInitialCapacity = 16;
+
+        private LexerCache()
+        {
+            _identBuffer = new char[32];
+        }
+
+        public static LexerCache GetInstance()
         {
-            _triviaMap = TextKeyedCache<SyntaxTrivia>.GetInstance();
-            _tokenMap = TextKeyedCache<SyntaxToken>.GetInstance();
-            _keywordKindMap = s_keywordKindPool.Allocate();
+            return s_lexerCachePool.Allocate();
         }
 
-        internal void Free()
+        public void Free()
         {
-            _keywordKindMap.Free();
-            _triviaMap.Free();
-            _tokenMap.Free();
+            if (_keywordKindMap != null)
+            {
+                _keywordKindMap.Free();
+                _keywordKindMap = null;
+            }
+
+            if (_triviaMap != null)
+            {
+                _triviaMap.Free();
+                _triviaMap = null;
+            }
+
+            if (_tokenMap != null)
+            {
+                _tokenMap.Free();
+                _tokenMap = null;
+            }
+
+            if (_stringBuilder != null)
+            {
+                _stringBuilder.Free();
+                _stringBuilder = null;
+            }
+
+            if (_leadingTriviaCache != null)
+            {
+                if (_leadingTriviaCache.Capacity > LeadingTriviaCacheInitialCapacity * 2)
+                {
+                    // Don't reuse _leadingTriviaCache if it has grown too large for pooling.
+                    _leadingTriviaCache = null;
+                }
+                else
+                {
+                    _leadingTriviaCache.Clear();
+                }
+            }
+
+            if (_trailingTriviaCache != null)
+            {
+                if (_trailingTriviaCache.Capacity > TrailingTriviaCacheInitialCapacity * 2)
+                {
+                    // Don't reuse _trailingTriviaCache if it has grown too large for pooling.
+                    _trailingTriviaCache = null;
+                }
+                else
+                {
+                    _trailingTriviaCache.Clear();
+                }
+            }
+
+            s_lexerCachePool.Free(this);
+        }
+
+        internal char[] IdentBuffer => _identBuffer;
+
+        private TextKeyedCache<SyntaxTrivia> TriviaMap
+        {
+            get
+            {
+                _triviaMap ??= TextKeyedCache<SyntaxTrivia>.GetInstance();
+
+                return _triviaMap;
+            }
+        }
+
+        private TextKeyedCache<SyntaxToken> TokenMap
+        {
+            get
+            {
+                _tokenMap ??= TextKeyedCache<SyntaxToken>.GetInstance();
+
+                return _tokenMap;
+            }
+        }
+
+        private CachingIdentityFactory<string, SyntaxKind> KeywordKindMap
+        {
+            get
+            {
+                _keywordKindMap ??= s_keywordKindPool.Allocate();
+
+                return _keywordKindMap;
+            }
+        }
+
+        internal PooledStringBuilder StringBuilder
+        {
+            get
+            {
+                _stringBuilder ??= PooledStringBuilder.GetInstance();
+
+                return _stringBuilder;
+            }
+        }
+
+        internal SyntaxListBuilder LeadingTriviaCache
+        {
+            get
+            {
+                _leadingTriviaCache ??= new SyntaxListBuilder(LeadingTriviaCacheInitialCapacity);
+
+                return _leadingTriviaCache;
+            }
+        }
+
+        internal SyntaxListBuilder TrailingTriviaCache
+        {
+            get
+            {
+                _trailingTriviaCache ??= new SyntaxListBuilder(TrailingTriviaCacheInitialCapacity);
+
+                return _trailingTriviaCache;
+            }
         }
 
         internal bool TryGetKeywordKind(string key, out SyntaxKind kind)
@@ -57,7 +177,7 @@ internal bool TryGetKeywordKind(string key, out SyntaxKind kind)
                 return false;
             }
 
-            kind = _keywordKindMap.GetOrMakeValue(key);
+            kind = KeywordKindMap.GetOrMakeValue(key);
             return kind != SyntaxKind.None;
         }
 
@@ -69,12 +189,12 @@ internal SyntaxTrivia LookupTrivia<TArg>(
             Func<TArg, SyntaxTrivia> createTriviaFunction,
             TArg data)
         {
-            var value = _triviaMap.FindItem(textBuffer, keyStart, keyLength, hashCode);
+            var value = TriviaMap.FindItem(textBuffer, keyStart, keyLength, hashCode);
 
             if (value == null)
             {
                 value = createTriviaFunction(data);
-                _triviaMap.AddItem(textBuffer, keyStart, keyLength, hashCode, value);
+                TriviaMap.AddItem(textBuffer, keyStart, keyLength, hashCode, value);
             }
 
             return value;
@@ -109,15 +229,15 @@ internal SyntaxToken LookupToken<TArg>(
             Func<TArg, SyntaxToken> createTokenFunction,
             TArg data)
         {
-            var value = _tokenMap.FindItem(textBuffer, keyStart, keyLength, hashCode);
+            var value = TokenMap.FindItem(textBuffer, keyStart, keyLength, hashCode);
 
             if (value == null)
             {
 #if COLLECT_STATS
                     Miss();
 #endif
                 value = createTokenFunction(data);
-                _tokenMap.AddItem(textBuffer, keyStart, keyLength, hashCode, value);
+                TokenMap.AddItem(textBuffer, keyStart, keyLength, hashCode, value);
             }
             else
             {

src/Compilers/Core/Portable/Syntax/InternalSyntax/SyntaxListBuilder.cs

@@ -11,6 +11,7 @@ internal class SyntaxListBuilder
     {
         private ArrayElement<GreenNode?>[] _nodes;
         public int Count { get; private set; }
+        public int Capacity => _nodes.Length;
 
         public SyntaxListBuilder(int size)
         {
@@ -24,6 +25,7 @@ public static SyntaxListBuilder Create()
 
         public void Clear()
         {
+            Array.Clear(_nodes, 0, _nodes.Length);
             this.Count = 0;
         }