start on #478

Author: dadhi

src/Directory.Build.props

@@ -33,6 +33,7 @@
     </ItemGroup>
 
     <PropertyGroup>
+        <Features>strict</Features>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     </PropertyGroup>
 

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -42,13 +42,15 @@ namespace FastExpressionCompiler.LightExpression
     using static FastExpressionCompiler.LightExpression.Expression;
     using PE = FastExpressionCompiler.LightExpression.ParameterExpression;
     using FastExpressionCompiler.LightExpression.ImTools;
+    using FastExpressionCompiler.LightExpression.ILDecoder;
     using static FastExpressionCompiler.LightExpression.ImTools.SmallMap4;
 #else
 namespace FastExpressionCompiler
 {
     using static System.Linq.Expressions.Expression;
     using PE = System.Linq.Expressions.ParameterExpression;
     using FastExpressionCompiler.ImTools;
+    using FastExpressionCompiler.ILDecoder;
     using static FastExpressionCompiler.ImTools.SmallMap4;
 #endif
     using System;
@@ -104,6 +106,8 @@ public interface IDelegateDebugInfo
         string ExpressionString { get; }
         /// <summary>The equivalent C# code of the lambda expression</summary>
         string CSharpString { get; }
+        /// <summary>Delegate IL op-codes and tokens</summary>
+        string ILString { get; }
 
         // todo: @feature add the debug info to the nested lambdas
         // /// <summary>Total nested lambda counting</summary>
@@ -514,19 +518,17 @@ internal static object TryCompileBoundToFirstClosureParam(Type delegateType, Exp
             var collectResult = TryCollectInfo(ref closureInfo, bodyExpr, paramExprs, null, ref closureInfo.NestedLambdas, flags);
             if (collectResult == Result.OK)
             {
+                var constantsAndNestedLambdas = (closureInfo.Status & ClosureStatus.HasClosure) != 0
+                    ? closureInfo.GetArrayOfConstantsAndNestedLambdas()
+                    : null;
+
                 ArrayClosure closure;
-                if ((flags & CompilerFlags.EnableDelegateDebugInfo) == 0)
-                {
-                    closure = (closureInfo.Status & ClosureStatus.HasClosure) == 0
-                        ? EmptyArrayClosure
-                        : new ArrayClosure(closureInfo.GetArrayOfConstantsAndNestedLambdas());
-                }
+                var hasDebugInfo = (flags & CompilerFlags.EnableDelegateDebugInfo) != 0;
+                if (!hasDebugInfo)
+                    closure = constantsAndNestedLambdas == null ? EmptyArrayClosure : new ArrayClosure(constantsAndNestedLambdas);
                 else
-                {   // todo: @feature add the debug info to the nested lambdas!
+                {
                     var debugExpr = Lambda(delegateType, bodyExpr, paramExprs?.ToReadOnlyList() ?? Tools.Empty<PE>());
-                    var constantsAndNestedLambdas = (closureInfo.Status & ClosureStatus.HasClosure) == 0
-                        ? null
-                        : closureInfo.GetArrayOfConstantsAndNestedLambdas();
                     closure = new DebugArrayClosure(constantsAndNestedLambdas, debugExpr);
                 }
 
@@ -548,6 +550,8 @@ internal static object TryCompileBoundToFirstClosureParam(Type delegateType, Exp
                 {
                     il.Demit(OpCodes.Ret);
                     compiledDelegate = dynMethod.CreateDelegate(delegateType, closure);
+                    if (hasDebugInfo)
+                        ((DebugArrayClosure)closure).ILString = compiledDelegate.Method.ToILString().ToString();
                 }
 
                 DynamicMethodHacks.FreePooledILGenerator(dynMethod, il);
@@ -1007,6 +1011,9 @@ public sealed class DebugArrayClosure : ArrayClosure, IDelegateDebugInfo
 
             private readonly Lazy<string> _csharpString;
             public string CSharpString => _csharpString.Value;
+
+            public string ILString { get; internal set; }
+
             public DebugArrayClosure(object[] constantsAndNestedLambdas, LambdaExpression expr)
                 : base(constantsAndNestedLambdas)
             {
@@ -1804,7 +1811,7 @@ private static bool FindAlreadyCompiledNestedLambdaInfoInLambdas(
             return false;
         }
 
-        private static bool TryCompileNestedLambda(ref ClosureInfo nestedClosureInfo, NestedLambdaInfo nestedLambdaInfo, CompilerFlags setup)
+        private static bool TryCompileNestedLambda(ref ClosureInfo nestedClosureInfo, NestedLambdaInfo nestedLambdaInfo, CompilerFlags flags)
         {
             // 1. Try to compile nested lambda in place
             // 2. Check that parameters used in compiled lambda are passed or closed by outer lambda
@@ -1829,28 +1836,34 @@ private static bool TryCompileNestedLambda(ref ClosureInfo nestedClosureInfo, Ne
             nestedClosureInfo.NestedLambdas = nestedLambdaInfo.NestedLambdas;
             nestedClosureInfo.NonPassedParameters = nestedLambdaInfo.NonPassedParameters;
 
-            var nestedConstsAndLambdas = nestedClosureInfo.GetArrayOfConstantsAndNestedLambdas();
+            var constantsAndNestedLambdas = (nestedClosureInfo.Status & ClosureStatus.HasClosure) != 0
+                ? nestedClosureInfo.GetArrayOfConstantsAndNestedLambdas()
+                : null;
 
             ArrayClosure nestedLambdaClosure = null;
             var hasNonPassedParameters = nestedLambdaInfo.NonPassedParameters.Count != 0;
             if (!hasNonPassedParameters)
-                nestedLambdaClosure = (nestedClosureInfo.Status & ClosureStatus.HasClosure) == 0
-                    ? EmptyArrayClosure
-                    : new ArrayClosure(nestedConstsAndLambdas);
+            {
+                var hasDebugInfo = (flags & CompilerFlags.EnableDelegateDebugInfo) != 0;
+                if (!hasDebugInfo)
+                    nestedLambdaClosure = constantsAndNestedLambdas == null ? EmptyArrayClosure : new ArrayClosure(constantsAndNestedLambdas);
+                else
+                    nestedLambdaClosure = new DebugArrayClosure(constantsAndNestedLambdas, nestedLambdaExpr);
+            }
 
             var closurePlusParamTypes = RentPooledOrNewClosureTypeToParamTypes(nestedLambdaParamExprs);
 
             var method = new DynamicMethod(string.Empty, nestedReturnType, closurePlusParamTypes, typeof(ArrayClosure), true);
             var il = DynamicMethodHacks.RentPooledOrNewILGenerator(method, nestedReturnType, closurePlusParamTypes);
 
-            if (nestedConstsAndLambdas != null)
+            if (constantsAndNestedLambdas != null)
                 EmittingVisitor.EmitLoadConstantsAndNestedLambdasIntoVars(il, ref nestedClosureInfo);
 
             var parent = nestedReturnType == typeof(void) ? ParentFlags.IgnoreResult : ParentFlags.LambdaCall;
             if (nestedReturnType.IsByRef)
                 parent |= ParentFlags.ReturnByRef;
 
-            var emitOk = EmittingVisitor.TryEmit(nestedLambdaBody, nestedLambdaParamExprs, il, ref nestedClosureInfo, setup, parent);
+            var emitOk = EmittingVisitor.TryEmit(nestedLambdaBody, nestedLambdaParamExprs, il, ref nestedClosureInfo, flags, parent);
             if (emitOk)
             {
                 il.Demit(OpCodes.Ret);
@@ -1862,8 +1875,8 @@ private static bool TryCompileNestedLambda(ref ClosureInfo nestedClosureInfo, Ne
                     : method.CreateDelegate(Tools.GetFuncOrActionType(closurePlusParamTypes, nestedReturnType), null);
 
                 nestedLambdaInfo.Lambda = !hasNonPassedParameters ? nestedLambda
-                    : nestedConstsAndLambdas == null ? new NestedLambdaForNonPassedParams(nestedLambda)
-                    : new NestedLambdaForNonPassedParamsWithConstants(nestedLambda, nestedConstsAndLambdas);
+                    : constantsAndNestedLambdas == null ? new NestedLambdaForNonPassedParams(nestedLambda)
+                    : new NestedLambdaForNonPassedParamsWithConstants(nestedLambda, constantsAndNestedLambdas);
             }
             DynamicMethodHacks.FreePooledILGenerator(method, il);
             FreePooledClosureTypeAndParamTypes(closurePlusParamTypes);

src/FastExpressionCompiler/TestTools.cs

@@ -17,6 +17,7 @@ namespace FastExpressionCompiler.LightExpression;
 using FastExpressionCompiler.LightExpression.ImTools;
 #else
 namespace FastExpressionCompiler;
+
 using FastExpressionCompiler.ILDecoder;
 using FastExpressionCompiler.ImTools;
 using System.Linq.Expressions;

test/FastExpressionCompiler.TestsRunner/Program.cs

@@ -15,7 +15,7 @@ public static void Main()
             // LightExpression.ILGeneratorTools.DisableILGeneratorPooling = true;
 
             // new Issue461_InvalidProgramException_when_null_checking_type_by_ref().Run();
-            // new LightExpression.UnitTests.NestedLambdasSharedToExpressionCodeStringTest().Run();
+            new LightExpression.UnitTests.NestedLambdasSharedToExpressionCodeStringTest().Run();
             // new Issue55_CompileFast_crash_with_ref_parameter().Run();
 
             var t = new LightExpression.TestRun(LightExpression.TestFlags.RethrowException);