Prevent "await Task.FromResult()"

[omsmith]

A developer working on an async method may end up following a series of steps resulting in a completely unnecessary return await Task.FromResult( foo ); expression, instead of the much simpler return foo;.

This analyzer would not be about correctness, but cleanliness.

async Task<bool> Foo() {
  bool knownResult = false;

  return await Task.FromResult( knownResult ); // D2LXXXX: Do not await a Task.FromResult. Simply use the result value instead.
}

Writing this analyzer becomes somewhat easier due to D2L0055, which requires that all awaited tasks are configured, and so we can limit the syntax we expect somewhat

async Task<int> Foo() => await Task.FromResult( 1 ).ConfigureAwait( false );
async Task<int> Bar() => await Task.FromResult( 2 ).SafeAsync();

Breaking this down:

• Analyze IAwaitOperations.
• Look at the syntax's Operand (Task.FromResult( 1 ).ConfigureAwait( false ))
• Expect an InvocationExpression and access it's Expression (Task.FromResult( 1 ).ConfigureAwait)
• Expect a MemberAccessExpression and access it's Expression (Task.FromResult( 1 ))
• Expect an IncovationExpression and access it's Expression
• Expect a MemberAccessExpression
• If the member is a static FromResult and the Expression is of type Task, raise a diagnostic

Clearly there are other scenarios this would not cover, but I would not expect an initial implementation to.

async Task<int> Foo() {
  ConfiguredTaskAwaitable<int> t = Task.FromResult( 1 ).ConfigureAwait( false );
  return await t;
}

async Task<int> Foo() {
  Task<int> t = Task.FromResult( 1 );
  return await t.ConfigureAwait( false );
}

async Task<int> Foo() {
  Task<int> t = Task.FromResult( 1 );
  ConfiguredTaskAwaitable<int> a = t.ConfigureAwait( false );
  return await a;
}

Additionally, a codefix could be provided to remove the await expression.

async Task<bool> Foo() {
  bool knownResult = false;

-  return await Task.FromResult( knownResult );
+  return knownResult;
}

It's worth noting that applying this codefix could easily end up with warning CS1998, but that's probably reasonable to let the developer deal with converting it to a non-async method.

// warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
async Task<bool> Foo() {
  bool knownResult = false;

  return knownResult;
}