Nested Linq expression trees result in quotation related calls

[krontogiannis]

Trying to extract a Linq expression which contains a nested Linq expression results in expression with Quotation related calls.

Repro steps

open System
open System.Linq.Expressions

type LinqExpr =
    static member fromFunc<'T, 'U>(e : Expression<Func<'T, 'U>>) = e

let expr = LinqExpr.fromFunc(fun () -> LinqExpr.fromFunc(fun y -> y + 1))

val it : Expression<Func<unit,Expression<Func<int,int>>>> =
  unitVar0 => fromFunc(QuotationToLambdaExpression(SubstHelper(NewDelegate (Func`2, y, Call (None, op_Addition, [y, Value (1)])), new [] {}, new [] {})))
    {Body = fromFunc(QuotationToLambdaExpression(SubstHelper(NewDelegate (Func`2, y, Call (None, op_Addition, [y, Value (1)])), new [] {}, new [] {})));
     CanReduce = false;
     Name = null;
     NodeType = Lambda;
     Parameters = seq [unitVar0];
     ReturnType = System.Linq.Expressions.Expression`1[System.Func`2[System.Int32,System.Int32]];
     TailCall = false;
     Type = System.Func`2[Microsoft.FSharp.Core.Unit,System.Linq.Expressions.Expression`1[System.Func`2[System.Int32,System.Int32]]];}

Expected behavior

The resulting expression tree should not contain quotation related calls, but probably use an ExpressionType.Quote for the nested expression.

Actual behavior

Expression tree contains this expression tree:

QuotationToLambdaExpression(SubstHelper(NewDelegate (Func`2, y, Call (None, op_Addition, [y, Value (1)])), new [] {}, new [] {}))

Known workarounds

None.

Related information

Provide any related information

• Windows 10
• .NET Framework, any version
• Visual Studio 2015/2017
• Severity: low

[bessgeor]

For anyone interested, I've came up with a solution for my special case. Generic case solution (without updates on LeafExpressionConverter) should involve some kind of robust unique identifying and retrieving of identifiers from instances of arbitrary data type (I thought that reinterpret cast may do the trick, but haven't tested this), something like (int)((object)Guid.NewGuid()), but survivng the compilation of expression.

The problem involved is the usage of LinqToDb.CompiledQuery.Compile - it accepts expression containing LINQ calls (that accept expressions themsellves) and fails on converting of nested expressions defined in F#. In my case, it successfully compiles a query by using

let compileFSharpQuery query =
  let visitor = AST_Conversion.FSharpLambdaVisitor()
  let expr = LeafExpressionConverter.QuotationToLambdaExpression query
  let rewritten = visitor.VisitAndConvert(expr, "compileFSharpQuery")
  CompiledQuery.Compile rewritten

May require modifications in the gist for other queries, though.