Support duck-typed awaitables and task-like types for Task/Async-related analyzers

ChangeLog.md

@@ -14,6 +14,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fix analyzer [RCS1140](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1140) ([PR](https://github.com/dotnet/roslynator/pull/1524))
 - Fix analyzer [RCS1077](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1077) ([PR](https://github.com/dotnet/roslynator/pull/1544))
 
+### Changed
+- Add support for duck-typed awaitables and task-like types for Task/Async-related analyzers ([PR](https://github.com/dotnet/roslynator/pull/1535))
+  - Affects the following analyzers:
+    - [RCS1046](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1046)
+    - [RCS1047](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1047)
+    - [RCS1090](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1090)
+    - [RCS1174](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1174)
+    - [RCS1229](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1229)
+    - [RCS1261](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1261)
+  - Affects refactoring [RR0209](https://josefpihrt.github.io/docs/roslynator/refactorings/RR0209)
+
 ## [4.12.6] - 2024-09-23
 
 ### Added

src/Analyzers.CodeFixes/CSharp/CodeFixes/DisposeResourceAsynchronouslyCodeFixProvider.cs

@@ -120,7 +120,7 @@ private static async Task<Document> RefactorAsync(
 
                 IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, cancellationToken);
 
-                UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol);
+                UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol, semanticModel, node.SpanStart);
                 var newBody = (BlockSyntax)rewriter.VisitBlock(newNode.Body);
 
                 newNode = newNode
@@ -138,7 +138,7 @@ private static async Task<Document> RefactorAsync(
 
                 IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(localFunction, cancellationToken);
 
-                UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol);
+                UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol, semanticModel, node.SpanStart);
                 var newBody = (BlockSyntax)rewriter.VisitBlock(newNode.Body);
 
                 newNode = newNode
@@ -156,7 +156,7 @@ private static async Task<Document> RefactorAsync(
 
                 var methodSymbol = (IMethodSymbol)semanticModel.GetSymbol(lambdaExpression, cancellationToken);
 
-                UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol);
+                UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol, semanticModel, node.SpanStart);
                 var newBody = (BlockSyntax)rewriter.VisitBlock((BlockSyntax)newNode.Body);
 
                 newNode = newNode
@@ -174,7 +174,7 @@ private static async Task<Document> RefactorAsync(
 
                 var methodSymbol = (IMethodSymbol)semanticModel.GetSymbol(anonymousMethod, cancellationToken);
 
-                UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol);
+                UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol, semanticModel, node.SpanStart);
                 var newBody = (BlockSyntax)rewriter.VisitBlock((BlockSyntax)newNode.Body);
 
                 newNode = newNode

src/Analyzers.CodeFixes/CSharp/CodeFixes/UseAsyncAwaitCodeFixProvider.cs

@@ -66,7 +66,7 @@ private static async Task<Document> RefactorAsync(
                 {
                     IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, cancellationToken);
 
-                    UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol);
+                    UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol, semanticModel, node.SpanStart);
 
                     var newNode = (MethodDeclarationSyntax)rewriter.VisitMethodDeclaration(methodDeclaration);
 
@@ -78,7 +78,7 @@ private static async Task<Document> RefactorAsync(
                 {
                     IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(localFunction, cancellationToken);
 
-                    UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol);
+                    UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol, semanticModel, node.SpanStart);
 
                     var newBody = (BlockSyntax)rewriter.VisitBlock(localFunction.Body);
 
@@ -92,7 +92,7 @@ private static async Task<Document> RefactorAsync(
                 {
                     var methodSymbol = (IMethodSymbol)semanticModel.GetSymbol(lambda, cancellationToken);
 
-                    UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol);
+                    UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol, semanticModel, node.SpanStart);
 
                     var newBody = (BlockSyntax)rewriter.VisitBlock((BlockSyntax)lambda.Body);
 
@@ -106,7 +106,7 @@ private static async Task<Document> RefactorAsync(
                 {
                     var methodSymbol = (IMethodSymbol)semanticModel.GetSymbol(lambda, cancellationToken);
 
-                    UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol);
+                    UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol, semanticModel, node.SpanStart);
 
                     var newBody = (BlockSyntax)rewriter.VisitBlock((BlockSyntax)lambda.Body);
 
@@ -120,7 +120,7 @@ private static async Task<Document> RefactorAsync(
                 {
                     var methodSymbol = (IMethodSymbol)semanticModel.GetSymbol(anonymousMethod, cancellationToken);
 
-                    UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol);
+                    UseAsyncAwaitRewriter rewriter = UseAsyncAwaitRewriter.Create(methodSymbol, semanticModel, node.SpanStart);
 
                     var newBody = (BlockSyntax)rewriter.VisitBlock((BlockSyntax)anonymousMethod.Body);
 

src/Analyzers.CodeFixes/CSharp/SyntaxRewriters/UseAsyncAwaitRewriter.cs

@@ -24,19 +24,14 @@ private UseAsyncAwaitRewriter(bool keepReturnStatement)
 
     public bool KeepReturnStatement { get; }
 
-    public static UseAsyncAwaitRewriter Create(IMethodSymbol methodSymbol)
+    public static UseAsyncAwaitRewriter Create(IMethodSymbol methodSymbol, SemanticModel semanticModel, int position)
     {
         ITypeSymbol returnType = methodSymbol.ReturnType.OriginalDefinition;
 
-        var keepReturnStatement = false;
+        bool keepReturnStatement = returnType is INamedTypeSymbol { Arity: 1 }
+            && returnType.IsAwaitable(semanticModel, position);
 
-        if (returnType.EqualsOrInheritsFrom(MetadataNames.System_Threading_Tasks_ValueTask_T)
-            || returnType.EqualsOrInheritsFrom(MetadataNames.System_Threading_Tasks_Task_T))
-        {
-            keepReturnStatement = true;
-        }
-
-        return new UseAsyncAwaitRewriter(keepReturnStatement: keepReturnStatement);
+        return new UseAsyncAwaitRewriter(keepReturnStatement);
     }
 
     public override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node)

src/Analyzers/CSharp/Analysis/ConfigureAwaitAnalyzer.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System.Collections.Immutable;
+using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -65,7 +66,10 @@ private static void AddCallToConfigureAwait(SyntaxNodeAnalysisContext context)
         if (typeSymbol is null)
             return;
 
-        if (!SymbolUtility.IsAwaitable(typeSymbol))
+        if (!typeSymbol.IsAwaitable(context.SemanticModel, expression.SpanStart))
+            return;
+
+        if (!IsConfigureAwaitable(typeSymbol, context.SemanticModel, expression.SpanStart))
             return;
 
         DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.ConfigureAwait, awaitExpression.Expression, "Add");
