private static void AnalyzeParenthesizedLambdaExpression(SyntaxNodeAnalysisContext context)
{
var lambda = (ParenthesizedLambdaExpressionSyntax)context.Node;
if (lambda.ContainsDiagnostics)
{
return;
}
ParameterInfo parameterInfo = SyntaxInfo.ParameterInfo(lambda);
if (!parameterInfo.Success)
{
return;
}
var methodSymbol = (IMethodSymbol)context.SemanticModel.GetSymbol(lambda, context.CancellationToken);
if (methodSymbol == null)
{
return;
}
if (SymbolUtility.IsEventHandlerMethod(methodSymbol))
{
return;
}
Analyze(context, parameterInfo);
}
private static void AnalyzeAnonymousMethodExpression(SyntaxNodeAnalysisContext context)
{
var anonymousMethod = (AnonymousMethodExpressionSyntax)context.Node;
if (anonymousMethod.ContainsDiagnostics)
{
return;
}
ParameterInfo parameterInfo = SyntaxInfo.ParameterInfo(anonymousMethod);
if (!parameterInfo.Success)
{
return;
}
var methodSymbol = (IMethodSymbol)context.SemanticModel.GetSymbol(anonymousMethod, context.CancellationToken);
if (methodSymbol == null)
{
return;
}
if (SymbolUtility.IsEventHandlerMethod(methodSymbol))
{
return;
}
Analyze(context, parameterInfo);
}
public static void AnalyzeSimpleLambdaExpression(SyntaxNodeAnalysisContext context, INamedTypeSymbol eventArgsSymbol)
{
var lambda = (SimpleLambdaExpressionSyntax)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);
}
private static void AnalyzeLocalFunctionStatement(SyntaxNodeAnalysisContext context)
{
var localFunctionStatement = (LocalFunctionStatementSyntax)context.Node;
if (localFunctionStatement.ContainsDiagnostics)
{
return;
}
ParameterInfo parameterInfo = SyntaxInfo.ParameterInfo(localFunctionStatement);
if (!parameterInfo.Success)
{
return;
}
IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(localFunctionStatement, context.CancellationToken);
if (methodSymbol == null)
{
return;
}
if (SymbolUtility.IsEventHandlerMethod(methodSymbol))
{
return;
}
Analyze(context, parameterInfo);
}
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 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);
}
protected override ImmutableArray <ParameterSyntax> FindUnusedSyntax(
MethodDeclarationSyntax node,
ParameterListSyntax list,
SeparatedSyntaxList <ParameterSyntax> separatedList,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
if (!node.IsParentKind(SyntaxKind.InterfaceDeclaration) &&
GetBody(node) != null &&
!GetModifiers(node).ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword))
{
IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(node, cancellationToken);
if (methodSymbol != null &&
!SymbolUtility.IsEventHandlerMethod(methodSymbol, semanticModel) &&
!methodSymbol.ImplementsInterfaceMember())
{
return(base.FindUnusedSyntax(node, list, separatedList, semanticModel, cancellationToken));
}
}
return(ImmutableArray <ParameterSyntax> .Empty);
}
private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
{
var methodDeclaration = (MethodDeclarationSyntax)context.Node;
if (methodDeclaration.ContainsDiagnostics)
{
return;
}
if (!methodDeclaration.IsParentKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.RecordDeclaration, SyntaxKind.RecordStructDeclaration))
{
return;
}
if (methodDeclaration.Modifiers.ContainsAny(
SyntaxKind.AbstractKeyword,
SyntaxKind.VirtualKeyword,
SyntaxKind.OverrideKeyword,
SyntaxKind.PartialKeyword))
{
return;
}
ParameterInfo parameterInfo = SyntaxInfo.ParameterInfo(methodDeclaration);
if (!parameterInfo.Success)
{
return;
}
if (ContainsOnlyThrowNewExpression(parameterInfo.Body))
{
return;
}
IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
if (methodSymbol == null)
{
return;
}
if (SymbolUtility.IsEventHandlerMethod(methodSymbol))
{
return;
}
if (!methodSymbol.ExplicitInterfaceImplementations.IsDefaultOrEmpty)
{
return;
}
if (methodSymbol.ImplementsInterfaceMember(allInterfaces: true))
{
return;
}
UnusedParameterWalker walker = null;
try
{
walker = UnusedParameterWalker.GetInstance();
walker.SetValues(context.SemanticModel, context.CancellationToken);
FindUnusedNodes(parameterInfo, walker);
if (walker.Nodes.Count > 0 &&
!MethodReferencedAsMethodGroupWalker.IsReferencedAsMethodGroup(methodDeclaration, methodSymbol, context.SemanticModel, context.CancellationToken))
{
foreach (KeyValuePair <string, NodeSymbolInfo> kvp in walker.Nodes)
{
ReportDiagnostic(context, kvp.Value.Node);
}
}
}
finally
{
if (walker != null)
{
UnusedParameterWalker.Free(walker);
}
}
}
private static void AnalyzeAssignmentExpression(SyntaxNodeAnalysisContext context)
{
var assignmentExpression = (AssignmentExpressionSyntax)context.Node;
AssignmentExpressionInfo info = SyntaxInfo.AssignmentExpressionInfo(assignmentExpression);
if (!info.Success)
{
return;
}
ExpressionSyntax right = info.Right;
if (right.Kind() != SyntaxKind.ObjectCreationExpression)
{
return;
}
if (right.SpanContainsDirectives())
{
return;
}
ExpressionSyntax left = info.Left;
if (!left.IsKind(SyntaxKind.IdentifierName, SyntaxKind.SimpleMemberAccessExpression))
{
return;
}
var objectCreation = (ObjectCreationExpressionSyntax)right;
ExpressionSyntax expression = objectCreation
.ArgumentList?
.Arguments
.SingleOrDefault(shouldThrow: false)?
.Expression
.WalkDownParentheses();
if (expression == null)
{
return;
}
if (!expression.IsKind(SyntaxKind.IdentifierName, SyntaxKind.SimpleMemberAccessExpression))
{
return;
}
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
if (!(semanticModel.GetSymbol(assignmentExpression, cancellationToken) is IMethodSymbol methodSymbol))
{
return;
}
if (!methodSymbol.MethodKind.Is(MethodKind.EventAdd, MethodKind.EventRemove))
{
return;
}
if (!(methodSymbol.Parameters.SingleOrDefault(shouldThrow: false)?.Type is INamedTypeSymbol typeSymbol))
{
return;
}
if (!SymbolUtility.IsEventHandlerMethod(typeSymbol.DelegateInvokeMethod))
{
return;
}
if (semanticModel.GetSymbol(expression, cancellationToken)?.Kind != SymbolKind.Method)
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.RemoveRedundantDelegateCreation, right);
DiagnosticHelpers.ReportToken(context, DiagnosticDescriptors.RemoveRedundantDelegateCreationFadeOut, objectCreation.NewKeyword);
DiagnosticHelpers.ReportNode(context, DiagnosticDescriptors.RemoveRedundantDelegateCreationFadeOut, objectCreation.Type);
CSharpDiagnosticHelpers.ReportParentheses(context, DiagnosticDescriptors.RemoveRedundantDelegateCreationFadeOut, objectCreation.ArgumentList);
}