added test for #495

Author: Maksim Volkau

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -1217,9 +1217,7 @@ public enum Result
             /// <summary>TypeEqual is not supported </summary>
             NotSupported_TypeEqual = 1009,
             /// <summary>`when` in catch is not supported yet</summary>
-            NotSupported_ExceptionCatchFilter = 1010,
-            /// <summary>Example: lambda return type requires bool, but body has an object type</summary>
-            NotSupported_NoCoalesceBetweenLambdaReturnTypeAndBodyType = 1011
+            NotSupported_ExceptionCatchFilter = 1010
         }
 
         /// <summary>Return value is ignored</summary>
@@ -2343,7 +2341,7 @@ public static bool TryEmit(Expression expr,
                                         {
                                             // But we cannot use the return pattern and eliminate the target label if we have more gotos referencing it, see #430
                                             var (gotos, labels) = closure.TargetToGotosAndLabels.Map.TryGetValueRef(label.Target, out var found);
-                                            if (found && gotos <= labels)
+                                            if (found & gotos <= labels)
                                             {
                                                 if ((parent & ParentFlags.TryCatch) != 0)
                                                 {

test/FastExpressionCompiler.IssueTests/Issue495_Incomplete_pattern_detection_for_NotSupported_1007_Return_goto_from_TryCatch_with_Assign_generates_invalid_IL.cs

@@ -0,0 +1,91 @@
+#if NET8_0_OR_GREATER
+using System;
+using System.Reflection.Emit;
+using System.Text.Json;
+
+#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 Issue495_Incomplete_pattern_detection_for_NotSupported_1007_Return_goto_from_TryCatch_with_Assign_generates_invalid_IL : ITestX
+{
+    public void Run(TestRun t)
+    {
+        ReturnGotoFromTryCatchWithAssign_ShouldBeDetectedAsError1007(t);
+    }
+
+    public void ReturnGotoFromTryCatchWithAssign_ShouldBeDetectedAsError1007(TestContext t)
+    {
+        // Arrange: Build expression with Return(label, Assign(...)) inside TryCatch
+        var variable = Variable(typeof(object), "var");
+        var finalResult = Variable(typeof(object), "finalResult");
+        var returnLabel = Label(typeof(object), "return");
+        var exceptionParam = Parameter(typeof(Exception), "ex");
+
+        var block = Block(
+            new[] { variable, finalResult },
+            TryCatch(
+                Block(
+                    typeof(void),
+                    Assign(variable, Constant("hello", typeof(object))),
+                    IfThen(
+                        NotEqual(variable, Constant(null, typeof(object))),
+                        // FEC should detect this as error 1007 and reject it
+                        Return(returnLabel, Assign(finalResult, variable), typeof(object))
+                        // @wip other patters:
+                        // - Return(label, Block(Assign(var, value), value))
+                        // - Return(label, Call(MethodThatAssigns, ref var, value))
+                        // - Return(label, Coalesce(value, Assign(var, default)))
+                    ),
+                    Assign(finalResult, Constant("default", typeof(object))),
+                    Label(returnLabel, Constant("fallback", typeof(object)))
+                ),
+                Catch(exceptionParam, Empty())
+            ),
+            finalResult
+        );
+
+        var expr = Lambda<Func<object>>(block);
+
+        expr.PrintCSharp();
+        var @cs = (Func<object>)(() => //object
+        {
+            object var = null;
+            object finalResult = null;
+            try
+            {
+                var = (object)"hello";
+                if (var != null)
+                {
+                    return finalResult = var;
+                }; // todo: @wip remove ;
+                finalResult = (object)"default";
+                // return:; // todo: @wip remove or comment or rename but make it a valid c#
+            }
+            catch (Exception ex) // no need for ex
+            {
+                ; // todo: @wip remove ; 
+            }
+            return finalResult;
+        });
+
+
+        var fs = expr.CompileSys();
+        fs.PrintIL(format: ILDecoder.ILFormat.AssertOpCodes);
+        fs();
+
+        // Act: CompileFast should throw NotSupportedExpressionException or return null
+        // var ff = expr.CompileFast(ifFastFailedReturnNull: true);
+        // ff.PrintIL(format: ILDecoder.ILFormat.AssertOpCodes);
+
+        // // Expected: compiled should be null (pattern detected as unsupported)
+        // t.IsNull(ff);
+    }
+}
+#endif

test/FastExpressionCompiler.TestsRunner/Program.cs

@@ -34,6 +34,16 @@ public static void Main()
             // new Issue441_Fails_to_pass_Constant_as_call_parameter_by_reference().Run();
             // new Issue461_InvalidProgramException_when_null_checking_type_by_ref().Run();
 
+            var st = new TestRun(TestFlags.RethrowException);
+
+            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
+            st.Run(new Issue487_Fix_ToCSharpString_output_for_boolean_equality_expressions());
+            st.Run(new Issue475_Reuse_DynamicMethod_if_possible());
+#endif
+
             var lt = new LightExpression.TestRun(LightExpression.TestFlags.RethrowException);
 
 #if NET8_0_OR_GREATER
@@ -46,15 +56,6 @@ public static void Main()
             lt.Run(new LightExpression.IssueTests.Issue473_InvalidProgramException_when_using_Expression_Condition_with_converted_decimal_expression());
             lt.Run(new LightExpression.IssueTests.Issue476_System_ExecutionEngineException_with_nullables_on_repeated_calls_to_ConcurrentDictionary());
 
-            var st = new TestRun(TestFlags.RethrowException);
-
-            st.Run(new Issue480_CLR_detected_an_invalid_program_exception());
-
-#if NET8_0_OR_GREATER
-            st.Run(new Issue487_Fix_ToCSharpString_output_for_boolean_equality_expressions());
-            st.Run(new Issue475_Reuse_DynamicMethod_if_possible());
-#endif
-
             RunAllTests();
         }