@@ -75,39 +79,43 @@ private static void RemoveCallToConfigureAwait(SyntaxNodeAnalysisContext context
     {
         var awaitExpression = (AwaitExpressionSyntax)context.Node;
 
+        // await (expr).ConfigureAwait(false);
+        //       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         ExpressionSyntax expression = awaitExpression.Expression;
 
+        // await (expr).ConfigureAwait(false);
+        //             ^^^^^^^^^^^^^^^^^^^^^^
         SimpleMemberInvocationExpressionInfo invocationInfo = SyntaxInfo.SimpleMemberInvocationExpressionInfo(expression);
 
-        if (!IsConfigureAwait(expression))
+        if (!IsConfigureAwait(invocationInfo))
             return;
 
-        ITypeSymbol typeSymbol = context.SemanticModel.GetTypeSymbol(expression, context.CancellationToken);
+        ITypeSymbol awaitedType = context.SemanticModel.GetTypeSymbol(expression, context.CancellationToken);
 
-        if (typeSymbol is null)
+        if (awaitedType is null)
             return;
 
-        switch (typeSymbol.MetadataName)
-        {
-            case "ConfiguredTaskAwaitable":
-            case "ConfiguredTaskAwaitable`1":
-            case "ConfiguredValueTaskAwaitable":
-            case "ConfiguredValueTaskAwaitable`1":
-                {
-                    if (typeSymbol.ContainingNamespace.HasMetadataName(MetadataNames.System_Runtime_CompilerServices))
-                    {
-                        DiagnosticHelpers.ReportDiagnostic(
-                            context,
-                            DiagnosticRules.ConfigureAwait,
-                            Location.Create(
-                                awaitExpression.SyntaxTree,
-                                TextSpan.FromBounds(invocationInfo.OperatorToken.SpanStart, expression.Span.End)),
-                            "Remove");
-                    }
-
-                    break;
-                }
-        }
+        if (!awaitedType.IsAwaitable(context.SemanticModel, expression.SpanStart))
+            return;
+
+        // await (expr).ConfigureAwait(false);
+        //        ^^^^
+        // This expression may not be awaitable, in which case removing ConfigureAwait is not possible.
+        ITypeSymbol configuredType = context.SemanticModel.GetTypeSymbol(invocationInfo.Expression, context.CancellationToken);
+
+        if (configuredType is null)
+            return;
+
+        if (!configuredType.IsAwaitable(context.SemanticModel, invocationInfo.Expression.SpanStart))
+            return;
+
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.ConfigureAwait,
+            Location.Create(
+                awaitExpression.SyntaxTree,
+                TextSpan.FromBounds(invocationInfo.OperatorToken.SpanStart, expression.Span.End)),
+            "Remove");
     }
 
     public static bool IsConfigureAwait(ExpressionSyntax expression)
