/// <summary> /// Recurrent function for removeing bagical number from last statement in given BlockSyntax. /// </summary> /// <param name="oldBlock">BlockSyntax in which a statement is defined</param> /// <param name="root">Root in which a statement was defind orignally</param> /// <returns>New BlockSyntax with removed magical number in a statement</returns> private BlockSyntax RemoveMagicalNumber(BlockSyntax oldBlock, SyntaxNode root) { StatementSyntax node = oldBlock.Statements.Last(); // Find all magical numbers in a statement var numericalNode = node.DescendantNodes() .FirstOrDefault(n => n.IsKind(SyntaxKind.NumericLiteralExpression)); if (numericalNode != null) { var expresion = (LocalDeclarationStatementSyntax)SyntaxFactory .ParseStatement($"var {FindFreeVariableName(root, oldBlock)} = {numericalNode.ToFullString()};") .WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(SyntaxFactory .ParseTrailingTrivia("\n")); return(RemoveMagicalNumber(oldBlock.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia) .AddStatements(expresion) .AddStatements(node.ReplaceNode(numericalNode, SyntaxFactory.IdentifierName(expresion.Declaration .Variables[0] .Identifier))), root)); } else { return(oldBlock); } }
public static async Task <Document> RefactorAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken) { StatementSyntax newStatement = statement .WithLeadingTrivia(statement.GetLeadingTrivia().Insert(0, CSharpFactory.NewLineTrivia())) .WithFormatterAnnotation(); if (statement.IsParentKind(SyntaxKind.Block)) { var block = (BlockSyntax)statement.Parent; if (block.IsSingleLine(includeExteriorTrivia: false)) { SyntaxTriviaList triviaList = block.CloseBraceToken.LeadingTrivia .Add(CSharpFactory.NewLineTrivia()); BlockSyntax newBlock = block .WithCloseBraceToken(block.CloseBraceToken.WithLeadingTrivia(triviaList)) .WithStatements(block.Statements.Replace(statement, newStatement)) .WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(block, newBlock, cancellationToken).ConfigureAwait(false)); } else { return(await document.ReplaceNodeAsync(statement, newStatement, cancellationToken).ConfigureAwait(false)); } } else { return(await document.ReplaceNodeAsync(statement, newStatement, cancellationToken).ConfigureAwait(false)); } }
public static StatementSyntax AddIndention(StatementSyntax statementSyntax, int level) { IEnumerable <SyntaxTrivia> indention = statementSyntax.GetLeadingTrivia().ToList(); indention = AddIndention(level, indention); return(statementSyntax.WithLeadingTrivia(indention)); }
private static UsingStatementSyntax CreateUsingStatement(StatementSyntax statement, BlockSyntax block) { return(SyntaxFactory.UsingStatement(block) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); }
private BlockSyntax ToBlockSyntax(StatementSyntax body, SyntaxTriviaList leading, SyntaxTriviaList trailing) { //TODO: fix trivia var bracketLeadingTrivia = leading.Insert(0, SyntaxFactory.EndOfLine(Environment.NewLine)); List <StatementSyntax> statements = new List <StatementSyntax>(); if (body.Kind() == SyntaxKind.Block) { body = (StatementSyntax)Visit(body); return((BlockSyntax)body); } else { var leadingTrivia = body.GetLeadingTrivia(); body = (StatementSyntax)Visit(body); statements.Add(body); } BlockSyntax block = SyntaxFactory.Block(statements); block = block.WithOpenBraceToken( SyntaxFactory.Token(SyntaxKind.OpenBraceToken) .WithLeadingTrivia(bracketLeadingTrivia) .WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine)) ); block = block.WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken). WithLeadingTrivia(bracketLeadingTrivia). WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine))); return(block); }
private static ExpressionSyntax TryGetExpression(StatementSyntax firstStatement) { if (firstStatement.Kind() == SyntaxKind.ExpressionStatement) { return ((ExpressionStatementSyntax)firstStatement).Expression; } else if (firstStatement.Kind() == SyntaxKind.ReturnStatement) { var returnStatement = (ReturnStatementSyntax)firstStatement; if (returnStatement.Expression != null) { // If there are any comments on the return keyword, move them to // the expression. return firstStatement.GetLeadingTrivia().Any(t => t.IsSingleOrMultiLineComment()) ? returnStatement.Expression.WithLeadingTrivia(returnStatement.GetLeadingTrivia()) : returnStatement.Expression; } } else if (firstStatement.Kind() == SyntaxKind.ThrowStatement) { var throwStatement = (ThrowStatementSyntax)firstStatement; if (throwStatement.Expression != null) { return SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression); } } return null; }
private static ExpressionSyntax TryGetExpression(StatementSyntax firstStatement) { if (firstStatement.Kind() == SyntaxKind.ExpressionStatement) { return(((ExpressionStatementSyntax)firstStatement).Expression); } else if (firstStatement.Kind() == SyntaxKind.ReturnStatement) { var returnStatement = (ReturnStatementSyntax)firstStatement; if (returnStatement.Expression != null) { // If there are any comments on the return keyword, move them to // the expression. return(firstStatement.GetLeadingTrivia().Any(t => t.IsSingleOrMultiLineComment()) ? returnStatement.Expression.WithLeadingTrivia(returnStatement.GetLeadingTrivia()) : returnStatement.Expression); } } else if (firstStatement.Kind() == SyntaxKind.ThrowStatement) { var throwStatement = (ThrowStatementSyntax)firstStatement; if (throwStatement.Expression != null) { return(SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression)); } } return(null); }
private static void AnalyzeElseClause(SyntaxNodeAnalysisContext context) { var elseClause = (ElseClauseSyntax)context.Node; StatementSyntax statement = elseClause.Statement; if (!statement.IsKind(SyntaxKind.IfStatement)) { return; } SyntaxTriviaList trailingTrivia = elseClause.ElseKeyword.TrailingTrivia; if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(trailingTrivia)) { return; } if (!statement.GetLeadingTrivia().IsEmptyOrWhitespace()) { return; } DiagnosticHelpers.ReportDiagnostic( context, DiagnosticDescriptors.RemoveNewLineBetweenIfKeywordAndElseKeyword, Location.Create(elseClause.SyntaxTree, new TextSpan(trailingTrivia.Last().SpanStart, 0))); }
private static bool TryGetExpression(StatementSyntax firstStatement, LanguageVersion languageVersion, [NotNullWhen(true)] out ExpressionSyntax?expression, out SyntaxToken semicolonToken) { if (firstStatement is ExpressionStatementSyntax exprStatement) { expression = exprStatement.Expression; semicolonToken = exprStatement.SemicolonToken; return(true); } else if (firstStatement is ReturnStatementSyntax returnStatement) { if (returnStatement.Expression != null) { // If there are any comments or directives on the return keyword, move them to // the expression. expression = firstStatement.GetLeadingTrivia().Any(t => t.IsDirective || t.IsSingleOrMultiLineComment()) ? returnStatement.Expression.WithLeadingTrivia(returnStatement.GetLeadingTrivia()) : returnStatement.Expression; semicolonToken = returnStatement.SemicolonToken; return(true); } } else if (firstStatement is ThrowStatementSyntax throwStatement) { if (languageVersion >= LanguageVersion.CSharp7 && throwStatement.Expression != null) { expression = SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression); semicolonToken = throwStatement.SemicolonToken; return(true); } } expression = null; semicolonToken = default; return(false); }
public static Task <Document> RemoveRedundantAssignmentAfterLocalDeclarationAsync( Document document, VariableDeclaratorSyntax declarator, CancellationToken cancellationToken = default) { var declaration = (VariableDeclarationSyntax)declarator.Parent; var localDeclaration = (LocalDeclarationStatementSyntax)declaration.Parent; StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(localDeclaration); SyntaxList <StatementSyntax> statements = statementsInfo.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 = localDeclaration.GetTrailingTrivia(); if (!trailingTrivia.IsEmptyOrWhitespace()) { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trailingTrivia.Concat(nextStatement.GetTrailingTrivia())); } else { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(nextStatement.GetTrailingTrivia()); } SyntaxTriviaList leadingTrivia = nextStatement.GetLeadingTrivia(); if (!leadingTrivia.IsEmptyOrWhitespace()) { newLocalDeclaration = newLocalDeclaration.WithLeadingTrivia(newLocalDeclaration.GetLeadingTrivia().Concat(leadingTrivia)); } SyntaxList <StatementSyntax> newStatements = statements .Replace(localDeclaration, newLocalDeclaration) .RemoveAt(index + 1); return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); }
public static Task <Document> RefactorAsync( Document document, VariableDeclaratorSyntax declarator, CancellationToken cancellationToken) { var declaration = (VariableDeclarationSyntax)declarator.Parent; var localDeclaration = (LocalDeclarationStatementSyntax)declaration.Parent; StatementContainer 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 = localDeclaration.GetTrailingTrivia(); if (trailingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia())) { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trailingTrivia.Concat(nextStatement.GetTrailingTrivia())); } else { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(nextStatement.GetTrailingTrivia()); } SyntaxTriviaList leadingTrivia = nextStatement.GetLeadingTrivia(); if (leadingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia())) { newLocalDeclaration = newLocalDeclaration.WithLeadingTrivia(newLocalDeclaration.GetLeadingTrivia().Concat(leadingTrivia)); } SyntaxList <StatementSyntax> newStatements = statements .Replace(localDeclaration, newLocalDeclaration) .RemoveAt(index + 1); return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
private static BlockSyntax CreateNewBlockParent(StatementSyntax statement, SemanticModel semanticModel, ObjectCreationExpressionSyntax objectCreationExpression, ISymbol variableSymbol) { var blockParent = statement.FirstAncestorOrSelf <BlockSyntax>(); var assignmentExpressions = ObjectInitializerAnalyzer.FindAssingmentExpressions(semanticModel, statement, variableSymbol); var newBlockParent = SyntaxFactory.Block() .WithLeadingTrivia(blockParent.GetLeadingTrivia()) .WithTrailingTrivia(blockParent.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newAssignmentExpressions = new List <ExpressionStatementSyntax>(); for (int i = 0; i < blockParent.Statements.Count; i++) { var blockStatement = blockParent.Statements[i]; if (blockStatement.Equals(statement)) { var initializationExpressions = new List <AssignmentExpressionSyntax>(); foreach (var expressionStatement in assignmentExpressions) { var assignmentExpression = expressionStatement.Expression as AssignmentExpressionSyntax; var memberAccess = assignmentExpression.Left as MemberAccessExpressionSyntax; var propertyIdentifier = memberAccess.Name as IdentifierNameSyntax; initializationExpressions.Add(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, propertyIdentifier, assignmentExpression.Right)); } var initializers = SyntaxFactory.SeparatedList <ExpressionSyntax>(initializationExpressions); var newObjectCreationExpression = objectCreationExpression.WithInitializer( SyntaxFactory.InitializerExpression( SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.OpenBraceToken, SyntaxFactory.ParseTrailingTrivia("\n")), initializers, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.CloseBraceToken, SyntaxFactory.ParseTrailingTrivia("")) )) .WithLeadingTrivia(objectCreationExpression.GetLeadingTrivia()) .WithTrailingTrivia(objectCreationExpression.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newLocalDeclarationStatement = statement.ReplaceNode(objectCreationExpression, newObjectCreationExpression) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); newBlockParent = newBlockParent.AddStatements(newLocalDeclarationStatement); i += initializationExpressions.Count; } else { newBlockParent = newBlockParent.AddStatements(blockStatement .WithLeadingTrivia(blockStatement.GetLeadingTrivia()) .WithTrailingTrivia(blockStatement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); } } return(newBlockParent); }
public static async Task <Solution> Replace(CodeRefactoringContext context, LocalDeclarationStatementSyntax localDeclarationStatement, StatementSyntax oldStatement) { var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); var localStatementWithTrivia = localDeclarationStatement .WithLeadingTrivia(oldStatement.GetLeadingTrivia()) .WithTrailingTrivia(oldStatement.GetTrailingTrivia()); var block = oldStatement.AncestorsAndSelf().OfType <BlockSyntax>().First(); var newRoot = root.ReplaceNode(block, block.ReplaceNode(oldStatement, localStatementWithTrivia)); var newDocument = context.Document.WithSyntaxRoot(newRoot); return(await LocalVariableRenamer.RenameVariable(newDocument, context)); }
private static async Task <Document> RefactorAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement); var methodDeclaration = (MethodDeclarationSyntax)statementsInfo.Parent.Parent; SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); string name = methodDeclaration.Identifier.ValueText; if (!name.EndsWith("Iterator", StringComparison.Ordinal)) { name += "Iterator"; } name = NameGenerator.Default.EnsureUniqueLocalName(name, semanticModel, statement.SpanStart, cancellationToken: cancellationToken); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(statement); List <StatementSyntax> localFunctionStatements = statements.Skip(index).ToList(); int lastIndex = localFunctionStatements.Count - 1; localFunctionStatements[lastIndex] = localFunctionStatements[lastIndex].WithoutTrailingTrivia(); LocalFunctionStatementSyntax localFunction = LocalFunctionStatement( default(SyntaxTokenList), methodDeclaration.ReturnType.WithoutTrivia(), Identifier(name).WithRenameAnnotation(), ParameterList(), Block(localFunctionStatements).WithTrailingTrivia(statements.Last().GetTrailingTrivia())); localFunction = localFunction.WithFormatterAnnotation(); ReturnStatementSyntax returnStatement = ReturnStatement( Token(SyntaxKind.ReturnKeyword).WithLeadingTrivia(statement.GetLeadingTrivia()), InvocationExpression(IdentifierName(name)), SemicolonToken()); SyntaxList <StatementSyntax> newStatements = statements.ReplaceRange( index, statements.Count - index, new StatementSyntax[] { returnStatement, localFunction }); return(await document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken).ConfigureAwait(false)); }
private static SyntaxNode ProcessTemplates(List <AopTemplate> templates, StatementSyntax node, ClassDeclarationSyntax classDeclaration) { SyntaxNode result = node; string startingWhitespace = ""; if (node.HasLeadingTrivia) { startingWhitespace = node.GetLeadingTrivia().ToFullString(); } string closingWhitespace = ""; if (node.HasTrailingTrivia) { closingWhitespace = node.GetTrailingTrivia().ToFullString(); } var aopCsharpTemplateService = new AopCsharpTemplateService(); foreach (AopTemplate template in templates.OrderBy(o => o.AdvicePriority)) { Console.Out.WriteLine($"\tProcessing template {template.TemplateName}"); string sourceCode = aopCsharpTemplateService.ProcessTemplate(template.TemplateName, new Dictionary <string, object>() { { "ClassNode", classDeclaration }, { "MethodNode", result is MethodDeclarationSyntax ? result : null }, { "PropertyNode", result is PropertyDeclarationSyntax ? result : null }, { "StatementNode", result is StatementSyntax ? result : null }, { "ExtraTag", template.ExtraTag } }); // if sourceCode is null, it means no changes were done to original code and we keep it as-is if (sourceCode == null) { continue; } sourceCode = sourceCode.Trim(' ', '\r', '\n'); if (!Regex.IsMatch(sourceCode, "^\\s*\\{.*\\}\\s*$", RegexOptions.Singleline)) { sourceCode = (new StringBuilder()).AppendLine("{").AppendLine(sourceCode).AppendLine(startingWhitespace + "}").ToString(); } result = SyntaxFactory.ParseStatement(startingWhitespace + sourceCode + closingWhitespace); } return(result); }
public static StatementSyntax InsertLeadingEndOfLine(this StatementSyntax statement) { var leadingTrivia = statement.GetLeadingTrivia(); if (leadingTrivia.Count > 0 && leadingTrivia[0].IsKind(SyntaxKind.EndOfLineTrivia)) { return(statement); } else { leadingTrivia = leadingTrivia.Insert(0, SyntaxFactory.EndOfLine(Environment.NewLine)); return(statement.WithLeadingTrivia(leadingTrivia)); } }
private async Task <Document> AddNewLineBefore( Document document, StatementSyntax statement, CancellationToken cancellationToken) { var leadingTriviaWithEOL = statement.GetLeadingTrivia().Insert(0, SyntaxFactory.EndOfLine(Environment.NewLine)); var newStatement = statement.WithLeadingTrivia(leadingTriviaWithEOL); var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); root = root.ReplaceNode(statement, newStatement); return(document.WithSyntaxRoot(root)); }
private static SyntaxRemoveOptions GetRemoveOptions(StatementSyntax statement) { SyntaxRemoveOptions removeOptions = Remover.DefaultMemberRemoveOptions; if (statement.GetLeadingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia())) { removeOptions &= ~SyntaxRemoveOptions.KeepLeadingTrivia; } if (statement.GetTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia())) { removeOptions &= ~SyntaxRemoveOptions.KeepTrailingTrivia; } return(removeOptions); }
public static Task <Document> RefactorAsync( Document document, UnsafeStatementSyntax unsafeStatement, SyntaxNode containingNode, CancellationToken cancellationToken) { SyntaxToken keyword = unsafeStatement.UnsafeKeyword; BlockSyntax block = unsafeStatement.Block; SyntaxList <StatementSyntax> statements = block.Statements; SyntaxNode newNode = null; int count = statements.Count; if (count == 0) { newNode = containingNode.RemoveNode(unsafeStatement); } else { StatementSyntax first = statements.First(); StatementSyntax last = statements.Last(); SyntaxTriviaList leadingTrivia = keyword.LeadingTrivia .AddRange(keyword.TrailingTrivia.EmptyIfWhitespace()) .AddRange(block.GetLeadingTrivia().EmptyIfWhitespace()) .AddRange(block.OpenBraceToken.TrailingTrivia.EmptyIfWhitespace()) .AddRange(first.GetLeadingTrivia().EmptyIfWhitespace()); SyntaxTriviaList trailingTrivia = last.GetTrailingTrivia().EmptyIfWhitespace() .AddRange(block.CloseBraceToken.LeadingTrivia.EmptyIfWhitespace()) .AddRange(block.GetTrailingTrivia()); statements = statements .ReplaceAt(0, first.WithLeadingTrivia(leadingTrivia)) .ReplaceAt(count - 1, last.WithTrailingTrivia(trailingTrivia)); newNode = containingNode.ReplaceNode(unsafeStatement, statements.Select(f => f.WithFormatterAnnotation())); } newNode = newNode.InsertModifier(SyntaxKind.UnsafeKeyword); return(document.ReplaceNodeAsync(containingNode, newNode, cancellationToken)); }
private async Task <Document> ReplaceBinaryAnd(Document document, InvocationExpressionSyntax invocationExpression, bool isIsTrue, SyntaxKind kind, CancellationToken cancellationToken) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken); ArgumentListSyntax arguments = invocationExpression.ArgumentList; BinaryExpressionSyntax expr = (BinaryExpressionSyntax)arguments.Arguments[0].Expression; var left = expr.Left; var right = expr.Right; ArgumentSyntax[] additionalArguments = arguments.Arguments.Skip(1).ToArray(); var leftAssert = CreateAssert(left, isIsTrue, additionalArguments); var rightAssert = CreateAssert(right, isIsTrue, additionalArguments); SyntaxNode node = invocationExpression; BlockSyntax parentBlock = null; while (parentBlock == null && node != null) { parentBlock = node.Parent as BlockSyntax; node = node.Parent; } int statementIndex = parentBlock.Statements.IndexOf(x => x.Contains(invocationExpression)); StatementSyntax statement = parentBlock.Statements[statementIndex]; var leadingTrivia = statement.GetLeadingTrivia(); var trailingTrivia = statement.GetTrailingTrivia(); var statements = parentBlock.Statements.Insert(statementIndex, rightAssert.WithLeadingTrivia().WithTrailingTrivia(trailingTrivia)); statements = statements.Insert(statementIndex, leftAssert.WithLeadingTrivia(leadingTrivia)); statements = statements.RemoveAt(statementIndex + 2); var newBlock = parentBlock.WithStatements(statements); root = root.ReplaceNode(parentBlock, newBlock); return(document.WithSyntaxRoot(root)); }
StatementSyntax ApplyNodeChange(StatementSyntax statementNode) { var isCleanupDone = false; var leadingTriviaList = statementNode.GetLeadingTrivia(); if (statementNode.IsKind(SyntaxKind.EmptyStatement)) // remove unused semicolons { return(null); } if (_lastTokenIsACloseBrace) { if (CheckOption((int)CleanupTypes.Adding_Blank_After_Block_Close_Bracket)) { if (leadingTriviaList.Count(x => x.IsKind(SyntaxKind.EndOfLineTrivia)) < 2) { leadingTriviaList = CleanUpListWithExactNumberOfWhiteSpaces(leadingTriviaList, 1, null); isCleanupDone = true; } } else if (CheckOption((int)CleanupTypes.RemoveDuplicateBetweenMethodsStatements)) { leadingTriviaList = CleanUpListWithDefaultWhiteSpaces(leadingTriviaList, null); isCleanupDone = true; } } else if (CheckOption((int)CleanupTypes.RemoveDuplicateBetweenMethodsStatements)) { leadingTriviaList = CleanUpListWithDefaultWhiteSpaces(leadingTriviaList, null); isCleanupDone = true; } if (!isCleanupDone) { leadingTriviaList = ProcessSpecialTrivias(leadingTriviaList, false); } statementNode = statementNode.WithLeadingTrivia(leadingTriviaList); // _LastMember = null; return(statementNode); }
private static async Task <Document> DuplicateStatementAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken = default(CancellationToken)) { var block = (BlockSyntax)statement.Parent; int index = block.Statements.IndexOf(statement); if (index == 0 && block.OpenBraceToken.GetFullSpanEndLine() == statement.GetFullSpanStartLine()) { statement = statement.WithLeadingTrivia(statement.GetLeadingTrivia().Insert(0, CSharpFactory.NewLineTrivia())); } BlockSyntax newBlock = block.WithStatements(block.Statements.Insert(index + 1, statement)); return(await document.ReplaceNodeAsync(block, newBlock, cancellationToken).ConfigureAwait(false)); }
private static IEnumerable <StatementSyntax> GetNewNodes(StatementSyntax statement) { List <SyntaxTrivia> list; if (statement.IsParentKind(SyntaxKind.ElseClause)) { list = new List <SyntaxTrivia>() { CSharpFactory.NewLine() }; } else { list = statement.Parent.GetLeadingTrivia() .Reverse() .SkipWhile(f => f.IsWhitespaceTrivia()) .Reverse() .ToList(); } if (statement.IsKind(SyntaxKind.Block)) { SyntaxList <StatementSyntax> .Enumerator en = ((BlockSyntax)statement).Statements.GetEnumerator(); if (en.MoveNext()) { list.AddRange(en.Current.GetLeadingTrivia()); yield return(en.Current.WithLeadingTrivia(list)); while (en.MoveNext()) { yield return(en.Current); } } } else { list.AddRange(statement.GetLeadingTrivia()); yield return(statement.WithLeadingTrivia(list)); } }
public static Task <Document> RefactorAsync( Document document, UnsafeStatementSyntax unsafeStatement, CancellationToken cancellationToken) { SyntaxToken keyword = unsafeStatement.UnsafeKeyword; BlockSyntax block = unsafeStatement.Block; SyntaxToken openBrace = block.OpenBraceToken; SyntaxToken closeBrace = block.CloseBraceToken; SyntaxList <StatementSyntax> statements = block.Statements; StatementSyntax firstStatement = statements.First(); IEnumerable <SyntaxTrivia> leadingTrivia = keyword .TrailingTrivia.EmptyIfWhitespace() .Concat(openBrace.LeadingTrivia.EmptyIfWhitespace()) .Concat(openBrace.TrailingTrivia.EmptyIfWhitespace()) .Concat(firstStatement.GetLeadingTrivia().EmptyIfWhitespace()); leadingTrivia = keyword.LeadingTrivia.AddRange(leadingTrivia); statements = statements.ReplaceAt(0, firstStatement.WithLeadingTrivia(leadingTrivia)); StatementSyntax lastStatement = statements.Last(); IEnumerable <SyntaxTrivia> trailingTrivia = lastStatement .GetTrailingTrivia().EmptyIfWhitespace() .Concat(closeBrace.LeadingTrivia.EmptyIfWhitespace()) .Concat(closeBrace.TrailingTrivia.EmptyIfWhitespace()); trailingTrivia = closeBrace.TrailingTrivia.InsertRange(0, trailingTrivia); statements = statements.ReplaceAt(statements.Count - 1, lastStatement.WithTrailingTrivia(trailingTrivia)); return(document.ReplaceNodeAsync(unsafeStatement, statements, cancellationToken)); }
public static async Task <Document> RefactorAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken); StatementSyntax newStatement = statement .WithLeadingTrivia(statement.GetLeadingTrivia().Insert(0, SyntaxHelper.NewLine)) .WithAdditionalAnnotations(Formatter.Annotation); if (statement.Parent.IsKind(SyntaxKind.Block)) { var block = (BlockSyntax)statement.Parent; if (block.IsSingleline(includeExteriorTrivia: false)) { SyntaxTriviaList triviaList = block.CloseBraceToken.LeadingTrivia .Add(SyntaxHelper.NewLine); BlockSyntax newBlock = block .WithCloseBraceToken(block.CloseBraceToken.WithLeadingTrivia(triviaList)) .WithStatements(block.Statements.Replace(statement, newStatement)) .WithAdditionalAnnotations(Formatter.Annotation); root = root.ReplaceNode(block, newBlock); } else { root = root.ReplaceNode(statement, newStatement); } } else { root = root.ReplaceNode(statement, newStatement); } return(document.WithSyntaxRoot(root)); }
StatementSyntax ApplyNodeChange(StatementSyntax statementNode) { var triviList = statementNode.GetLeadingTrivia(); var zeroCondition = _lastTokenIsAOpenBrace || _lastToken == default(SyntaxToken); if (zeroCondition) { triviList = CleanUpListWithExactNumberOfWhitespaces(triviList, 0); } else if (_lastTokenIsACloseBrace) { triviList = CleanUpListWithExactNumberOfWhitespaces(triviList, 1, itsForCloseBrace: false); } else { triviList = CleanUpListWithDefaultWhitespaces(triviList); } statementNode = statementNode.WithLeadingTrivia(triviList); return(statementNode); }
public static StatementSyntax Trivia(this StatementSyntax node, StatementSyntax that) { return node.WithLeadingTrivia(that.GetLeadingTrivia()).WithTrailingTrivia(that.GetTrailingTrivia()); }
public static void AnalyzerSwitchSection(SyntaxNodeAnalysisContext context) { var switchSection = (SwitchSectionSyntax)context.Node; if (!(switchSection.Statements.SingleOrDefault(shouldThrow: false) is BlockSyntax block)) { return; } SyntaxList <StatementSyntax> statements = block.Statements; StatementSyntax firstStatement = statements.FirstOrDefault(); if (firstStatement == null) { return; } SyntaxToken openBrace = block.OpenBraceToken; if (!AnalyzeTrivia(openBrace.LeadingTrivia)) { return; } if (!AnalyzeTrivia(openBrace.TrailingTrivia)) { return; } if (!AnalyzeTrivia(firstStatement.GetLeadingTrivia())) { return; } StatementSyntax lastStatement = statements.Last(); if (!AnalyzeTrivia(lastStatement.GetTrailingTrivia())) { return; } SyntaxToken closeBrace = block.CloseBraceToken; if (!AnalyzeTrivia(closeBrace.LeadingTrivia)) { return; } if (!AnalyzeTrivia(closeBrace.TrailingTrivia)) { return; } DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.RemoveUnnecessaryBraces, openBrace); DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.RemoveUnnecessaryBracesFadeOut, closeBrace); bool AnalyzeTrivia(SyntaxTriviaList trivia) { return(trivia.All(f => f.IsKind(SyntaxKind.WhitespaceTrivia, SyntaxKind.EndOfLineTrivia, SyntaxKind.SingleLineCommentTrivia))); } }
private static UsingStatementSyntax CreateUsingStatement(StatementSyntax statement, BlockSyntax block) { return SyntaxFactory.UsingStatement(block) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); }
public static StatementSyntax WithoutLeadingBlankLinesInTrivia(this StatementSyntax statement) => statement.WithLeadingTrivia(statement.GetLeadingTrivia().WithoutLeadingBlankLines());
private static async Task <Document> RefactorAsync( Document document, StringConcatenationExpression concatenation, StatementSyntax statement, CancellationToken cancellationToken) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); string name = NameGenerator.Default.EnsureUniqueLocalName(DefaultNames.StringBuilderVariable, semanticModel, statement.SpanStart, cancellationToken: cancellationToken); IdentifierNameSyntax stringBuilderName = IdentifierName(name); TypeSyntax type = semanticModel.GetTypeByMetadataName(MetadataNames.System_Text_StringBuilder).ToMinimalTypeSyntax(semanticModel, statement.SpanStart); var statements = new List <StatementSyntax>() { LocalDeclarationStatement(VarType(), Identifier(name).WithRenameAnnotation(), ObjectCreationExpression(type, ArgumentList())).WithLeadingTrivia(statement.GetLeadingTrivia()) }; ImmutableArray <ExpressionSyntax> expressions = concatenation.Expressions; ExpressionSyntax newInvocation = null; for (int i = 0; i < expressions.Length; i++) { if (expressions[i].IsKind(SyntaxKind.InterpolatedStringExpression)) { var interpolatedString = (InterpolatedStringExpressionSyntax)expressions[i]; bool isVerbatim = interpolatedString.IsVerbatim(); SyntaxList <InterpolatedStringContentSyntax> contents = interpolatedString.Contents; for (int j = 0; j < contents.Count; j++) { InterpolatedStringContentConversion conversion = InterpolatedStringContentConversion.Create(contents[j], isVerbatim); newInvocation = SimpleMemberInvocationExpression( newInvocation ?? stringBuilderName, IdentifierName(conversion.Name), ArgumentList(conversion.Arguments)); } } else { newInvocation = SimpleMemberInvocationExpression( newInvocation ?? stringBuilderName, IdentifierName("Append"), Argument(expressions[i].WithoutTrivia())); } } statements.Add(ExpressionStatement(newInvocation)); statements.Add(statement .ReplaceNode(concatenation.OriginalExpression, SimpleMemberInvocationExpression(stringBuilderName, IdentifierName("ToString"))) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithoutLeadingTrivia()); if (EmbeddedStatementHelper.IsEmbeddedStatement(statement)) { BlockSyntax block = Block(statements).WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(statement, block, cancellationToken).ConfigureAwait(false)); } else { for (int i = 0; i < statements.Count; i++) { statements[i] = statements[i].WithFormatterAnnotation(); } return(await document.ReplaceNodeAsync(statement, statements, cancellationToken).ConfigureAwait(false)); } }
private static BlockSyntax CreateNewBlockParent(StatementSyntax statement, SemanticModel semanticModel, ObjectCreationExpressionSyntax objectCreationExpression, ISymbol variableSymbol) { var blockParent = statement.FirstAncestorOrSelf<BlockSyntax>(); var assignmentExpressions = ObjectInitializerAnalyzer.FindAssignmentExpressions(semanticModel, statement, variableSymbol); var newBlockParent = SyntaxFactory.Block() .WithLeadingTrivia(blockParent.GetLeadingTrivia()) .WithTrailingTrivia(blockParent.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newAssignmentExpressions = new List<ExpressionStatementSyntax>(); for (int i = 0; i < blockParent.Statements.Count; i++) { var blockStatement = blockParent.Statements[i]; if (blockStatement.Equals(statement)) { var initializationExpressions = new List<AssignmentExpressionSyntax>(); foreach (var expressionStatement in assignmentExpressions) { var assignmentExpression = expressionStatement.Expression as AssignmentExpressionSyntax; var memberAccess = assignmentExpression.Left as MemberAccessExpressionSyntax; var propertyIdentifier = memberAccess.Name as IdentifierNameSyntax; initializationExpressions.Add(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, propertyIdentifier, assignmentExpression.Right)); } var initializers = SyntaxFactory.SeparatedList<ExpressionSyntax>(initializationExpressions); var newObjectCreationExpression = objectCreationExpression.WithInitializer( SyntaxFactory.InitializerExpression( SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.OpenBraceToken, SyntaxFactory.ParseTrailingTrivia("\n")), initializers, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.CloseBraceToken, SyntaxFactory.ParseTrailingTrivia("")) )) .WithLeadingTrivia(objectCreationExpression.GetLeadingTrivia()) .WithTrailingTrivia(objectCreationExpression.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newLocalDeclarationStatement = statement.ReplaceNode(objectCreationExpression, newObjectCreationExpression) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); newBlockParent = newBlockParent.AddStatements(newLocalDeclarationStatement); i += initializationExpressions.Count; } else { newBlockParent = newBlockParent.AddStatements(blockStatement .WithLeadingTrivia(blockStatement.GetLeadingTrivia()) .WithTrailingTrivia(blockStatement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); } } return newBlockParent; }
/// <summary> /// Applies whitespace trivia and new line trivia from another statement syntax to this one. /// </summary> /// <param name="statement">The StatementSyntax to update.</param> /// <param name="otherStatement">The StatementSyntax to copy trivia from.</param> /// <returns>The original statement syntax updated with the other statement syntax's whitespace and new line trivia.</returns> public static StatementSyntax WithWhitespaceTriviaFrom(this StatementSyntax statement, StatementSyntax otherStatement) => statement .WithLeadingTrivia(otherStatement?.GetLeadingTrivia().Where(t => t.IsKind(SyntaxKind.EndOfLineTrivia) || t.IsKind(SyntaxKind.WhitespaceTrivia)) ?? SyntaxTriviaList.Empty) .WithTrailingTrivia(otherStatement?.GetTrailingTrivia().Where(t => t.IsKind(SyntaxKind.EndOfLineTrivia) || t.IsKind(SyntaxKind.WhitespaceTrivia)) ?? SyntaxTriviaList.Empty);
private static BlockSyntax CreateNewBlockParent(StatementSyntax statement, SemanticModel semanticModel, ObjectCreationExpressionSyntax objectCreationExpression, ISymbol variableSymbol) { var blockParent = statement.FirstAncestorOrSelf<BlockSyntax>(); var assignmentExpressions = ObjectInitializerAnalyzer.FindAssignmentExpressions(semanticModel, statement, variableSymbol); var newBlockParent = SyntaxFactory.Block() .WithLeadingTrivia(blockParent.GetLeadingTrivia()) .WithTrailingTrivia(blockParent.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); for (int i = 0; i < blockParent.Statements.Count; i++) { var blockStatement = blockParent.Statements[i]; if (blockStatement.Equals(statement)) { var initializationExpressions = new List<AssignmentExpressionSyntax>(); foreach (var expressionStatement in assignmentExpressions) { var assignmentExpression = expressionStatement.Expression as AssignmentExpressionSyntax; var memberAccess = assignmentExpression.Left as MemberAccessExpressionSyntax; var propertyIdentifier = memberAccess.Name as IdentifierNameSyntax; var newAssignmentExpression = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, propertyIdentifier, assignmentExpression.Right); initializationExpressions.Add(newAssignmentExpression); } if (objectCreationExpression.Initializer != null) { var existentInitilizers = objectCreationExpression.Initializer.Expressions.Cast<AssignmentExpressionSyntax>() .Where(ae => { var propertyIdentifier = ae.Left.ToFullString().Trim(); return initializationExpressions.All(ie => ie.Left.ToFullString().Trim() != propertyIdentifier); }) .Select(ae => ae.WithoutTrivia()) .ToList(); initializationExpressions.InsertRange(0, existentInitilizers); } var initializers = SyntaxFactory.SeparatedList<ExpressionSyntax>(initializationExpressions); var newObjectCreationExpression = objectCreationExpression.WithInitializer( SyntaxFactory.InitializerExpression( SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.OpenBraceToken, SyntaxFactory.ParseTrailingTrivia(Environment.NewLine)), initializers, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.CloseBraceToken, SyntaxFactory.ParseTrailingTrivia("")) )) .WithLeadingTrivia(objectCreationExpression.GetLeadingTrivia()) .WithTrailingTrivia(objectCreationExpression.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); if (newObjectCreationExpression.ArgumentList?.Arguments.Count == 0) { newObjectCreationExpression = newObjectCreationExpression.WithArgumentList(null); } var newLocalDeclarationStatement = statement.ReplaceNode(objectCreationExpression, newObjectCreationExpression) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); newBlockParent = newBlockParent.AddStatements(newLocalDeclarationStatement); i += initializationExpressions.Count; } else { newBlockParent = newBlockParent.AddStatements(blockStatement .WithLeadingTrivia(blockStatement.GetLeadingTrivia()) .WithTrailingTrivia(blockStatement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); } } return newBlockParent; }
private static BlockSyntax CreateNewBlockParent(StatementSyntax statement, SemanticModel semanticModel, ObjectCreationExpressionSyntax objectCreationExpression, ISymbol variableSymbol) { var blockParent = statement.FirstAncestorOrSelf<BlockSyntax>(); var assignmentExpressions = ObjectInitializerAnalyzer.FindAssignmentExpressions(semanticModel, statement, variableSymbol); var newBlockParent = SyntaxFactory.Block() .WithLeadingTrivia(blockParent.GetLeadingTrivia()) .WithTrailingTrivia(blockParent.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); for (int i = 0; i < blockParent.Statements.Count; i++) { var blockStatement = blockParent.Statements[i]; if (blockStatement.Equals(statement)) { var initializationExpressions = new List<AssignmentExpressionSyntax>(); foreach (var expressionStatement in assignmentExpressions) { var assignmentExpression = expressionStatement.Expression as AssignmentExpressionSyntax; var memberAccess = assignmentExpression.Left as MemberAccessExpressionSyntax; var propertyIdentifier = memberAccess.Name as IdentifierNameSyntax; var newAssignmentExpression = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, propertyIdentifier, assignmentExpression.Right); initializationExpressions.Add(newAssignmentExpression.WithTriviaFrom(expressionStatement)); } if (objectCreationExpression.Initializer != null) { var existentInitilizers = objectCreationExpression.Initializer.Expressions.Cast<AssignmentExpressionSyntax>() .Where(ae => { var propertyIdentifier = ae.Left.ToFullString().Trim(); return initializationExpressions.All(ie => ie.Left.ToFullString().Trim() != propertyIdentifier); }) .Select(ae => ae.WithoutTrivia()) .ToList(); initializationExpressions.InsertRange(0, existentInitilizers); } // Trailing trivia will be added before the separator if a simple separator list is used. This builds the separator token for expression // such that the trailing trivia from the original expression is added after the comma on the same line. var initializerSeparators = initializationExpressions.Take(initializationExpressions.Count - 1).Select(expr => SyntaxFactory.Token(SyntaxKind.CommaToken).WithTrailingTrivia(expr.GetTrailingTrivia())).ToList(); var lastInitializer = initializationExpressions.Last(); // Preserve the last initializer before rebuilding the list. // Get all but the last initializer without the trailing trivia. Trivia will be added after the separator from the list above. initializationExpressions = initializationExpressions.Take(initializationExpressions.Count - 1).Select(expr => expr.WithoutTrailingTrivia()).ToList(); initializationExpressions.Add(lastInitializer); // Add the last initializer with all of its trivia. var initializers = SyntaxFactory.SeparatedList<ExpressionSyntax>(initializationExpressions, initializerSeparators); var newObjectCreationExpression = objectCreationExpression.WithInitializer( SyntaxFactory.InitializerExpression( SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.OpenBraceToken, SyntaxFactory.ParseTrailingTrivia(Environment.NewLine)), initializers, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.CloseBraceToken, SyntaxFactory.ParseTrailingTrivia("")) )) .WithLeadingTrivia(objectCreationExpression.GetLeadingTrivia()) .WithTrailingTrivia(objectCreationExpression.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); if (newObjectCreationExpression.ArgumentList?.Arguments.Count == 0) { newObjectCreationExpression = newObjectCreationExpression.WithArgumentList(null); } var newLocalDeclarationStatement = statement.ReplaceNode(objectCreationExpression, newObjectCreationExpression) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); newBlockParent = newBlockParent.AddStatements(newLocalDeclarationStatement); i += initializationExpressions.Count; } else { newBlockParent = newBlockParent.AddStatements(blockStatement .WithLeadingTrivia(blockStatement.GetLeadingTrivia()) .WithTrailingTrivia(blockStatement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); } } return newBlockParent; }
private static async Task <StatementsInfo> RefactorAsync( Document document, StatementsInfo statementsInfo, StatementSyntax statement, StatementSyntax newStatement, int index, int count, bool removeReturnStatement, SemanticModel semanticModel, CancellationToken cancellationToken) { ReturnStatementSyntax returnStatement = FindReturnStatementBelow(statementsInfo.Statements, index); ExpressionSyntax expression = returnStatement.Expression; ExpressionSyntax newExpression = null; ISymbol symbol = semanticModel.GetSymbol(expression, cancellationToken); if (symbol.IsLocal() && index > 0) { LocalDeclarationStatementSyntax localDeclarationStatement = FindLocalDeclarationStatementAbove(statementsInfo.Statements, index); if (localDeclarationStatement?.ContainsDiagnostics == false && !localDeclarationStatement.SpanOrTrailingTriviaContainsDirectives() && !statement.GetLeadingTrivia().Any(f => f.IsDirective)) { SeparatedSyntaxList <VariableDeclaratorSyntax> declarators = localDeclarationStatement.Declaration.Variables; VariableDeclaratorSyntax declarator = FindVariableDeclarator(semanticModel, symbol, declarators, cancellationToken); if (declarator != null) { ExpressionSyntax value = declarator.Initializer?.Value; if (removeReturnStatement || value != null) { IEnumerable <ReferencedSymbol> referencedSymbols = await SymbolFinder.FindReferencesAsync(symbol, document.Solution(), cancellationToken).ConfigureAwait(false); if (referencedSymbols.First().Locations.Count() == count + 1) { newExpression = value; if (declarators.Count == 1) { statementsInfo = statementsInfo.RemoveNode(localDeclarationStatement, RemoveHelper.GetRemoveOptions(localDeclarationStatement)); index--; } else { statementsInfo = statementsInfo.ReplaceNode(localDeclarationStatement, localDeclarationStatement.RemoveNode(declarator, RemoveHelper.GetRemoveOptions(declarator))); } returnStatement = FindReturnStatementBelow(statementsInfo.Statements, index); } } } } } if (removeReturnStatement) { statementsInfo = statementsInfo.RemoveNode(returnStatement, RemoveHelper.GetRemoveOptions(returnStatement)); } else if (newExpression != null) { statementsInfo = statementsInfo.ReplaceNode(returnStatement, returnStatement.WithExpression(newExpression.WithTriviaFrom(expression))); } return(statementsInfo.ReplaceNode(statementsInfo.Statements[index], newStatement)); }