Fix net472 throw helpers and restore closure constant policy

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/e4fd589e-da46-45a0-877b-94c254d85cd8

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

Author: Copilot

src/FastExpressionCompiler.LightExpression/FlatExpression.cs

@@ -152,6 +152,7 @@ internal bool ShouldCloneWhenLinked() =>
 /// <summary>Stores an expression tree as a flat node array plus out-of-line closure constants.</summary>
 public struct ExprTree
 {
+    private static readonly object ClosureConstantMarker = new();
     internal const byte ParameterByRefFlag = 1;
     internal const byte ParameterDeclarationFlag = 2;
     private const byte ConstantInlineValue32Flag = 1;
@@ -201,6 +202,12 @@ public int Constant(object value, Type type)
         if (TryGetInlineConstantValue32(value, type, out var value32))
             return AddRawInlineConstantNode(type, value32);
 
+        if (ShouldStoreConstantInClosureConstants(value, type))
+        {
+            var constantIndex = ClosureConstants.Add(value);
+            return AddRawExpressionNodeWithChildIndex(type, ClosureConstantMarker, ExpressionType.Constant, constantIndex);
+        }
+
         return AddRawExpressionNode(type, value, ExpressionType.Constant);
     }
 
@@ -997,6 +1004,12 @@ private int AddConstant(System.Linq.Expressions.ConstantExpression constant)
             if (TryGetInlineConstantValue32(constant.Value, constant.Type, out var value32))
                 return _tree.AddRawInlineConstantNode(constant.Type, value32);
 
+            if (ShouldStoreConstantInClosureConstants(constant.Value, constant.Type))
+            {
+                var constantIndex = _tree.ClosureConstants.Add(constant.Value);
+                return _tree.AddRawExpressionNodeWithChildIndex(constant.Type, ClosureConstantMarker, constant.NodeType, constantIndex);
+            }
+
             return _tree.AddRawExpressionNode(constant.Type, constant.Value, constant.NodeType);
         }
 
@@ -1307,6 +1320,10 @@ private static bool TryGetInlineConstantValue32(object value, Type type, out int
         }
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool ShouldStoreConstantInClosureConstants(object value, Type type) =>
+        value != null && value is not string && value is not Type && !type.IsEnum && Type.GetTypeCode(type) == TypeCode.Object;
+
     private static object ReadInlineConstantValue32(Type type, int value32)
     {
         if (type.IsEnum)
@@ -1438,7 +1455,9 @@ public SysExpr ReadExpression(int index)
                     return SysExpr.Constant(
                         node.HasFlag(ConstantInlineValue32Flag)
                             ? ReadInlineConstantValue32(node.Type, node.Value32)
-                            : node.Obj,
+                            : ReferenceEquals(node.Obj, ClosureConstantMarker)
+                                ? _tree.ClosureConstants[node.ChildIdx]
+                                : node.Obj,
                         node.Type);
                 case ExpressionType.Default:
                     return SysExpr.Default(node.Type);
@@ -1790,44 +1809,36 @@ private SysExpr[] ReadExpressions(in ChildList childIndexes)
 
 internal static class Throw
 {
-    [DoesNotReturn]
     public static void DuplicateParameterDeclaration(string name) =>
         throw new ArgumentException($"The parameter or variable `{name ?? "?"}` is declared more than once.");
 
-    [DoesNotReturn]
     public static void ParameterDeclarationExpected(int index) =>
         throw new ArgumentException($"Expected a parameter declaration node at index {index}.");
 
-    [DoesNotReturn]
     public static void UndeclaredParameterUsage(string name) =>
         throw new InvalidOperationException($"The parameter or variable `{name ?? "?"}` is used before it is declared.");
 
-    [DoesNotReturn]
     public static void UnsupportedInlineConstantType(Type type) =>
         throw new NotSupportedException($"Inline 32-bit constant storage does not support `{type}`.");
 
-    [DoesNotReturn]
     public static T DuplicateParameterDeclaration<T>(string name)
     {
         DuplicateParameterDeclaration(name);
         return default;
     }
 
-    [DoesNotReturn]
     public static T ParameterDeclarationExpected<T>(int index)
     {
         ParameterDeclarationExpected(index);
         return default;
     }
 
-    [DoesNotReturn]
     public static T UndeclaredParameterUsage<T>(string name)
     {
         UndeclaredParameterUsage(name);
         return default;
     }
 
-    [DoesNotReturn]
     public static T UnsupportedInlineConstantType<T>(Type type)
     {
         UnsupportedInlineConstantType(type);

test/FastExpressionCompiler.LightExpression.UnitTests/LightExpressionTests.cs

@@ -29,7 +29,7 @@ public int Run()
             Expression_produced_by_ToExpressionString_should_compile();
             Multiple_methods_in_block_should_be_aligned_when_output_to_csharp();
             Can_roundtrip_light_expression_through_flat_expression();
-            Flat_expression_preserves_parameter_and_label_identity_without_closure_constant_storage();
+            Flat_expression_preserves_parameter_and_label_identity_and_collects_closure_constants();
             Flat_expression_uses_parameter_declarations_parent_links_and_inline_constants();
             Can_convert_dynamic_runtime_variables_and_debug_info_to_light_expression_and_flat_expression();
             Can_build_flat_expression_directly_with_light_expression_like_api();
@@ -390,14 +390,15 @@ public void Can_roundtrip_light_expression_through_flat_expression()
             Asserts.AreEqual(2, a.Dop.Count());
         }
 
-        public void Flat_expression_preserves_parameter_and_label_identity_without_closure_constant_storage()
+        public void Flat_expression_preserves_parameter_and_label_identity_and_collects_closure_constants()
         {
             var valueHolder = new S();
             var valueField = typeof(S).GetField(nameof(S.Value));
             var constExpr = Lambda<Func<string>>(Field(Constant(valueHolder), valueField));
             var constFlat = constExpr.ToFlatExpression();
 
-            Asserts.AreEqual(0, constFlat.ClosureConstants.Count);
+            Asserts.AreEqual(1, constFlat.ClosureConstants.Count);
+            Asserts.AreSame(valueHolder, constFlat.ClosureConstants[0]);
             Asserts.AreEqual(null, ((LambdaExpression)constFlat.ToLightExpression()).CompileFast<Func<string>>(true)());
 
             var p = SysExpr.Parameter(typeof(int), "p");