@@ -124,4 +132,12 @@ private static bool IsConfigureAwait(SimpleMemberInvocationExpressionInfo invoca
             && string.Equals(invocationInfo.NameText, "ConfigureAwait")
             && invocationInfo.Arguments.Count == 1;
     }
+
+    private static bool IsConfigureAwaitable(ITypeSymbol typeSymbol, SemanticModel semanticModel, int position)
+    {
+        return semanticModel.LookupSymbols(position, typeSymbol, "ConfigureAwait", includeReducedExtensionMethods: true)
+            .OfType<IMethodSymbol>()
+            .Any(method => method.ReturnType.IsAwaitable(semanticModel, position)
+                && method.HasSingleParameter(SpecialType.System_Boolean));
+    }
 }

src/Analyzers/CSharp/Analysis/DisposeResourceAsynchronouslyAnalyzer.cs

@@ -131,7 +131,7 @@ private static void Analyze(
                 : context.SemanticModel.GetSymbol(containingMethod, context.CancellationToken)) as IMethodSymbol;
 
             if (methodSymbol?.IsErrorType() == false
-                && SymbolUtility.IsAwaitable(methodSymbol.ReturnType))
+                && methodSymbol.ReturnType.IsAwaitableTaskType(context.SemanticModel, context.Node.SpanStart))
             {
                 ReportDiagnostic(context, usingKeyword);
             }

src/Analyzers/CSharp/Analysis/NonAsynchronousMethodNameShouldNotEndWithAsyncAnalyzer.cs

@@ -38,10 +38,6 @@ public override void Initialize(AnalysisContext context)
 
         context.RegisterCompilationStartAction(startContext =>
         {
-            INamedTypeSymbol asyncAction = startContext.Compilation.GetTypeByMetadataName("Windows.Foundation.IAsyncAction");
-
-            bool shouldCheckWindowsRuntimeTypes = asyncAction is not null;
-
             startContext.RegisterSyntaxNodeAction(
                 c =>
                 {
@@ -50,14 +46,14 @@ public override void Initialize(AnalysisContext context)
                         DiagnosticRules.AsynchronousMethodNameShouldEndWithAsync,
                         DiagnosticRules.NonAsynchronousMethodNameShouldNotEndWithAsync))
                     {
-                        AnalyzeMethodDeclaration(c, shouldCheckWindowsRuntimeTypes);
+                        AnalyzeMethodDeclaration(c);
                     }
                 },
                 SyntaxKind.MethodDeclaration);
         });
     }
 
