public static void AnalyzeIndexerDeclaration(SyntaxNodeAnalysisContext context)
{
var indexerDeclaration = (IndexerDeclarationSyntax)context.Node;
if (indexerDeclaration.ContainsDiagnostics)
return;
if (indexerDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration))
return;
if (indexerDeclaration.Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword))
return;
ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(indexerDeclaration);
if (!parametersInfo.Success)
return;
if (ContainsOnlyThrowNewExpression(parametersInfo.Body))
return;
IPropertySymbol propertySymbol = context.SemanticModel.GetDeclaredSymbol(indexerDeclaration, context.CancellationToken);
if (propertySymbol?.ExplicitInterfaceImplementations.IsDefaultOrEmpty != true)
return;
if (propertySymbol.ImplementsInterfaceMember())
return;
Analyze(context, parametersInfo, isIndexer: true);
}
public static void AnalyzeAnonymousMethodExpression(SyntaxNodeAnalysisContext context, INamedTypeSymbol eventArgsSymbol)
{
var anonymousMethod = (AnonymousMethodExpressionSyntax)context.Node;
if (anonymousMethod.ContainsDiagnostics)
{
return;
}
ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(anonymousMethod);
if (!parametersInfo.Success)
{
return;
}
var methodSymbol = (IMethodSymbol)context.SemanticModel.GetSymbol(anonymousMethod, context.CancellationToken);
if (methodSymbol == null)
{
return;
}
if (SymbolUtility.IsEventHandlerMethod(methodSymbol, eventArgsSymbol))
{
return;
}
Analyze(context, parametersInfo);
}
public static void AnalyzeLocalFunctionStatement(SyntaxNodeAnalysisContext context, INamedTypeSymbol eventArgsSymbol)
{
var localFunctionStatement = (LocalFunctionStatementSyntax)context.Node;
if (localFunctionStatement.ContainsDiagnostics)
{
return;
}
ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(localFunctionStatement);
if (!parametersInfo.Success)
{
return;
}
var methodSymbol = (IMethodSymbol)context.SemanticModel.GetDeclaredSymbol(localFunctionStatement, context.CancellationToken);
if (methodSymbol == null)
{
return;
}
if (SymbolUtility.IsEventHandlerMethod(methodSymbol, eventArgsSymbol))
{
return;
}
Analyze(context, parametersInfo);
}
public static void AnalyzeOperatorDeclaration(SyntaxNodeAnalysisContext context)
{
var operatorDeclaration = (OperatorDeclarationSyntax)context.Node;
if (operatorDeclaration.ContainsDiagnostics)
return;
ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(operatorDeclaration);
if (!parametersInfo.Success)
return;
if (ContainsOnlyThrowNewExpression(parametersInfo.Body))
return;
Analyze(context, parametersInfo);
}
public static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context, INamedTypeSymbol eventArgsSymbol)
{
var methodDeclaration = (MethodDeclarationSyntax)context.Node;
if (methodDeclaration.ContainsDiagnostics)
return;
if (methodDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration))
return;
if (methodDeclaration.Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword))
return;
ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(methodDeclaration);
if (!parametersInfo.Success)
return;
if (ContainsOnlyThrowNewExpression(parametersInfo.Body))
return;
IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
if (methodSymbol == null)
return;
if (SymbolUtility.IsEventHandlerMethod(methodSymbol, eventArgsSymbol))
return;
if (!methodSymbol.ExplicitInterfaceImplementations.IsDefaultOrEmpty)
return;
if (methodSymbol.ImplementsInterfaceMember())
return;
Dictionary<string, NodeSymbolInfo> unusedNodes = FindUnusedNodes(context, parametersInfo);
if (unusedNodes.Count == 0)
return;
if (IsReferencedAsMethodGroup(context, methodDeclaration))
return;
foreach (KeyValuePair<string, NodeSymbolInfo> kvp in unusedNodes)
ReportDiagnostic(context, kvp.Value.Node);
}
public static void AnalyzeConstructorDeclaration(
SyntaxNodeAnalysisContext context,
INamedTypeSymbol serializationInfoSymbol,
INamedTypeSymbol streamingContextSymbol)
{
var constructorDeclaration = (ConstructorDeclarationSyntax)context.Node;
if (constructorDeclaration.ContainsDiagnostics)
{
return;
}
ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(constructorDeclaration);
if (!parametersInfo.Success)
{
return;
}
if (ContainsOnlyThrowNewExpression(parametersInfo.Body))
{
return;
}
// Skip a constructor that is required by ISerializable interface
if (serializationInfoSymbol != null &&
parametersInfo.Parameters.Count == 2)
{
IMethodSymbol symbol = context.SemanticModel.GetDeclaredSymbol(constructorDeclaration, context.CancellationToken);
if (symbol != null)
{
ImmutableArray <IParameterSymbol> parameters = symbol.Parameters;
if (parameters.Length == 2 &&
parameters[0].Type.Equals(serializationInfoSymbol) &&
parameters[1].Type.Equals(streamingContextSymbol))
{
return;
}
}
}
Analyze(context, parametersInfo);
}
public static void AnalyzeParenthesizedLambdaExpression(SyntaxNodeAnalysisContext context, INamedTypeSymbol eventArgsSymbol)
{
var lambda = (ParenthesizedLambdaExpressionSyntax)context.Node;
if (lambda.ContainsDiagnostics)
return;
ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(lambda);
if (!parametersInfo.Success)
return;
var methodSymbol = (IMethodSymbol)context.SemanticModel.GetSymbol(lambda, context.CancellationToken);
if (methodSymbol == null)
return;
if (SymbolUtility.IsEventHandlerMethod(methodSymbol, eventArgsSymbol))
return;
Analyze(context, parametersInfo);
}
public static void AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context)
{
var constructorDeclaration = (ConstructorDeclarationSyntax)context.Node;
if (constructorDeclaration.ContainsDiagnostics)
{
return;
}
ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(constructorDeclaration);
if (!parametersInfo.Success)
{
return;
}
if (ContainsOnlyThrowNewException(parametersInfo.Body, context.SemanticModel, context.CancellationToken))
{
return;
}
Analyze(context, parametersInfo);
}
