private static List <BaseFieldDeclarationSyntax> DeclarationSplitter(
Document document,
VariableDeclarationSyntax declaration,
Func <VariableDeclarationSyntax, BaseFieldDeclarationSyntax> declarationFactory,
SyntaxTriviaList declarationTrailingTrivia)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declaration.Variables;
VariableDeclaratorSyntax first = variables.First();
BaseFieldDeclarationSyntax previous = null;
var newFieldDeclarations = new List <BaseFieldDeclarationSyntax>(variables.Count);
foreach (SyntaxNodeOrToken nodeOrToken in variables.GetWithSeparators())
{
if (previous == null)
{
VariableDeclaratorSyntax variable = (VariableDeclaratorSyntax)nodeOrToken.AsNode();
variable = variable.WithIdentifier(variable.Identifier.WithoutLeadingWhitespace());
var variableDeclarator = SyntaxFactory.SingletonSeparatedList(variable);
previous = declarationFactory(declaration.WithVariables(variableDeclarator));
if (variable != first)
{
var triviaList = previous.GetLeadingTrivia().WithoutDirectiveTrivia();
previous = previous.WithLeadingTrivia(triviaList);
}
}
else
{
SyntaxToken commaToken = nodeOrToken.AsToken();
SyntaxTriviaList trailingTrivia = commaToken.TrailingTrivia;
if (trailingTrivia.Any())
{
if (!trailingTrivia.Last().IsKind(SyntaxKind.EndOfLineTrivia))
{
trailingTrivia = trailingTrivia.WithoutTrailingWhitespace().Add(FormattingHelper.GetNewLineTrivia(document));
}
}
else
{
trailingTrivia = SyntaxTriviaList.Create(FormattingHelper.GetNewLineTrivia(document));
}
newFieldDeclarations.Add(previous.WithTrailingTrivia(trailingTrivia));
previous = null;
}
}
newFieldDeclarations.Add(previous.WithTrailingTrivia(declarationTrailingTrivia));
return(newFieldDeclarations);
}
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;
SyntaxToken nextToken;
switch (location)
{
case TokenSpacingProperties.LocationPreceding:
var prevToken = token.GetPreviousToken();
switch (action)
{
case TokenSpacingProperties.ActionInsert:
if (!replaceMap.ContainsKey(prevToken))
{
UpdateReplaceMap(replaceMap, token, t => t.WithLeadingTrivia(t.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;
}
UpdateReplaceMap(replaceMap, prevToken, t => t.WithTrailingTrivia());
if ((!preserveLayout || !tokenIsFirstInLine) &&
triviaList.All(i => i.IsKind(SyntaxKind.WhitespaceTrivia) || i.IsKind(SyntaxKind.EndOfLineTrivia)))
{
UpdateReplaceMap(replaceMap, token, t => t.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));
UpdateReplaceMap(replaceMap, token, t => t.WithLeadingTrivia().WithTrailingTrivia(trailingTrivia));
}
else
{
// Just move the token and keep all surrounding trivia.
SyntaxTriviaList trailingTrivia = triviaList.AddRange(token.TrailingTrivia);
UpdateReplaceMap(replaceMap, token, t => t.WithLeadingTrivia().WithTrailingTrivia(trailingTrivia));
}
}
else
{
SyntaxTriviaList trailingTrivia = triviaList.AddRange(token.TrailingTrivia.WithoutLeadingWhitespace(endOfLineIsWhitespace: false));
nextToken = token.GetNextToken();
if (nextToken.IsKind(SyntaxKind.SemicolonToken))
{
// make the semicolon 'sticky'
UpdateReplaceMap(replaceMap, token, t => t.WithLeadingTrivia().WithTrailingTrivia());
UpdateReplaceMap(replaceMap, nextToken, t => t.WithLeadingTrivia().WithTrailingTrivia(trailingTrivia.WithoutTrailingWhitespace()));
}
else
{
UpdateReplaceMap(replaceMap, token, t => t.WithLeadingTrivia().WithTrailingTrivia(trailingTrivia));
}
}
break;
case TokenSpacingProperties.ActionRemoveImmediate:
UpdateReplaceMap(replaceMap, token, t => t.WithLeadingTrivia(t.LeadingTrivia.WithoutTrailingWhitespace(endOfLineIsWhitespace: false)));
if (!replaceMap[token].LeadingTrivia.Any())
{
UpdateReplaceMap(replaceMap, prevToken, t => t.WithTrailingTrivia(t.TrailingTrivia.WithoutTrailingWhitespace(endOfLineIsWhitespace: false)));
}
break;
}
break;
case TokenSpacingProperties.LocationFollowing:
nextToken = token.GetNextToken();
switch (action)
{
case TokenSpacingProperties.ActionInsert:
if (!replaceMap.ContainsKey(nextToken))
{
// If the token is already present in the map and it has trailing trivia, then it has already been
// processed during an earlier step in the fix all process, so no additional processing is needed.
if (!replaceMap.ContainsKey(token) || (replaceMap[token].TrailingTrivia.Count == 0))
{
UpdateReplaceMap(replaceMap, token, t => t.WithTrailingTrivia(t.TrailingTrivia.Insert(0, SyntaxFactory.Space)));
}
}
break;
case TokenSpacingProperties.ActionRemove:
triviaList = token.TrailingTrivia.AddRange(nextToken.LeadingTrivia);
bool preserveLayout = layout == TokenSpacingProperties.LayoutPreserve;
UpdateReplaceMap(replaceMap, token, t => t.WithTrailingTrivia());
UpdateReplaceMap(replaceMap, nextToken, t => t.WithLeadingTrivia(triviaList.WithoutLeadingWhitespace(endOfLineIsWhitespace: !preserveLayout)));
break;
}
break;
}
}
private static List <BaseFieldDeclarationSyntax> DeclarationSplitter(
Document document,
VariableDeclarationSyntax declaration,
Func <VariableDeclarationSyntax, BaseFieldDeclarationSyntax> declarationFactory,
SyntaxTriviaList declarationTrailingTrivia)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declaration.Variables;
VariableDeclaratorSyntax first = variables.First();
BaseFieldDeclarationSyntax previous = null;
var newFieldDeclarations = new List <BaseFieldDeclarationSyntax>(variables.Count);
foreach (SyntaxNodeOrToken nodeOrToken in variables.GetWithSeparators())
{
if (previous == null)
{
VariableDeclaratorSyntax variable = (VariableDeclaratorSyntax)nodeOrToken.AsNode();
variable = variable.WithIdentifier(variable.Identifier.WithoutLeadingWhitespace());
var variableDeclarator = SyntaxFactory.SingletonSeparatedList(variable);
previous = declarationFactory(declaration.WithVariables(variableDeclarator));
if (variable != first)
{
var triviaList = previous.GetLeadingTrivia().WithoutDirectiveTrivia();
// Remove all leading blank lines
var nonBlankLinetriviaIndex = TriviaHelper.IndexOfFirstNonBlankLineTrivia(triviaList);
if (nonBlankLinetriviaIndex > 0)
{
triviaList = triviaList.RemoveRange(0, nonBlankLinetriviaIndex);
}
// Add a blank line if the first line contains a comment.
var nonWhitespaceTriviaIndex = TriviaHelper.IndexOfFirstNonWhitespaceTrivia(triviaList, false);
if (nonWhitespaceTriviaIndex >= 0)
{
switch (triviaList[nonWhitespaceTriviaIndex].Kind())
{
case SyntaxKind.SingleLineCommentTrivia:
case SyntaxKind.MultiLineCommentTrivia:
triviaList = triviaList.Insert(0, SyntaxFactory.CarriageReturnLineFeed);
break;
}
}
previous = previous.WithLeadingTrivia(triviaList);
}
}
else
{
SyntaxToken commaToken = nodeOrToken.AsToken();
SyntaxTriviaList trailingTrivia = commaToken.TrailingTrivia;
if (trailingTrivia.Any())
{
if (!trailingTrivia.Last().IsKind(SyntaxKind.EndOfLineTrivia))
{
trailingTrivia = trailingTrivia.WithoutTrailingWhitespace().Add(FormattingHelper.GetNewLineTrivia(document));
}
}
else
{
trailingTrivia = SyntaxTriviaList.Create(FormattingHelper.GetNewLineTrivia(document));
}
newFieldDeclarations.Add(previous.WithTrailingTrivia(trailingTrivia));
previous = null;
}
}
newFieldDeclarations.Add(previous.WithTrailingTrivia(declarationTrailingTrivia));
return(newFieldDeclarations);
}