Grab 4 more bits for use as node flags. Use additional bit to store if nodes contain attributes within them.

src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Internal.Generated.cs

@@ -15864,6 +15864,7 @@ internal sealed partial class AttributeSyntax : CSharpSyntaxNode
     internal AttributeSyntax(SyntaxKind kind, NameSyntax name, AttributeArgumentListSyntax? argumentList, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
       : base(kind, diagnostics, annotations)
     {
+        this.flags |= NodeFlags.ContainsAttributes;
         this.SlotCount = 2;
         this.AdjustFlagsAndWidth(name);
         this.name = name;
@@ -15878,6 +15879,7 @@ internal AttributeSyntax(SyntaxKind kind, NameSyntax name, AttributeArgumentList
       : base(kind)
     {
         this.SetFactoryContext(context);
+        this.flags |= NodeFlags.ContainsAttributes;
         this.SlotCount = 2;
         this.AdjustFlagsAndWidth(name);
         this.name = name;
@@ -15891,6 +15893,7 @@ internal AttributeSyntax(SyntaxKind kind, NameSyntax name, AttributeArgumentList
     internal AttributeSyntax(SyntaxKind kind, NameSyntax name, AttributeArgumentListSyntax? argumentList)
       : base(kind)
     {
+        this.flags |= NodeFlags.ContainsAttributes;
         this.SlotCount = 2;
         this.AdjustFlagsAndWidth(name);
         this.name = name;
@@ -30780,17 +30783,7 @@ public AttributeSyntax Attribute(NameSyntax name, AttributeArgumentListSyntax? a
         if (name == null) throw new ArgumentNullException(nameof(name));
 #endif
 
-        int hash;
-        var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.Attribute, name, argumentList, this.context, out hash);
-        if (cached != null) return (AttributeSyntax)cached;
-
-        var result = new AttributeSyntax(SyntaxKind.Attribute, name, argumentList, this.context);
-        if (hash >= 0)
-        {
-            SyntaxNodeCache.AddNode(result, hash);
-        }
-
-        return result;
+        return new AttributeSyntax(SyntaxKind.Attribute, name, argumentList, this.context);
     }
 
     public AttributeArgumentListSyntax AttributeArgumentList(SyntaxToken openParenToken, CoreSyntax.SeparatedSyntaxList<AttributeArgumentSyntax> arguments, SyntaxToken closeParenToken)
@@ -35996,17 +35989,7 @@ public static AttributeSyntax Attribute(NameSyntax name, AttributeArgumentListSy
         if (name == null) throw new ArgumentNullException(nameof(name));
 #endif
 
-        int hash;
-        var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.Attribute, name, argumentList, out hash);
-        if (cached != null) return (AttributeSyntax)cached;
-
-        var result = new AttributeSyntax(SyntaxKind.Attribute, name, argumentList);
-        if (hash >= 0)
-        {
-            SyntaxNodeCache.AddNode(result, hash);
-        }
-
-        return result;
+        return new AttributeSyntax(SyntaxKind.Attribute, name, argumentList);
     }
 
     public static AttributeArgumentListSyntax AttributeArgumentList(SyntaxToken openParenToken, CoreSyntax.SeparatedSyntaxList<AttributeArgumentSyntax> arguments, SyntaxToken closeParenToken)

src/Compilers/CSharp/Portable/SourceGeneration/CSharpSyntaxHelper.cs

@@ -2,10 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.PooledObjects;
-using Microsoft.CodeAnalysis.SourceGeneration;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp
@@ -21,9 +19,6 @@ private CSharpSyntaxHelper()
         public override bool IsCaseSensitive
             => true;
 
-        protected override int AttributeListKind
-            => (int)SyntaxKind.AttributeList;
-
         public override bool IsValidIdentifier(string name)
             => SyntaxFacts.IsValidIdentifier(name);
 

src/Compilers/CSharp/Test/Syntax/Parsing/CollectionExpressionParsingTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -17096,4 +17097,35 @@ public void TreatKeywordAsCollectionExprElement()
         }
         EOF();
     }
+
+    [Theory, CombinatorialData]
+    public void CollectionExpressionParsingSlotCounts([CombinatorialRange(1, 20)] int count)
+    {
+        // Validate no errors for collections with small and large number of elements.  Importantly, we want to test the
+        // boundary points where the slot count of the collection crosses over the amount that can be directly stored in
+        // the node, versus the slot count stored in subclass nodes.
+        var text = $"[{string.Join(", ", Enumerable.Range(1, count).Select(i => $"A{i}"))}]";
+
+        UsingExpression(text, TestOptions.Regular);
+
+        N(SyntaxKind.CollectionExpression);
+        N(SyntaxKind.OpenBracketToken);
+
+        for (var i = 1; i <= count; i++)
+        {
+            N(SyntaxKind.ExpressionElement);
+            N(SyntaxKind.IdentifierName);
+            {
+                N(SyntaxKind.IdentifierToken, $"A{i}");
+            }
+
+            if (i < count)
+            {
+                N(SyntaxKind.CommaToken);
+            }
+        }
+
+        N(SyntaxKind.CloseBracketToken);
+        EOF();
+    }
 }

src/Compilers/Core/Portable/SourceGeneration/ISyntaxHelper.cs

@@ -32,14 +32,12 @@ internal interface ISyntaxHelper
         void AddAliases(GreenNode node, ArrayBuilder<(string aliasName, string symbolName)> aliases, bool global);
         void AddAliases(CompilationOptions options, ArrayBuilder<(string aliasName, string symbolName)> aliases);
 
-        bool ContainsAttributeList(SyntaxNode root);
         bool ContainsGlobalAliases(SyntaxNode root);
     }
 
     internal abstract class AbstractSyntaxHelper : ISyntaxHelper
     {
         public abstract bool IsCaseSensitive { get; }
-        protected abstract int AttributeListKind { get; }
 
         public abstract bool IsValidIdentifier(string name);
 
@@ -60,18 +58,5 @@ internal abstract class AbstractSyntaxHelper : ISyntaxHelper
         public abstract void AddAliases(CompilationOptions options, ArrayBuilder<(string aliasName, string symbolName)> aliases);
 
         public abstract bool ContainsGlobalAliases(SyntaxNode root);
-
-        public bool ContainsAttributeList(SyntaxNode root)
-        {
-            var attributeListKind = this.AttributeListKind;
-
-            foreach (var node in root.Green.EnumerateNodes())
-            {
-                if (node.RawKind == attributeListKind)
-                    return true;
-            }
-
-            return false;
-        }
     }
 }

