internal static ConditionalStatementInfo Create( IfStatementSyntax ifStatement, bool walkDownParentheses = true, bool allowMissing = false) { if (ifStatement?.IsParentKind(SyntaxKind.ElseClause) != false) { return(default);
internal static SimplifyCodeBranchingKind?GetKind(IfStatementSyntax ifStatement, SemanticModel semanticModel, CancellationToken cancellationToken) { ExpressionSyntax condition = ifStatement.Condition?.WalkDownParentheses(); if (condition?.IsMissing != false) { return(null); } StatementSyntax ifStatementStatement = ifStatement.Statement; if (ifStatementStatement == null) { return(null); } ElseClauseSyntax elseClause = ifStatement.Else; if (elseClause != null) { if (IsFixableIfElseInsideWhile(ifStatement, elseClause)) { return(SimplifyCodeBranchingKind.IfElseInsideWhile); } else { var ifStatementBlock = ifStatementStatement as BlockSyntax; if (ifStatementBlock?.Statements.Any() == false && ifStatementBlock.OpenBraceToken.TrailingTrivia.IsEmptyOrWhitespace() && ifStatementBlock.CloseBraceToken.LeadingTrivia.IsEmptyOrWhitespace() && IsFixableIfElseWithEmptyIf(ifStatement, elseClause)) { return(SimplifyCodeBranchingKind.IfElseWithEmptyIf); } else if (IsFixableIfElseWithReturnOrContinueInsideIf(ifStatement, elseClause)) { return(SimplifyCodeBranchingKind.LastIfElseWithReturnOrContinueInsideIf); } } } else if (IsFixableSimpleIfInsideWhileOrDo(ifStatement, semanticModel, cancellationToken)) { return(SimplifyCodeBranchingKind.SimplifyIfInsideWhileOrDo); } else if (!ifStatement.IsParentKind(SyntaxKind.ElseClause) && (ifStatement.SingleNonBlockStatementOrDefault() is DoStatementSyntax doStatement) && CSharpFactory.AreEquivalent(condition, doStatement.Condition?.WalkDownParentheses())) { return(SimplifyCodeBranchingKind.SimpleIfContainingOnlyDo); } return(null); }
private static void AnalyzeElseClause(SyntaxNodeAnalysisContext context) { var elseClause = (ElseClauseSyntax)context.Node; StatementSyntax statement = elseClause.Statement; if (statement?.Kind() != SyntaxKind.Block) { return; } var block = (BlockSyntax)statement; if (block.Statements.Any()) { return; } IfStatementSyntax topmostIf = elseClause.GetTopmostIf(); if (topmostIf.IsParentKind(SyntaxKind.IfStatement)) { var parentIf = (IfStatementSyntax)topmostIf.Parent; if (parentIf.Else != null) { return; } } if (!elseClause.ElseKeyword.TrailingTrivia.IsEmptyOrWhitespace()) { return; } SyntaxToken openBrace = block.OpenBraceToken; if (!openBrace.LeadingTrivia.IsEmptyOrWhitespace()) { return; } if (!openBrace.TrailingTrivia.IsEmptyOrWhitespace()) { return; } if (!block.CloseBraceToken.LeadingTrivia.IsEmptyOrWhitespace()) { return; } DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.RemoveEmptyElseClause, elseClause); }
private static IfStatementSyntax GetUpdatedIfStatement( IsPatternExpressionSyntax updatedCondition, ImmutableArray <SyntaxTrivia> trivia, IfStatementSyntax originalIf, IfStatementSyntax currentIf) { var newIf = currentIf.ReplaceNode(currentIf.Condition, updatedCondition); newIf = originalIf.IsParentKind(SyntaxKind.ElseClause) ? newIf.ReplaceToken(newIf.CloseParenToken, newIf.CloseParenToken.WithTrailingTrivia(trivia)) : newIf.WithPrependedLeadingTrivia(trivia); return(newIf.WithAdditionalAnnotations(Formatter.Annotation)); }
private static void AnalyzeElseClause(SyntaxNodeAnalysisContext context) { var elseClause = (ElseClauseSyntax)context.Node; if (elseClause.Statement?.Kind() == SyntaxKind.Block) { IfStatementSyntax ifStatement = elseClause.GetTopmostIf(); if (ifStatement.IsParentKind(SyntaxKind.Block)) { AnalyzeStatement(context, ifStatement, (BlockSyntax)elseClause.Statement); } } }
private static void Analyze(SyntaxNodeAnalysisContext context, StatementSyntax statement, Func <SyntaxKind, bool> predicate) { if (statement.IsParentKind(SyntaxKind.Block)) { var block = (BlockSyntax)statement.Parent; SyntaxNode parent = block.Parent; if (parent != null) { SyntaxKind kind = parent.Kind(); if (predicate(kind)) { if (IsRemovable(block, statement, kind)) { ReportDiagnostic(context, statement); } } else if (kind == SyntaxKind.ElseClause) { var elseClause = (ElseClauseSyntax)parent; if (!elseClause.ContinuesWithIf()) { IfStatementSyntax ifStatement = elseClause.GetTopmostIf(); if (ifStatement.IsParentKind(SyntaxKind.Block)) { block = (BlockSyntax)ifStatement.Parent; parent = block.Parent; if (parent != null) { kind = parent.Kind(); if (predicate(kind) && IsRemovable(block, ifStatement, kind)) { ReportDiagnostic(context, statement); } } } } } } } }
public static IfStatementSyntax GetPreviousIf(IfStatementSyntax ifStatement) { if (ifStatement == null) { throw new ArgumentNullException(nameof(ifStatement)); } if (ifStatement.IsParentKind(SyntaxKind.ElseClause) && ifStatement.Parent.IsParentKind(SyntaxKind.IfStatement)) { return((IfStatementSyntax)ifStatement.Parent.Parent); } return(null); }
public static void ComputeRefactoring(RefactoringContext context, IfStatementSyntax ifStatement) { if (ifStatement.IsParentKind(SyntaxKind.ElseClause)) { return; } if (ifStatement.Else == null) { return; } foreach (IfStatementOrElseClause ifOrElse in ifStatement.AsCascade()) { StatementSyntax statement = ifOrElse.Statement; if (statement is BlockSyntax block) { statement = block.Statements.LastOrDefault(); } if (statement == null) { return; } if (!statement.IsKind( SyntaxKind.ReturnStatement, SyntaxKind.ContinueStatement, SyntaxKind.BreakStatement, SyntaxKind.ThrowStatement)) { return; } } context.RegisterRefactoring( "Split if-else", cancellationToken => RefactorAsync(context.Document, ifStatement, cancellationToken), RefactoringIdentifiers.SplitIfElse); }
internal static SimpleIfElseInfo Create( IfStatementSyntax ifStatement, bool walkDownParentheses = true, bool allowMissing = false) { if (ifStatement?.IsParentKind(SyntaxKind.ElseClause) != false) { return(Default); } StatementSyntax whenFalse = ifStatement.Else?.Statement; if (!Check(whenFalse, allowMissing)) { return(Default); } if (whenFalse.IsKind(SyntaxKind.IfStatement)) { return(Default); } StatementSyntax whenTrue = ifStatement.Statement; if (!Check(whenTrue, allowMissing)) { return(Default); } ExpressionSyntax condition = WalkAndCheck(ifStatement.Condition, walkDownParentheses, allowMissing); if (condition == null) { return(Default); } return(new SimpleIfElseInfo(ifStatement, condition, whenTrue, whenFalse)); }
internal static void ComputeRefactoring(RefactoringContext context, IfStatementSyntax ifStatement) { SimpleIfStatementInfo simpleIf = SyntaxInfo.SimpleIfStatementInfo(ifStatement); if (simpleIf.Success) { if (simpleIf.Condition.IsKind(SyntaxKind.LogicalOrExpression)) { context.RegisterRefactoring( "Split if", ct => SplitSimpleIfAsync(context.Document, ifStatement, ct), RefactoringDescriptors.SplitIf); } } else if (ifStatement.IsParentKind(SyntaxKind.ElseClause) && ifStatement.Else == null && ifStatement.Condition.IsKind(SyntaxKind.LogicalOrExpression)) { context.RegisterRefactoring( "Split if", ct => SplitLastElseIfAsync(context.Document, ifStatement, ct), RefactoringDescriptors.SplitIf); } }
private static ReduceIfNestingAnalysisResult AnalyzeCore( IfStatementSyntax ifStatement, SemanticModel semanticModel, SyntaxKind jumpKind, ReduceIfNestingOptions options, CancellationToken cancellationToken = default(CancellationToken)) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(ifStatement); if (!statementsInfo.Success) { return(Fail(ifStatement)); } SyntaxNode node = statementsInfo.Parent; SyntaxNode parent = node.Parent; SyntaxKind parentKind = parent.Kind(); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; if (statementsInfo.IsParentSwitchSection || parentKind == SyntaxKind.SwitchSection) { SyntaxNode switchSection = (statementsInfo.IsParentSwitchSection) ? node : parent; if (!options.AllowSwitchSection()) { return(Fail(switchSection)); } if (ifStatement != statements.LastButOneOrDefault()) { return(Fail(switchSection)); } if (!IsFixableJumpStatement(statements.Last(), ref jumpKind)) { return(Fail(switchSection)); } if (!options.AllowNestedFix() && IsNestedFix(switchSection.Parent, semanticModel, options, cancellationToken)) { return(Fail(switchSection)); } return(Success(jumpKind, switchSection)); } if (parentKind.Is( SyntaxKind.ForStatement, SyntaxKind.ForEachStatement, SyntaxKind.DoStatement, SyntaxKind.WhileStatement)) { if (!options.AllowLoop()) { return(Fail(parent)); } StatementSyntax lastStatement = statements.Last(); if (ifStatement == lastStatement) { jumpKind = SyntaxKind.ContinueStatement; } else { if (ifStatement != statements.LastButOneOrDefault()) { return(Fail(parent)); } if (!IsFixableJumpStatement(lastStatement, ref jumpKind)) { return(Fail(parent)); } } if (!options.AllowNestedFix() && IsNestedFix(parent.Parent, semanticModel, options, cancellationToken)) { return(Fail(parent)); } return(Success(jumpKind, parent)); } if (!IsFixable(ifStatement, statements, ref jumpKind)) { return(Fail(node)); } switch (parentKind) { case SyntaxKind.ConstructorDeclaration: case SyntaxKind.DestructorDeclaration: case SyntaxKind.SetAccessorDeclaration: case SyntaxKind.AddAccessorDeclaration: case SyntaxKind.RemoveAccessorDeclaration: { if (jumpKind == SyntaxKind.None) { jumpKind = SyntaxKind.ReturnStatement; } else if (jumpKind != SyntaxKind.ReturnStatement) { return(Fail(parent)); } return(Success(jumpKind, parent)); } case SyntaxKind.OperatorDeclaration: case SyntaxKind.ConversionOperatorDeclaration: case SyntaxKind.GetAccessorDeclaration: { if (jumpKind == SyntaxKind.None) { return(Fail(parent)); } return(Success(jumpKind, parent)); } case SyntaxKind.MethodDeclaration: { var methodDeclaration = (MethodDeclarationSyntax)parent; if (jumpKind != SyntaxKind.None) { return(Success(jumpKind, parent)); } if (methodDeclaration.ReturnsVoid()) { return(Success(SyntaxKind.ReturnStatement, parent)); } if (methodDeclaration.Modifiers.Contains(SyntaxKind.AsyncKeyword) && semanticModel .GetDeclaredSymbol(methodDeclaration, cancellationToken)? .ReturnType .HasMetadataName(MetadataNames.System_Threading_Tasks_Task) == true) { return(Success(SyntaxKind.ReturnStatement, parent)); } if (semanticModel .GetDeclaredSymbol(methodDeclaration, cancellationToken)? .ReturnType .OriginalDefinition .IsIEnumerableOrIEnumerableOfT() == true && methodDeclaration.ContainsYield()) { return(Success(SyntaxKind.YieldBreakStatement, parent)); } break; } case SyntaxKind.LocalFunctionStatement: { var localFunction = (LocalFunctionStatementSyntax)parent; if (jumpKind != SyntaxKind.None) { return(Success(jumpKind, parent)); } if (localFunction.ReturnsVoid()) { return(Success(SyntaxKind.ReturnStatement, parent)); } if (localFunction.Modifiers.Contains(SyntaxKind.AsyncKeyword) && semanticModel.GetDeclaredSymbol(localFunction, cancellationToken)? .ReturnType .HasMetadataName(MetadataNames.System_Threading_Tasks_Task) == true) { return(Success(SyntaxKind.ReturnStatement, parent)); } if (semanticModel.GetDeclaredSymbol(localFunction, cancellationToken)? .ReturnType .OriginalDefinition .IsIEnumerableOrIEnumerableOfT() == true && localFunction.ContainsYield()) { return(Success(SyntaxKind.YieldBreakStatement, parent)); } break; } case SyntaxKind.AnonymousMethodExpression: case SyntaxKind.SimpleLambdaExpression: case SyntaxKind.ParenthesizedLambdaExpression: { var anonymousFunction = (AnonymousFunctionExpressionSyntax)parent; if (jumpKind != SyntaxKind.None) { return(Success(jumpKind, parent)); } if (!(semanticModel.GetSymbol(anonymousFunction, cancellationToken) is IMethodSymbol methodSymbol)) { return(Fail(parent)); } if (methodSymbol.ReturnsVoid) { return(Success(SyntaxKind.ReturnStatement, parent)); } if (anonymousFunction.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword && methodSymbol.ReturnType.HasMetadataName(MetadataNames.System_Threading_Tasks_Task)) { return(Success(SyntaxKind.ReturnStatement, parent)); } break; } case SyntaxKind.IfStatement: { ifStatement = (IfStatementSyntax)parent; if (ifStatement.IsParentKind(SyntaxKind.ElseClause)) { if (ifStatement.Else != null) { return(Fail(parent)); } if (!options.AllowIfInsideIfElse()) { return(Fail(parent)); } return(AnalyzeCore(ifStatement.GetTopmostIf(), semanticModel, jumpKind, options, cancellationToken)); } else { if (!IsFixable(ifStatement)) { return(Fail(parent)); } if (!options.AllowNestedFix()) { return(Fail(parent)); } return(AnalyzeCore(ifStatement, semanticModel, jumpKind, options, cancellationToken)); } } case SyntaxKind.ElseClause: { if (!options.AllowIfInsideIfElse()) { return(Fail(parent)); } var elseClause = (ElseClauseSyntax)parent; return(AnalyzeCore(elseClause.GetTopmostIf(), semanticModel, jumpKind, options, cancellationToken)); } } return(Fail(parent)); }