private static void AddCallToConfigureAwait(SyntaxNodeAnalysisContext context)
{
var awaitExpression = (AwaitExpressionSyntax)context.Node;
ExpressionSyntax expression = awaitExpression.Expression;
if (IsConfigureAwait(expression))
{
return;
}
ITypeSymbol typeSymbol = context.SemanticModel.GetTypeSymbol(expression, context.CancellationToken);
if (typeSymbol == null)
{
return;
}
if (!SymbolUtility.IsAwaitable(typeSymbol))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.AddCallToConfigureAwaitOrViceVersa, awaitExpression.Expression, AnalyzerOptions.RemoveCallToConfigureAwait);
}
public static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context, bool shouldCheckWindowsRuntimeTypes)
{
var methodDeclaration = (MethodDeclarationSyntax)context.Node;
if (methodDeclaration.Modifiers.Contains(SyntaxKind.OverrideKeyword))
{
return;
}
if (methodDeclaration.Identifier.ValueText.EndsWith("Async", StringComparison.Ordinal))
{
IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
if (methodSymbol.IsAsync)
{
return;
}
if (!methodSymbol.Name.EndsWith("Async", StringComparison.Ordinal))
{
return;
}
if (SymbolUtility.IsAwaitable(methodSymbol.ReturnType, shouldCheckWindowsRuntimeTypes))
{
return;
}
SyntaxToken identifier = methodDeclaration.Identifier;
DiagnosticHelpers.ReportDiagnostic(context,
DiagnosticDescriptors.NonAsynchronousMethodNameShouldNotEndWithAsync,
identifier);
DiagnosticHelpers.ReportDiagnostic(context,
DiagnosticDescriptors.NonAsynchronousMethodNameShouldNotEndWithAsyncFadeOut,
Location.Create(identifier.SyntaxTree, TextSpan.FromBounds(identifier.Span.End - 5, identifier.Span.End)));
}
else
{
IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
if (methodSymbol.Name.EndsWith("Async", StringComparison.Ordinal))
{
return;
}
if (SymbolUtility.CanBeEntryPoint(methodSymbol))
{
return;
}
if (!SymbolUtility.IsAwaitable(methodSymbol.ReturnType, shouldCheckWindowsRuntimeTypes))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.AsynchronousMethodNameShouldEndWithAsync, methodDeclaration.Identifier);
}
}
private static void AnalyzeAnonymousMethodExpression(SyntaxNodeAnalysisContext context)
{
var anonymousMethod = (AnonymousMethodExpressionSyntax)context.Node;
if (anonymousMethod.AsyncKeyword.IsKind(SyntaxKind.AsyncKeyword))
{
return;
}
BlockSyntax body = anonymousMethod.Block;
if (body == null)
{
return;
}
if (context.SemanticModel.GetSymbol(anonymousMethod, context.CancellationToken) is not IMethodSymbol methodSymbol)
{
return;
}
if (!SymbolUtility.IsAwaitable(methodSymbol.ReturnType))
{
return;
}
if (IsFixable(body, context))
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.UseAsyncAwait, anonymousMethod);
}
}
private static void AnalyzeLocalFunctionStatement(SyntaxNodeAnalysisContext context)
{
var localFunction = (LocalFunctionStatementSyntax)context.Node;
if (localFunction.Modifiers.Contains(SyntaxKind.AsyncKeyword))
{
return;
}
BlockSyntax body = localFunction.Body;
if (body == null)
{
return;
}
if (!body.Statements.Any())
{
return;
}
IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(localFunction, context.CancellationToken);
if (!SymbolUtility.IsAwaitable(methodSymbol.ReturnType))
{
return;
}
if (IsFixable(body, context))
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.UseAsyncAwait, localFunction.Identifier);
}
}
private static void AnalyzeParenthesizedLambdaExpression(SyntaxNodeAnalysisContext context)
{
var parenthesizedLambda = (ParenthesizedLambdaExpressionSyntax)context.Node;
if (parenthesizedLambda.AsyncKeyword.IsKind(SyntaxKind.AsyncKeyword))
{
return;
}
if (parenthesizedLambda.Body is not BlockSyntax body)
{
return;
}
if (context.SemanticModel.GetSymbol(parenthesizedLambda, context.CancellationToken) is not IMethodSymbol methodSymbol)
{
return;
}
if (!SymbolUtility.IsAwaitable(methodSymbol.ReturnType))
{
return;
}
if (IsFixable(body, context))
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.UseAsyncAwait, parenthesizedLambda);
}
}