Invalid Program after Coalesce

[ackava]

Sample C# Code

        public class Variable
        {

            public string Name { get; set; }
            public Variable(string name)
            {
                Name = name;
            }
        }

    Func<Variable, string, Variable> fx  = (input, text) => {
         input = input ?? new Variable("default");
         input.Value = text;
        return input;
    };

Test Case

        public class Variable
        {

            public string Name { get; set; }
            public Variable(string name)
            {
                Name = name;
            }
        }


        [Test]
        public void CoalescFail()
        {
            var input = Parameter(typeof(Variable));
            var text = Parameter(typeof(string));
            var ctor = typeof(Variable).GetConstructor(new Type[] { typeof(string) });
            var property = typeof(Variable).GetProperty(nameof(Variable.Name));

            var lambda = Lambda(
                Block(
                Coalesce(input, New(ctor, Constant("default"))),
                Assign(Property(input, property), text),
                input), input, text);

            var t = lambda.ToExpressionString();

            var fx = lambda.CompileFast<Func<Variable, string,Variable>>();

            Assert.NotNull(fx(null,  "a"));
        }

It seems any statement after coalesc is failing.

If you look at this link, coalesc is done without loading null on to the stack. This could be improvement.

https://sharplab.io/#v2:C4LglgNgPgAgTARgLACgYGYAE9MGFMDeqmJ2WMALJgLIAUAlIcaQL7MntnYIBs3ADHgD2AQwgBTAM4BjWjASCwAOwAOAV2AAaAZgAmI4CMZEUpM9gDsmZeuCYA/Pb0GRDpwCIR7gNyc2p0lR/VCA

[dadhi]

Thanks for posting, will check.

[dadhi]

@ackava

Hi again, the expression is wrong in the sense you are not assigning the result of Coalesce.
Both System and Fast Compile are failing with the NullRefEx.

I have changed the Expression and everything is fine, check the test

FastExpressionCompiler/test/FastExpressionCompiler.IssueTests/Issue284_Invalid_Program_after_Coalesce.cs

Line 34 in 0cb6229

Assign(input, // NOTE: Don't forget to Assign!

You may also do expr.PrintCSharp(); in your test and quickly see if the expression is OK.

[ackava]

@dadhi Sorry in this test case I have forgotten, but I have a large library in which I am assigning result of Coalesc, but it is still failing, but Linq Expression isn't failing. I will try to isolate the case where it is working in Linq and failing in Fast.

[dadhi]

@ackava You may also try to replace Coalesce with Conditional and see if the results change.. I mean, the bug may be in one but not in another.

[ackava]

@dadhi

I think I found root cause, problem is due to New expression after Coalesce. .

Try this code,

First try commenting CompileSys it will result in Invalid program runtime. But if you uncomment CompileSys, it will

            var input = Parameter(typeof(Variable));
            var text = Parameter(typeof(string));
            var ctor = typeof(Variable).GetConstructor(new Type[] { typeof(string) });
            var property = typeof(Variable).GetProperty(nameof(Variable.Name));

            var lambda = Lambda(
                Block(
                Coalesce(input, New(ctor, Constant("default"))),
                Assign(Property(input, property), text),
                input), input, text);

            // var t = lambda.ToExpressionString();

            var fx2 = lambda.CompileSys();
            fx2.PrintIL();
            Assert.Throws(typeof(System.Reflection.TargetInvocationException), () =>
             fx2.DynamicInvoke(null, "a"));


            var fx = lambda.CompileFast<Func<Variable, string, Variable>>();
            fx.PrintIL();
            Assert.Throws(typeof(System.Reflection.TargetInvocationException), () =>
             fx(null, "a"));

I know the expression is wrong, but CompileSys successfully throws NullReferenceException, but CompileFast results in Invalid runtime.

The point here is, generated IL corrupts some state, instead of throwing exception.

If you look at the PrintIL,

<il>
0    ldarg.1
1    dup
2    ldnull
3    ceq
5    brfalse 23
10   pop
11   ldstr default
16   newobj Variable..ctor
21   br.s 23
23   pop
24   ldarg.1
25   ldarg.2
26   callvirt Variable.set_Name
31   ldarg.1
32   ret
</il>
<il>
0    dup // did not push first parameter
1    ldnull
2    ceq
4    brfalse 15
9    pop
10   newobj Variable..ctor // did not push `new` arguments
15   ldarg.1
16   ldarg.2
17   call Variable.set_Name
22   ldarg.1
23   ret
</il>

There are two problems,

1. Notice at line 0, LE produces ldarg1, where else dup assumes first parameter is loaded on the stack.
2. At Line 10 in Fast Generator, newobj Variable.ctor does not push default string.

I have confirmed that code generated with Assign is exactly same. But without assign, code generated returns in Invalid Runtime. That is due to Arguments for New not being pushed onto the stack and not loading first parameter onto the stack.

Now though my expression is wrong here, but it is still a valid code, and it should return null reference as expected. But in many other cases when expression is valid and running correctly with LE, Fast Expression is throwing invalid runtime, and combination of Coalesce is root issue.

I am sure if this problem is addressed, it will resolve other dependent issues with Coalesce.

[dadhi]

@ackava Good, I will look.