Merge pull request #521 from dadhi/copilot/optimize-expression-representation

Add flat LightExpression model with direct FE builder API, fill remaining LE conversion gaps, add LE vs FE creation benchmark, and start deterministic FE/LE property testing

Author: dadhi

src/FastExpressionCompiler.LightExpression/Expression.cs

@@ -2773,11 +2773,11 @@ internal static Expression ConvertToLightExpression(SysExpr sysExpr, ref SmallLi
                     var pe = (System.Linq.Expressions.ParameterExpression)sysExpr;
                     return Expression.Parameter(pe.IsByRef ? exprType.MakeByRefType() : exprType, pe.Name);
                 }
-            case ExpressionType.Lambda:
-                {
-                    var le = (System.Linq.Expressions.LambdaExpression)sysExpr;
-                    var body = le.Body.ToLightExpression(ref exprsConverted);
-                    var retType = le.ReturnType;
+            case ExpressionType.Lambda:
+                {
+                    var le = (System.Linq.Expressions.LambdaExpression)sysExpr;
+                    var body = le.Body.ToLightExpression(ref exprsConverted);
+                    var retType = le.ReturnType;
                     var pars = le.Parameters;
                     var parCount = pars.Count;
                     switch (parCount)
@@ -2819,16 +2819,40 @@ internal static Expression ConvertToLightExpression(SysExpr sysExpr, ref SmallLi
                                 (ParameterExpression)pars[5].ToLightExpression(ref exprsConverted), retType);
                         default:
                             var pes = new ParameterExpression[parCount];
-                            for (var i = 0; i < pes.Length; i++)
-                                pes[i] = (ParameterExpression)le.Parameters[i].ToLightExpression(ref exprsConverted);
-                            return Expression.Lambda(exprType, body, pes, retType);
-                    }
-                }
-            default:
-                if (sysExpr is System.Linq.Expressions.UnaryExpression ue)
-                {
-                    var operand = ue.Operand.ToLightExpression(ref exprsConverted);
-                    return Expression.MakeUnary(nodeType, operand, exprType, ue.Method);
+                            for (var i = 0; i < pes.Length; i++)
+                                pes[i] = (ParameterExpression)le.Parameters[i].ToLightExpression(ref exprsConverted);
+                            return Expression.Lambda(exprType, body, pes, retType);
+                    }
+                }
+            case ExpressionType.Dynamic:
+                {
+                    var de = (System.Linq.Expressions.DynamicExpression)sysExpr;
+                    var sysArgs = de.Arguments;
+                    var args = new Expression[sysArgs.Count];
+                    for (var i = 0; i < args.Length; ++i)
+                        args[i] = sysArgs[i].ToLightExpression(ref exprsConverted);
+                    return new DynamicExpression(de.DelegateType, de.Binder, args);
+                }
+            case ExpressionType.RuntimeVariables:
+                {
+                    var rve = (System.Linq.Expressions.RuntimeVariablesExpression)sysExpr;
+                    var sysVars = rve.Variables;
+                    var vars = new ParameterExpression[sysVars.Count];
+                    for (var i = 0; i < vars.Length; ++i)
+                        vars[i] = (ParameterExpression)sysVars[i].ToLightExpression(ref exprsConverted);
+                    return new RuntimeVariablesExpression(vars);
+                }
+            case ExpressionType.DebugInfo:
+                {
+                    var die = (System.Linq.Expressions.DebugInfoExpression)sysExpr;
+                    return Expression.DebugInfo(new SymbolDocumentInfo(die.Document.FileName),
+                        die.StartLine, die.StartColumn, die.EndLine, die.EndColumn);
+                }
+            default:
+                if (sysExpr is System.Linq.Expressions.UnaryExpression ue)
+                {
+                    var operand = ue.Operand.ToLightExpression(ref exprsConverted);
+                    return Expression.MakeUnary(nodeType, operand, exprType, ue.Method);
                 }
 
                 if (sysExpr is System.Linq.Expressions.BinaryExpression be)
@@ -5924,4 +5948,4 @@ public interface IParameterProvider
     ParameterExpression GetParameter(int index);
 }
 
-#nullable restore
+#nullable restore