fixed: #498

Author: Maksim Volkau

.vscode/settings.json

@@ -38,6 +38,7 @@
         "Maksim",
         "NETCOREAPP",
         "NETFRAMEWORK",
+        "NETSTANDARD",
         "Newarr",
         "Newobj",
         "outparameter",

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -2222,7 +2222,7 @@ public static bool TryEmit(Expression expr,
                             }
                         case ExpressionType.Not:
                             {
-                                if (!exprType.IsPrimitive) // todo: @feat #496 
+                                if (!exprType.IsPrimitive) // todo: @feat #496
                                 {
                                     Debug.WriteLine("Unsupported: Nullable<bool> in !x (is invalid C# but valid expression) is not supported yet, see #480: " + expr);
                                     return false;
@@ -2531,6 +2531,10 @@ private static bool TryEmitLoop(LoopExpression loopExpr, IReadOnlyList<PE> param
                 CompilerFlags setup, ParentFlags parent)
 #endif
             {
+                // Loop expression itself does not leave a value on stack.
+                // If its body produces a value (e.g. a nested typed break/goto path), we need to ignore it before branching back to the loop head, see #498.
+                parent |= ParentFlags.IgnoreResult;
+
                 // Mark the start of the loop body:
                 var loopBodyLabel = il.DefineLabel();
                 il.DmarkLabel(loopBodyLabel);

test/FastExpressionCompiler.IssueTests/Issue498_InvalidProgramException_when_using_loop.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Reflection.Emit;
+
+#if LIGHT_EXPRESSION
+using FastExpressionCompiler.LightExpression.ImTools;
+using static FastExpressionCompiler.LightExpression.Expression;
+namespace FastExpressionCompiler.LightExpression.IssueTests;
+#else
+using System.Linq.Expressions;
+using static System.Linq.Expressions.Expression;
+namespace FastExpressionCompiler.IssueTests;
+#endif
+
+public struct Issue498_InvalidProgramException_when_using_loop : ITestX
+{
+    public void Run(TestRun t)
+    {
+        Original_test(t);
+    }
+
+    public void Original_test(TestContext t)
+    {
+        // Creating a label that represents the return value
+        var result = Variable(typeof(int), "result");
+        var x = Variable(typeof(int), "x");
+
+        var endMain = Label(typeof(int), "endMain");
+        var endSub1 = Label(typeof(void), "endSub1");
+        var continue1 = Label(typeof(void), "continue1");
+
+        var loopExpression = Loop(
+            Block(
+                Loop(
+                    Block(
+                        IfThen(GreaterThanOrEqual(x, Constant(10)),
+                            Break(endMain, result)),
+                        AddAssign(result, Constant(1)),
+                        AddAssign(x, Constant(1))
+                        ),
+                    endSub1,
+                    continue1
+                    )
+                ),
+            endMain
+        );
+
+        var body = Block([result, x], loopExpression);
+        var expr = Lambda<Func<int>>(body);
+        expr.PrintCSharp();
+
+        var _ = (Func<int>)(() => //int
+        {
+            int result = default;
+            int x = default;
+            while (true)
+            {
+                while (true)
+                {
+                continue1:;
+                    if (x >= 10)
+                    {
+                        return result;
+                    }
+                    result += 1;
+                    x += 1;
+                }
+            endSub1:;
+            }
+        endMain:;
+        });
+
+        var fs = expr.CompileSys();
+        fs.PrintIL(format: ILDecoder.ILFormat.AssertOpCodes);
+        var calResult = fs();
+        t.AreEqual(10, calResult);
+
+        // Act: CompileFast should throw NotSupportedExpressionException or return null
+        var ff = expr.CompileFast(ifFastFailedReturnNull: true);
+        t.IsNotNull(ff);
+        ff.PrintIL(format: ILDecoder.ILFormat.AssertOpCodes);
+
+        ff.AssertOpCodes(
+           OpCodes.Ldloc_1, //        at IL_0000
+           OpCodes.Ldc_I4_S, // 10    at IL_0001
+           OpCodes.Clt, //            at IL_0003
+           OpCodes.Ldc_I4_0, //       at IL_0005
+           OpCodes.Ceq, //            at IL_0006
+           OpCodes.Brfalse, // IL_0019at IL_0008
+           OpCodes.Ldloc_0, //        at IL_0013
+           OpCodes.Br, // IL_0037     at IL_0014
+           OpCodes.Ldloc_0, //        at IL_0019
+           OpCodes.Ldc_I4_1, //       at IL_0020
+           OpCodes.Add, //            at IL_0021
+           OpCodes.Stloc_0, //        at IL_0022
+           OpCodes.Ldloc_1, //        at IL_0023
+           OpCodes.Ldc_I4_1, //       at IL_0024
+           OpCodes.Add, //            at IL_0025
+           OpCodes.Stloc_1, //        at IL_0026
+           OpCodes.Br, // IL_0000     at IL_0027
+           OpCodes.Br, // IL_0000     at IL_0032
+           OpCodes.Ret  //            at IL_0037
+        );
+
+        calResult = ff();
+        t.AreEqual(10, calResult);
+    }
+}

test/FastExpressionCompiler.TestsRunner/Program.cs

@@ -51,6 +51,7 @@ public static void Main()
 
             var st = new TestRun(TestFlags.RethrowException);
 
+            st.Run(new Issue498_InvalidProgramException_when_using_loop());
             st.Run(new Issue495_Incomplete_pattern_detection_for_NotSupported_1007_Return_goto_from_TryCatch_with_Assign_generates_invalid_IL());
             st.Run(new Issue480_CLR_detected_an_invalid_program_exception());
 #if NET8_0_OR_GREATER