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); }