public override async Task <Document> RefactorAsync(Document document, CancellationToken cancellationToken) { IStatementContainer container = StatementContainer.Create(IfStatement); SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(IfStatement); ExpressionSyntax left = Left.WithoutTrivia(); ExpressionSyntax right = Right.WithoutTrivia(); SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); right = AddCastExpressionIfNecessary(right, semanticModel, IfStatement.SpanStart, cancellationToken); StatementSyntax newNode = CreateStatement( CoalesceExpression( left.Parenthesize().WithSimplifierAnnotation(), right.Parenthesize().WithSimplifierAnnotation())); newNode = newNode .WithLeadingTrivia(IfStatement.GetLeadingTrivia()) .WithTrailingTrivia(statements[index + 1].GetTrailingTrivia()) .WithFormatterAnnotation(); SyntaxList <StatementSyntax> newStatements = statements .RemoveAt(index) .ReplaceAt(index, newNode); return(await document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken).ConfigureAwait(false)); }
public static Task <Document> RefactorAsync( Document document, IStatementContainer container, ImmutableArray <IfStatementSyntax> ifStatements, CancellationToken cancellationToken = default(CancellationToken)) { IfStatementSyntax newIfStatement = IfStatement( CreateCondition(ifStatements), Block(CreateStatements(ifStatements))); SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(ifStatements[0]); SyntaxList <StatementSyntax> newStatements = statements.Replace( ifStatements[0], newIfStatement .WithLeadingTrivia(ifStatements[0].GetLeadingTrivia()) .WithTrailingTrivia(ifStatements[ifStatements.Length - 1].GetTrailingTrivia())); for (int i = 1; i < ifStatements.Length; i++) { newStatements = newStatements.RemoveAt(index + 1); } return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
private static Task <Document> RefactorAsync( Document document, IfStatementSyntax ifStatement, ReturnStatementSyntax returnStatement, IStatementContainer container, CancellationToken cancellationToken) { SyntaxList <StatementSyntax> statements = container.Statements; IfStatement ifElse = IfStatement.Create(ifStatement); StatementSyntax statement = returnStatement; if (ifElse.Nodes.Any(f => f.Statement?.IsKind(SyntaxKind.Block) == true)) { statement = SyntaxFactory.Block(statement); } ElseClauseSyntax elseClause = SyntaxFactory.ElseClause(statement).WithFormatterAnnotation(); IfStatementSyntax lastIfStatement = ifElse.Nodes.Last(); IfStatementSyntax newIfStatement = ifStatement.ReplaceNode( lastIfStatement, lastIfStatement.WithElse(elseClause)); SyntaxList <StatementSyntax> newStatements = statements .Replace(ifStatement, newIfStatement) .RemoveAt(statements.IndexOf(returnStatement)); return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
public static Task <Document> RefactorAsync( Document document, ObjectCreationExpressionSyntax objectCreation, SelectedStatementCollection selectedStatements, CancellationToken cancellationToken = default(CancellationToken)) { IStatementContainer container = selectedStatements.Container; ExpressionStatementSyntax[] expressionStatements = selectedStatements .Skip(1) .Cast <ExpressionStatementSyntax>() .ToArray(); StatementSyntax firstNode = selectedStatements.First; SyntaxList <StatementSyntax> newStatements = container.Statements.Replace( firstNode, firstNode.ReplaceNode( objectCreation, objectCreation.WithInitializer(CreateInitializer(objectCreation, expressionStatements)))); int count = expressionStatements.Length; int index = selectedStatements.FirstIndex + 1; while (count > 0) { newStatements = newStatements.RemoveAt(index); count--; } return(document.ReplaceNodeAsync( container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
public static Task <Document> RefactorAsync( Document document, VariableDeclaratorSyntax declarator, CancellationToken cancellationToken) { var declaration = (VariableDeclarationSyntax)declarator.Parent; var localDeclaration = (LocalDeclarationStatementSyntax)declaration.Parent; IStatementContainer container = StatementContainer.Create(localDeclaration); SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(localDeclaration); StatementSyntax nextStatement = statements[index + 1]; var expressionStatement = (ExpressionStatementSyntax)nextStatement; var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression; ExpressionSyntax right = assignment.Right; EqualsValueClauseSyntax initializer = declarator.Initializer; ExpressionSyntax value = initializer?.Value; VariableDeclaratorSyntax newDeclarator = (value != null) ? declarator.ReplaceNode(value, right) : declarator.WithInitializer(EqualsValueClause(right)); LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration.ReplaceNode(declarator, newDeclarator); SyntaxTriviaList trailingTrivia = nextStatement.GetTrailingTrivia(); IEnumerable <SyntaxTrivia> trivia = container .Node .DescendantTrivia(TextSpan.FromBounds(localDeclaration.Span.End, right.SpanStart)); if (!trivia.All(f => f.IsWhitespaceOrEndOfLineTrivia())) { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trivia.Concat(trailingTrivia)); } else { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trailingTrivia); } SyntaxList <StatementSyntax> newStatements = statements .Replace(localDeclaration, newLocalDeclaration) .RemoveAt(index + 1); return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
private static Task <Document> RefactorAsync( Document document, StatementSyntax statement, IfStatementSyntax ifStatement, int statementIndex, IStatementContainer container, ExpressionSyntax expression, CancellationToken cancellationToken) { var expressionStatement = (ExpressionStatementSyntax)ifStatement.GetSingleStatementOrDefault(); var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression; ExpressionSyntax left = expression .WithoutTrailingTrivia() .Parenthesize(moveTrivia: true) .WithSimplifierAnnotation(); ExpressionSyntax right = assignment.Right .WithTrailingTrivia(expression.GetTrailingTrivia()) .Parenthesize(moveTrivia: true) .WithSimplifierAnnotation(); BinaryExpressionSyntax newNode = CSharpFactory.CoalesceExpression(left, right); StatementSyntax newStatement = statement.ReplaceNode(expression, newNode); IEnumerable <SyntaxTrivia> trivia = container.Node.DescendantTrivia(TextSpan.FromBounds(statement.Span.End, ifStatement.Span.End)); if (!trivia.All(f => f.IsWhitespaceOrEndOfLineTrivia())) { newStatement = newStatement.WithTrailingTrivia(trivia); newStatement = newStatement.AppendToTrailingTrivia(ifStatement.GetTrailingTrivia()); } else { newStatement = newStatement.WithTrailingTrivia(ifStatement.GetTrailingTrivia()); } SyntaxList <StatementSyntax> newStatements = container.Statements .Remove(ifStatement) .ReplaceAt(statementIndex, newStatement); return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
public override Task <Document> RefactorAsync( Document document, CancellationToken cancellationToken = default(CancellationToken)) { IStatementContainer container = StatementContainer.Create(IfStatement); SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(IfStatement); TStatement newStatement = CreateNewStatement(); SyntaxList <StatementSyntax> newStatements = statements .RemoveAt(index) .ReplaceAt(index - 1, newStatement); return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
private static Task <Document> RefactorAsync( Document document, IStatementContainer statementContainer, StatementSyntax statement, InitializerExpressionSyntax initializer, ExpressionSyntax expression, CancellationToken cancellationToken) { ExpressionStatementSyntax[] expressions = Refactor(initializer, expression).ToArray(); expressions[expressions.Length - 1] = expressions[expressions.Length - 1] .WithTrailingTrivia(statement.GetTrailingTrivia()); SyntaxList <StatementSyntax> statements = statementContainer.Statements; int index = statements.IndexOf(statement); StatementSyntax newStatement = statement.RemoveNode(initializer, SyntaxRemoveOptions.KeepNoTrivia); SyntaxKind statementKind = statement.Kind(); if (statementKind == SyntaxKind.ExpressionStatement) { var expressionStatement = (ExpressionStatementSyntax)newStatement; newStatement = expressionStatement .WithExpression(expressionStatement.Expression.WithoutTrailingTrivia()); } else if (statementKind == SyntaxKind.LocalDeclarationStatement) { var localDeclaration = (LocalDeclarationStatementSyntax)newStatement; newStatement = localDeclaration .WithDeclaration(localDeclaration.Declaration.WithoutTrailingTrivia()); } SyntaxList <StatementSyntax> newStatements = statements.Replace(statement, newStatement); SyntaxNode newNode = statementContainer .NodeWithStatements(newStatements.InsertRange(index + 1, expressions)) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(statementContainer.Node, newNode, cancellationToken)); }
private static SyntaxNode AddNextIf( IStatementContainer container, IfStatementSyntax ifStatement, IfStatementSyntax newIfStatement, ExpressionSyntax expression) { IfStatementSyntax nextIfStatement = ifStatement.WithCondition(expression) .WithFormatterAnnotation(); SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(ifStatement); SyntaxList <StatementSyntax> newStatements = statements .Replace(ifStatement, newIfStatement) .Insert(index + 1, nextIfStatement); return(container.NodeWithStatements(newStatements)); }
public override Task <Document> RefactorAsync(Document document, CancellationToken cancellationToken = default(CancellationToken)) { IStatementContainer container = StatementContainer.Create(IfStatement); SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(IfStatement); ConditionalExpressionSyntax conditionalExpression = IfRefactoringHelper.CreateConditionalExpression(IfStatement.Condition, Expression1, Expression2); StatementSyntax newStatement = CreateStatement(conditionalExpression) .WithLeadingTrivia(IfStatement.GetLeadingTrivia()) .WithTrailingTrivia(statements[index + 1].GetTrailingTrivia()) .WithFormatterAnnotation(); SyntaxList <StatementSyntax> newStatements = statements .RemoveAt(index) .ReplaceAt(index, newStatement); return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
public Task <Document> RefactorAsync( Document document, SelectedStatementCollection selectedStatements, CancellationToken cancellationToken = default(CancellationToken)) { IStatementContainer container = selectedStatements.Container; StatementSyntax[] statements = selectedStatements.ToArray(); int index = selectedStatements.FirstIndex; SyntaxTriviaList leadingTrivia = statements[0].GetLeadingTrivia(); SyntaxTriviaList trailingTrivia = statements[statements.Length - 1].GetTrailingTrivia(); statements[0] = statements[0].WithLeadingTrivia(); statements[statements.Length - 1] = statements[statements.Length - 1].WithTrailingTrivia(); SyntaxList <StatementSyntax> newStatements = container.Statements; int cnt = statements.Length; while (cnt > 0) { newStatements = newStatements.RemoveAt(index); cnt--; } TStatement statement = CreateStatement(statements.ToImmutableArray()); statement = statement .WithLeadingTrivia(leadingTrivia) .WithTrailingTrivia(trailingTrivia) .WithFormatterAnnotation(); newStatements = newStatements.Insert(index, statement); return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
private static Task <Document> RefactorAsync( Document document, IStatementContainer container, LocalDeclarationStatementSyntax[] localDeclarations, CancellationToken cancellationToken = default(CancellationToken)) { LocalDeclarationStatementSyntax localDeclaration = localDeclarations[0]; SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(localDeclaration); VariableDeclaratorSyntax[] variables = localDeclarations .Skip(1) .Select(f => f.Declaration) .SelectMany(f => f.Variables) .ToArray(); LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration .AddDeclarationVariables(variables) .WithTrailingTrivia(localDeclarations[localDeclarations.Length - 1].GetTrailingTrivia()) .WithFormatterAnnotation(); SyntaxList <StatementSyntax> newStatements = statements.Replace( localDeclaration, newLocalDeclaration); for (int i = 1; i < localDeclarations.Length; i++) { newStatements = newStatements.RemoveAt(index + 1); } return(document.ReplaceNodeAsync( container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
private static Task<Document> RefactorAsync( Document document, ExpressionSyntax expression, SyntaxList<StatementSyntax> statements, IStatementContainer container, int statementIndex, int lastStatementIndex, CancellationToken cancellationToken) { IEnumerable<StatementSyntax> blockStatements = statements .Skip(statementIndex + 1) .Take(lastStatementIndex - statementIndex); IfStatementSyntax ifStatement = CreateNullCheck(expression, List(blockStatements)); if (lastStatementIndex < statements.Count - 1) ifStatement = ifStatement.AppendToTrailingTrivia(NewLineTrivia()); IEnumerable<StatementSyntax> newStatements = statements.Take(statementIndex + 1) .Concat(new IfStatementSyntax[] { ifStatement }) .Concat(statements.Skip(lastStatementIndex + 1)); return document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken); }