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);
}
}
public static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
{
var methodDeclaration = (MethodDeclarationSyntax)context.Node;
if (!methodDeclaration.Modifiers.Contains(SyntaxKind.AsyncKeyword))
{
return;
}
if (methodDeclaration.Identifier.ValueText.EndsWith("Async", StringComparison.Ordinal))
{
return;
}
if (methodDeclaration.Body?.Statements.Any() == false)
{
return;
}
IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
if (methodSymbol?.IsAsync != true)
{
return;
}
if (methodSymbol.Name.EndsWith("Async", StringComparison.Ordinal))
{
return;
}
if (SymbolUtility.CanBeEntryPoint(methodSymbol))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.AsynchronousMethodNameShouldEndWithAsync, methodDeclaration.Identifier);
}
private static bool IsAnalyzable(ISymbol symbol)
{
switch (symbol.Kind)
{
case SymbolKind.Namespace:
{
return(false);
}
case SymbolKind.NamedType:
{
var namedType = (INamedTypeSymbol)symbol;
return(namedType.TypeKind != TypeKind.Class ||
!namedType.IsStatic);
}
case SymbolKind.Event:
{
var eventSymbol = (IEventSymbol)symbol;
return(eventSymbol.ExplicitInterfaceImplementations.IsDefaultOrEmpty &&
!eventSymbol.ImplementsInterfaceMember(allInterfaces: true));
}
case SymbolKind.Field:
{
var fieldSymbol = (IFieldSymbol)symbol;
return(!fieldSymbol.ImplementsInterfaceMember(allInterfaces: true));
}
case SymbolKind.Property:
{
var propertySymbol = (IPropertySymbol)symbol;
return(propertySymbol.ExplicitInterfaceImplementations.IsDefaultOrEmpty &&
!propertySymbol.ImplementsInterfaceMember(allInterfaces: true));
}
case SymbolKind.Method:
{
var methodSymbol = (IMethodSymbol)symbol;
switch (methodSymbol.MethodKind)
{
case MethodKind.Ordinary:
{
return(methodSymbol.ExplicitInterfaceImplementations.IsDefaultOrEmpty &&
!SymbolUtility.CanBeEntryPoint(methodSymbol) &&
!methodSymbol.ImplementsInterfaceMember(allInterfaces: true));
}
case MethodKind.Constructor:
{
return(true);
}
}
return(false);
}
default:
{
Debug.Fail(symbol.Kind.ToString());
return(false);
}
}
}