src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxValueProvider_ForAttributeWithSimpleName.cs

@@ -234,6 +234,10 @@ void processMember(SyntaxNode member)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
+            // Don't bother descending into nodes that don't contain attributes.
+            if (!member.ContainsAttributes)
+                return;
+
             // nodes can be arbitrarily deep.  Use an explicit stack over recursion to prevent a stack-overflow.
             var nodeStack = s_nodeStackPool.Allocate();
             nodeStack.Push(member);
@@ -244,6 +248,10 @@ void processMember(SyntaxNode member)
                 {
                     var node = nodeStack.Pop();
 
+                    // Don't bother descending into nodes that don't contain attributes.
+                    if (!node.ContainsAttributes)
+                        continue;
+
                     if (syntaxHelper.IsAttributeList(node))
                     {
                         foreach (var attribute in syntaxHelper.GetAttributesOfAttributeList(node))

src/Compilers/Core/Portable/Syntax/GreenNode.NodeFlagsAndSlotCount.cs

@@ -0,0 +1,74 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal abstract partial class GreenNode
+    {
+        /// <summary>
+        /// Combination of <see cref="NodeFlags"/> and <see cref="SlotCount"/> stored in a single 16bit value.
+        /// </summary>
+        private struct NodeFlagsAndSlotCount
+        {
+            /// <summary>
+            /// 4 bits for the SlotCount.  This allows slot counts of 0-14 to be stored as a direct byte.  All 1s
+            /// indicates that the slot count must be computed.
+            /// </summary>
+            private const ushort SlotCountMask = 0b1111000000000000;
+            private const ushort NodeFlagsMask = 0b0000111111111111;
+
+            private const int SlotCountShift = 12;
+            private const int MaxSlotCount = 15;
+
+            /// <summary>
+            /// 12 bits for the NodeFlags.  This allows for up to 12 distinct bits to be stored to designate interesting
+            /// aspects of a node.
+            /// </summary>
+
+            /// <summary>
+            /// CCCCFFFFFFFFFFFF for Count bits then Flag bits.
+            /// </summary>
+            private ushort _data;
+
+            public byte SlotCount
+            {
+                readonly get
+                {
+                    var shifted = _data >> SlotCountShift;
+                    Debug.Assert(shifted <= MaxSlotCount);
+                    var result = (byte)shifted;
+                    return result == MaxSlotCount ? byte.MaxValue : result;
+                }
+
+                set
+                {
+                    if (value >= MaxSlotCount)
+                        value = MaxSlotCount;
+                    Debug.Assert(value <= MaxSlotCount);
+
+                    // Clear out everything but the node-flags, and then assign into the slot-count segment.
+                    _data = (ushort)((_data & NodeFlagsMask) | (value << SlotCountShift));
+                }
+            }
+
+            public NodeFlags NodeFlags
+            {
+                readonly get
+                {
+                    return (NodeFlags)(_data & NodeFlagsMask);
+                }
+
+                set
+                {
+                    Debug.Assert((ushort)value <= NodeFlagsMask);
+
+                    // Clear out everything but the slot-count, and then assign into the node-flags segment.
+                    _data = (ushort)((_data & SlotCountMask) | (ushort)value);
+                }
+            }
+        }
+    }
+}

src/Compilers/Core/Portable/Syntax/GreenNode.cs

@@ -26,10 +26,21 @@ private string GetDebuggerDisplay()
         internal const int ListKind = 1;
 
         private readonly ushort _kind;
-        protected NodeFlags flags;
-        private byte _slotCount;
+        private NodeFlagsAndSlotCount _nodeFlagsAndSlotCount;
         private int _fullWidth;
 
+        protected NodeFlags flags
+        {
+            get => _nodeFlagsAndSlotCount.NodeFlags;
+            set => _nodeFlagsAndSlotCount.NodeFlags = value;
+        }
+
+        private byte _slotCount
+        {
+            get => _nodeFlagsAndSlotCount.SlotCount;
+            set => _nodeFlagsAndSlotCount.SlotCount = value;
+        }
+
         private static readonly ConditionalWeakTable<GreenNode, DiagnosticInfo[]> s_diagnosticsTable =
             new ConditionalWeakTable<GreenNode, DiagnosticInfo[]>();
 
@@ -234,8 +245,13 @@ public virtual int FindSlotIndexContainingOffset(int offset)
         #endregion
 
         #region Flags 
+
+        /// <summary>
+        /// Special flags a node can have.  Note: while this is typed as being `ushort`, we can only practically use 12
+        /// of those 16 bits as we use the remaining 4 bits to store the slot count of a node.
+        /// </summary>
         [Flags]
-        internal enum NodeFlags : byte
+        internal enum NodeFlags : ushort
         {
             None = 0,
             ContainsDiagnostics = 1 << 0,
@@ -244,12 +260,13 @@ internal enum NodeFlags : byte
             ContainsSkippedText = 1 << 3,
             ContainsAnnotations = 1 << 4,
             IsNotMissing = 1 << 5,
+            ContainsAttributes = 1 << 6,
 
-            FactoryContextIsInAsync = 1 << 6,
-            FactoryContextIsInQuery = 1 << 7,
+            FactoryContextIsInAsync = 1 << 7,
+            FactoryContextIsInQuery = 1 << 8,
             FactoryContextIsInIterator = FactoryContextIsInQuery,  // VB does not use "InQuery", but uses "InIterator" instead
 
-            InheritMask = ContainsDiagnostics | ContainsStructuredTrivia | ContainsDirectives | ContainsSkippedText | ContainsAnnotations | IsNotMissing,
+            InheritMask = ContainsDiagnostics | ContainsStructuredTrivia | ContainsDirectives | ContainsSkippedText | ContainsAnnotations | ContainsAttributes | IsNotMissing,
         }
 
         internal NodeFlags Flags
@@ -324,6 +341,14 @@ public bool ContainsDirectives
             }
         }
 