-    private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context, bool shouldCheckWindowsRuntimeTypes)
+    private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
     {
         var methodDeclaration = (MethodDeclarationSyntax)context.Node;
 
@@ -74,7 +70,7 @@ private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context,
             if (!methodSymbol.Name.EndsWith("Async", StringComparison.Ordinal))
                 return;
 
-            if (SymbolUtility.IsAwaitable(methodSymbol.ReturnType, shouldCheckWindowsRuntimeTypes)
+            if (methodSymbol.ReturnType.IsAwaitable(context.SemanticModel, methodDeclaration.SpanStart)
                 || IsAsyncEnumerableLike(methodSymbol.ReturnType.OriginalDefinition))
             {
                 return;
@@ -105,7 +101,7 @@ private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context,
             if (methodSymbol.ImplementsInterfaceMember(allInterfaces: true))
                 return;
 
-            if (!SymbolUtility.IsAwaitable(methodSymbol.ReturnType, shouldCheckWindowsRuntimeTypes)
+            if (!methodSymbol.ReturnType.IsAwaitable(context.SemanticModel, methodDeclaration.SpanStart)
                 && !methodSymbol.ReturnType.OriginalDefinition.HasMetadataName(in MetadataNames.System_Collections_Generic_IAsyncEnumerable_T))
             {
                 return;

src/Analyzers/CSharp/Analysis/RemoveRedundantAsyncAwaitAnalyzer.cs

@@ -175,7 +175,7 @@ void ReportAwaitAndConfigureAwait(AwaitExpressionSyntax awaitExpression)
 
             ITypeSymbol typeSymbol = context.SemanticModel.GetTypeSymbol(expression, context.CancellationToken);
 
-            if (typeSymbol?.OriginalDefinition.HasMetadataName(MetadataNames.System_Runtime_CompilerServices_ConfiguredTaskAwaitable_T) == true
+            if (typeSymbol?.OriginalDefinition.IsAwaitable(context.SemanticModel, expression.SpanStart) == true
                 && (expression is InvocationExpressionSyntax invocation))
             {
                 var memberAccess = invocation.Expression as MemberAccessExpressionSyntax;

src/Analyzers/CSharp/Analysis/UseAsyncAwaitAnalyzer.cs

@@ -55,9 +55,10 @@ private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
         if (!body.Statements.Any())
             return;
 
-        IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
+        if (context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken) is not IMethodSymbol methodSymbol)
+            return;
 
-        if (!SymbolUtility.IsAwaitable(methodSymbol.ReturnType))
+        if (!methodSymbol.ReturnType.IsAwaitableTaskType(context.SemanticModel, body.SpanStart))
             return;
 
         if (IsFixable(body, context))
@@ -79,9 +80,10 @@ private static void AnalyzeLocalFunctionStatement(SyntaxNodeAnalysisContext cont
         if (!body.Statements.Any())
             return;
 
-        IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(localFunction, context.CancellationToken);
+        if (context.SemanticModel.GetDeclaredSymbol(localFunction, context.CancellationToken) is not IMethodSymbol methodSymbol)
+            return;
 
-        if (!SymbolUtility.IsAwaitable(methodSymbol.ReturnType))
+        if (!methodSymbol.ReturnType.IsAwaitableTaskType(context.SemanticModel, body.SpanStart))
             return;
 
         if (IsFixable(body, context))
@@ -101,7 +103,7 @@ private static void AnalyzeSimpleLambdaExpression(SyntaxNodeAnalysisContext cont
         if (context.SemanticModel.GetSymbol(simpleLambda, context.CancellationToken) is not IMethodSymbol methodSymbol)
             return;
 
-        if (!SymbolUtility.IsAwaitable(methodSymbol.ReturnType))
+        if (!methodSymbol.ReturnType.IsAwaitableTaskType(context.SemanticModel, body.SpanStart))
             return;
 
         if (IsFixable(body, context))
@@ -121,7 +123,7 @@ private static void AnalyzeParenthesizedLambdaExpression(SyntaxNodeAnalysisConte
         if (context.SemanticModel.GetSymbol(parenthesizedLambda, context.CancellationToken) is not IMethodSymbol methodSymbol)
             return;
 
-        if (!SymbolUtility.IsAwaitable(methodSymbol.ReturnType))
+        if (!methodSymbol.ReturnType.IsAwaitableTaskType(context.SemanticModel, body.SpanStart))
             return;
 
         if (IsFixable(body, context))
@@ -143,7 +145,7 @@ private static void AnalyzeAnonymousMethodExpression(SyntaxNodeAnalysisContext c
         if (context.SemanticModel.GetSymbol(anonymousMethod, context.CancellationToken) is not IMethodSymbol methodSymbol)
             return;
 
-        if (!SymbolUtility.IsAwaitable(methodSymbol.ReturnType))
+        if (!methodSymbol.ReturnType.IsAwaitableTaskType(context.SemanticModel, body.SpanStart))
             return;
 
         if (IsFixable(body, context))

src/Common/CSharp/Analysis/RemoveAsyncAwaitAnalysis.cs

@@ -364,7 +364,7 @@ private static bool VerifyTypes(
 
         ITypeSymbol returnType = methodSymbol.ReturnType;
 
-        if (returnType?.OriginalDefinition.EqualsOrInheritsFrom(MetadataNames.System_Threading_Tasks_Task_T) != true)
+        if (returnType?.OriginalDefinition.IsAwaitable(semanticModel, node.SpanStart) != true)
             return false;
 
         ITypeSymbol typeArgument = ((INamedTypeSymbol)returnType).TypeArguments.SingleOrDefault(shouldThrow: false);
@@ -394,7 +394,7 @@ private static bool VerifyTypes(
 
         ITypeSymbol returnType = methodSymbol.ReturnType;
 
-        if (returnType?.OriginalDefinition.EqualsOrInheritsFrom(MetadataNames.System_Threading_Tasks_Task_T) != true)
+        if (returnType?.OriginalDefinition.IsAwaitable(semanticModel, node.SpanStart) != true)
             return false;
 
         ITypeSymbol typeArgument = ((INamedTypeSymbol)returnType).TypeArguments.SingleOrDefault(shouldThrow: false);
@@ -417,15 +417,15 @@ private static bool VerifyAwaitType(AwaitExpressionSyntax awaitExpression, IType
         if (expressionTypeSymbol is null)
             return false;
 
-        if (expressionTypeSymbol.OriginalDefinition.EqualsOrInheritsFrom(MetadataNames.System_Threading_Tasks_Task_T))
+        if (expressionTypeSymbol.OriginalDefinition.IsAwaitable(semanticModel, expression.SpanStart))
             return true;
 
         SimpleMemberInvocationExpressionInfo invocationInfo = SyntaxInfo.SimpleMemberInvocationExpressionInfo(expression);
 
         return invocationInfo.Success
             && invocationInfo.Arguments.Count == 1
             && invocationInfo.NameText == "ConfigureAwait"
-            && expressionTypeSymbol.OriginalDefinition.HasMetadataName(MetadataNames.System_Runtime_CompilerServices_ConfiguredTaskAwaitable_T);
+            && expressionTypeSymbol.OriginalDefinition.IsAwaitable(semanticModel, expression.SpanStart);
     }
 
     private static IMethodSymbol GetMethodSymbol(