updated readme

Author: dadhi

README.md

@@ -300,17 +300,91 @@ FEC V3 has added powerful diagnostics and code generation tools.
 
 You may pass the optional `CompilerFlags.EnableDelegateDebugInfo`  into the `CompileFast` methods.
 
-`EnableDelegateDebugInfo` adds the diagnostic info into the compiled delegate including its source Expression and C# code. 
-Can be used as following:
+`EnableDelegateDebugInfo` adds the diagnostic info into the compiled delegate including its source Expression and compiled IL code. 
+
+It can be used as following:
 
 ```cs
-var f = e.CompileFast(true, CompilerFlags.EnableDelegateDebugInfo);
-var di = f.Target as IDelegateDebugInfo;
-Asserts.IsNotNull(di.Expression);
-Asserts.IsNotNull(di.ExpressionString);
-Asserts.IsNotNull(di.CSharpString);
+System.Linq.Expressions.Expression<Func<int, Func<int>>> e = 
+  n => () => n + 1;
+var f = e.CompileFast(flags: CompilerFlags.EnableDelegateDebugInfo);
+var d = f.TryGetDebugInfo();
+d.PrintExpression();
+d.PrintCSharp();
+d.PrintIL(); // available in NET8+
 ```
 
+<details><summary>Expand to see the output of the above code...</summary>
+
+
+Output of `d.PrintExpression()` is the valid C#:
+
+```cs
+var p = new ParameterExpression[1]; // the parameter expressions
+var e = new Expression[3]; // the unique expressions
+var expr = Lambda<Func<int, Func<int>>>(
+  e[0]=Lambda<Func<int>>(
+      e[1]=MakeBinary(ExpressionType.Add,
+          p[0]=Parameter(typeof(int), "n"),
+          e[2]=Constant(1)), new ParameterExpression[0]),
+  p[0 // (int n)
+      ]);
+```
+
+Output of `d.PrintCSharp()` is the valid C#:
+
+```cs
+var @cs = (Func<int, Func<int>>)((int n) => //Func<int>
+    (Func<int>)(() => //int
+        n + 1));
+```
+
+Output of `d.PrintIL()` (includes the IL of the nested lambda):
+
+```
+<Caller>
+0   ldarg.0
+1   ldfld object[] ExpressionCompiler.ArrayClosure.ConstantsAndNestedLambdas
+6   stloc.0
+7   ldloc.0
+8   ldc.i4.0
+9   ldelem.ref
+10  stloc.1
+11  ldloc.1
+12  ldc.i4.1
+13  newarr object
+18  stloc.2
+19  ldloc.2
+20  stfld object[] ExpressionCompiler.NestedLambdaForNonPassedParams.NonPassedParams
+25  ldloc.2
+26  ldc.i4.0
+27  ldarg.1
+28  box int
+33  stelem.ref
+34  ldloc.1
+35  ldfld object ExpressionCompiler.NestedLambdaForNonPassedParams.NestedLambda
+40  ldloc.2
+41  ldloc.1
+42  ldfld object[] ExpressionCompiler.NestedLambdaForNonPassedParamsWithConstants.ConstantsAndNestedLambdas
+47  newobj ExpressionCompiler.ArrayClosureWithNonPassedParams(System.Object[], System.Object[])
+52  call Func<int> ExpressionCompiler.CurryClosureFuncs.Curry(System.Func`2[FastExpressionCompiler.LightExpression.ExpressionCompiler+ArrayClosure,System.Int32], ArrayClosure)
+57  ret
+</Caller>
+<0_nested_in_Caller>
+0   ldarg.0
+1   ldfld object[] ExpressionCompiler.ArrayClosureWithNonPassedParams.NonPassedParams
+6   ldc.i4.0
+7   ldelem.ref
+8   unbox.any int
+13  ldc.i4.1
+14  add
+15  ret
+</0_nested_in_Caller>
+```
+
+</details>
+
+
 ### ThrowOnNotSupportedExpression and NotSupported_ flags
 
 FEC V3.1 has added the compiler flag `CompilerFlags.ThrowOnNotSupportedExpression`.

src/FastExpressionCompiler/TestTools.cs

@@ -65,9 +65,12 @@ public static void AssertOpCodes(this IEnumerable<ILInstruction> il, params OpCo
 #endif
     }
 
-    public static void PrintExpression(this Expression expr, bool completeTypeNames = false)
+    public static void PrintExpression(this Expression expr, bool completeTypeNames = false,
+        [CallerMemberName] string caller = "", [CallerFilePath] string filePath = "")
     {
         if (!AllowPrintExpression) return;
+        Console.WriteLine();
+        Console.WriteLine($"//{Path.GetFileNameWithoutExtension(filePath)}.{caller}");
         Console.WriteLine(
             expr.ToExpressionString(out var _, out var _, out var _,
             stripNamespace: true,
@@ -76,6 +79,10 @@ public static void PrintExpression(this Expression expr, bool completeTypeNames
         );
     }
 
+    public static void PrintExpression(this IDelegateDebugInfo debugInfo, bool completeTypeNames = false,
+        [CallerMemberName] string caller = "", [CallerFilePath] string filePath = "") =>
+        PrintExpression(debugInfo.Expression, completeTypeNames, caller, filePath);
+
     public static void PrintCSharp(this Expression expr, bool completeTypeNames = false,
         [CallerMemberName] string caller = "", [CallerFilePath] string filePath = "")
     {
@@ -129,8 +136,9 @@ public static void PrintCSharp(this Expression expr, ref string result)
     /// In case of nested lambda represented in the expression of the Constant Delegate, 
     /// and the Delegate.Target being IDelegateDebugInfo, you may call `IDelegateDebugInfo.EnumerateNestedLambdas()`
     /// and output C# for each nested lambda</summary>
-    public static void PrintCSharp(this IDelegateDebugInfo debugInfo) =>
-        debugInfo.Expression.PrintCSharp();
+    public static void PrintCSharp(this IDelegateDebugInfo debugInfo, bool completeTypeNames = false,
+        [CallerMemberName] string caller = "", [CallerFilePath] string filePath = "") =>
+        debugInfo.Expression.PrintCSharp(completeTypeNames, caller, filePath);
 
     public static void PrintIL(this Delegate dlg, [CallerMemberName] string tag = null)
     {
@@ -178,10 +186,10 @@ private static void PrintIL(IDelegateDebugInfo debugInfo,
         {
             ref var printedTag = ref uniquePrinted.AddOrGetValueRef(nested, out var printed);
             if (printed)
-                PrintIL($"{printedTag}", "already printed", static (ap, s) => s.Append(ap));
+                PrintIL($"{printedTag}", "printed already", static (ap, s) => s.Append(ap));
             else
             {
-                printedTag = $"{n}_{tag}";
+                printedTag = $"{n}_nested_in_{tag}";
                 PrintIL(nested, ref totalNestedCount, ref uniquePrinted, printedTag);
             }
             ++n;

test/FastExpressionCompiler.IssueTests/Issue347_InvalidProgramException_on_compiling_an_expression_that_returns_a_record_which_implements_IList.cs

@@ -21,12 +21,27 @@ public class Issue347_InvalidProgramException_on_compiling_an_expression_that_re
     {
         public int Run()
         {
+            Issue478_Test_diagnostics();
             Test_struct_parameter_in_closure_of_the_nested_lambda();
             Test_passing_struct_item_in_object_array_parameter();
             Test_nullable_param_in_closure_of_the_nested_lambda();
             Test_nullable_of_struct_and_struct_field_in_the_nested_lambda();
             Test_original();
-            return 5;
+            return 6;
+        }
+
+        public void Issue478_Test_diagnostics()
+        {
+            System.Linq.Expressions.Expression<Func<int, Func<int>>> expr = n => () => n + 1;
+            var e = expr.FromSysExpression();
+            e.PrintExpression();
+            e.PrintCSharp();
+
+            var f = e.CompileFast(flags: CompilerFlags.EnableDelegateDebugInfo);
+            var d = f.TryGetDebugInfo();
+            d.PrintExpression();
+            d.PrintCSharp();
+            d.PrintIL();
         }
 
         public void Test_passing_struct_item_in_object_array_parameter()