Roslyn: Incorrect CS4014 shown when using the async method with System.Linq.Expression

[vsfeedback]

Here is the code snippet that clearly demonstrates the issue:

class Program {
    static void Main(string[] args) {
        RaiseCanExecuteChanged(() => Load());// <<< illegal CS4014 here
    }
    static async Task Load() {
        await Task.Delay(1000);
    }
    static void RaiseCanExecuteChanged(Expression<Action> selector) {
        /* ... */
    }
}

The impact of this issue:

it is impossible to compile the solution when "Threat warnings as errors" level is set to all(our default settings).

_This issue has been moved from https://developercommunity.visualstudio.com/content/problem/447121/incorrect-cs4014-show-when-using-the-async-method.html
VSTS ticketId: 787866_
_These are the original issue comments:_
(no comments)
_These are the original issue solutions:_
(no solutions)

[gafter]

It is possible to use a #pragma to suppress the warning.

[gafter]

This is by design. The warning is correct. Suppress it if you don't want it.

[DmitryGaravsky]

@gafter
Hi Neal,

This is by design.

Could you please to provide a bit more detailed description of this design?

Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call.

There is no method-call here. There is no execution. There is nothing "awaitable" at all.

Under the syntax-sugar there is a simple object's construction only:

    var method = typeof(Program).GetMethod("Load", BindingFlags.NonPublic | BindingFlags.Static);
    RaiseCanExecuteChanged(
        Expression.Lambda<Action>(
            Expression.Call((Expression)null, method))
        );

So I really do not understand why this warning is shown.

[gafter]

The method call in the source program is Load(). Its return type is awaitable. It can be executed, and the point of the warning is that this may be a misuse of the API.

Since it is inside a (expression) lambda, it may or may not be executed, but the compiler does not and should not track whether it is actually invoked.