Bugfix: GetAwaitExpressionInfo ignores BoundConversion

src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs

@@ -898,9 +898,9 @@ public override AwaitExpressionInfo GetAwaitExpressionInfo(AwaitExpressionSyntax
  {
  throw new ArgumentException("node.Kind==" + node.Kind());
  }
-
- var bound = GetUpperBoundNode(node);
- BoundAwaitableInfo awaitableInfo = (((bound as BoundExpressionStatement)?.Expression ?? bound) as BoundAwaitExpression)?.AwaitableInfo;
+ var boundAwait = FindBoundAwait(GetLowerBoundNode(node), node)
+  ?? FindBoundAwait(GetUpperBoundNode(node), node);
+ var awaitableInfo = boundAwait?.AwaitableInfo;
  if (awaitableInfo == null)
  {
  return default(AwaitExpressionInfo);
@@ -910,7 +910,40 @@ public override AwaitExpressionInfo GetAwaitExpressionInfo(AwaitExpressionSyntax
  getAwaiter: (IMethodSymbol)awaitableInfo.GetAwaiter?.ExpressionSymbol.GetPublicSymbol(),
  isCompleted: awaitableInfo.IsCompleted.GetPublicSymbol(),
  getResult: awaitableInfo.GetResult.GetPublicSymbol(),
- isDynamic: awaitableInfo.IsDynamic);
+ isDynamic: awaitableInfo.IsDynamic
+ );
+
+ static BoundAwaitExpression FindBoundAwait(BoundNode rootSearchNode, AwaitExpressionSyntax node)
+ {
+ var cur = rootSearchNode;
+ while (true)
+ {
+ switch (cur)
+ {
+ case BoundAwaitExpression ba:
+ if (ba.Syntax == node)
+ {
+ return ba;
+ }
+ else
+ {
+ return null;
+ }
+ case BoundExpressionStatement boundExpressionStatement:
+ cur = boundExpressionStatement.Expression;
+ break;
+ case BoundConversion boundConversion:
+ //e.g.: await something + "aText"
+ cur = boundConversion.Operand;
+ break;
+ case BoundBadStatement:
+ case BoundBadExpression:
+ return null;
+ default:
+ return null;
+ }
+ }
+ }
  }
 
  public override ForEachStatementInfo GetForEachStatementInfo(ForEachStatementSyntax node)

src/Compilers/CSharp/Test/Semantic/Semantics/AwaitExpressionTests.cs

@@ -20,6 +20,97 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests
  /// </summary>
  public class AwaitExpressionTests : CompilingTestBase
  {
+ [Fact]
+ public void TestAwaitInfoExtensionMethod()
+ {
+ var text =
+@"using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+static class App{
+ public static async Task Main(){
+ MyAwaitable Get()
+ {
+ return new MyAwaitable();
+ }
+
+ var x = Get();
+ x.SetValue(42);
+
+ Console.WriteLine(await x + ""!"");
+ }
+}
+
+struct MyAwaitable
+{
+ private ValueTask<int> task;
+ private TaskCompletionSource<int> source;
+
+ private TaskCompletionSource<int> Source
+ {
+ get
+ {
+ if (source == null)
+ {
+ source = new TaskCompletionSource<int>();
+ task = new ValueTask<int>(source.Task);
+ }
+ return source;
+ }
+ }
+ internal ValueTask<int> Task
+ {
+ get
+ {
+ _ = Source;
+ return task;
+ }
+ }
+
+ public void SetValue(int i)
+ {
+ Source.SetResult(i);
+ }
+}
+
+static class MyAwaitableExtension
+{
+ public static System.Runtime.CompilerServices.ValueTaskAwaiter<int> GetAwaiter(this MyAwaitable a)
+ {
+ return a.Task.GetAwaiter();
+ }
+}";
+ var refApis = System.AppDomain.CurrentDomain.GetAssemblies().Where(a => !a.IsDynamic).Select(
+ a => MetadataReference.CreateFromFile(a.Location)
+ );
+ var tree = SyntaxFactory.SyntaxTree(SyntaxFactory.ParseCompilationUnit(text));
+ var csCompilation = CSharpCompilation.Create("something",
+ new[] { tree },
+ refApis,
+ new CSharpCompilationOptions(OutputKind.ConsoleApplication)
+ );
+
+ var model = csCompilation.GetSemanticModel(tree);
+ var awaitExpression = tree.GetRoot().DescendantNodes().OfType<AwaitExpressionSyntax>().First();
+
+ var op = model.GetOperation(awaitExpression);
+ var info = model.GetAwaitExpressionInfo(awaitExpression);
+
+ Assert.Equal(
+ "System.Runtime.CompilerServices.ValueTaskAwaiter<System.Int32> MyAwaitableExtension.GetAwaiter(this MyAwaitable a)",
+ info.GetAwaiterMethod.ToTestDisplayString()
+ );
+ Assert.Equal(
+ "System.Int32 System.Runtime.CompilerServices.ValueTaskAwaiter<System.Int32>.GetResult()",
+ info.GetResultMethod.ToTestDisplayString()
+ );
+ Assert.Equal(
+ "System.Boolean System.Runtime.CompilerServices.ValueTaskAwaiter<System.Int32>.IsCompleted { get; }",
+ info.IsCompletedProperty.ToTestDisplayString()
+ );
+ }
+
  [Fact]
  [WorkItem(711413, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/711413")]
  public void TestAwaitInfo()
@@ -70,15 +161,17 @@ public void DefaultAwaitExpressionInfo()
  Assert.Equal(0, info.GetHashCode());
  }
 
- private AwaitExpressionInfo GetAwaitExpressionInfo(string text, out CSharpCompilation compilation, params DiagnosticDescription[] diagnostics)
+ private AwaitExpressionInfo GetAwaitExpressionInfo(string text,
+ out CSharpCompilation compilation, params DiagnosticDescription[] diagnostics)
  {
  var tree = Parse(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5));
  var comp = CreateCompilationWithMscorlib45(new SyntaxTree[] { tree }, new MetadataReference[] { SystemRef });
  comp.VerifyDiagnostics(diagnostics);
  compilation = comp;
  var syntaxNode = (AwaitExpressionSyntax)tree.FindNodeOrTokenByKind(SyntaxKind.AwaitExpression).AsNode();
  var treeModel = comp.GetSemanticModel(tree);
- return treeModel.GetAwaitExpressionInfo(syntaxNode);
+ var awaitExpr = treeModel.GetAwaitExpressionInfo(syntaxNode);
+ return awaitExpr;
  }
 
  private AwaitExpressionInfo GetAwaitExpressionInfo(string text, params DiagnosticDescription[] diagnostics)