private IndentationResult?GetIndentationFromCommaSeparatedList <T>(SeparatedSyntaxList <T> list, SyntaxToken token) where T : SyntaxNode
{
var index = list.GetWithSeparators().IndexOf(token);
if (index < 0)
{
return(GetDefaultIndentationFromToken(token));
}
// find node that starts at the beginning of a line
var snapshot = LineToBeIndented.Snapshot;
for (int i = (index - 1) / 2; i >= 0; i--)
{
var node = list[i];
var firstToken = node.GetFirstToken(includeZeroWidth: true);
if (firstToken.IsFirstTokenOnLine(snapshot))
{
return(GetIndentationOfLine(snapshot.GetLineFromPosition(firstToken.SpanStart)));
}
}
// smart indenter has a special indent block rule for comma separated list, so don't
// need to add default additional space for multiline expressions
return(GetDefaultIndentationFromTokenLine(token, additionalSpace: 0));
}
public SeparatedSyntaxListBuilder <TNode> AddRange(SeparatedSyntaxList <TNode> nodes, int count)
{
CheckExpectedElement();
SyntaxNodeOrTokenList list = nodes.GetWithSeparators();
_builder.AddRange(list, this.Count, Math.Min(count << 1, list.Count));
_expectedSeparator = ((_builder.Count & 1) != 0);
return(this);
}
public SeparatedSyntaxListBuilder <TNode> AddRange(SeparatedSyntaxList <TNode> nodes)
{
CheckExpectedElement();
SyntaxNodeOrTokenList list = nodes.GetWithSeparators();
_builder.AddRange(list);
_expectedSeparator = ((_builder.Count & 1) != 0);
return(this);
}
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);
}
public SeparatedSyntaxList <TNode> VisitList <TNode>(SeparatedSyntaxList <TNode> list) where TNode : LuaSyntaxNode
{
// A separated list is filled with Lua nodes and Lua tokens. Both of which
// derive from InternalSyntax.LuaSyntaxNode. So this cast is appropriately
// typesafe.
var withSeps = (SyntaxList <LuaSyntaxNode>)list.GetWithSeparators();
var result = VisitList(withSeps);
if (result != withSeps)
{
return(result.AsSeparatedList <TNode>());
}
return(list);
}
private ImmutableArray <Edit> GetWrapLongLinesEdits(
WrappingStyle wrappingStyle, SyntaxTrivia indentationTrivia)
{
var result = ArrayBuilder <Edit> .GetInstance();
AddTextChangeBetweenOpenAndFirstItem(wrappingStyle, result);
var currentOffset = wrappingStyle == WrappingStyle.WrapFirst_IndentRest
? indentationTrivia.FullWidth()
: _afterOpenTokenIndentationTrivia.FullWidth();
var itemsAndSeparators = _listItems.GetWithSeparators();
for (var i = 0; i < itemsAndSeparators.Count; i += 2)
{
var item = itemsAndSeparators[i].AsNode();
// Figure out where we'd be after this item.
currentOffset += item.Span.Length;
if (i > 0)
{
if (currentOffset < WrappingColumn)
{
// this item would not make us go pass our preferred wrapping column. So
// keep it on this line, making sure there's a space between the previous
// comma and us.
result.Add(Edit.UpdateBetween(itemsAndSeparators[i - 1], SingleWhitespaceTrivia, NoTrivia, item));
currentOffset += " ".Length;
}
else
{
// not the first item on the line and this item makes us go past the wrapping
// limit. We want to wrap before this item.
result.Add(Edit.UpdateBetween(itemsAndSeparators[i - 1], NewLineTrivia, indentationTrivia, item));
currentOffset = indentationTrivia.FullWidth() + item.Span.Length;
}
}
// Get rid of any spaces between the list item and the following token (a
// comma or close token).
var nextToken = item.GetLastToken().GetNextToken();
result.Add(Edit.DeleteBetween(item, nextToken));
currentOffset += nextToken.Span.Length;
}
return(result.ToImmutableAndFree());
}
private static TypeArgumentListSyntax ParameterToArgumentListSyntax(TypeParameterListSyntax typeParameters)
{
var list = new SeparatedSyntaxList <TypeSyntax>();
list = list.AddRange(typeParameters.Parameters.Select(p => SyntaxFactory.ParseName(p.ToString()).WithTriviaFrom(p)));
for (int i = 0; i < list.SeparatorCount; i++)
{
var separator = list.GetSeparator(i);
// Make sure the parameter list looks nice
// Cannot use ReplaceSeparator due to dotnet/roslyn#2630: https://github.com/dotnet/roslyn/issues/2630
list = SyntaxFactory.SeparatedList <TypeSyntax>(list.GetWithSeparators().Replace(separator, separator.WithTrailingTrivia(SyntaxFactory.Space)));
}
return(SyntaxFactory.TypeArgumentList(list));
}
private static async Task <Document> SortEnumMembersAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SpecialType enumSpecialType = semanticModel.GetDeclaredSymbol(enumDeclaration).EnumUnderlyingType.SpecialType;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = members
.OrderBy(f => GetConstantValue(f, semanticModel, cancellationToken), EnumValueComparer.GetInstance(enumSpecialType))
.ToSeparatedSyntaxList();
if (AreSeparatedWithEmptyLine(members))
{
for (int i = 0; i < newMembers.Count; i++)
{
newMembers = newMembers.ReplaceAt(i, newMembers[i].TrimLeadingTrivia());
}
for (int i = 0; i < newMembers.Count - 1; i++)
{
SyntaxToken separator = newMembers.GetSeparator(i);
newMembers = newMembers.ReplaceSeparator(
separator,
separator.TrimTrailingTrivia().AppendToTrailingTrivia(new SyntaxTrivia[] { NewLine(), NewLine() }));
}
}
if (newMembers.SeparatorCount == members.SeparatorCount - 1)
{
SyntaxNodeOrTokenList newMembersWithSeparators = newMembers.GetWithSeparators();
newMembersWithSeparators = newMembersWithSeparators.Add(CommaToken());
newMembers = newMembersWithSeparators.ToSeparatedSyntaxList <EnumMemberDeclarationSyntax>();
}
MemberDeclarationSyntax newNode = enumDeclaration
.WithMembers(newMembers)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
private SeparatedSyntaxList <ArgumentSyntax> CreateArguments(SeparatedSyntaxList <AnonymousObjectMemberDeclaratorSyntax> initializers) => SyntaxFactory.SeparatedList <ArgumentSyntax>(CreateArguments(initializers.GetWithSeparators()));
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);
}
public override SyntaxNodeOrTokenList GetWithSeparators() => SyntaxList.GetWithSeparators();
protected override SyntaxNodeOrTokenList ToNodesOrTokens(SeparatedSyntaxList <TElementNode> value) => value.GetWithSeparators();
// deal with separated lists and removal of associated separators
public override SeparatedSyntaxList <TNode> VisitList <TNode>(SeparatedSyntaxList <TNode> list)
{
var eolKind = Language.SyntaxFacts.DefaultEndOfLineKind;
var withSeps = list.GetWithSeparators();
bool removeNextSeparator = false;
SyntaxNodeOrTokenListBuilder alternate = null;
for (int i = 0, n = withSeps.Count; i < n; i++)
{
var item = withSeps[i];
SyntaxNodeOrToken visited;
if (item.IsToken) // separator
{
if (removeNextSeparator)
{
removeNextSeparator = false;
visited = default(SyntaxNodeOrToken);
}
else
{
visited = this.VisitListSeparator(item.AsToken());
}
}
else
{
var node = (TNode)item.AsNode();
if (this.IsForRemoval(node))
{
if (alternate == null)
{
alternate = new SyntaxNodeOrTokenListBuilder(n);
alternate.Add(withSeps, 0, i);
}
CommonSyntaxNodeRemover.GetSeparatorInfo(
withSeps, i, eolKind.GetValue(),
out bool nextTokenIsSeparator, out bool nextSeparatorBelongsToNode);
if (!nextSeparatorBelongsToNode &&
alternate.Count > 0 &&
alternate[alternate.Count - 1].IsToken)
{
var separator = alternate[alternate.Count - 1].AsToken();
this.AddTrivia(separator, node);
alternate.RemoveLast();
}
else if (nextTokenIsSeparator)
{
var separator = withSeps[i + 1].AsToken();
this.AddTrivia(node, separator);
removeNextSeparator = true;
}
else
{
this.AddTrivia(node);
}
visited = default;
}
else
{
visited = this.VisitListElement((TNode)item.AsNode());
}
}
if (item != visited && alternate == null)
{
alternate = new SyntaxNodeOrTokenListBuilder(n);
alternate.Add(withSeps, 0, i);
}
if (alternate != null && visited.GetKind() != SyntaxKind.None)
{
alternate.Add(visited);
}
}
if (alternate != null)
{
return(alternate.ToList().AsSeparatedList <TNode>());
}
return(list);
}