Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -0,0 +1,170 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Operations;

namespace Microsoft.VisualStudio.Threading.Analyzers;

/// <summary>
/// Recognizes cases where accessing <see cref="System.Threading.Tasks.Task{TResult}.Result"/> cannot block.
/// </summary>
internal static class TaskCompletionAnalysis
{
/// <summary>
/// Determines whether a task is known to be complete at a particular <c>Result</c> access.
/// </summary>
/// <param name="context">The analyzer context.</param>
/// <param name="resultAccess">The <c>Result</c> access.</param>
/// <returns><see langword="true"/> if the task is known to be complete; otherwise, <see langword="false"/>.</returns>
internal static bool IsTaskKnownToBeCompleted(SyntaxNodeAnalysisContext context, MemberAccessExpressionSyntax resultAccess)
{
ISymbol? taskSymbol = context.SemanticModel.GetSymbolInfo(resultAccess.Expression, context.CancellationToken).Symbol;
if (taskSymbol is ILocalSymbol { RefKind: not RefKind.None }
|| taskSymbol is IParameterSymbol { RefKind: not RefKind.None }
|| taskSymbol is not ILocalSymbol and not IParameterSymbol)
{
return false;
}

SyntaxNode executableScope = GetExecutableScope(resultAccess);
ISymbol? executableSymbol = executableScope switch
{
AnonymousFunctionExpressionSyntax anonymousFunction => context.SemanticModel.GetSymbolInfo(anonymousFunction, context.CancellationToken).Symbol,
LocalFunctionStatementSyntax localFunction => context.SemanticModel.GetDeclaredSymbol(localFunction, context.CancellationToken),
BaseMethodDeclarationSyntax method => context.SemanticModel.GetDeclaredSymbol(method, context.CancellationToken),
AccessorDeclarationSyntax accessor => context.SemanticModel.GetDeclaredSymbol(accessor, context.CancellationToken),
_ => null,
};
if (!SymbolEqualityComparer.Default.Equals(taskSymbol.ContainingSymbol, executableSymbol))
{
return false;
}

return IsGuardedBySuccessfulCompletion(context, resultAccess, taskSymbol, executableScope)
|| IsContinueWithAntecedent(context, resultAccess, taskSymbol, executableScope);
}

private static bool IsGuardedBySuccessfulCompletion(
SyntaxNodeAnalysisContext context,
MemberAccessExpressionSyntax resultAccess,
ISymbol taskSymbol,
SyntaxNode executableScope)
{
foreach (IfStatementSyntax ifStatement in resultAccess.Ancestors()
.TakeWhile(ancestor => ancestor != executableScope)
.OfType<IfStatementSyntax>())
{
if (ifStatement.Statement.Span.Contains(resultAccess.Span)
&& ConditionProvesSuccessfulCompletion(context, ifStatement.Condition, taskSymbol)
&& !MayWriteSymbol(context, executableScope, taskSymbol))
{
return true;
}
}

return false;
}

private static bool IsContinueWithAntecedent(
SyntaxNodeAnalysisContext context,
MemberAccessExpressionSyntax resultAccess,
ISymbol taskSymbol,
SyntaxNode executableScope)
{
if (executableScope is not AnonymousFunctionExpressionSyntax anonymousFunction
|| taskSymbol is not IParameterSymbol { ContainingSymbol: IMethodSymbol containingMethod, Ordinal: 0 } antecedentParameter
|| !SymbolEqualityComparer.Default.Equals(
containingMethod,
context.SemanticModel.GetSymbolInfo(anonymousFunction, context.CancellationToken).Symbol)
|| anonymousFunction.Parent is not ArgumentSyntax argument
|| argument.Parent is not ArgumentListSyntax argumentList
|| argumentList.Parent is not InvocationExpressionSyntax continueWithInvocation
|| context.SemanticModel.GetSymbolInfo(continueWithInvocation, context.CancellationToken).Symbol is not IMethodSymbol continueWithMethod
|| continueWithMethod.Name != nameof(System.Threading.Tasks.Task.ContinueWith)
|| !Utils.IsTask(continueWithMethod.ContainingType))
{
return false;
}

if (context.SemanticModel.GetOperation(argument, context.CancellationToken) is not IArgumentOperation argumentOperation
|| argumentOperation.Parameter?.Type is not INamedTypeSymbol { TypeKind: TypeKind.Delegate } continuationDelegate
|| continuationDelegate.DelegateInvokeMethod is not { Parameters.Length: > 0 } delegateInvokeMethod
|| !SymbolEqualityComparer.Default.Equals(delegateInvokeMethod.Parameters[0].Type, antecedentParameter.Type))
{
return false;
}

return !MayWriteSymbol(context, executableScope, taskSymbol);
}

private static bool ConditionProvesSuccessfulCompletion(SyntaxNodeAnalysisContext context, ExpressionSyntax condition, ISymbol expectedTaskSymbol)
{
while (condition is ParenthesizedExpressionSyntax parenthesized)
{
condition = parenthesized.Expression;
}

if (condition is BinaryExpressionSyntax { RawKind: (int)SyntaxKind.LogicalAndExpression } logicalAnd)
{
return ConditionProvesSuccessfulCompletion(context, logicalAnd.Left, expectedTaskSymbol)
|| ConditionProvesSuccessfulCompletion(context, logicalAnd.Right, expectedTaskSymbol);
}

if (condition is not MemberAccessExpressionSyntax { Name.Identifier.ValueText: "IsCompletedSuccessfully" } completionAccess)
{
return false;
}

ISymbol? completionProperty = context.SemanticModel.GetSymbolInfo(completionAccess, context.CancellationToken).Symbol;
ISymbol? completedTaskSymbol = context.SemanticModel.GetSymbolInfo(completionAccess.Expression, context.CancellationToken).Symbol;
return completionProperty is IPropertySymbol { ContainingType: { } containingType }
&& Utils.IsTask(containingType)
&& SymbolEqualityComparer.Default.Equals(expectedTaskSymbol, completedTaskSymbol);
}

private static bool MayWriteSymbol(SyntaxNodeAnalysisContext context, SyntaxNode executableScope, ISymbol expectedTaskSymbol)
{
if (executableScope.DescendantNodes()
.OfType<RefExpressionSyntax>()
.Any())
{
return true;
}
Comment thread
AArnott marked this conversation as resolved.
Resolved

foreach (SyntaxNode node in executableScope.DescendantNodes())
{
ExpressionSyntax? writtenExpression = node switch
{
AssignmentExpressionSyntax assignment => assignment.Left,
PrefixUnaryExpressionSyntax prefix when prefix.IsKind(SyntaxKind.PreIncrementExpression) || prefix.IsKind(SyntaxKind.PreDecrementExpression) => prefix.Operand,
PostfixUnaryExpressionSyntax postfix when postfix.IsKind(SyntaxKind.PostIncrementExpression) || postfix.IsKind(SyntaxKind.PostDecrementExpression) => postfix.Operand,
ArgumentSyntax argument when argument.RefOrOutKeyword.IsKind(SyntaxKind.RefKeyword) || argument.RefOrOutKeyword.IsKind(SyntaxKind.OutKeyword) => argument.Expression,
_ => null,
};

if (writtenExpression is not null && writtenExpression.DescendantNodesAndSelf()
.OfType<ExpressionSyntax>()
.Any(candidate => SymbolEqualityComparer.Default.Equals(
context.SemanticModel.GetSymbolInfo(candidate, context.CancellationToken).Symbol,
expectedTaskSymbol)))
{
return true;
}
}

return false;
}

private static SyntaxNode GetExecutableScope(ExpressionSyntax expression)
=> expression.Ancestors().FirstOrDefault(ancestor =>
ancestor is AnonymousFunctionExpressionSyntax
or LocalFunctionStatementSyntax
or QueryExpressionSyntax
or BaseMethodDeclarationSyntax
or AccessorDeclarationSyntax) ?? expression;
}
Original file line number Diff line number Diff line change
Expand Up @@ -240,6 +240,14 @@ private bool InspectMemberAccess(SyntaxNodeAnalysisContext context, ExpressionSy
{
if (item.Method.IsMatch(memberSymbol))
{
if (memberSymbol is IPropertySymbol { Name: nameof(Task<int>.Result), ContainingType: { } containingType }
&& Utils.IsTask(containingType)
&& memberName.Parent is MemberAccessExpressionSyntax resultAccess
&& TaskCompletionAnalysis.IsTaskKnownToBeCompleted(context, resultAccess))
{
return false;
}

// Check if this method is excluded from VSTHRD103 diagnostics
if (this.excludedMethods.Contains(memberSymbol))
{
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -4,8 +4,6 @@
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
Expand Down Expand Up @@ -100,7 +98,7 @@ private void InspectMemberAccess(SyntaxNodeAnalysisContext context, MemberAccess
{
if (invokedMember is IPropertySymbol { Name: nameof(Task<int>.Result), ContainingType: { } containingType }
&& Utils.IsTask(containingType)
&& this.IsGuardedBySuccessfulCompletion(context, memberAccessSyntax))
&& TaskCompletionAnalysis.IsTaskKnownToBeCompleted(context, memberAccessSyntax))
{
return;
}
Expand All @@ -112,95 +110,5 @@ private void InspectMemberAccess(SyntaxNodeAnalysisContext context, MemberAccess
}
}
}

private bool IsGuardedBySuccessfulCompletion(SyntaxNodeAnalysisContext context, MemberAccessExpressionSyntax resultAccess)
{
ISymbol? taskSymbol = context.SemanticModel.GetSymbolInfo(resultAccess.Expression, context.CancellationToken).Symbol;
if (taskSymbol is not ILocalSymbol and not IParameterSymbol)
{
return false;
}

foreach (IfStatementSyntax ifStatement in resultAccess.Ancestors()
.TakeWhile(ancestor => ancestor is not LocalFunctionStatementSyntax)
.OfType<IfStatementSyntax>())
{
if (ifStatement.Statement.Span.Contains(resultAccess.Span)
&& ConditionProvesSuccessfulCompletion(ifStatement.Condition, taskSymbol)
&& !MayWriteSymbolBefore(ifStatement.Condition, resultAccess, taskSymbol)
&& !MayWriteSymbolBefore(ifStatement.Statement, resultAccess, taskSymbol))
{
return true;
}
}

return false;

bool ConditionProvesSuccessfulCompletion(ExpressionSyntax condition, ISymbol expectedTaskSymbol)
{
while (condition is ParenthesizedExpressionSyntax parenthesized)
{
condition = parenthesized.Expression;
}

if (condition is BinaryExpressionSyntax { RawKind: (int)SyntaxKind.LogicalAndExpression } logicalAnd)
{
return ConditionProvesSuccessfulCompletion(logicalAnd.Left, expectedTaskSymbol)
|| ConditionProvesSuccessfulCompletion(logicalAnd.Right, expectedTaskSymbol);
}

if (condition is not MemberAccessExpressionSyntax { Name.Identifier.ValueText: "IsCompletedSuccessfully" } completionAccess)
{
return false;
}

ISymbol? completionProperty = context.SemanticModel.GetSymbolInfo(completionAccess, context.CancellationToken).Symbol;
ISymbol? completedTaskSymbol = context.SemanticModel.GetSymbolInfo(completionAccess.Expression, context.CancellationToken).Symbol;
return completionProperty is IPropertySymbol { ContainingType: { } containingType }
&& Utils.IsTask(containingType)
&& SymbolEqualityComparer.Default.Equals(expectedTaskSymbol, completedTaskSymbol);
}

bool MayWriteSymbolBefore(SyntaxNode region, ExpressionSyntax expression, ISymbol expectedTaskSymbol)
{
SyntaxNode executableScope = expression.Ancestors().FirstOrDefault(ancestor =>
ancestor is AnonymousFunctionExpressionSyntax
or LocalFunctionStatementSyntax
or BaseMethodDeclarationSyntax
or AccessorDeclarationSyntax) ?? region;
if (executableScope.DescendantNodes()
.OfType<RefExpressionSyntax>()
.Where(refExpression => refExpression.SpanStart < expression.SpanStart)
.Any(refExpression => SymbolEqualityComparer.Default.Equals(
context.SemanticModel.GetSymbolInfo(refExpression.Expression, context.CancellationToken).Symbol,
expectedTaskSymbol)))
{
return true;
}

foreach (SyntaxNode node in region.DescendantNodes().Where(node => node.SpanStart < expression.SpanStart))
{
ExpressionSyntax? writtenExpression = node switch
{
AssignmentExpressionSyntax assignment => assignment.Left,
PrefixUnaryExpressionSyntax prefix when prefix.IsKind(SyntaxKind.PreIncrementExpression) || prefix.IsKind(SyntaxKind.PreDecrementExpression) => prefix.Operand,
PostfixUnaryExpressionSyntax postfix when postfix.IsKind(SyntaxKind.PostIncrementExpression) || postfix.IsKind(SyntaxKind.PostDecrementExpression) => postfix.Operand,
ArgumentSyntax argument when argument.RefOrOutKeyword.IsKind(SyntaxKind.RefKeyword) || argument.RefOrOutKeyword.IsKind(SyntaxKind.OutKeyword) => argument.Expression,
_ => null,
};

if (writtenExpression is not null && writtenExpression.DescendantNodesAndSelf()
.OfType<ExpressionSyntax>()
.Any(candidate => SymbolEqualityComparer.Default.Equals(
context.SemanticModel.GetSymbolInfo(candidate, context.CancellationToken).Symbol,
expectedTaskSymbol)))
{
return true;
}
}

return false;
}
}
}
}
Loading
Loading