Code coverage of inline functions using F# in visual studio 2012

Question

The code coverage tool in Visual studio 2012 marks all inline functions as uncovered even when they were covered.

Is there any way how to make code coverage work for inline functions?

Answer 1

When you write an inline function, the compiler inlines the body of the function into the calling code. As discussed in the comments, it also does not emit debug information for this inlined body (and so you cannot step into the function - I think this could be fixed - submit a request to fsbugs at microsoft dot com).

However, the compiler also generates a dynamic version of the code - if you write say:

let inline add a b = a + b

then there is actually an add method in the compiled code. The method will be generic ('a -> 'b -> 'c) and uses dynamic lookup to find an appropriate implementation of the + operator (because .NET generics cannot represent such constraints).

The dynamic implementation will be invoked when you use reflection or quotations:

open Microsoft.FSharp.Linq.RuntimeHelpers
<@ add 1 2 @> |> LeafExpressionConverter.EvaluateQuotation |> printfn "Got: %A"

If you put breakpoint inside add and run the above code than the breakpoint will be hit (and I assume the code coverage tool will report the function as covered).

But keep in mind that this is not the code that is actually executed when you write add 1 2 in normal code - the code executing here is a different implementation (that uses slow dynamic lookup, rather than inlining).

Answer 2

Aren't inline functions directly integrated into the calling code? If so no actual method is called as the code is 'inlined' and for each place they are used a new copy of the inlined code exists.