public static SyntaxTriviaList RemoveIfDef(SyntaxTriviaList trivia) { int inDirective = 0; for (int i = 0; i < trivia.Count; i++) { if (trivia[i].Kind() == SyntaxKind.IfDirectiveTrivia) { trivia = trivia.RemoveAt(i); i--; inDirective++; } else if (trivia[i].Kind() == SyntaxKind.EndIfDirectiveTrivia) { trivia = trivia.RemoveAt(i); i--; inDirective--; } else if (inDirective > 0) { trivia = trivia.RemoveAt(i); i--; } } return(trivia); }
private static SyntaxTriviaList RemoveTriviaAtIndex(SyntaxTriviaList newTrivia, int index) { // Remove trivia newTrivia = newTrivia.RemoveAt(index); // Remove end of line after trivia if (index < newTrivia.Count && newTrivia.ElementAt(index).Kind() == SyntaxKind.EndOfLineTrivia) { newTrivia = newTrivia.RemoveAt(index); } return(newTrivia); }
private static SyntaxTriviaList RemoveHeaderDecorationLines(SyntaxTriviaList trivia, StyleCopSettings settings) { if (!string.IsNullOrEmpty(settings.DocumentationRules.HeaderDecoration)) { var decorationRemovalList = new List <int>(); for (int i = 0; i < trivia.Count; i++) { var triviaLine = trivia[i]; if (triviaLine.IsKind(SyntaxKind.SingleLineCommentTrivia) && triviaLine.ToFullString().Contains(settings.DocumentationRules.HeaderDecoration)) { decorationRemovalList.Add(i); // also remove the line break if (i + 1 < trivia.Count && trivia[i + 1].IsKind(SyntaxKind.EndOfLineTrivia)) { decorationRemovalList.Add(i + 1); } } } // Remove decoration lines in reverse order. for (int i = decorationRemovalList.Count - 1; i >= 0; i--) { trivia = trivia.RemoveAt(decorationRemovalList[i]); } } return(trivia); }
/// <summary> /// Determines how many type parameters of the <see cref="OriginalDeclaration"/> should the <see cref="CurrentDeclaration"/> have. /// </summary> /// <param name="count">Number of type parameters to take.</param> public void WithTypeParameters(int count) { if (DefaultParamUtilities.TryUpdateTypeParameters(CurrentDeclaration.TypeParameterList, count, out TypeParameterListSyntax? updated)) { CurrentDeclaration = CurrentDeclaration.WithTypeParameterList(updated); } CheckDirectCall(count); SyntaxTokenList modifiers = CurrentDeclaration.Modifiers; if (!modifiers.Any()) { SyntaxTriviaList trivia = CurrentDeclaration.ReturnType.GetLeadingTrivia(); if (trivia.Any()) { trivia = trivia.RemoveAt(trivia.Count - 1); CurrentDeclaration = CurrentDeclaration.WithReturnType(CurrentDeclaration.ReturnType.WithLeadingTrivia(trivia)); } } if (DefaultParamUtilities.TryAddNewModifier(_newModifierIndexes, count, _numNonDefaultParam, ref modifiers)) { CurrentDeclaration = CurrentDeclaration.WithModifiers(modifiers); } }
/// <summary> /// Determines how many type parameters of the <see cref="OriginalDeclaration"/> should the <see cref="CurrentDeclaration"/> have. /// </summary> /// <param name="count">Number of type parameters to take.</param> public void WithTypeParameters(int count) { if (DefaultParamUtilities.TryUpdateTypeParameters(CurrentDeclaration.TypeParameterList, count, out TypeParameterListSyntax? updated)) { CurrentDeclaration = CurrentDeclaration.WithTypeParameterList(updated); } SyntaxTokenList modifiers = CurrentDeclaration.Modifiers; if (!modifiers.Any()) { SyntaxTriviaList trivia = CurrentDeclaration.DelegateKeyword.LeadingTrivia; if (trivia.Any()) { trivia = trivia.RemoveAt(trivia.Count - 1); CurrentDeclaration = CurrentDeclaration.WithDelegateKeyword(CurrentDeclaration.DelegateKeyword.WithLeadingTrivia(trivia)); } } if (DefaultParamUtilities.TryAddNewModifier(_newModifierIndexes, count, _numNonDefaultParam, ref modifiers)) { CurrentDeclaration = CurrentDeclaration.WithModifiers(modifiers); } }
private static SyntaxTriviaList RemoveTrivia(SyntaxTriviaList triviaList, int index) { int first = FindFirstTriviaToRemove(triviaList, index); int last = FindLastTriviaToRemove(triviaList, index); for (int i = last; i >= first; i--) { triviaList = triviaList.RemoveAt(i); } return(triviaList); }
private void DoTestAddInsertRemoveReplaceOnEmptyList(SyntaxTriviaList list) { Assert.Equal(0, list.Count); var triviaD = SyntaxFactory.ParseLeadingTrivia("/*D*/")[0]; var triviaE = SyntaxFactory.ParseLeadingTrivia("/*E*/")[0]; var newList = list.Add(triviaD); Assert.Equal(1, newList.Count); Assert.Equal("/*D*/", newList.ToFullString()); newList = list.AddRange(new[] { triviaD, triviaE }); Assert.Equal(2, newList.Count); Assert.Equal("/*D*//*E*/", newList.ToFullString()); newList = list.Insert(0, triviaD); Assert.Equal(1, newList.Count); Assert.Equal("/*D*/", newList.ToFullString()); newList = list.InsertRange(0, new[] { triviaD, triviaE }); Assert.Equal(2, newList.Count); Assert.Equal("/*D*//*E*/", newList.ToFullString()); newList = list.Remove(triviaD); Assert.Equal(0, newList.Count); Assert.Equal(-1, list.IndexOf(triviaD)); Assert.Throws <ArgumentOutOfRangeException>(() => list.RemoveAt(0)); Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(1, triviaD)); Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(-1, triviaD)); Assert.Throws <ArgumentOutOfRangeException>( () => list.InsertRange(1, new[] { triviaD }) ); Assert.Throws <ArgumentOutOfRangeException>( () => list.InsertRange(-1, new[] { triviaD }) ); Assert.Throws <ArgumentOutOfRangeException>(() => list.Replace(triviaD, triviaE)); Assert.Throws <ArgumentOutOfRangeException>( () => list.ReplaceRange(triviaD, new[] { triviaE }) ); Assert.Throws <ArgumentOutOfRangeException>(() => list.Add(default(SyntaxTrivia))); Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(0, default(SyntaxTrivia))); Assert.Throws <ArgumentNullException>( () => list.AddRange((IEnumerable <SyntaxTrivia>)null) ); Assert.Throws <ArgumentNullException>( () => list.InsertRange(0, (IEnumerable <SyntaxTrivia>)null) ); }
private SyntaxNode StripLeadingLineBreak( SyntaxNode node, SyntaxToken token, SyntaxTriviaList trivia, int triviaPosition) { node = base.Visit(node); if (node == null) { return(null); } trivia = trivia.RemoveAt(triviaPosition); var newToken = token.WithLeadingTrivia(trivia); node = node.ReplaceToken(token, newToken); return(node); }
static SyntaxTriviaList FlushDuplicateTrivia( SyntaxTriviaList trivia, int startIndex, int endIndex, bool allowExtraNewLine) { int allowedNewLines = allowExtraNewLine ? 2 : 1; var newLineCount = 0; for (; endIndex >= startIndex; endIndex--) { if (newLineCount == allowedNewLines) { trivia = trivia.RemoveAt(endIndex); } else if (trivia[endIndex].IsKind(SyntaxKind.EndOfLineTrivia)) { newLineCount++; } } return trivia; }
private SyntaxTriviaList AlterIndent(SyntaxTriviaList leadTrivia) { var whitespaces = leadTrivia .Select((trivia, i) => new { Trivia = trivia, Index = i }) .Where(o => o.Trivia.IsKind(SyntaxKind.WhitespaceTrivia)) .ToList(); foreach (var whitespace in whitespaces) { var trivia = whitespace.Trivia.ToFullString(); leadTrivia = leadTrivia .RemoveAt(whitespace.Index) .Insert(whitespace.Index, _subtract ? Whitespace(trivia.Substring(0, Math.Max(trivia.Length - _indent.Length, 0))) : Whitespace(trivia + _indent)); } return(leadTrivia); }
private static void UpdateReplaceMap(Dictionary <SyntaxToken, SyntaxToken> replaceMap, SyntaxToken token, Diagnostic diagnostic) { string location; if (!diagnostic.Properties.TryGetValue(TokenSpacingProperties.LocationKey, out location)) { return; } string action; if (!diagnostic.Properties.TryGetValue(TokenSpacingProperties.ActionKey, out action)) { return; } string layout; if (!diagnostic.Properties.TryGetValue(TokenSpacingProperties.LayoutKey, out layout)) { layout = TokenSpacingProperties.LayoutPack; } SyntaxTriviaList triviaList; switch (location) { case TokenSpacingProperties.LocationPreceding: var prevToken = token.GetPreviousToken(); switch (action) { case TokenSpacingProperties.ActionInsert: if (!replaceMap.ContainsKey(prevToken)) { replaceMap[token] = token.WithLeadingTrivia(token.LeadingTrivia.Add(SyntaxFactory.Space)); } break; case TokenSpacingProperties.ActionRemove: bool tokenIsFirstInLine = token.IsFirstInLine(); bool preserveLayout = layout == TokenSpacingProperties.LayoutPreserve; triviaList = prevToken.TrailingTrivia.AddRange(token.LeadingTrivia); if (triviaList.Any(t => t.IsDirective)) { break; } replaceMap[prevToken] = prevToken.WithTrailingTrivia(); if ((!preserveLayout || !tokenIsFirstInLine) && triviaList.All(i => i.IsKind(SyntaxKind.WhitespaceTrivia) || i.IsKind(SyntaxKind.EndOfLineTrivia))) { replaceMap[token] = token.WithLeadingTrivia(); } else if (tokenIsFirstInLine && token.IsLastInLine()) { /* This block covers the case where `token` is the only non-trivia token on its line. However, * the line may still contain non-whitespace trivia which we want the removal process to * preserve. This code fix only removes the whitespace surrounding `token` if it is the only * non-whitespace token on the line. */ int lastNewLineLeading = token.LeadingTrivia.LastIndexOf(SyntaxKind.EndOfLineTrivia); int firstNewLineFollowing = token.TrailingTrivia.IndexOf(SyntaxKind.EndOfLineTrivia); bool onlyWhitespace = true; for (int i = lastNewLineLeading + 1; i < token.LeadingTrivia.Count; i++) { onlyWhitespace &= token.LeadingTrivia[i].IsKind(SyntaxKind.WhitespaceTrivia); } firstNewLineFollowing = firstNewLineFollowing == -1 ? token.TrailingTrivia.Count : firstNewLineFollowing; for (int i = 0; i < firstNewLineFollowing; i++) { onlyWhitespace &= token.TrailingTrivia[i].IsKind(SyntaxKind.WhitespaceTrivia); } if (onlyWhitespace) { // Move the token, and remove the other tokens from its line. Keep all other surrounding // trivia. Keep the last newline that precedes token, but not the first that follows it. SyntaxTriviaList trailingTrivia = prevToken.TrailingTrivia; if (lastNewLineLeading >= 0) { trailingTrivia = trailingTrivia.AddRange(token.LeadingTrivia.Take(lastNewLineLeading + 1)); } // firstNewLineFollowing was adjusted above to account for the missing case. trailingTrivia = trailingTrivia.AddRange(token.TrailingTrivia.Take(firstNewLineFollowing)); replaceMap[token] = token.WithLeadingTrivia().WithTrailingTrivia(trailingTrivia); } else { // Just move the token and keep all surrounding trivia. SyntaxTriviaList trailingTrivia = triviaList.AddRange(token.TrailingTrivia); replaceMap[token] = token.WithLeadingTrivia().WithTrailingTrivia(trailingTrivia); } } else { SyntaxTriviaList trailingTrivia = triviaList.AddRange(token.TrailingTrivia.WithoutLeadingWhitespace(endOfLineIsWhitespace: false)); replaceMap[token] = token.WithLeadingTrivia().WithTrailingTrivia(trailingTrivia); } break; case TokenSpacingProperties.ActionRemoveImmediate: SyntaxTriviaList tokenLeadingTrivia = token.LeadingTrivia; while (tokenLeadingTrivia.Any() && tokenLeadingTrivia.Last().IsKind(SyntaxKind.WhitespaceTrivia)) { tokenLeadingTrivia = tokenLeadingTrivia.RemoveAt(tokenLeadingTrivia.Count - 1); } replaceMap[token] = token.WithLeadingTrivia(tokenLeadingTrivia); if (!tokenLeadingTrivia.Any()) { SyntaxTriviaList previousTrailingTrivia = prevToken.TrailingTrivia; while (previousTrailingTrivia.Any() && previousTrailingTrivia.Last().IsKind(SyntaxKind.WhitespaceTrivia)) { previousTrailingTrivia = previousTrailingTrivia.RemoveAt(previousTrailingTrivia.Count - 1); } replaceMap[prevToken] = prevToken.WithTrailingTrivia(previousTrailingTrivia); } break; } break; case TokenSpacingProperties.LocationFollowing: var nextToken = token.GetNextToken(); switch (action) { case TokenSpacingProperties.ActionInsert: if (!replaceMap.ContainsKey(nextToken)) { replaceMap[token] = token.WithTrailingTrivia(token.TrailingTrivia.Insert(0, SyntaxFactory.Space)); } break; case TokenSpacingProperties.ActionRemove: triviaList = token.TrailingTrivia.AddRange(nextToken.LeadingTrivia); replaceMap[token] = token.WithTrailingTrivia(); replaceMap[nextToken] = nextToken.WithLeadingTrivia(triviaList.WithoutLeadingWhitespace(true)); break; } break; } }
private static SyntaxTriviaList RemoveHeaderDecorationLines(SyntaxTriviaList trivia, StyleCopSettings settings) { if (!string.IsNullOrEmpty(settings.DocumentationRules.HeaderDecoration)) { var decorationRemovalList = new List<int>(); for (int i = 0; i < trivia.Count; i++) { var triviaLine = trivia[i]; if (triviaLine.Kind() == SyntaxKind.SingleLineCommentTrivia && triviaLine.ToFullString().Contains(settings.DocumentationRules.HeaderDecoration)) { decorationRemovalList.Add(i); // also remove the line break if (i + 1 < trivia.Count && trivia[i + 1].Kind() == SyntaxKind.EndOfLineTrivia) { decorationRemovalList.Add(i + 1); } } } // Remove decoration lines in reverse order. for (int i = decorationRemovalList.Count - 1; i >= 0; i--) { trivia = trivia.RemoveAt(decorationRemovalList[i]); } } return trivia; }
private static T RemoveNode <T>( T declaration, Func <T, SyntaxList <MemberDeclarationSyntax> > getMembers, int index, SyntaxRemoveOptions removeOptions) where T : SyntaxNode { SyntaxList <MemberDeclarationSyntax> members = getMembers(declaration); T newDeclaration = declaration.RemoveNode(members[index], removeOptions); if (index == 0 && index < members.Count - 1) { members = getMembers(newDeclaration); MemberDeclarationSyntax nextMember = members[index]; SyntaxTriviaList leadingTrivia = nextMember.GetLeadingTrivia(); SyntaxTrivia trivia = leadingTrivia.FirstOrDefault(); if (trivia.IsEndOfLineTrivia()) { MemberDeclarationSyntax newNextMember = nextMember.WithLeadingTrivia(leadingTrivia.RemoveAt(0)); newDeclaration = newDeclaration.ReplaceNode(nextMember, newNextMember); } } return(newDeclaration); }
private static SyntaxNode RemoveNode(MemberDeclarationSyntax member) { MemberDeclarationListInfo memberList = SyntaxInfo.MemberDeclarationListInfo(member.Parent); SyntaxList <MemberDeclarationSyntax> members = memberList.Members; MemberDeclarationListInfo newMemberList = memberList.RemoveNode(member, SyntaxRemoveOptions.KeepUnbalancedDirectives); int index = members.IndexOf(member); if (index == 0 && index < members.Count - 1) { MemberDeclarationSyntax nextMember = newMemberList[index]; SyntaxTriviaList leadingTrivia = nextMember.GetLeadingTrivia(); if (leadingTrivia.FirstOrDefault().IsEndOfLineTrivia()) { MemberDeclarationSyntax newNextMember = nextMember.WithLeadingTrivia(leadingTrivia.RemoveAt(0)); newMemberList = newMemberList.ReplaceNode(nextMember, newNextMember); } } return(newMemberList.Parent); }
private static SyntaxNode ReplaceHeader(Document document, SyntaxNode root, StyleCopSettings settings, bool isMalformedHeader) { // If the header is well formed Xml then we parse out the copyright otherwise // Skip single line comments, whitespace, and end of line trivia until a blank line is encountered. SyntaxTriviaList trivia = root.GetLeadingTrivia(); bool onBlankLine = false; bool inCopyright = isMalformedHeader; int? copyrightTriviaIndex = null; var removalList = new List <int>(); var leadingSpaces = string.Empty; string possibleLeadingSpaces = string.Empty; // remove header decoration lines, they will be re-generated trivia = RemoveHeaderDecorationLines(trivia, settings); // Need to do this with index so we get the line endings correct. for (int i = 0; i < trivia.Count; i++) { var triviaLine = trivia[i]; bool done = false; switch (triviaLine.Kind()) { case SyntaxKind.SingleLineCommentTrivia: if (possibleLeadingSpaces != string.Empty) { leadingSpaces = possibleLeadingSpaces; } if (!isMalformedHeader) { var openingTag = triviaLine.ToFullString().Contains("<copyright "); var closingTag = triviaLine.ToFullString().Contains("</copyright>") || (openingTag && triviaLine.ToFullString().Trim().EndsWith("/>")); if (openingTag) { inCopyright = !closingTag; copyrightTriviaIndex = i; } else if (inCopyright) { removalList.Add(i); inCopyright = !closingTag; } } else { removalList.Add(i); } onBlankLine = false; break; case SyntaxKind.WhitespaceTrivia: if (leadingSpaces == string.Empty) { possibleLeadingSpaces = triviaLine.ToFullString(); } if (inCopyright) { removalList.Add(i); } break; case SyntaxKind.EndOfLineTrivia: if (inCopyright) { removalList.Add(i); } if (onBlankLine) { done = true; } else { onBlankLine = true; } break; default: done = true; break; } if (done) { break; } } // Remove copyright lines in reverse order. for (int i = removalList.Count - 1; i >= 0; i--) { trivia = trivia.RemoveAt(removalList[i]); } string newLineText = document.Project.Solution.Workspace.Options.GetOption(FormattingOptions.NewLine, LanguageNames.CSharp); var newLineTrivia = SyntaxFactory.EndOfLine(newLineText); var newHeaderTrivia = CreateNewHeader(leadingSpaces + "//", GetFileName(document), settings, newLineText); if (!isMalformedHeader && copyrightTriviaIndex.HasValue) { // Does the copyright element have leading whitespace? If so remove it. if ((copyrightTriviaIndex.Value > 0) && trivia[copyrightTriviaIndex.Value - 1].IsKind(SyntaxKind.WhitespaceTrivia)) { copyrightTriviaIndex--; trivia = trivia.RemoveAt(copyrightTriviaIndex.Value); } // Replace copyright element in place. return(root.WithLeadingTrivia(trivia.ReplaceRange(trivia[copyrightTriviaIndex.Value], newHeaderTrivia))); } else { // Add blank line if we don't already have comments at top of file. if (!FirstLineIsComment(trivia)) { newHeaderTrivia = newHeaderTrivia.Add(newLineTrivia); } // Insert header at top of the file. return(root.WithLeadingTrivia(newHeaderTrivia.Add(newLineTrivia).AddRange(trivia))); } }
private static SyntaxTriviaList RemoveTriviaAtIndex(SyntaxTriviaList newTrivia, int index) { // Remove trivia newTrivia = newTrivia.RemoveAt(index); // Remove end of line after trivia if (index < newTrivia.Count && newTrivia.ElementAt(index).Kind() == SyntaxKind.EndOfLineTrivia) { newTrivia = newTrivia.RemoveAt(index); } return newTrivia; }
private void DoTestAddInsertRemoveReplaceOnEmptyList(SyntaxTriviaList list) { Assert.Equal(0, list.Count); var triviaD = SyntaxFactory.ParseLeadingTrivia("/*D*/")[0]; var triviaE = SyntaxFactory.ParseLeadingTrivia("/*E*/")[0]; var newList = list.Add(triviaD); Assert.Equal(1, newList.Count); Assert.Equal("/*D*/", newList.ToFullString()); newList = list.AddRange(new[] { triviaD, triviaE }); Assert.Equal(2, newList.Count); Assert.Equal("/*D*//*E*/", newList.ToFullString()); newList = list.Insert(0, triviaD); Assert.Equal(1, newList.Count); Assert.Equal("/*D*/", newList.ToFullString()); newList = list.InsertRange(0, new[] { triviaD, triviaE }); Assert.Equal(2, newList.Count); Assert.Equal("/*D*//*E*/", newList.ToFullString()); newList = list.Remove(triviaD); Assert.Equal(0, newList.Count); Assert.Equal(-1, list.IndexOf(triviaD)); Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(0)); Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(1, triviaD)); Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(-1, triviaD)); Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(1, new[] { triviaD })); Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(-1, new[] { triviaD })); Assert.Throws<ArgumentException>(() => list.Replace(triviaD, triviaE)); Assert.Throws<ArgumentException>(() => list.ReplaceRange(triviaD, new[] { triviaE })); Assert.Throws<ArgumentException>(() => list.Add(default(SyntaxTrivia))); Assert.Throws<ArgumentException>(() => list.Insert(0, default(SyntaxTrivia))); Assert.Throws<ArgumentNullException>(() => list.AddRange((IEnumerable<SyntaxTrivia>)null)); Assert.Throws<ArgumentNullException>(() => list.InsertRange(0, (IEnumerable<SyntaxTrivia>)null)); }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); if (!TryFindFirstAncestorOrSelf(root, context.Span, out CompilationUnitSyntax compilationUnit)) { return; } Document document = context.Document; Diagnostic diagnostic = context.Diagnostics[0]; switch (diagnostic.Id) { case DiagnosticIdentifiers.NormalizeWhitespaceAtEndOfFile: { bool preferNewLineAtEndOfFile = document.GetConfigOptions(compilationUnit.SyntaxTree).PreferNewLineAtEndOfFile() ?? false; CodeAction codeAction = CodeAction.Create( (preferNewLineAtEndOfFile) ? CodeFixTitles.AddNewLine : CodeFixTitles.RemoveNewLine, ct => { SyntaxToken endOfFile = compilationUnit.EndOfFileToken; SyntaxTriviaList leading = endOfFile.LeadingTrivia; SyntaxToken oldToken; SyntaxToken newToken; if (!preferNewLineAtEndOfFile) { if (leading.Any()) { SyntaxTrivia last = leading.Last(); if (last.GetStructure() is DirectiveTriviaSyntax directive) { SyntaxTriviaList trailing = directive.GetTrailingTrivia(); DirectiveTriviaSyntax newDirective = directive.WithTrailingTrivia(trailing.RemoveAt(trailing.Count - 1)); return(document.ReplaceNodeAsync(directive, newDirective, ct)); } else { oldToken = endOfFile; int index = leading.Count - 1; for (int i = leading.Count - 2; i >= 0; i--) { if (leading[i].IsWhitespaceOrEndOfLineTrivia()) { index--; } } newToken = oldToken.WithLeadingTrivia(leading.RemoveRange(index, leading.Count - index)); } } else { oldToken = endOfFile.GetPreviousToken(); SyntaxTriviaList trailing = oldToken.TrailingTrivia; newToken = oldToken.WithTrailingTrivia(trailing.RemoveAt(trailing.Count - 1)); } } else if (leading.Any()) { oldToken = endOfFile; if (leading.Span.Start == 0 && leading.All(f => f.IsWhitespaceOrEndOfLineTrivia())) { newToken = oldToken.WithoutLeadingTrivia(); } else { newToken = oldToken.AppendEndOfLineToLeadingTrivia(); } } else { oldToken = endOfFile.GetPreviousToken(); newToken = oldToken.AppendEndOfLineToTrailingTrivia(); } return(document.ReplaceTokenAsync(oldToken, newToken, ct)); }, GetEquivalenceKey(diagnostic)); context.RegisterCodeFix(codeAction, diagnostic); break; } } }