feat(#533): inline small-enum constants in _data to avoid boxing

Extend the inline-constant path to cover enum types whose underlying type
is ≤ 32 bits (byte/sbyte/char/short/ushort/int/uint — virtually all C# enums).
Raw bits are stored in _data via System.Convert.ToInt64 + uint cast; the
Reader reconstructs the typed enum via Enum.ToObject using the underlying
TypeCode. Long/ulong-backed enums (extremely rare) continue to be boxed
in Obj.

Add FlatExpressionThrow.UnsupportedInlineConstantType(Type, TypeCode)
overload for the error path in ReadInlineValue.

Add Flat_enum_constant_stored_inline_roundtrip test covering all six
underlying types (byte/sbyte/short/ushort/int/uint), verifying no
ClosureConstants allocation and correct value round-trip. (1679 tests)

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/0ffda673-c511-49f5-ad08-e070318b3781

Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

Author: Copilot

src/FastExpressionCompiler.LightExpression/FlatExpression.cs

@@ -190,9 +190,18 @@ public int Constant(object value) =>
     /// <summary>Adds a constant node with an explicit constant type.</summary>
     public int Constant(object value, Type type)
     {
-        if (value == null || value is string || value is Type || type.IsEnum || value is decimal)
+        if (value == null || value is string || value is Type || value is decimal)
             return AddRawExpressionNode(type, value, ExpressionType.Constant);
 
+        if (type.IsEnum)
+        {
+            var underlyingTc = Type.GetTypeCode(Enum.GetUnderlyingType(type));
+            if (IsSmallPrimitive(underlyingTc))
+                return AddInlineConstantNode(type, (uint)System.Convert.ToInt64(value));
+            // long/ulong-backed enum (extremely rare): store boxed in Obj
+            return AddRawExpressionNode(type, value, ExpressionType.Constant);
+        }
+
         if (type.IsPrimitive)
         {
             var tc = Type.GetTypeCode(type);
@@ -1003,8 +1012,17 @@ private int AddConstant(System.Linq.Expressions.ConstantExpression constant)
             var value = constant.Value;
             var type = constant.Type;
 
-            if (value == null || value is string || value is Type || type.IsEnum || value is decimal)
+            if (value == null || value is string || value is Type || value is decimal)
+                return _tree.AddRawExpressionNode(type, value, ExpressionType.Constant);
+
+            if (type.IsEnum)
+            {
+                var underlyingTc = Type.GetTypeCode(Enum.GetUnderlyingType(type));
+                if (IsSmallPrimitive(underlyingTc))
+                    return _tree.AddInlineConstantNode(type, (uint)System.Convert.ToInt64(value));
+                // long/ulong-backed enum (extremely rare): store boxed in Obj
                 return _tree.AddRawExpressionNode(type, value, ExpressionType.Constant);
+            }
 
             if (type.IsPrimitive)
             {
@@ -1669,8 +1687,21 @@ private ChildList GetChildren(int index)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static object ReadInlineValue(Type type, uint data) =>
-            Type.GetTypeCode(type) switch
+        private static object ReadInlineValue(Type type, uint data)
+        {
+            if (type.IsEnum)
+                return Enum.ToObject(type, Type.GetTypeCode(Enum.GetUnderlyingType(type)) switch
+                {
+                    TypeCode.Byte => (object)(byte)data,
+                    TypeCode.SByte => (object)(sbyte)(byte)data,
+                    TypeCode.Char => (object)(char)(ushort)data,
+                    TypeCode.Int16 => (object)(short)(ushort)data,
+                    TypeCode.UInt16 => (object)(ushort)data,
+                    TypeCode.Int32 => (object)(int)data,
+                    TypeCode.UInt32 => (object)data,
+                    var tc => FlatExpressionThrow.UnsupportedInlineConstantType<object>(type, tc)
+                });
+            return Type.GetTypeCode(type) switch
             {
                 TypeCode.Boolean => (object)(data != 0),
                 TypeCode.Byte => (object)(byte)data,
@@ -1683,6 +1714,7 @@ private static object ReadInlineValue(Type type, uint data) =>
                 TypeCode.Single => (object)FloatBits.ToFloat(data),
                 _ => FlatExpressionThrow.UnsupportedInlineConstantType<object>(type)
             };
+        }
 
         [RequiresUnreferencedCode(FastExpressionCompiler.LightExpression.Trimming.Message)]
         private SysExpr[] ReadExpressions(in ChildList childIndexes)
@@ -1722,6 +1754,10 @@ internal static class FlatExpressionThrow
     internal static T UnsupportedInlineConstantType<T>(Type type) =>
         throw new NotSupportedException($"Cannot reconstruct inline constant of type {type}");
 
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    internal static T UnsupportedInlineConstantType<T>(Type type, TypeCode tc) =>
+        throw new NotSupportedException($"Cannot reconstruct inline constant of type {type} with TypeCode {tc}");
+
     [MethodImpl(MethodImplOptions.NoInlining)]
     internal static T UnsupportedInlineConstantType<T>(object value, TypeCode tc) =>
         throw new NotSupportedException($"Cannot convert value '{value}' of TypeCode {tc} to an inline constant");

test/FastExpressionCompiler.LightExpression.UnitTests/LightExpressionTests.cs

@@ -39,7 +39,8 @@ public int Run()
             Flat_block_variables_and_refs_yield_same_identity();
             Flat_nested_lambda_captures_outer_parameter_identity();
             Flat_out_of_order_decl_block_in_lambda_compiles_correctly();
-            return 22;
+            Flat_enum_constant_stored_inline_roundtrip();
+            return 23;
         }
 
 
@@ -649,5 +650,41 @@ public void Flat_out_of_order_decl_block_in_lambda_compiles_correctly()
             // p=0 → v1 = 0, v2 = 0
             Asserts.AreEqual(0, func(0));
         }
+
+        enum ByteEnum : byte { A = 1, B = 200 }
+        enum SByteEnum : sbyte { A = -1, B = 50 }
+        enum ShortEnum : short { A = -1000, B = 30000 }
+        enum UShortEnum : ushort { A = 0, B = 60000 }
+        enum IntEnum : int { A = int.MinValue, B = 42 }
+        enum UIntEnum : uint { A = 0, B = uint.MaxValue }
+
+        public void Flat_enum_constant_stored_inline_roundtrip()
+        {
+            // Verify that enum constants with ≤32-bit underlying types are stored inline
+            // (no ClosureConstants entry, no boxing) and round-trip correctly.
+            void Check<TEnum>(TEnum enumValue) where TEnum : Enum
+            {
+                var fe = default(ExprTree);
+                var idx = fe.Constant(enumValue, typeof(TEnum));
+                Asserts.AreEqual(0, fe.ClosureConstants.Count,
+                    $"{typeof(TEnum).Name}.{enumValue} should be inline (no ClosureConstants), but got {fe.ClosureConstants.Count}");
+                fe.RootIndex = fe.Lambda<Func<TEnum>>(idx);
+                var result = (TEnum)((System.Linq.Expressions.LambdaExpression)fe.ToExpression()).Compile().DynamicInvoke()!;
+                Asserts.AreEqual(enumValue, result, $"Round-trip failed for {typeof(TEnum).Name}.{enumValue}");
+            }
+
+            Check(ByteEnum.A);
+            Check(ByteEnum.B);
+            Check(SByteEnum.A);
+            Check(SByteEnum.B);
+            Check(ShortEnum.A);
+            Check(ShortEnum.B);
+            Check(UShortEnum.A);
+            Check(UShortEnum.B);
+            Check(IntEnum.A);
+            Check(IntEnum.B);
+            Check(UIntEnum.A);
+            Check(UIntEnum.B);
+        }
     }
 }