private static void Analyze(
SyntaxNodeAnalysisContext context,
ParameterListSyntax parameterList,
SeparatedSyntaxList <ParameterSyntax> parameters)
{
if (parameterList
.DescendantTrivia(parameterList.Span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.SimplifyLambdaExpressionParameterList,
parameterList.GetLocation());
foreach (ParameterSyntax parameter in parameters)
{
if (parameter.Type != null)
{
context.FadeOutNode(FadeOutDescriptor, parameter.Type);
}
}
if (parameters.Count == 1)
{
context.FadeOutToken(FadeOutDescriptor, parameterList.OpenParenToken);
context.FadeOutToken(FadeOutDescriptor, parameterList.CloseParenToken);
}
}
}
private static void SimplifyBooleanComparisonFadeOut(
SyntaxNodeAnalysisContext context,
BinaryExpressionSyntax binaryExpression)
{
DiagnosticDescriptor descriptor = DiagnosticDescriptors.SimplifyBooleanComparisonFadeOut;
context.FadeOutToken(descriptor, binaryExpression.OperatorToken);
ExpressionSyntax left = binaryExpression.Left;
ExpressionSyntax right = binaryExpression.Right;
if (binaryExpression.IsKind(SyntaxKind.EqualsExpression))
{
if (left.IsKind(SyntaxKind.FalseLiteralExpression))
{
context.FadeOutNode(descriptor, left);
if (right.IsKind(SyntaxKind.LogicalNotExpression))
{
context.FadeOutToken(descriptor, ((PrefixUnaryExpressionSyntax)right).OperatorToken);
}
}
else if (right.IsKind(SyntaxKind.FalseLiteralExpression))
{
context.FadeOutNode(descriptor, right);
if (left.IsKind(SyntaxKind.LogicalNotExpression))
{
context.FadeOutToken(descriptor, ((PrefixUnaryExpressionSyntax)left).OperatorToken);
}
}
}
else if (binaryExpression.IsKind(SyntaxKind.NotEqualsExpression))
{
if (left.IsKind(SyntaxKind.TrueLiteralExpression))
{
context.FadeOutNode(descriptor, left);
if (right.IsKind(SyntaxKind.LogicalNotExpression))
{
context.FadeOutToken(descriptor, ((PrefixUnaryExpressionSyntax)right).OperatorToken);
}
}
else if (right.IsKind(SyntaxKind.TrueLiteralExpression))
{
context.FadeOutNode(descriptor, right);
if (left.IsKind(SyntaxKind.LogicalNotExpression))
{
context.FadeOutToken(descriptor, ((PrefixUnaryExpressionSyntax)left).OperatorToken);
}
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context)
{
var returnStatement = (ReturnStatementSyntax)context.Node;
ExpressionSyntax expression = returnStatement.Expression;
if (expression?.IsKind(SyntaxKind.IdentifierName) != true)
{
return;
}
LocalDeclarationStatementSyntax localDeclaration = GetLocalDeclaration(returnStatement);
if (localDeclaration == null)
{
return;
}
VariableDeclaratorSyntax declarator = GetVariableDeclarator(localDeclaration);
if (declarator == null)
{
return;
}
ISymbol symbol = context.SemanticModel.GetSymbol(expression, context.CancellationToken);
if (symbol?.IsLocal() != true)
{
return;
}
ISymbol symbol2 = context.SemanticModel.GetDeclaredSymbol(declarator, context.CancellationToken);
if (symbol.Equals(symbol2))
{
TextSpan span = TextSpan.FromBounds(localDeclaration.Span.Start, returnStatement.Span.End);
if (returnStatement.Parent
.DescendantTrivia(span, descendIntoTrivia: false)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.MergeLocalDeclarationWithReturnStatement,
Location.Create(context.Node.SyntaxTree, span));
}
context.FadeOutNode(FadeOutDescriptor, localDeclaration.Declaration.Type);
context.FadeOutToken(FadeOutDescriptor, declarator.Identifier);
context.FadeOutToken(FadeOutDescriptor, declarator.Initializer.EqualsToken);
context.FadeOutToken(FadeOutDescriptor, localDeclaration.SemicolonToken);
context.FadeOutNode(FadeOutDescriptor, expression);
}
}
private static void FadeOut(
SyntaxNodeAnalysisContext context,
BinaryExpressionSyntax binaryExpression)
{
context.FadeOutToken(FadeOutDescriptor, binaryExpression.OperatorToken);
ExpressionSyntax left = binaryExpression.Left;
ExpressionSyntax right = binaryExpression.Right;
if (binaryExpression.IsKind(SyntaxKind.EqualsExpression))
{
if (left.IsKind(SyntaxKind.FalseLiteralExpression))
{
context.FadeOutNode(FadeOutDescriptor, left);
if (right.IsKind(SyntaxKind.LogicalNotExpression))
{
context.FadeOutToken(FadeOutDescriptor, ((PrefixUnaryExpressionSyntax)right).OperatorToken);
}
}
else if (right.IsKind(SyntaxKind.FalseLiteralExpression))
{
context.FadeOutNode(FadeOutDescriptor, right);
if (left.IsKind(SyntaxKind.LogicalNotExpression))
{
context.FadeOutToken(FadeOutDescriptor, ((PrefixUnaryExpressionSyntax)left).OperatorToken);
}
}
}
else if (binaryExpression.IsKind(SyntaxKind.NotEqualsExpression))
{
if (left.IsKind(SyntaxKind.TrueLiteralExpression))
{
context.FadeOutNode(FadeOutDescriptor, left);
if (right.IsKind(SyntaxKind.LogicalNotExpression))
{
context.FadeOutToken(FadeOutDescriptor, ((PrefixUnaryExpressionSyntax)right).OperatorToken);
}
}
else if (right.IsKind(SyntaxKind.TrueLiteralExpression))
{
context.FadeOutNode(FadeOutDescriptor, right);
if (left.IsKind(SyntaxKind.LogicalNotExpression))
{
context.FadeOutToken(FadeOutDescriptor, ((PrefixUnaryExpressionSyntax)left).OperatorToken);
}
}
}
}
private static void FadeOut(
SyntaxNodeAnalysisContext context,
IfStatementSyntax ifStatement,
IfStatementSyntax nestedIf)
{
context.FadeOutToken(DiagnosticDescriptors.MergeIfStatementWithNestedIfStatementFadeOut, nestedIf.IfKeyword);
context.FadeOutToken(DiagnosticDescriptors.MergeIfStatementWithNestedIfStatementFadeOut, nestedIf.OpenParenToken);
context.FadeOutToken(DiagnosticDescriptors.MergeIfStatementWithNestedIfStatementFadeOut, nestedIf.CloseParenToken);
if (ifStatement.Statement.IsKind(SyntaxKind.Block) &&
nestedIf.Statement.IsKind(SyntaxKind.Block))
{
context.FadeOutBraces(DiagnosticDescriptors.MergeIfStatementWithNestedIfStatementFadeOut, (BlockSyntax)nestedIf.Statement);
}
}
private static void FadeOut(SyntaxNodeAnalysisContext context, ParameterListSyntax parameterList)
{
foreach (ParameterSyntax parameter in parameterList.Parameters)
{
if (parameter.Type != null)
{
context.FadeOutNode(DiagnosticDescriptors.SimplifyLambdaExpressionParameterListFadeOut, parameter.Type);
}
}
if (parameterList.Parameters.Count == 1)
{
context.FadeOutToken(DiagnosticDescriptors.SimplifyLambdaExpressionParameterListFadeOut, parameterList.OpenParenToken);
context.FadeOutToken(DiagnosticDescriptors.SimplifyLambdaExpressionParameterListFadeOut, parameterList.CloseParenToken);
}
}
private static void FadeOut(SyntaxNodeAnalysisContext context, IfStatementSyntax ifStatement, ReturnStatementSyntax returnStatement)
{
context.FadeOutToken(_fadeOutDescriptor, ifStatement.IfKeyword);
context.FadeOutToken(_fadeOutDescriptor, ifStatement.OpenParenToken);
context.FadeOutToken(_fadeOutDescriptor, ifStatement.CloseParenToken);
context.FadeOutNode(_fadeOutDescriptor, ifStatement.Statement);
if (ifStatement.Else != null)
{
context.FadeOutNode(_fadeOutDescriptor, ifStatement.Else);
}
else
{
context.FadeOutNode(_fadeOutDescriptor, returnStatement);
}
}
private static void AnalyzeExpression(SyntaxNodeAnalysisContext context, ExpressionSyntax expression)
{
if (expression?.IsKind(SyntaxKind.ParenthesizedExpression) == true)
{
var parenthesizedExpression = (ParenthesizedExpressionSyntax)expression;
SyntaxToken openParen = parenthesizedExpression.OpenParenToken;
SyntaxToken closeParen = parenthesizedExpression.CloseParenToken;
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveRedundantParentheses,
openParen.GetLocation(),
additionalLocations: new Location[] { closeParen.GetLocation() });
context.FadeOutToken(DiagnosticDescriptors.RemoveRedundantParenthesesFadeOut, openParen);
context.FadeOutToken(DiagnosticDescriptors.RemoveRedundantParenthesesFadeOut, closeParen);
}
}
private static void FadeOut(SyntaxNodeAnalysisContext context, BlockSyntax block)
{
context.FadeOutBraces(DiagnosticDescriptors.SimplifyLambdaExpressionFadeOut, block);
if (block.Statements[0].IsKind(SyntaxKind.ReturnStatement))
{
context.FadeOutToken(DiagnosticDescriptors.SimplifyLambdaExpressionFadeOut, ((ReturnStatementSyntax)block.Statements[0]).ReturnKeyword);
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, AssignmentExpressionSyntax assignment)
{
ExpressionSyntax right = assignment.Right;
if (right?.IsKind(SyntaxKind.ObjectCreationExpression) == true)
{
var objectCreation = (ObjectCreationExpressionSyntax)right;
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(objectCreation, cancellationToken);
if (typeSymbol != null &&
Symbol.IsEventHandlerOrConstructedFromEventHandlerOfT(typeSymbol, semanticModel))
{
ArgumentListSyntax argumentList = objectCreation.ArgumentList;
if (argumentList != null)
{
SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments;
if (arguments.Count == 1)
{
ArgumentSyntax argument = arguments.First();
ExpressionSyntax expression = argument.Expression;
if (expression != null)
{
IMethodSymbol methodSymbol = semanticModel.GetMethodSymbol(expression, cancellationToken);
if (methodSymbol != null)
{
ExpressionSyntax left = assignment.Left;
if (left?.IsMissing == false &&
semanticModel.GetSymbol(left, cancellationToken)?.IsEvent() == true &&
!objectCreation.SpanContainsDirectives())
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantDelegateCreation, right.GetLocation());
context.FadeOutToken(DiagnosticDescriptors.RemoveRedundantDelegateCreationFadeOut, objectCreation.NewKeyword);
context.FadeOutNode(DiagnosticDescriptors.RemoveRedundantDelegateCreationFadeOut, objectCreation.Type);
context.FadeOutParentheses(DiagnosticDescriptors.RemoveRedundantDelegateCreationFadeOut, objectCreation.ArgumentList);
}
}
}
}
}
}
}
}
private static void FadeOut(SyntaxNodeAnalysisContext context, AnonymousMethodExpressionSyntax anonymousMethod)
{
DiagnosticDescriptor descriptor = DiagnosticDescriptors.ReplaceAnonymousMethodWithLambdaExpressionFadeOut;
context.FadeOutToken(descriptor, anonymousMethod.DelegateKeyword);
BlockSyntax block = anonymousMethod.Block;
if (block.Statements.Count == 1 && block.IsSingleLine())
{
StatementSyntax statement = block.Statements[0];
if (statement.IsKind(SyntaxKind.ReturnStatement, SyntaxKind.ExpressionStatement))
{
context.FadeOutBraces(descriptor, block);
if (statement.IsKind(SyntaxKind.ReturnStatement))
{
context.FadeOutToken(descriptor, ((ReturnStatementSyntax)statement).ReturnKeyword);
}
}
}
}
private static void ReportDiagnostic(SyntaxNodeAnalysisContext context, AccessorListSyntax accessorList, ExpressionSyntax expression)
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExpressionBodiedMember,
accessorList.GetLocation());
SyntaxNode parent = expression.Parent;
if (parent.IsKind(SyntaxKind.ReturnStatement))
{
context.FadeOutToken(FadeOutDescriptor, ((ReturnStatementSyntax)parent).ReturnKeyword);
}
context.FadeOutBraces(FadeOutDescriptor, accessorList);
}
private static bool AnalyzeBlock(SyntaxNodeAnalysisContext context, BlockSyntax block, bool checkTrivia = true)
{
if (block == null)
{
return(false);
}
SyntaxList <StatementSyntax> statements = block.Statements;
if (statements.Count != 1)
{
return(false);
}
var returnStatement = statements[0] as ReturnStatementSyntax;
if (returnStatement == null)
{
return(false);
}
if (returnStatement.Expression == null)
{
return(false);
}
if (checkTrivia && block
.DescendantTrivia(descendIntoTrivia: true)
.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
return(false);
}
if (!returnStatement.IsSingleLine())
{
return(false);
}
context.ReportDiagnostic(
DiagnosticDescriptors.UseExpressionBodiedMember,
block.GetLocation());
context.FadeOutToken(DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut, returnStatement.ReturnKeyword);
context.FadeOutBraces(DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut, block);
return(true);
}
private static void RemoveRedundantBooleanLiteralFadeOut(
SyntaxNodeAnalysisContext context,
BinaryExpressionSyntax binaryExpression)
{
DiagnosticDescriptor descriptor = DiagnosticDescriptors.RemoveRedundantBooleanLiteralFadeOut;
context.FadeOutToken(descriptor, binaryExpression.OperatorToken);
ExpressionSyntax left = binaryExpression.Left;
ExpressionSyntax right = binaryExpression.Right;
switch (binaryExpression.Kind())
{
case SyntaxKind.EqualsExpression:
case SyntaxKind.LogicalAndExpression:
{
if (left.IsKind(SyntaxKind.TrueLiteralExpression))
{
context.FadeOutNode(descriptor, left);
}
else if (right.IsKind(SyntaxKind.TrueLiteralExpression))
{
context.FadeOutNode(descriptor, right);
}
break;
}
case SyntaxKind.NotEqualsExpression:
case SyntaxKind.LogicalOrExpression:
{
if (left.IsKind(SyntaxKind.FalseLiteralExpression))
{
context.FadeOutNode(descriptor, left);
}
else if (right.IsKind(SyntaxKind.FalseLiteralExpression))
{
context.FadeOutNode(descriptor, right);
}
break;
}
}
}
private static void AnalyzeAccessorList(SyntaxNodeAnalysisContext context, AccessorListSyntax accessorList)
{
if (accessorList == null)
{
return;
}
SyntaxList <AccessorDeclarationSyntax> accessors = accessorList.Accessors;
if (accessors.Count != 1)
{
return;
}
AccessorDeclarationSyntax accessor = accessors[0];
if (accessor.Body == null)
{
return;
}
if (!accessor.IsKind(SyntaxKind.GetAccessorDeclaration))
{
return;
}
if (accessor.AttributeLists.Count != 0)
{
return;
}
if (accessor.Body
.DescendantTrivia(descendIntoTrivia: true)
.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
return;
}
if (AnalyzeBlock(context, accessor.Body, checkTrivia: false))
{
context.FadeOutToken(DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut, accessor.Keyword);
context.FadeOutBraces(DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut, accessorList);
}
}
private void AnalyzeAccessorDeclaration(SyntaxNodeAnalysisContext context)
{
var accessor = (AccessorDeclarationSyntax)context.Node;
if (accessor.ExpressionBody == null &&
!accessor.AttributeLists.Any())
{
BlockSyntax body = accessor.Body;
ExpressionSyntax expression = UseExpressionBodiedMemberRefactoring.GetExpression(body);
if (expression != null &&
expression.IsSingleLine())
{
var accessorList = accessor.Parent as AccessorListSyntax;
if (accessorList != null)
{
SyntaxList <AccessorDeclarationSyntax> accessors = accessorList.Accessors;
if (accessors.Count == 1 &&
accessors.First().IsKind(SyntaxKind.GetAccessorDeclaration))
{
if (accessorList.DescendantTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
ReportDiagnostic(context, accessorList, expression);
context.FadeOutToken(FadeOutDescriptor, accessor.Keyword);
context.FadeOutBraces(FadeOutDescriptor, body);
}
return;
}
}
if (accessor.DescendantTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
ReportDiagnostic(context, body, expression);
}
}
}
}
private void AnalyzeLambdaExpression(SyntaxNodeAnalysisContext context)
{
var lambda = (LambdaExpressionSyntax)context.Node;
if (SimplifyLambdaExpressionRefactoring.CanRefactor(lambda))
{
CSharpSyntaxNode body = lambda.Body;
context.ReportDiagnostic(DiagnosticDescriptors.SimplifyLambdaExpression, body.GetLocation());
var block = (BlockSyntax)body;
context.FadeOutBraces(DiagnosticDescriptors.SimplifyLambdaExpressionFadeOut, block);
StatementSyntax statement = block.Statements[0];
if (statement.IsKind(SyntaxKind.ReturnStatement))
{
context.FadeOutToken(DiagnosticDescriptors.SimplifyLambdaExpressionFadeOut, ((ReturnStatementSyntax)statement).ReturnKeyword);
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, AssignmentExpressionSyntax assignment)
{
switch (assignment.Kind())
{
case SyntaxKind.AddAssignmentExpression:
case SyntaxKind.SubtractAssignmentExpression:
{
ExpressionSyntax left = assignment.Left;
ExpressionSyntax right = assignment.Right;
if (left?.IsMissing == false &&
right?.IsNumericLiteralExpression(1) == true)
{
ITypeSymbol typeSymbol = context.SemanticModel.GetTypeSymbol(left, context.CancellationToken);
if (typeSymbol?.SupportsPrefixOrPostfixUnaryOperator() == true &&
!assignment.SpanContainsDirectives())
{
ReportDiagnostic(context, assignment);
SyntaxToken operatorToken = assignment.OperatorToken;
if (operatorToken.Span.Length == 2)
{
context.ReportDiagnostic(FadeOutDescriptor, Location.Create(assignment.SyntaxTree, new TextSpan(operatorToken.SpanStart, 1)));
}
context.FadeOutNode(FadeOutDescriptor, assignment.Right);
}
}
break;
}
case SyntaxKind.SimpleAssignmentExpression:
{
ExpressionSyntax left = assignment.Left;
ExpressionSyntax right = assignment.Right;
if (left?.IsMissing == false &&
right?.IsMissing == false &&
right.IsKind(SyntaxKind.AddExpression, SyntaxKind.SubtractExpression))
{
var binaryExpression = (BinaryExpressionSyntax)right;
ExpressionSyntax binaryLeft = binaryExpression.Left;
ExpressionSyntax binaryRight = binaryExpression.Right;
if (binaryLeft?.IsMissing == false &&
binaryRight?.IsNumericLiteralExpression(1) == true)
{
ITypeSymbol typeSymbol = context.SemanticModel.GetTypeSymbol(left, context.CancellationToken);
if (typeSymbol?.SupportsPrefixOrPostfixUnaryOperator() == true &&
left.IsEquivalentTo(binaryLeft, topLevel: false) &&
!assignment.SpanContainsDirectives())
{
ReportDiagnostic(context, assignment);
context.FadeOutToken(FadeOutDescriptor, assignment.OperatorToken);
context.FadeOutNode(FadeOutDescriptor, binaryLeft);
context.FadeOutNode(FadeOutDescriptor, binaryRight);
}
}
}
break;
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, IfStatementSyntax ifStatement)
{
SyntaxNode parent = ifStatement.Parent;
if (parent?.IsKind(SyntaxKind.Block) == true)
{
ReturnStatementSyntax returnStatement = GetReturnStatement(ifStatement.Statement);
LiteralExpressionSyntax booleanLiteral = GetBooleanLiteral(returnStatement);
if (booleanLiteral != null)
{
ReturnStatementSyntax returnStatement2 = null;
LiteralExpressionSyntax booleanLiteral2 = null;
TextSpan span = ifStatement.Span;
ElseClauseSyntax @else = ifStatement.Else;
if (@else != null)
{
returnStatement2 = GetReturnStatement(@else.Statement);
booleanLiteral2 = GetBooleanLiteral(returnStatement2);
}
else
{
var block = (BlockSyntax)parent;
SyntaxList <StatementSyntax> statements = block.Statements;
int index = statements.IndexOf(ifStatement);
if (index < statements.Count - 1 &&
(index == 0 || !IsIfStatementWithReturnStatement(statements[index - 1])))
{
StatementSyntax nextStatement = statements[index + 1];
if (nextStatement.IsKind(SyntaxKind.ReturnStatement))
{
returnStatement2 = (ReturnStatementSyntax)nextStatement;
booleanLiteral2 = GetBooleanLiteral(returnStatement2);
if (booleanLiteral2 != null)
{
span = TextSpan.FromBounds(ifStatement.SpanStart, returnStatement2.Span.End);
}
}
}
}
if (booleanLiteral2 != null &&
IsOppositeBooleanLiteral(booleanLiteral, booleanLiteral2) &&
parent
.DescendantTrivia(span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.ReplaceIfStatementWithReturnStatement,
Location.Create(context.Node.SyntaxTree, span));
context.FadeOutToken(FadeOutDescriptor, ifStatement.IfKeyword);
context.FadeOutToken(FadeOutDescriptor, ifStatement.OpenParenToken);
context.FadeOutToken(FadeOutDescriptor, ifStatement.CloseParenToken);
context.FadeOutNode(FadeOutDescriptor, ifStatement.Statement);
if (ifStatement.Else != null)
{
context.FadeOutNode(FadeOutDescriptor, @else);
}
else
{
context.FadeOutNode(FadeOutDescriptor, returnStatement2);
}
}
}
}
}
