public static async Task <Document> RefactorAsync( Document document, IfStatementSyntax ifStatement, CancellationToken cancellationToken = default(CancellationToken)) { ElseClauseSyntax elseClause = ifStatement.Else; StatementSyntax whenTrue = ifStatement.Statement; StatementSyntax whenFalse = elseClause.Statement; SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); ElseClauseSyntax newElseClause = null; if ((whenFalse as BlockSyntax)?.Statements.Any() != false) { newElseClause = elseClause.WithStatement(whenTrue.WithTriviaFrom(whenFalse)); } IfStatementSyntax newIfStatement = ifStatement .WithCondition(Negator.LogicallyNegate(ifStatement.Condition, semanticModel, cancellationToken)) .WithStatement(whenFalse.WithTriviaFrom(whenTrue)) .WithElse(newElseClause) .WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(ifStatement, newIfStatement, cancellationToken).ConfigureAwait(false)); }
private async Task <Document> AddMissingBracesAsync(Document document, SyntaxNode errorStatement, CancellationToken c) { // With two different node types, I'll build up the appropriate new statements for each // type and plug them in with common code. SyntaxNode toReplace = null; if (errorStatement is IfStatementSyntax) { IfStatementSyntax newIfStatement = errorStatement as IfStatementSyntax; newIfStatement = newIfStatement.WithStatement(SyntaxFactory.Block(newIfStatement.Statement)).WithAdditionalAnnotations(Formatter.Annotation); toReplace = newIfStatement; } else if (errorStatement is ElseClauseSyntax) { ElseClauseSyntax newElseStatement = errorStatement as ElseClauseSyntax; newElseStatement = newElseStatement.WithStatement(SyntaxFactory.Block(newElseStatement.Statement)).WithAdditionalAnnotations(Formatter.Annotation); toReplace = newElseStatement; } if (toReplace != null) { // Poke in our new call and update the document. var root = await document.GetSyntaxRootAsync(c); var newRoot = root.ReplaceNode(errorStatement, toReplace); var newDocument = document.WithSyntaxRoot(newRoot); return(newDocument); } else { return(null); } }
protected Task <Document> RemoveBracesAsync(Document document, SyntaxNode root, StatementSyntax statement, ElseClauseSyntax elseClause, CancellationToken token) { var newElseClause = elseClause.WithStatement(statement); var newRoot = root.ReplaceNode(elseClause, newElseClause); return(Task.FromResult(document.WithSyntaxRoot(newRoot))); }
private static async Task <Document> InvertIfElseAsync( Document document, IfStatementSyntax ifStatement, CancellationToken cancellationToken = default(CancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); ElseClauseSyntax elseClause = ifStatement.Else; StatementSyntax whenTrue = ifStatement.Statement; StatementSyntax whenFalse = elseClause.Statement; SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); IfStatementSyntax newIfStatement = ifStatement.Update( ifKeyword: ifStatement.IfKeyword, openParenToken: ifStatement.OpenParenToken, condition: SyntaxInverter.LogicallyInvert(ifStatement.Condition, semanticModel, cancellationToken), closeParenToken: ifStatement.CloseParenToken, statement: whenFalse.WithTriviaFrom(whenTrue), @else: elseClause.WithStatement(whenTrue.WithTriviaFrom(whenFalse))); newIfStatement = newIfStatement.WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(ifStatement, newIfStatement, cancellationToken).ConfigureAwait(false)); }
public static ElseClauseSyntax AddBraces(ElseClauseSyntax elseClause) { Debug.Assert(elseClause != null && NeedsBraces(elseClause)); return elseClause .WithStatement(SyntaxFactory.Block(elseClause.Statement)) .WithAdditionalAnnotations(Formatter.Annotation); }
public override SyntaxNode VisitElseClause(ElseClauseSyntax node) { if (node != this.ContainerOfStatementsOrFieldToReplace) { return(base.VisitElseClause(node)); } return(node.WithStatement(ReplaceStatementIfNeeded(node.Statement))); }
public override SyntaxNode?VisitElseClause(ElseClauseSyntax node) { if (node.Statement is BlockSyntax) { return(base.VisitElseClause(node)); } return(base.VisitElseClause(node.WithStatement(SyntaxFactory.Block(node.Statement)))); }
public override SyntaxNode VisitElseClause(ElseClauseSyntax node) { if (_previousIf.Equals(node.Parent) && node.Statement?.Kind() == SyntaxKind.Block) { return(node.WithStatement(((BlockSyntax)node.Statement).Statements[0])); } return(base.VisitElseClause(node)); }
public override SyntaxNode VisitElseClause(ElseClauseSyntax node) { if (!ShouldRun(node)) { return(base.VisitElseClause(node)); } var newNode = node.WithStatement(SyntaxFactory.EmptyStatement()); return(newNode); }
public override SyntaxNode VisitElseClause(ElseClauseSyntax elseClause) { if (elseClause.Statement is BlockSyntax) { return(base.VisitElseClause(elseClause)); } return(base.VisitElseClause( elseClause.WithStatement( SyntaxFactory.Block( SyntaxFactory.SingletonList( elseClause.Statement))))); }
public override SyntaxNode VisitElseClause(ElseClauseSyntax node) { var blockResumeLocation = GetBlockResumeLocation(node.Statement); node = (ElseClauseSyntax)base.VisitElseClause(node); // We leave "else if" alone. if (node.Statement.Kind() == SyntaxKind.IfStatement) { return(node); } node = node.WithStatement(InjectedBlock(node.Statement, blockResumeLocation)); return(node); }
public override SyntaxNode VisitElseClause(ElseClauseSyntax node) { if (node == null) { throw new ArgumentNullException(nameof(node)); } if (_previousIf.Equals(node.Parent) && node.Statement?.IsKind(SyntaxKind.Block, SyntaxKind.IfStatement) == false) { return(node.WithStatement(SyntaxFactory.Block(node.Statement))); } return(base.VisitElseClause(node)); }
public static Task <Document> RefactorAsync( Document document, ElseClauseSyntax elseClause, CancellationToken cancellationToken) { var block = (BlockSyntax)elseClause.Statement; var ifStatement = (IfStatementSyntax)block.Statements[0]; ElseClauseSyntax newElseClause = elseClause .WithStatement(ifStatement) .WithElseKeyword(elseClause.ElseKeyword.WithoutTrailingTrivia()) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(elseClause, newElseClause, cancellationToken)); }
public override SyntaxNode VisitElseClause(ElseClauseSyntax node) { if (node == null) { throw new ArgumentNullException(nameof(node)); } if (_previousIf.Equals(node.Parent) && node.Statement != null && node.Statement.IsKind(SyntaxKind.Block)) { return(node.WithStatement(((BlockSyntax)node.Statement).Statements[0])); } return(base.VisitElseClause(node)); }
private static async Task <Document> RemoveBracesFromElseClauseAsync( Document document, ElseClauseSyntax elseClause, CancellationToken cancellationToken) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken); var block = (BlockSyntax)elseClause.Statement; var ifStatement = (IfStatementSyntax)block.Statements[0]; ElseClauseSyntax newElseClause = elseClause .WithStatement(ifStatement) .WithElseKeyword(elseClause.ElseKeyword.WithoutTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); SyntaxNode newRoot = oldRoot.ReplaceNode(elseClause, newElseClause); return(document.WithSyntaxRoot(newRoot)); }
ElseClauseSyntax GetNewIfWithElse(ElseClauseSyntax elseNode, StatementSyntax singleStatementInsideElse) { var newElse = elseNode .WithElseKeyword( elseNode.ElseKeyword .WithTrailingTrivia() ) .WithStatement( singleStatementInsideElse .WithLeadingTrivia(SyntaxFactory.Space) //.WithTrailingTrivia(trailingTriviaList) ); if (singleStatementInsideElse is ReturnStatementSyntax returnStatement) { if (returnStatement.Expression == null || returnStatement.Expression is LiteralExpressionSyntax || returnStatement.Expression.Span.Length <= MAX_RETURN_STATEMENT_LENGTH) { return(newElse); } } if (singleStatementInsideElse is IfStatementSyntax == false) { if ( singleStatementInsideElse.WithoutTrivia().DescendantTrivia().Any(t => t.IsKind(SyntaxKind.EndOfLineTrivia)) || singleStatementInsideElse.Span.Length + 5 > MAX_IF_LINE_LENGTH ) { return(elseNode.WithStatement(singleStatementInsideElse)); } } return(newElse); }
private SyntaxNode GetNewElseNode(ElseClauseSyntax elseClause) { return(elseClause.WithStatement(SyntaxFactory.Block(elseClause.Statement))); }
private SyntaxNode GetNewElseNode(ElseClauseSyntax elseClause) { return elseClause.WithStatement(SyntaxFactory.Block(elseClause.Statement)); }