+        public bool ContainsAttributes
+        {
+            get
+            {
+                return (this.flags & NodeFlags.ContainsAttributes) != 0;
+            }
+        }
+
         public bool ContainsDiagnostics
         {
             get

src/Compilers/Core/Portable/Syntax/SyntaxNode.cs

@@ -442,6 +442,8 @@ public bool ContainsDiagnostics
         /// </summary>
         public bool ContainsDirectives => this.Green.ContainsDirectives;
 
+        internal bool ContainsAttributes => this.Green.ContainsAttributes;
+
         /// <summary>
         /// Returns true if this node contains any directives (e.g. <c>#if</c>, <c>#nullable</c>, etc.) within it with a matching kind.
         /// </summary>

src/Compilers/Core/Portable/Syntax/SyntaxTree.cs

@@ -433,7 +433,7 @@ internal SourceGeneratorSyntaxTreeInfo GetSourceGeneratorInfo(
                 if (syntaxHelper.ContainsGlobalAliases(root))
                     result |= SourceGeneratorSyntaxTreeInfo.ContainsGlobalAliases;
 
-                if (syntaxHelper.ContainsAttributeList(root))
+                if (root.ContainsAttributes)
                     result |= SourceGeneratorSyntaxTreeInfo.ContainsAttributeList;
 
                 _sourceGeneratorInfo = result;