Fix to unwrap non-generic Task to void

src/EditorFeatures/CSharpTest/Diagnostics/GenerateMethod/GenerateMethodTests.cs

@@ -2573,7 +2573,7 @@ private static int Goo()
 
         [WorkItem(30232, "https://github.com/dotnet/roslyn/issues/30232")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
-        public async Task TestGenerateInAsyncSimpleLambda()
+        public async Task TestGenerateInAsyncTaskOfTSimpleLambda()
         {
             await TestInRegularAndScriptAsync(
 @"using System;
@@ -2605,7 +2605,7 @@ private static int Goo(string x)
 
         [WorkItem(30232, "https://github.com/dotnet/roslyn/issues/30232")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
-        public async Task TestGenerateInAsyncParenthesizedLambda()
+        public async Task TestGenerateInAsyncTaskOfTParenthesizedLambda()
         {
             await TestInRegularAndScriptAsync(
 @"using System;
@@ -2635,6 +2635,132 @@ private static int Goo()
 }");
         }
 
+        [WorkItem(30232, "https://github.com/dotnet/roslyn/issues/30232")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
+        public async Task TestGenerateInAsyncTaskSimpleLambda()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        Func<string, Task> f = async x => [|Goo|](x);
+    }
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        Func<string, Task> f = async x => Goo(x);
+    }
+
+    private static void Goo(string x)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [WorkItem(30232, "https://github.com/dotnet/roslyn/issues/30232")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
+        public async Task TestGenerateInAsyncTaskParenthesizedLambda()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        Func<Task> f = async () => [|Goo|]();
+    }
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        Func<Task> f = async () => Goo();
+    }
+
+    private static void Goo()
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
+        public async Task TestGenerateInAsyncVoidSimpleLambda()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        Action<string> f = async x => [|Goo|](x);
+    }
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        Action<string> f = async x => Goo(x);
+    }
+
+    private static void Goo(string x)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
+        public async Task TestGenerateInAsyncVoidParenthesizedLambda()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        Action f = async () => [|Goo|]();
+    }
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        Action f = async () => Goo();
+    }
+
+    private static void Goo()
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
         public async Task TestGenerateInAssignmentInAnonymousMethod()
         {
@@ -6458,7 +6584,7 @@ private static C x()
 
         [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
-        public async Task TestGenerateMethodInExpressionBodiedAsyncMethod()
+        public async Task TestGenerateMethodInExpressionBodiedAsyncTaskOfTMethod()
         {
             await TestInRegularAndScriptAsync(
 @"class C
@@ -6478,6 +6604,49 @@ private static C x()
 }");
         }
 
+        [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
+        public async Task TestGenerateMethodInExpressionBodiedAsyncTaskMethod()
+        {
+            await TestInRegularAndScriptAsync(
+@"class C
+{
+    public static async System.Threading.Tasks.Task GetValue(C p) => [|x|]();
+}",
+@"using System;
+
+class C
+{
+    public static async System.Threading.Tasks.Task GetValue(C p) => x();
+
+    private static void x()
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
+        public async Task TestGenerateMethodInExpressionBodiedAsyncVoidMethod()
+        {
+            await TestInRegularAndScriptAsync(
+@"class C
+{
+    public static async void GetValue(C p) => [|x|]();
+}",
+@"using System;
+
+class C
+{
+    public static async void GetValue(C p) => x();
+
+    private static void x()
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
         public async Task TestGenerateMethodInExpressionBodiedOperator()
         {
@@ -7971,7 +8140,7 @@ private int GenerateMethod()
 
         [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
-        public async Task TestGenerateMethodInExpressionBodiedAsyncLocalFunction()
+        public async Task TestGenerateMethodInExpressionBodiedAsyncTaskOfTLocalFunction()
         {
             await TestInRegularAndScriptAsync(
 @"class Class
@@ -7997,6 +8166,61 @@ private int GenerateMethod()
 }");
         }
 
+        [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
+        public async Task TestGenerateMethodInExpressionBodiedAsyncTaskLocalFunction()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Class
+{
+    void Method()
+    {
+        async System.Threading.Tasks.Task Local() => [|GenerateMethod()|];
+    }
+}",
+@"using System;
+
+class Class
+{
+    void Method()
+    {
+        async System.Threading.Tasks.Task Local() => GenerateMethod();
+    }
+
+    private void GenerateMethod()
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
+        public async Task TestGenerateMethodInExpressionBodiedAsyncVoidLocalFunction()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Class
+{
+    void Method()
+    {
+        async void Local() => [|GenerateMethod()|];
+    }
+}",
+@"using System;
+
+class Class
+{
+    void Method()
+    {
+        async void Local() => GenerateMethod();
+    }
+
+    private void GenerateMethod()
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
         [WorkItem(26993, "https://github.com/dotnet/roslyn/issues/26993")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
         public async Task TestGenerateMethodInBlockBodiedLocalFunction()
@@ -8032,7 +8256,7 @@ private int GenerateMethod()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
-        public async Task TestGenerateMethodInBlockBodiedAsyncLocalFunction()
+        public async Task TestGenerateMethodInBlockBodiedAsyncTaskOfTLocalFunction()
         {
             await TestInRegularAndScriptAsync(
 @"class Class

src/EditorFeatures/CSharpTest/GenerateVariable/GenerateVariableTests.cs

@@ -1475,7 +1475,7 @@ static void Main(string[] args)
 
         [WorkItem(30232, "https://github.com/dotnet/roslyn/issues/30232")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
-        public async Task TestGenerateFieldInAsyncSimpleLambda()
+        public async Task TestGenerateFieldInAsyncTaskOfTSimpleLambda()
         {
             await TestInRegularAndScriptAsync(
 @"using System;
@@ -1504,7 +1504,7 @@ static void Main(string[] args)
 
         [WorkItem(30232, "https://github.com/dotnet/roslyn/issues/30232")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
-        public async Task TestGenerateFieldInAsyncParenthesizedLambda()
+        public async Task TestGenerateFieldInAsyncTaskOfTParenthesizedLambda()
         {
             await TestInRegularAndScriptAsync(
 @"using System;
@@ -6543,7 +6543,7 @@ public async Task TestGeneratePropertyInExpressionBodiedMethod()
 
         [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
-        public async Task TestGeneratePropertyInExpressionBodiedAsyncMethod()
+        public async Task TestGeneratePropertyInExpressionBodiedAsyncTaskOfTMethod()
         {
             await TestInRegularAndScriptAsync(
 @"class C
@@ -7969,7 +7969,7 @@ public void Method()
 
         [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
-        public async Task TestGeneratePropertyInExpressionBodiedAsyncLocalFunction()
+        public async Task TestGeneratePropertyInExpressionBodiedAsyncTaskOfTLocalFunction()
         {
             await TestInRegularAndScriptAsync(
 @"class Program
@@ -8104,7 +8104,7 @@ int Local()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
-        public async Task TestGeneratePropertyInBlockBodiedAsyncLocalFunction()
+        public async Task TestGeneratePropertyInBlockBodiedAsyncTaskOfTLocalFunction()
         {
             await TestInRegularAndScriptAsync(
 @"class Program

src/EditorFeatures/CSharpTest/TypeInferrer/TypeInferrerTests.cs

@@ -705,7 +705,17 @@ public async Task TestReturnInMethod()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
-        public async Task TestReturnInAsyncMethod()
+        public async Task TestReturnInVoidMethod()
+        {
+            await TestInClassAsync(
+@"void M()
+{
+    return [|Goo()|];
+}", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestReturnInAsyncTaskOfTMethod()
         {
             await TestInClassAsync(
 @"async System.Threading.Tasks.Task<int> M()
@@ -715,10 +725,23 @@ public async Task TestReturnInAsyncMethod()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
-        public async Task TestReturnInVoidMethod()
+        public async Task TestReturnInAsyncTaskMethod()
         {
-            await TestInMethodAsync(
-@"return [|Goo()|];", "void");
+            await TestInClassAsync(
+@"async System.Threading.Tasks.Task M()
+{
+    return [|Goo()|];
+}", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestReturnInAsyncVoidMethod()
+        {
+            await TestInClassAsync(
+@"async void M()
+{
+    return [|Goo()|];
+}", "void");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
@@ -835,7 +858,7 @@ int F()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
-        public async Task TestReturnInAsyncLocalFunction()
+        public async Task TestReturnInAsyncTaskOfTLocalFunction()
         {
             await TestInClassAsync(
 @"void M()
@@ -847,6 +870,32 @@ async System.Threading.Tasks.Task<int> F()
 }", "global::System.Int32");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestReturnInAsyncTaskLocalFunction()
+        {
+            await TestInClassAsync(
+@"void M()
+{
+    async System.Threading.Tasks.Task F()
+    {
+        return [|Goo()|];
+    }
+}", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestReturnInAsyncVoidLocalFunction()
+        {
+            await TestInClassAsync(
+@"void M()
+{
+    async void F()
+    {
+        return [|Goo()|];
+    }
+}", "void");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
         public async Task TestExpressionBodiedConstructor()
         {
@@ -868,19 +917,34 @@ public async Task TestExpressionBodiedMethod()
 @"int M() => [|Goo()|];", "global::System.Int32");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedVoidMethod()
+        {
+            await TestInClassAsync(
+@"void M() => [|Goo()|];", "void");
+        }
+
         [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
-        public async Task TestExpressionBodiedAsyncMethod()
+        public async Task TestExpressionBodiedAsyncTaskOfTMethod()
         {
             await TestInClassAsync(
 @"async System.Threading.Tasks.Task<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 TestExpressionBodiedVoidMethod()
+        public async Task TestExpressionBodiedAsyncTaskMethod()
         {
             await TestInClassAsync(
-@"void M() => [|Goo()|];", "void");
+@"async System.Threading.Tasks.Task M() => [|Goo()|];", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedAsyncVoidMethod()
+        {
+            await TestInClassAsync(
+@"async void M() => [|Goo()|];", "void");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
@@ -965,7 +1029,7 @@ public async Task TestExpressionBodiedLocalFunction()
 
         [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
-        public async Task TestExpressionBodiedAsyncLocalFunction()
+        public async Task TestExpressionBodiedAsyncTaskOfTLocalFunction()
         {
             await TestInClassAsync(
 @"void M()
@@ -974,6 +1038,27 @@ public async Task TestExpressionBodiedAsyncLocalFunction()
 }", "global::System.Int32");
         }
 
+        [WorkItem(27647, "https://github.com/dotnet/roslyn/issues/27647")]
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedAsyncTaskLocalFunction()
+        {
+            await TestInClassAsync(
+@"void M()
+{
+    async System.Threading.Tasks.Task F() => [|Goo()|];
+}", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestExpressionBodiedAsyncVoidLocalFunction()
+        {
+            await TestInClassAsync(
+@"void M()
+{
+    async void F() => [|Goo()|];
+}", "void");
+        }
+
         [WorkItem(827897, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/827897")]
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
         public async Task TestYieldReturnInMethod()
@@ -1043,7 +1128,7 @@ public async Task TestReturnInAnonymousMethod()
 
         [WorkItem(4486, "https://github.com/dotnet/roslyn/issues/4486")]
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
-        public async Task TestReturnInAsyncSimpleLambda()
+        public async Task TestReturnInAsyncTaskOfTSimpleLambda()
         {
             await TestInMethodAsync(
 @"System.Func<string, System.Threading.Tasks.Task<int>> f = async s =>
@@ -1054,7 +1139,7 @@ public async Task TestReturnInAsyncSimpleLambda()
 
         [WorkItem(4486, "https://github.com/dotnet/roslyn/issues/4486")]
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
-        public async Task TestReturnInAsyncParenthesizedLambda()
+        public async Task TestReturnInAsyncTaskOfTParenthesizedLambda()
         {
             await TestInMethodAsync(
 @"System.Func<System.Threading.Tasks.Task<int>> f = async () =>
@@ -1065,7 +1150,7 @@ public async Task TestReturnInAsyncParenthesizedLambda()
 
         [WorkItem(4486, "https://github.com/dotnet/roslyn/issues/4486")]
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
-        public async Task TestReturnInAsyncAnonymousMethod()
+        public async Task TestReturnInAsyncTaskOfTAnonymousMethod()
         {
             await TestInMethodAsync(
 @"System.Func<System.Threading.Tasks.Task<int>> f = async delegate ()
@@ -1074,6 +1159,66 @@ public async Task TestReturnInAsyncAnonymousMethod()
 };", "global::System.Int32");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestReturnInAsyncTaskSimpleLambda()
+        {
+            await TestInMethodAsync(
+@"System.Func<string, System.Threading.Tasks.Task> f = async s =>
+{
+    return [|Goo()|];
+};", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestReturnInAsyncTaskParenthesizedLambda()
+        {
+            await TestInMethodAsync(
+@"System.Func<System.Threading.Tasks.Task> f = async () =>
+{
+    return [|Goo()|];
+};", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestReturnInAsyncTaskAnonymousMethod()
+        {
+            await TestInMethodAsync(
+@"System.Func<System.Threading.Tasks.Task> f = async delegate ()
+{
+    return [|Goo()|];
+};", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestReturnInAsyncVoidSimpleLambda()
+        {
+            await TestInMethodAsync(
+@"System.Action<string> f = async s =>
+{
+    return [|Goo()|];
+};", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestReturnInAsyncVoidParenthesizedLambda()
+        {
+            await TestInMethodAsync(
+@"System.Action f = async () =>
+{
+    return [|Goo()|];
+};", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestReturnInAsyncVoidAnonymousMethod()
+        {
+            await TestInMethodAsync(
+@"System.Action f = async delegate ()
+{
+    return [|Goo()|];
+};", "void");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
         public async Task TestSimpleLambda()
         {
@@ -1090,7 +1235,7 @@ public async Task TestParenthesizedLambda()
 
         [WorkItem(30232, "https://github.com/dotnet/roslyn/issues/30232")]
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
-        public async Task TestAsyncSimpleLambda()
+        public async Task TestAsyncTaskOfTSimpleLambda()
         {
             await TestInMethodAsync(
 @"System.Func<string, System.Threading.Tasks.Task<int>> f = async s => [|Goo()|];", "global::System.Int32");
@@ -1098,12 +1243,42 @@ public async Task TestAsyncSimpleLambda()
 
         [WorkItem(30232, "https://github.com/dotnet/roslyn/issues/30232")]
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
-        public async Task TestAsyncParenthesizedLambda()
+        public async Task TestAsyncTaskOfTParenthesizedLambda()
         {
             await TestInMethodAsync(
 @"System.Func<System.Threading.Tasks.Task<int>> f = async () => [|Goo()|];", "global::System.Int32");
         }
 
+        [WorkItem(30232, "https://github.com/dotnet/roslyn/issues/30232")]
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestAsyncTaskSimpleLambda()
+        {
+            await TestInMethodAsync(
+@"System.Func<string, System.Threading.Tasks.Task> f = async s => [|Goo()|];", "void");
+        }
+
+        [WorkItem(30232, "https://github.com/dotnet/roslyn/issues/30232")]
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestAsyncTaskParenthesizedLambda()
+        {
+            await TestInMethodAsync(
+@"System.Func<System.Threading.Tasks.Task> f = async () => [|Goo()|];", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestAsyncVoidSimpleLambda()
+        {
+            await TestInMethodAsync(
+@"System.Action<string> f = async s => [|Goo()|];", "void");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
+        public async Task TestAsyncVoidParenthesizedLambda()
+        {
+            await TestInMethodAsync(
+@"System.Action f = async () => [|Goo()|];", "void");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.TypeInferenceService)]
         public async Task TestExpressionTreeSimpleLambda()
         {

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

@@ -1811,9 +1811,17 @@ private IEnumerable<TypeInferenceInfo> InferTypeInRefExpression(RefExpressionSyn
 
             private ITypeSymbol UnwrapTaskLike(ITypeSymbol type, bool isAsync)
             {
-                return isAsync && type.OriginalDefinition.Equals(this.Compilation.TaskOfTType())
-                    ? ((INamedTypeSymbol)type).TypeArguments[0]
-                    : type;
+                if (!isAsync)
+                {
+                    return type;
+                }
+
+                return
+                    type.OriginalDefinition.Equals(this.Compilation.TaskOfTType())
+                        ? ((INamedTypeSymbol)type).TypeArguments[0] :
+                    type.OriginalDefinition.Equals(this.Compilation.TaskType())
+                        ? this.Compilation.GetSpecialType(SpecialType.System_Void) :
+                    type;
             }
 
             private IEnumerable<TypeInferenceInfo> InferTypeForReturnStatement(