public static Boolean IsOnLineByItself(ExpressionStatementSyntax node) { Boolean result = false; // Seems like Trivia is Trivia No notion of with our without :) string existingLeadingTrivia = node.GetLeadingTrivia().ToString(); //string existingLeadingTriviaFull = node.GetLeadingTrivia().ToFullString(); string existingTrailingTrivia = node.GetTrailingTrivia().ToString(); //string existingTrailingTriviaFull = node.GetTrailingTrivia().ToFullString(); if (String.IsNullOrWhiteSpace(existingLeadingTrivia) && String.IsNullOrWhiteSpace(existingTrailingTrivia)) { result = true; } else { var triviaList = node.GetLeadingTrivia().ToSyntaxTriviaList(); Boolean leadingTriviaResult = false; foreach (SyntaxTrivia syntaxTrivia in node.GetLeadingTrivia().ToSyntaxTriviaList()) { var triviaKind = syntaxTrivia.Kind(); if (triviaKind == SyntaxKind.EndOfLineTrivia || triviaKind == SyntaxKind.WhitespaceTrivia || triviaKind == SyntaxKind.MultiLineCommentTrivia || triviaKind == SyntaxKind.SingleLineCommentTrivia) { leadingTriviaResult = true; } } Boolean trailingTriviaResult = false; foreach (SyntaxTrivia syntaxTrivia in node.GetTrailingTrivia().ToSyntaxTriviaList()) { var triviaKind = syntaxTrivia.Kind(); if (triviaKind == SyntaxKind.EndOfLineTrivia || triviaKind == SyntaxKind.WhitespaceTrivia || triviaKind == SyntaxKind.MultiLineCommentTrivia || triviaKind == SyntaxKind.SingleLineCommentTrivia) { trailingTriviaResult = true; } } result = leadingTriviaResult & trailingTriviaResult; } return(result); }
private async Task <Solution> AddIsEnabledGuardAsync(Document document, ExpressionStatementSyntax expression, CancellationToken cancellationToken) { var memberAccessExpression = expression.DescendantNodes().OfType <MemberAccessExpressionSyntax>().First(); if (memberAccessExpression.Expression is IdentifierNameSyntax identifierNameSyntax) { if (expression.Expression is InvocationExpressionSyntax invocation) { var leadingTrivia = expression.GetLeadingTrivia(); var arg = invocation.ArgumentList.Arguments.First(); var source = identifierNameSyntax.Identifier.Text; var isEnabled = SyntaxFactory.ParseExpression($"{source}.IsEnabled()") as InvocationExpressionSyntax; isEnabled = isEnabled.ReplaceNode(isEnabled.ArgumentList, isEnabled.ArgumentList.AddArguments(arg)); SyntaxFactory.Token(SyntaxKind.IfKeyword); var ifStatement = SyntaxFactory.IfStatement( SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), isEnabled, SyntaxFactory.Token(SyntaxKind.CloseParenToken).WithTrailingTrivia(NewLine), Indent(expression), null).WithLeadingTrivia(leadingTrivia); // Produce a new solution that has all references to that type renamed, including the declaration. var originalSolution = document.Project.Solution; var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken); syntaxRoot = syntaxRoot.ReplaceNode(expression, ifStatement); var newSolution = originalSolution.WithDocumentSyntaxRoot(document.Id, syntaxRoot); return(newSolution); } } return(document.Project.Solution); }
public virtual Task <Document> InlineAsync( ExpressionStatementSyntax expressionStatement, SyntaxList <StatementSyntax> statements, CancellationToken cancellationToken = default(CancellationToken)) { int count = statements.Count; StatementSyntax[] newStatements = RewriteStatements(statements); newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia()); newStatements[count - 1] = newStatements[count - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia()); StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(expressionStatement); if (statementsInfo.Success) { StatementListInfo newInfo = statementsInfo.WithStatements(statementsInfo.Statements.ReplaceRange(expressionStatement, newStatements)); return(Document.ReplaceNodeAsync(statementsInfo.Parent, newInfo.Parent, cancellationToken)); } else { return(Document.ReplaceNodeAsync(expressionStatement, Block(newStatements), cancellationToken)); } }
private static async Task <Document> InlineMethodAsync( Document document, ExpressionStatementSyntax expressionStatement, StatementSyntax[] statements, ParameterInfo[] parameterInfos, CancellationToken cancellationToken = default(CancellationToken)) { statements = await ReplaceParameterExpressionWithArgumentExpressionAsync( parameterInfos, statements, document.Project.Solution, cancellationToken).ConfigureAwait(false); statements[0] = statements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia()); statements[statements.Length - 1] = statements[statements.Length - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia()); if (expressionStatement.IsParentKind(SyntaxKind.Block)) { var block = (BlockSyntax)expressionStatement.Parent; BlockSyntax newBlock = block.WithStatements(block.Statements.ReplaceRange(expressionStatement, statements)); return(await document.ReplaceNodeAsync(block, newBlock, cancellationToken).ConfigureAwait(false)); } else { return(await document.ReplaceNodeAsync(expressionStatement, Block(statements), cancellationToken).ConfigureAwait(false)); } }
private async Task <Document> MakeBlockAsync(Document document, ExpressionStatementSyntax trueStatement, CancellationToken cancellationToken) { // Create the important trivia that we need. var statementLeadingTrivia = trueStatement.GetLeadingTrivia(); var statementLeadingWhiteSpace = trueStatement.Parent.GetLeadingTrivia() .Where(t => t.Kind() == SyntaxKind.WhitespaceTrivia).Single(); var endOfLineTrivia = SyntaxFactory.EndOfLine("\r\n"); var blockLeadingTrivia = statementLeadingTrivia.Insert(0, endOfLineTrivia); // Create the statements that go in the block: var statements = new SyntaxList <StatementSyntax>(); statements = statements.Add(trueStatement.WithLeadingTrivia(blockLeadingTrivia)); // Create the brace tokens (with whitespace trivia) and the the block: var openingTokenWithTrivia = SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithLeadingTrivia(statementLeadingWhiteSpace); var closingTokenWithTrivia = SyntaxFactory.Token(SyntaxKind.CloseBraceToken).WithLeadingTrivia(statementLeadingWhiteSpace); var block = SyntaxFactory.Block(openingTokenWithTrivia, statements, closingTokenWithTrivia) .WithTrailingTrivia(endOfLineTrivia); // Replace the old statement with the block: var root = await document.GetSyntaxRootAsync(); var newRoot = root.ReplaceNode((SyntaxNode)trueStatement, block); var newDocument = document.WithSyntaxRoot(newRoot); return(newDocument); }
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node) { if (RemoveTestTriviaAnnotation(node.GetLeadingTrivia())) { return(null); } return(base.VisitExpressionStatement(node)); }
public ExpressionStatementSyntax TryReplaceAssignmentExpressionWithMethodCall(ExpressionStatementSyntax node, INamedTypeSymbol typeSymbol = null) { // There are 2 cases to consider // Either we stub a method/property by setting a property; set value being the stub lambda // Or by invoking a method having a single argument; method argument being the stub lambda StubbedCall msStub = null; var assignment = node.ChildNodes().OfType <AssignmentExpressionSyntax>().FirstOrDefault(); if (assignment != null) { var member = assignment.ChildNodes().FirstOrDefault() as MemberAccessExpressionSyntax; if (member == null) { return(null); } var resultExpression = assignment.Right; msStub = StubMsTestMethodOrPropertyCall(assignment, member, resultExpression, typeSymbol); } else { var invocation = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault(); if (invocation == null) { return(null); } var member = invocation.ChildNodes().FirstOrDefault() as MemberAccessExpressionSyntax; if (member == null) { return(null); } var argument = invocation.ArgumentList.ChildNodes().FirstOrDefault() as ArgumentSyntax; if (argument == null) { return(null); } msStub = StubMsTestMethodOrPropertyCall(invocation, member, argument.Expression, typeSymbol); } if (msStub != null) { var moqStub = MockMethodOrPropertyCall(msStub); var stubDefinition = SyntaxFactory.ExpressionStatement(moqStub.NewNode) .WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed); return(stubDefinition); } return(null); }
private static async Task <Solution> InlineAndRemoveMethodAsync( Document document, ExpressionStatementSyntax expressionStatement, MethodDeclarationSyntax methodDeclaration, StatementSyntax[] statements, ParameterInfo[] parameterInfos, CancellationToken cancellationToken = default(CancellationToken)) { if (expressionStatement.SyntaxTree.Equals(methodDeclaration.SyntaxTree)) { DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false); Solution solution = document.Project.Solution; StatementSyntax[] newStatements = await ReplaceParameterExpressionWithArgumentExpressionAsync( parameterInfos, statements, solution, cancellationToken).ConfigureAwait(false); newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia()); newStatements[statements.Length - 1] = newStatements[statements.Length - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia()); if (expressionStatement.Parent.IsKind(SyntaxKind.Block)) { var block = (BlockSyntax)expressionStatement.Parent; BlockSyntax newBlock = block.WithStatements(block.Statements.ReplaceRange(expressionStatement, newStatements)); editor.ReplaceNode(block, newBlock); } else { editor.ReplaceNode(expressionStatement, Block(newStatements)); } editor.RemoveNode(methodDeclaration); document = editor.GetChangedDocument(); return(document.Project.Solution); } else { Solution solution = document.Project.Solution; document = await InlineMethodAsync(document, expressionStatement, statements, parameterInfos, cancellationToken).ConfigureAwait(false); DocumentId documentId = solution.GetDocumentId(methodDeclaration.SyntaxTree); solution = document.Project.Solution; return(await RemoveMethodAsync(solution.GetDocument(documentId), methodDeclaration, cancellationToken).ConfigureAwait(false)); } }
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node) { if (node.Expression is ParenthesizedExpressionSyntax syntax) { var expression = syntax .Expression .WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia()); return(node.WithExpression(expression)); } return(base.VisitExpressionStatement(node)); }
private async Task <Document> RemoveCall(Document document, ExpressionStatementSyntax call, CancellationToken cancellationToken) { var editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false); var containsLeadingComment = call.GetLeadingTrivia() .Any(t => t.IsKind(SyntaxKind.MultiLineCommentTrivia) || t.IsKind(SyntaxKind.SingleLineCommentTrivia)); var removeOptions = containsLeadingComment ? SyntaxRemoveOptions.KeepLeadingTrivia | SyntaxRemoveOptions.AddElasticMarker : SyntaxRemoveOptions.KeepNoTrivia; editor.RemoveNode(call, removeOptions); return(editor.GetChangedDocument()); }
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node) { var invocationName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()?.ChildNodes().OfType <IdentifierNameSyntax>().FirstOrDefault()? .ChildTokens()?.FirstOrDefault().Text; if (invocationName == null) { invocationName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()? .ChildNodes().OfType <GenericNameSyntax>().FirstOrDefault()? .ChildTokens()?.FirstOrDefault().Text; } if (invocationName != null && invocationName.Equals("YIELD", StringComparison.OrdinalIgnoreCase)) { var genericName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()? .ChildNodes().OfType <GenericNameSyntax>().FirstOrDefault()? .ChildNodes().OfType <TypeArgumentListSyntax>().FirstOrDefault()? .ChildNodes().OfType <PredefinedTypeSyntax>().FirstOrDefault()?.Keyword.Text; var varName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()? .ChildNodes().OfType <ArgumentListSyntax>().FirstOrDefault()? .ChildNodes().OfType <ArgumentSyntax>().FirstOrDefault()? .ChildNodes().OfType <IdentifierNameSyntax>().FirstOrDefault()?.GetText().ToString(); String type = "var"; if (genericName != null) { type = genericName; } var leadingTrivia = node.GetLeadingTrivia(); var forEachExp = SyntaxFactory.ForEachStatement( SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.IdentifierName(type), SyntaxFactory.Identifier("item"), SyntaxFactory.Token(SyntaxKind.InKeyword), SyntaxFactory.IdentifierName(varName), SyntaxFactory.Token(SyntaxKind.CloseParenToken) .WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine)) .WithTrailingTrivia(leadingTrivia), SyntaxFactory.Block( SyntaxFactory.YieldStatement( SyntaxKind.YieldReturnStatement, SyntaxFactory.IdentifierName("item").WithLeadingTrivia(leadingTrivia) ) )).NormalizeWhitespace().WithLeadingTrivia(leadingTrivia) .WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine)); return(forEachExp); } return(base.VisitExpressionStatement(node)); }
private static ExpressionStatementSyntax CommentExpressionStatement(ExpressionStatementSyntax expressionStatement) { string[] triviaList = expressionStatement.GetLeadingTrivia().ToFullString().Split(Environment.NewLine.ToCharArray()); triviaList[triviaList.Length - 1] = "//" + triviaList[triviaList.Length - 1]; string resultTrivia = ""; for (int i = 0; i < triviaList.Length - 1; i++) { resultTrivia += triviaList[i] + Environment.NewLine; } resultTrivia += triviaList[triviaList.Length - 1]; return(expressionStatement.WithLeadingTrivia(SyntaxFactory.ParseLeadingTrivia(resultTrivia))); }
internal static void MoveOnPropertyChangedInside(this DocumentEditor editor, IfStatementSyntax ifTrySet, ExpressionStatementSyntax onPropertyChanged) { editor.RemoveNode(onPropertyChanged); editor.AddOnPropertyChanged(ifTrySet, OnPropertyChanged()); ExpressionStatementSyntax OnPropertyChanged() { if (onPropertyChanged.HasLeadingTrivia && onPropertyChanged.GetLeadingTrivia() is { } leadingTrivia&& leadingTrivia.TryFirst(out var first) && first.IsKind(SyntaxKind.EndOfLineTrivia)) { onPropertyChanged = onPropertyChanged.WithLeadingTrivia(leadingTrivia.Remove(first)); } return(onPropertyChanged.WithAdditionalAnnotations(Formatter.Annotation)); } }
public virtual async Task <Solution> InlineAndRemoveAsync( ExpressionStatementSyntax expressionStatement, SyntaxList <StatementSyntax> statements, CancellationToken cancellationToken = default(CancellationToken)) { if (expressionStatement.SyntaxTree == Declaration.SyntaxTree) { DocumentEditor editor = await DocumentEditor.CreateAsync(Document, cancellationToken).ConfigureAwait(false); StatementSyntax[] newStatements = RewriteStatements(statements); int count = statements.Count; newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia()); newStatements[count - 1] = newStatements[count - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia()); StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(expressionStatement); if (statementsInfo.Success) { StatementListInfo newStatementsInfo = statementsInfo.WithStatements(statementsInfo.Statements.ReplaceRange(expressionStatement, newStatements)); editor.ReplaceNode(statementsInfo.Parent, newStatementsInfo.Parent); } else { editor.ReplaceNode(expressionStatement, Block(newStatements)); } editor.RemoveNode(Declaration); return(editor.GetChangedDocument().Solution()); } else { Document newDocument = await InlineAsync(expressionStatement, statements, cancellationToken).ConfigureAwait(false); DocumentId documentId = Document.Solution().GetDocumentId(Declaration.SyntaxTree); newDocument = await newDocument.Solution().GetDocument(documentId).RemoveMemberAsync(Declaration, cancellationToken).ConfigureAwait(false); return(newDocument.Solution()); } }
public async Task <Solution> InlineAndRemoveMethodAsync( ExpressionStatementSyntax expressionStatement, SyntaxList <StatementSyntax> statements) { if (expressionStatement.SyntaxTree == MethodDeclaration.SyntaxTree) { DocumentEditor editor = await DocumentEditor.CreateAsync(Document, CancellationToken).ConfigureAwait(false); StatementSyntax[] newStatements = RewriteStatements(statements); int count = statements.Count; newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia()); newStatements[count - 1] = newStatements[count - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia()); StatementContainer container; if (StatementContainer.TryCreate(expressionStatement, out container)) { SyntaxNode newNode = container.NodeWithStatements(container.Statements.ReplaceRange(expressionStatement, newStatements)); editor.ReplaceNode(container.Node, newNode); } else { editor.ReplaceNode(expressionStatement, Block(newStatements)); } editor.RemoveNode(MethodDeclaration); return(editor.GetChangedDocument().Solution()); } else { Document newDocument = await InlineMethodAsync(expressionStatement, statements).ConfigureAwait(false); DocumentId documentId = Document.Solution().GetDocumentId(MethodDeclaration.SyntaxTree); newDocument = await newDocument.Solution().GetDocument(documentId).RemoveMemberAsync(MethodDeclaration, CancellationToken).ConfigureAwait(false); return(newDocument.Solution()); } }
public Task <Document> InlineMethodAsync( ExpressionStatementSyntax expressionStatement, SyntaxList <StatementSyntax> statements) { int count = statements.Count; StatementSyntax[] newStatements = RewriteStatements(statements); newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia()); newStatements[count - 1] = newStatements[count - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia()); if (StatementContainer.TryCreate(expressionStatement, out StatementContainer container)) { SyntaxNode newNode = container.NodeWithStatements(container.Statements.ReplaceRange(expressionStatement, newStatements)); return(Document.ReplaceNodeAsync(container.Node, newNode, CancellationToken)); } else { return(Document.ReplaceNodeAsync(expressionStatement, Block(newStatements), CancellationToken)); } }
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node) { Location loc = node.GetLocation(); bool suppress = false; bool wroteHeader = false; foreach (Diagnostic error in errors) { if ((loc.SourceSpan.Start <= error.Location.SourceSpan.Start) && (loc.SourceSpan.End >= error.Location.SourceSpan.End)) { #pragma warning disable CS0162 // unreachable if (trace) { if (!wroteHeader) { Console.WriteLine("REMOVING BROKEN: {0}", node.ToFullString().Replace(Environment.NewLine, " ")); wroteHeader = true; } Console.WriteLine(" ERROR: {0}: {1}", error.Id, error.GetMessage()); } #pragma warning restore CS0162 suppress = true; break; } } SyntaxNode updated = base.VisitExpressionStatement(node); if (suppress) { updated = SyntaxFactory.EmptyStatement( SyntaxFactory.Token( node.GetLeadingTrivia(), node.SemicolonToken.Kind(), node.GetTrailingTrivia())); } suppress = false; return(updated); }
public static async Task <Document> RefactorAsync( Document document, UseMethodChainingAnalysis analysis, ExpressionStatementSyntax expressionStatement, CancellationToken cancellationToken) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); InvocationExpressionSyntax invocationExpression = GetInvocationExpression(expressionStatement); SimpleMemberInvocationExpressionInfo invocationInfo = SyntaxInfo.SimpleMemberInvocationExpressionInfo(invocationExpression); ITypeSymbol returnType = semanticModel.GetMethodSymbol(invocationExpression, cancellationToken).ReturnType; string name = ((IdentifierNameSyntax)UseMethodChainingAnalysis.WalkDownMethodChain(invocationInfo).Expression).Identifier.ValueText; StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(expressionStatement); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(expressionStatement); string indentation = SyntaxTriviaAnalysis.GetIncreasedIndentation(expressionStatement, cancellationToken); var sb = new StringBuilder(invocationExpression.ToString()); int j = index; while (j < statements.Count - 1) { StatementSyntax statement = statements[j + 1]; if (!analysis.IsFixableStatement(statement, name, returnType, semanticModel, cancellationToken)) { break; } sb.AppendLine(); sb.Append(indentation); sb.Append(GetTextToAppend((ExpressionStatementSyntax)statement)); j++; } StatementSyntax lastStatement = statements[j]; SyntaxList <StatementSyntax> newStatements = statements; while (j > index) { newStatements = newStatements.RemoveAt(j); j--; } ExpressionSyntax newInvocationExpression = SyntaxFactory.ParseExpression(sb.ToString()); SyntaxTriviaList trailingTrivia = statementsInfo .Parent .DescendantTrivia(TextSpan.FromBounds(invocationExpression.Span.End, lastStatement.Span.End)) .ToSyntaxTriviaList() .EmptyIfWhitespace() .AddRange(lastStatement.GetTrailingTrivia()); ExpressionStatementSyntax newExpressionStatement = expressionStatement .ReplaceNode(invocationExpression, newInvocationExpression) .WithLeadingTrivia(expressionStatement.GetLeadingTrivia()) .WithTrailingTrivia(trailingTrivia) .WithFormatterAndSimplifierAnnotation(); newStatements = newStatements.ReplaceAt(index, newExpressionStatement); return(await document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken).ConfigureAwait(false)); }
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node) { if (node.ToString().Length < 110) { return(base.VisitExpressionStatement(node)); } var m = node.Expression; var rewritableToken = new List <SyntaxToken>(); var trivia = new SyntaxTriviaList(SyntaxFactory.EndOfLine("\n")); trivia = trivia.AddRange(node.GetLeadingTrivia().Reverse() .TakeWhile(x => x.IsDirective ^ !x.IsKind(SyntaxKind.EndOfLineTrivia))); trivia = trivia.Add(SyntaxFactory.Whitespace(" ")); var newExpression = SyntaxFactory.ParseExpression(""); while (m != null && m.ChildNodes().Any()) { var m2 = m.ChildNodes(); if (m2.FirstOrDefault() is MemberAccessExpressionSyntax && m2.LastOrDefault() is ArgumentListSyntax) { var methodName = m2.FirstOrDefault().As <MemberAccessExpressionSyntax>(); var arguments = m2.LastOrDefault().As <ArgumentListSyntax>(); m = m2.FirstOrDefault().As <MemberAccessExpressionSyntax>()?.Expression; if (newExpression.ToString() == "") { newExpression = SyntaxFactory.InvocationExpression(methodName.Name, arguments) .WithoutTrailingTrivia(); } else { newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.InvocationExpression(methodName.Name, arguments).WithoutTrailingTrivia(), SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString())); } } else if (m2.FirstOrDefault() is IdentifierNameSyntax && m2.LastOrDefault() is ArgumentListSyntax) { var identifierName = m2.FirstOrDefault() as IdentifierNameSyntax; var arguments = m2.LastOrDefault() as ArgumentListSyntax; m = null; if (newExpression.ToString() == "") { newExpression = SyntaxFactory.InvocationExpression(identifierName, arguments).WithoutTrailingTrivia(); } else { newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.InvocationExpression(identifierName.WithoutTrailingTrivia(), arguments.WithoutTrailingTrivia()), SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString())); } } else { if (newExpression.ToString() == "") { newExpression = m.WithoutTrailingTrivia(); } else { newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, m.WithoutTrailingTrivia(), SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString())); } m = null; } } if (m != null) { newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, m, SyntaxFactory.IdentifierName(newExpression.ToString())); } if (!newExpression.ToFullString().Equals(node.ToFullString())) { var lineSpan = node.GetFileLinePosSpan(); AddReport(new ChangesReport(node) { LineNumber = lineSpan.StartLinePosition.Line, Column = lineSpan.StartLinePosition.Character, Message = "your expression should be multi lined", Generator = nameof(MultiLineExpressionRewriter) }); } return(SyntaxFactory.ExpressionStatement(newExpression) .WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia())); }
public override Microsoft.CodeAnalysis.SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node) { var expression = node.Expression; ExpressionStatementSyntax newNode = null; if (_targetPatternRegEx.Match(node.Expression.ToString()).Success) { try { // Verify this expression is on line by itself. May not need to do this. // See if can have multiple ExpressionStatements on same line. if (VNCCA.Helpers.VB.IsOnLineByItself(node)) { // HACK(crhodes) // Figure out how to get Helpers to work here. Messages.AppendLine(String.Format("Removing {0} Method:({1,-35}) {2}", VNCCA.Helpers.VB.GetContainingContext(node, _configurationOptions), VNCCA.Helpers.VB.GetContainingMethodName(node), node.ToString())); if (_commentOutOnly) { List <SyntaxTrivia> newTrivia = new List <SyntaxTrivia>(); string existingLeadingTrivia = node.GetLeadingTrivia().ToString(); string existingLeadingTriviaFull = node.GetLeadingTrivia().ToFullString(); string existingTrailingTrivia = node.GetTrailingTrivia().ToString(); string existingTrailingTriviaFull = node.GetTrailingTrivia().ToFullString(); string startOfLineWhiteSpace = existingLeadingTrivia.Replace(System.Environment.NewLine, ""); newTrivia.Add(SyntaxFactory.CommentTrivia(existingLeadingTriviaFull)); newTrivia.Add(SyntaxFactory.CommentTrivia(VNCCA.Helpers.VB.MultiLineComment(_comment, startOfLineWhiteSpace))); newTrivia.Add(SyntaxFactory.CommentTrivia("' ")); newNode = node.WithLeadingTrivia(newTrivia); } else { // This removes the node newNode = null; } } else { Messages.AppendLine(String.Format("node: >{0}< >{1}< Is NOT OnLineByItself", node.ToString(), node.ToFullString())); newNode = node; } } catch (Exception ex) { Messages.AppendLine(string.Format("Ex:{0} InnerEx:{1}", ex.ToString(), ex.InnerException.ToString())); } } else { newNode = node; } return(newNode); }
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax syntaxNode) { bool?isAssertTF = IsAssertTrueOrFalse(syntaxNode); if (isAssertTF != null) { string firstArg = null, secondArg = null; var expr = syntaxNode.Expression as InvocationExpressionSyntax; var firstArgNode = expr.ArgumentList.Arguments.First().Expression; if (firstArgNode.IsKind(SyntaxKind.LogicalNotExpression)) { // revert True and False string fmt = isAssertTF.Value ? AssertFalseNoMsg : AssertTrueNoMsg; // the first char should be ! // the comments associated with this arg will be lost firstArg = firstArgNode.ToString().Trim().Substring(1); if (expr.ArgumentList.Arguments.Count == 2) { secondArg = expr.ArgumentList.Arguments.Last().ToString().Trim(); fmt = isAssertTF.Value ? AssertFalse : AssertTrue; } return(SyntaxFactory.ParseStatement(syntaxNode.GetLeadingTrivia().ToFullString() + string.Format(fmt, firstArg, secondArg) + syntaxNode.GetTrailingTrivia().ToFullString())); } else if (firstArgNode.IsKind(SyntaxKind.EqualsExpression) || firstArgNode.IsKind(SyntaxKind.NotEqualsExpression)) { BinaryExpressionSyntax expr2 = firstArgNode as BinaryExpressionSyntax; firstArg = expr2.Left.ToString().Trim(); secondArg = expr2.Right.ToString().Trim(); bool isEqual = firstArgNode.IsKind(SyntaxKind.EqualsExpression); // Assert.True(a==b) || Assert.False(a!=b) bool positive = isAssertTF.Value && isEqual || !(isAssertTF.Value || isEqual); var fmt = positive ? AssertEqual : AssertNotEqual; // special case if (IsSpecialValue(ref firstArg, ref secondArg, "null")) { // Assert.True(cond ==|!= null) || Assert.False(cond ==|!= null) fmt = positive ? AssertNull : AssertNotNull; } else if (IsSpecialValue(ref firstArg, ref secondArg, "true")) { // Assert.True(cond ==|!= true) || Assert.False(cond ==|!= true) fmt = positive ? AssertTrueNoMsg : AssertFalseNoMsg; } else if (IsSpecialValue(ref firstArg, ref secondArg, "false")) { // Assert.True(cond ==|!= false) || Assert.False(cond ==|!= false) fmt = positive ? AssertFalseNoMsg : AssertTrueNoMsg; } else { int v = 0; // if second is a const (int only for now) if (int.TryParse(secondArg, out v)) { // swap string tmp = firstArg; firstArg = secondArg; secondArg = tmp; } } return(SyntaxFactory.ParseStatement( syntaxNode.GetLeadingTrivia().ToFullString() + string.Format(fmt, firstArg, secondArg) + syntaxNode.GetTrailingTrivia().ToFullString())); } } return(base.VisitExpressionStatement(syntaxNode)); }
public static async Task <Document> RefactorAsync( Document document, ExpressionStatementSyntax expressionStatement, CancellationToken cancellationToken) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); INamedTypeSymbol symbol = semanticModel.GetTypeByMetadataName(MetadataNames.System_Text_StringBuilder); var invocationExpression = (InvocationExpressionSyntax)expressionStatement.Expression; MemberInvocationExpression memberInvocation = MemberInvocationExpression.Create(invocationExpression); ExpressionSyntax expression = GetFirstInvocationInMethodChain(memberInvocation, symbol, semanticModel, cancellationToken).Expression; StatementContainer statementContainer = StatementContainer.Create(expressionStatement); SyntaxList <StatementSyntax> statements = statementContainer.Statements; int index = statements.IndexOf(expressionStatement); string indentation = CSharpFormatter.GetIncreasedIndentation(expressionStatement, cancellationToken).ToString(); var sb = new StringBuilder(invocationExpression.ToString()); int j = index; while (j < statements.Count - 1) { StatementSyntax statement = statements[j + 1]; if (!IsFixable(statement, expression, symbol, semanticModel, cancellationToken)) { break; } sb.AppendLine(); sb.Append(indentation); sb.Append(GetTextToAppend((ExpressionStatementSyntax)statement, symbol, semanticModel, cancellationToken)); j++; } StatementSyntax lastStatement = statements[j]; SyntaxList <StatementSyntax> newStatements = statements; while (j > index) { newStatements = newStatements.RemoveAt(j); j--; } ExpressionSyntax newInvocationExpression = SyntaxFactory.ParseExpression(sb.ToString()); SyntaxTriviaList trailingTrivia = statementContainer .Node .DescendantTrivia(TextSpan.FromBounds(invocationExpression.Span.End, lastStatement.Span.End)) .ToSyntaxTriviaList() .EmptyIfWhitespace() .AddRange(lastStatement.GetTrailingTrivia()); ExpressionStatementSyntax newExpressionStatement = expressionStatement .WithExpression(newInvocationExpression) .WithLeadingTrivia(expressionStatement.GetLeadingTrivia()) .WithTrailingTrivia(trailingTrivia) .WithFormatterAndSimplifierAnnotations(); newStatements = newStatements.ReplaceAt(index, newExpressionStatement); return(await document.ReplaceNodeAsync(statementContainer.Node, statementContainer.NodeWithStatements(newStatements), cancellationToken).ConfigureAwait(false)); }
private async Task <Document> ConvertToAsyncPackageAsync(CodeFixContext context, Diagnostic diagnostic, CancellationToken cancellationToken) { SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); Compilation?compilation = await context.Document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); Assumes.NotNull(compilation); SyntaxNode root = await context.Document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); BaseTypeSyntax baseTypeSyntax = root.FindNode(diagnostic.Location.SourceSpan).FirstAncestorOrSelf <BaseTypeSyntax>(); ClassDeclarationSyntax classDeclarationSyntax = baseTypeSyntax.FirstAncestorOrSelf <ClassDeclarationSyntax>(); MethodDeclarationSyntax initializeMethodSyntax = classDeclarationSyntax.DescendantNodes() .OfType <MethodDeclarationSyntax>() .FirstOrDefault(method => method.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.OverrideKeyword)) && method.Identifier.Text == Types.Package.Initialize); InvocationExpressionSyntax?baseInitializeInvocationSyntax = initializeMethodSyntax?.Body?.DescendantNodes() .OfType <InvocationExpressionSyntax>() .FirstOrDefault(ies => ies.Expression is MemberAccessExpressionSyntax memberAccess && memberAccess.Name?.Identifier.Text == Types.Package.Initialize && memberAccess.Expression is BaseExpressionSyntax); var getServiceInvocationsSyntax = new List <InvocationExpressionSyntax>(); AttributeSyntax?packageRegistrationSyntax = null; { INamedTypeSymbol userClassSymbol = semanticModel.GetDeclaredSymbol(classDeclarationSyntax, context.CancellationToken); INamedTypeSymbol packageRegistrationType = compilation.GetTypeByMetadataName(Types.PackageRegistrationAttribute.FullName); AttributeData? packageRegistrationInstance = userClassSymbol?.GetAttributes().FirstOrDefault(a => Equals(a.AttributeClass, packageRegistrationType)); if (packageRegistrationInstance?.ApplicationSyntaxReference != null) { packageRegistrationSyntax = (AttributeSyntax)await packageRegistrationInstance.ApplicationSyntaxReference.GetSyntaxAsync(cancellationToken).ConfigureAwait(false); } } if (initializeMethodSyntax != null) { getServiceInvocationsSyntax.AddRange( from invocation in initializeMethodSyntax.DescendantNodes().OfType <InvocationExpressionSyntax>() let memberBinding = invocation.Expression as MemberAccessExpressionSyntax let identifierName = invocation.Expression as IdentifierNameSyntax where identifierName?.Identifier.Text == Types.Package.GetService || (memberBinding.Name.Identifier.Text == Types.Package.GetService && memberBinding.Expression.IsKind(SyntaxKind.ThisExpression)) select invocation); } // Make it easier to track nodes across changes. var nodesToTrack = new List <SyntaxNode?> { baseTypeSyntax, initializeMethodSyntax, baseInitializeInvocationSyntax, packageRegistrationSyntax, }; nodesToTrack.AddRange(getServiceInvocationsSyntax); nodesToTrack.RemoveAll(n => n == null); SyntaxNode updatedRoot = root.TrackNodes(nodesToTrack); // Replace the Package base type with AsyncPackage baseTypeSyntax = updatedRoot.GetCurrentNode(baseTypeSyntax); SimpleBaseTypeSyntax asyncPackageBaseTypeSyntax = SyntaxFactory.SimpleBaseType(Types.AsyncPackage.TypeSyntax.WithAdditionalAnnotations(Simplifier.Annotation)) .WithLeadingTrivia(baseTypeSyntax.GetLeadingTrivia()) .WithTrailingTrivia(baseTypeSyntax.GetTrailingTrivia()); updatedRoot = updatedRoot.ReplaceNode(baseTypeSyntax, asyncPackageBaseTypeSyntax); // Update the PackageRegistration attribute if (packageRegistrationSyntax != null) { LiteralExpressionSyntax trueExpression = SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression); packageRegistrationSyntax = updatedRoot.GetCurrentNode(packageRegistrationSyntax); AttributeArgumentSyntax allowsBackgroundLoadingSyntax = packageRegistrationSyntax.ArgumentList.Arguments.FirstOrDefault(a => a.NameEquals?.Name?.Identifier.Text == Types.PackageRegistrationAttribute.AllowsBackgroundLoading); if (allowsBackgroundLoadingSyntax != null) { updatedRoot = updatedRoot.ReplaceNode( allowsBackgroundLoadingSyntax, allowsBackgroundLoadingSyntax.WithExpression(trueExpression)); } else { updatedRoot = updatedRoot.ReplaceNode( packageRegistrationSyntax, packageRegistrationSyntax.AddArgumentListArguments( SyntaxFactory.AttributeArgument(trueExpression).WithNameEquals(SyntaxFactory.NameEquals(Types.PackageRegistrationAttribute.AllowsBackgroundLoading)))); } } // Find the Initialize override, if present, and update it to InitializeAsync if (initializeMethodSyntax != null) { IdentifierNameSyntax cancellationTokenLocalVarName = SyntaxFactory.IdentifierName("cancellationToken"); IdentifierNameSyntax progressLocalVarName = SyntaxFactory.IdentifierName("progress"); initializeMethodSyntax = updatedRoot.GetCurrentNode(initializeMethodSyntax); BlockSyntax newBody = initializeMethodSyntax.Body; SyntaxTriviaList leadingTrivia = SyntaxFactory.TriviaList( SyntaxFactory.Comment(@"// When initialized asynchronously, we *may* be on a background thread at this point."), SyntaxFactory.CarriageReturnLineFeed, SyntaxFactory.Comment(@"// Do any initialization that requires the UI thread after switching to the UI thread."), SyntaxFactory.CarriageReturnLineFeed, SyntaxFactory.Comment(@"// Otherwise, remove the switch to the UI thread if you don't need it."), SyntaxFactory.CarriageReturnLineFeed); ExpressionStatementSyntax switchToMainThreadStatement = SyntaxFactory.ExpressionStatement( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(Types.ThreadHelper.JoinableTaskFactory)), SyntaxFactory.IdentifierName(Types.JoinableTaskFactory.SwitchToMainThreadAsync))) .AddArgumentListArguments(SyntaxFactory.Argument(cancellationTokenLocalVarName)))) .WithLeadingTrivia(leadingTrivia) .WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed); if (baseInitializeInvocationSyntax != null) { var baseInitializeAsyncInvocationBookmark = new SyntaxAnnotation(); AwaitExpressionSyntax baseInitializeAsyncInvocationSyntax = SyntaxFactory.AwaitExpression( baseInitializeInvocationSyntax .WithLeadingTrivia() .WithExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.BaseExpression(), SyntaxFactory.IdentifierName(Types.AsyncPackage.InitializeAsync))) .AddArgumentListArguments( SyntaxFactory.Argument(cancellationTokenLocalVarName), SyntaxFactory.Argument(progressLocalVarName))) .WithLeadingTrivia(baseInitializeInvocationSyntax.GetLeadingTrivia()) .WithAdditionalAnnotations(baseInitializeAsyncInvocationBookmark); newBody = newBody.ReplaceNode(initializeMethodSyntax.GetCurrentNode(baseInitializeInvocationSyntax), baseInitializeAsyncInvocationSyntax); StatementSyntax baseInvocationStatement = newBody.GetAnnotatedNodes(baseInitializeAsyncInvocationBookmark).First().FirstAncestorOrSelf <StatementSyntax>(); newBody = newBody.InsertNodesAfter( baseInvocationStatement, new[] { switchToMainThreadStatement.WithLeadingTrivia(switchToMainThreadStatement.GetLeadingTrivia().Insert(0, SyntaxFactory.LineFeed)) }); } else { newBody = newBody.WithStatements( newBody.Statements.Insert(0, switchToMainThreadStatement)); } MethodDeclarationSyntax initializeAsyncMethodSyntax = initializeMethodSyntax .WithIdentifier(SyntaxFactory.Identifier(Types.AsyncPackage.InitializeAsync)) .WithReturnType(Types.Task.TypeSyntax.WithAdditionalAnnotations(Simplifier.Annotation)) .AddModifiers(SyntaxFactory.Token(SyntaxKind.AsyncKeyword)) .AddParameterListParameters( SyntaxFactory.Parameter(cancellationTokenLocalVarName.Identifier).WithType(Types.CancellationToken.TypeSyntax.WithAdditionalAnnotations(Simplifier.Annotation)), SyntaxFactory.Parameter(progressLocalVarName.Identifier).WithType(Types.IProgress.TypeSyntaxOf(Types.ServiceProgressData.TypeSyntax).WithAdditionalAnnotations(Simplifier.Annotation))) .WithBody(newBody); updatedRoot = updatedRoot.ReplaceNode(initializeMethodSyntax, initializeAsyncMethodSyntax); // Replace GetService calls with GetServiceAsync getServiceInvocationsSyntax = updatedRoot.GetCurrentNodes <InvocationExpressionSyntax>(getServiceInvocationsSyntax).ToList(); updatedRoot = updatedRoot.ReplaceNodes( getServiceInvocationsSyntax, (orig, node) => { InvocationExpressionSyntax invocation = node; if (invocation.Expression is IdentifierNameSyntax methodName) { invocation = invocation.WithExpression(SyntaxFactory.IdentifierName(Types.AsyncPackage.GetServiceAsync)); } else if (invocation.Expression is MemberAccessExpressionSyntax memberAccess) { invocation = invocation.WithExpression( memberAccess.WithName(SyntaxFactory.IdentifierName(Types.AsyncPackage.GetServiceAsync))); } return(SyntaxFactory.ParenthesizedExpression(SyntaxFactory.AwaitExpression(invocation)) .WithAdditionalAnnotations(Simplifier.Annotation)); }); updatedRoot = await Utils.AddUsingTaskEqualsDirectiveAsync(updatedRoot, cancellationToken); } Document newDocument = context.Document.WithSyntaxRoot(updatedRoot); newDocument = await ImportAdder.AddImportsAsync(newDocument, Simplifier.Annotation, cancellationToken : cancellationToken); return(newDocument); }
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node) { if (node.ToString().Length < 110) { return(base.VisitExpressionStatement(node)); } var m = node.Expression; List <SyntaxToken> rewritableToken = new List <SyntaxToken>(); var trivia = new SyntaxTriviaList(SyntaxFactory.EndOfLine("\n")); trivia = trivia.AddRange(node.GetLeadingTrivia().Reverse() .TakeWhile(x => !x.IsKind(SyntaxKind.EndOfLineTrivia))); trivia = trivia.Add(SyntaxFactory.Tab); var newExpression = SyntaxFactory.ParseExpression(""); while (m != null && m.ChildNodes().Any()) { var m2 = m.ChildNodes(); if (m2.FirstOrDefault() is MemberAccessExpressionSyntax && m2.LastOrDefault() is ArgumentListSyntax) { var methodName = m2.FirstOrDefault().As <MemberAccessExpressionSyntax>(); var arguments = m2.LastOrDefault().As <ArgumentListSyntax>(); m = m2.FirstOrDefault().As <MemberAccessExpressionSyntax>()?.Expression; if (newExpression.ToString() == "") { newExpression = SyntaxFactory.InvocationExpression(methodName.Name, arguments) .WithoutTrailingTrivia(); } else { newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.InvocationExpression(methodName.Name, arguments).WithoutTrailingTrivia(), SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString())); } } else if (m2.FirstOrDefault() is IdentifierNameSyntax && m2.LastOrDefault() is ArgumentListSyntax) { var identifierName = m2.FirstOrDefault() as IdentifierNameSyntax; var arguments = m2.LastOrDefault() as ArgumentListSyntax; m = null; if (newExpression.ToString() == "") { newExpression = SyntaxFactory.InvocationExpression(identifierName, arguments).WithoutTrailingTrivia(); } else { newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.InvocationExpression(identifierName.WithoutTrailingTrivia(), arguments.WithoutTrailingTrivia()), SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString())); } } else { if (newExpression.ToString() == "") { newExpression = m.WithoutTrailingTrivia(); } else { newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, m.WithoutTrailingTrivia(), SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString())); } m = null; } } if (m != null) { newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, m, SyntaxFactory.IdentifierName(newExpression.ToString())); } return(SyntaxFactory.ExpressionStatement(newExpression) .WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia())); }
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node) { SyntaxNode updatedNode = base.VisitExpressionStatement(node); if (node.Expression.Kind == SyntaxKind.AddAssignExpression || node.Expression.Kind == SyntaxKind.SubtractAssignExpression || node.Expression.Kind == SyntaxKind.MultiplyAssignExpression || node.Expression.Kind == SyntaxKind.DivideAssignExpression) { // Print value of the variable on the 'Left' side of // compound assignement statements encountered. var compoundAssignmentExpression = (BinaryExpressionSyntax)node.Expression; StatementSyntax consoleWriteLineStatement = Syntax.ParseStatement(string.Format("System.Console.WriteLine({0});", compoundAssignmentExpression.Left.ToString())); updatedNode = Syntax.Block(Syntax.List<StatementSyntax>( node.WithLeadingTrivia().WithTrailingTrivia(), // Remove leading and trailing trivia. consoleWriteLineStatement)) .WithLeadingTrivia(node.GetLeadingTrivia()) // Attach leading trivia from original node. .WithTrailingTrivia(node.GetTrailingTrivia()); // Attach trailing trivia from original node. } return updatedNode; }