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

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

@@ -15,9 +15,68 @@
 
 namespace Microsoft.CodeAnalysis
 {
+
     [DebuggerDisplay("{GetDebuggerDisplay(), nq}")]
     internal abstract partial class GreenNode
     {
+        /// <summary>
+        /// Combination of <see cref="NodeFlags"/> and <see cref="SlotCount"/> stored in a single 16bit value.
+        /// </summary>
+        internal 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 byte SlotCountMask = 0b1111;
+            private const int SlotCountShift = 12;
+
+            /// <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>
+            private const ushort NodeFlagsMask = 0b0000111111111111;
+
+            /// <summary>
+            /// CCCCFFFFFFFFFFFF for Count bits then Flag bits.
+            /// </summary>
+            private ushort _data;
+
+            public byte SlotCount
+            {
+                readonly get
+                {
+                    var shifted = _data >> SlotCountShift;
+                    Debug.Assert(shifted <= SlotCountMask);
+                    var result = (byte)shifted;
+                    return result == SlotCountMask ? byte.MaxValue : result;
+                }
+
+                set
+                {
+                    if (value == byte.MaxValue)
+                        value = SlotCountMask;
+                    Debug.Assert(value <= SlotCountMask);
+
+                    _data = (ushort)(_data | (value << SlotCountShift));
+                }
+            }
+
+            public NodeFlags NodeFlags
+            {
+                readonly get
+                {
+                    return (NodeFlags)(_data & NodeFlagsMask);
+                }
+
+                set
+                {
+                    Debug.Assert((ushort)value <= NodeFlagsMask);
+                    _data = (ushort)(_data | (ushort)value);
+                }
+            }
+        }
+
         private string GetDebuggerDisplay()
         {
             return this.GetType().Name + " " + this.KindText + " " + this.ToString();
@@ -26,10 +85,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 +304,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,