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); } } } } }