Fix to unwrap Task in async expression bodied methods

Fixes #27647

src/EditorFeatures/CSharpTest/TypeInferrer/TypeInferrerTests.cs

@@ -740,6 +740,77 @@ async System.Threading.Tasks.Task<int> F()
 }", "global::System.Int32");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedConstructor()
+        {
+            await TestInClassAsync(
+@"C() => [|Goo()|];", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedMethod()
+        {
+            await TestInClassAsync(
+@"int M() => [|Goo()|];", "global::System.Int32");
+        }
+
+        [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedAsyncMethod()
+        {
+            await TestInClassAsync(
+@"async System.Threading.Tasks.Task<int> M() => [|Goo()|];", "global::System.Int32");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedVoidMethod()
+        {
+            await TestInClassAsync(
+@"void M() => [|Goo()|];", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedProperty()
+        {
+            await TestInClassAsync(
+@"int P => [|Goo()|];", "global::System.Int32");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedPropertyGetter()
+        {
+            await TestInClassAsync(
+@"int P { get => [|Goo()|]; }", "global::System.Int32");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedPropertySetter()
+        {
+            await TestInClassAsync(
+@"int P { set => [|Goo()|]; }", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedLocalFunction()
+        {
+            await TestInClassAsync(
+@"void M()
+{
+    int F() => [|Goo()|];
+}", "global::System.Int32");
+        }
+
+        [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedAsyncLocalFunction()
+        {
+            await TestInClassAsync(
+@"void M()
+{
+    async System.Threading.Tasks.Task<int> F() => [|Goo()|];
+}", "global::System.Int32");
+        }
+
         [WorkItem(827897, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/827897")]
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
         public async Task TestYieldReturnInMethod()

src/Workspaces/CSharp/Portable/LanguageServices/CSharpTypeInferenceService.TypeInferrer.cs

@@ -173,16 +173,6 @@ private IEnumerable<TypeInferenceInfo> GetTypesSimple(ExpressionSyntax expressio
                 }
             }
 
-            private IEnumerable<TypeInferenceInfo> InferTypeInArrowExpressionClause(ArrowExpressionClauseSyntax arrowClause)
-            {
-                var parentSymbol = SemanticModel.GetDeclaredSymbol(arrowClause.Parent, CancellationToken);
-                var parentMemberType = GetMemberType(parentSymbol);
-
-                return parentMemberType != null 
-                    ? SpecializedCollections.SingletonEnumerable(new TypeInferenceInfo(parentMemberType))
-                    : SpecializedCollections.EmptyEnumerable<TypeInferenceInfo>();
-            }
-
             protected override IEnumerable<TypeInferenceInfo> InferTypesWorker_DoNotCallDirectly(int position)
             {
                 var syntaxTree = SemanticModel.SyntaxTree;
@@ -1784,7 +1774,7 @@ private IEnumerable<TypeInferenceInfo> InferTypeInYieldStatement(YieldStatementS
                 var declaration = yieldStatement.FirstAncestorOrSelf<SyntaxNode>(e => e is LocalFunctionStatementSyntax || e is MemberDeclarationSyntax);
                 var memberSymbol = GetDeclaredMemberSymbolFromOriginalSemanticModel(declaration);
 
-                var memberType = GetMemberType(memberSymbol);
+                var memberType = GetMemberType(memberSymbol, out _);
 
                 if (memberType is INamedTypeSymbol namedType)
                 {
@@ -1798,12 +1788,19 @@ private IEnumerable<TypeInferenceInfo> InferTypeInYieldStatement(YieldStatementS
                 return SpecializedCollections.EmptyEnumerable<TypeInferenceInfo>();
             }
 
-            private static ITypeSymbol GetMemberType(ISymbol memberSymbol)
+            private static ITypeSymbol GetMemberType(ISymbol memberSymbol, out bool isAsync)
             {
+                isAsync = false;
+
                 switch (memberSymbol)
                 {
-                    case IMethodSymbol method: return method.ReturnType;
-                    case IPropertySymbol property: return property.Type;
+                    case IMethodSymbol method:
+                        isAsync = method.IsAsync;
+                        return method.ReturnType;
+                    case IPropertySymbol property:
+                        return property.Type;
+                    case IFieldSymbol field:
+                        return field.Type;
                 }
 
                 return null;
@@ -1841,19 +1838,21 @@ private ITypeSymbol UnwrapTaskLike(ITypeSymbol type, bool isAsync)
                 }
 
                 var symbol = GetDeclaredMemberSymbolFromOriginalSemanticModel(ancestor);
+                var type = GetMemberType(symbol, out var isAsync);
 
-                switch (symbol)
-                {
-                    case IMethodSymbol method:
-                        return SpecializedCollections.SingletonEnumerable(
-                            new TypeInferenceInfo(UnwrapTaskLike(method.ReturnType, method.IsAsync)));
-                    case IPropertySymbol property:
-                        return SpecializedCollections.SingletonEnumerable(new TypeInferenceInfo(property.Type));
-                    case IFieldSymbol field:
-                        return SpecializedCollections.SingletonEnumerable(new TypeInferenceInfo(field.Type));
+                return type != null
+                    ? SpecializedCollections.SingletonEnumerable(new TypeInferenceInfo(UnwrapTaskLike(type, isAsync)))
+                    : SpecializedCollections.EmptyEnumerable<TypeInferenceInfo>();
             }
 
-                return SpecializedCollections.EmptyEnumerable<TypeInferenceInfo>();
+            private IEnumerable<TypeInferenceInfo> InferTypeInArrowExpressionClause(ArrowExpressionClauseSyntax arrowClause)
+            {
+                var symbol = GetDeclaredMemberSymbolFromOriginalSemanticModel(arrowClause.Parent);
+                var type = GetMemberType(symbol, out var isAsync);
+
+                return type != null
+                    ? SpecializedCollections.SingletonEnumerable(new TypeInferenceInfo(UnwrapTaskLike(type, isAsync)))
+                    : SpecializedCollections.EmptyEnumerable<TypeInferenceInfo>();
             }
 
             private ISymbol GetDeclaredMemberSymbolFromOriginalSemanticModel(SyntaxNode declarationInCurrentTree)