public virtual SyntaxTriviaList VisitList(SyntaxTriviaList list)
{
var count = list.Count;
if (count != 0)
{
SyntaxTriviaListBuilder alternate = null;
var index = -1;
foreach (var item in list)
{
index++;
var visited = this.VisitListElement(item);
//skip the null check since SyntaxTrivia is a value type
if (visited != item && alternate == null)
{
alternate = new SyntaxTriviaListBuilder(count);
alternate.Add(list, 0, index);
}
if (alternate != null && visited.CSharpKind() != SyntaxKind.None)
{
alternate.Add(visited);
}
}
if (alternate != null)
{
return(alternate.ToList());
}
}
return(list);
}
public SyntaxRemover(
SyntaxNode[] nodesToRemove,
SyntaxRemoveOptions options)
: base(nodesToRemove.Any(n => n.IsPartOfStructuredTrivia()))
{
_nodesToRemove = new HashSet <SyntaxNode>(nodesToRemove);
_options = options;
_searchSpan = ComputeTotalSpan(nodesToRemove);
_residualTrivia = SyntaxTriviaListBuilder.Create();
}
private static GreenNode CreateNode(SyntaxTrivia[] trivias)
{
if (trivias == null)
{
return(null);
}
var builder = new SyntaxTriviaListBuilder(trivias.Length);
builder.Add(trivias);
return(builder.ToList().Node);
}
private static void ClearAndFreeBuilder(SyntaxTriviaListBuilder builder)
{
// It's possible someone might create a list with a huge amount of trivia
// in it. We don't want to hold onto such items forever. So only cache
// reasonably sized lists. In IDE testing, around 99% of all trivia lists
// were 16 or less elements.
const int MaxBuilderCount = 16;
if (builder.Count <= MaxBuilderCount)
{
builder.Clear();
s_builderPool.Free(builder);
}
}
/// <summary>
/// Creates a new <see cref="SyntaxTriviaList"/> with the specified trivia inserted at the index.
/// </summary>
/// <param name="index">The index in the list to insert the trivia at.</param>
/// <param name="trivia">The trivia to insert.</param>
public SyntaxTriviaList InsertRange(int index, IEnumerable <SyntaxTrivia> trivia)
{
int thisCount = this.Count;
if (index < 0 || index > thisCount)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
if (trivia == null)
{
throw new ArgumentNullException(nameof(trivia));
}
// Just return ourselves if we're not being asked to add anything.
ICollection <SyntaxTrivia> triviaCollection = trivia as ICollection <SyntaxTrivia>;
if (triviaCollection != null && triviaCollection.Count == 0)
{
return(this);
}
SyntaxTriviaListBuilder builder = GetBuilder();
try
{
for (int i = 0; i < index; i++)
{
builder.Add(this[i]);
}
builder.AddRange(trivia);
for (int i = index; i < thisCount; i++)
{
builder.Add(this[i]);
}
return(builder.Count == thisCount ? this : builder.ToList());
}
finally
{
ClearAndFreeBuilder(builder);
}
}
public void TestStructuredTrivia()
{
var spaceTrivia = SyntaxTriviaListBuilder.Create().Add(SyntaxFactory.Whitespace(" ")).ToList();
var emptyTrivia = SyntaxTriviaListBuilder.Create().ToList();
var name = "goo";
var xmlStartElement = SyntaxFactory.XmlElementStartTag(
SyntaxFactory.Token(spaceTrivia, SyntaxKind.LessThanToken, default(SyntaxTriviaList)),
SyntaxFactory.XmlName(null,
SyntaxFactory.Identifier(name)),
default(SyntaxList <XmlAttributeSyntax>),
SyntaxFactory.Token(default(SyntaxTriviaList), SyntaxKind.GreaterThanToken, spaceTrivia));
var xmlEndElement = SyntaxFactory.XmlElementEndTag(
SyntaxFactory.Token(SyntaxKind.LessThanSlashToken),
SyntaxFactory.XmlName(null,
SyntaxFactory.Identifier(name)),
SyntaxFactory.Token(default(SyntaxTriviaList), SyntaxKind.GreaterThanToken, spaceTrivia));
var xmlElement = SyntaxFactory.XmlElement(xmlStartElement, default(SyntaxList <XmlNodeSyntax>), xmlEndElement);
Assert.Equal(" <goo> </goo> ", xmlElement.ToFullString());
Assert.Equal("<goo> </goo>", xmlElement.ToString());
var docComment = SyntaxFactory.DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia).WithContent(new SyntaxList <XmlNodeSyntax>(xmlElement));
Assert.Equal(" <goo> </goo> ", docComment.ToFullString());
// Assert.Equal("<goo> </goo>", docComment.GetText());
var child = (XmlElementSyntax)docComment.ChildNodesAndTokens()[0];
Assert.Equal(" <goo> </goo> ", child.ToFullString());
Assert.Equal("<goo> </goo>", child.ToString());
Assert.Equal(" <goo> ", child.StartTag.ToFullString());
Assert.Equal("<goo>", child.StartTag.ToString());
var sTrivia = SyntaxFactory.Trivia(docComment);
Assert.NotEqual(default(SyntaxTrivia), sTrivia);
var ident = SyntaxFactory.Identifier(SyntaxTriviaList.Create(sTrivia), "banana", spaceTrivia);
Assert.Equal(" <goo> </goo> banana ", ident.ToFullString());
Assert.Equal("banana", ident.ToString());
Assert.Equal(" <goo> </goo> ", ident.LeadingTrivia[0].ToFullString());
// Assert.Equal("<goo> </goo>", ident.LeadingTrivia[0].GetText());
var identExpr = SyntaxFactory.IdentifierName(ident);
// make sure FindLeaf digs into the structured trivia.
var result = identExpr.FindToken(3, true);
Assert.Equal(SyntaxKind.IdentifierToken, result.Kind());
Assert.Equal("goo", result.ToString());
var trResult = identExpr.FindTrivia(6, SyntaxTrivia.Any);
Assert.Equal(SyntaxKind.WhitespaceTrivia, trResult.Kind());
Assert.Equal(" ", trResult.ToString());
var foundDocComment = result.Parent.Parent.Parent.Parent;
Assert.Null(foundDocComment.Parent);
var identTrivia = identExpr.GetLeadingTrivia()[0];
var foundTrivia = ((DocumentationCommentTriviaSyntax)foundDocComment).ParentTrivia;
Assert.Equal(identTrivia, foundTrivia);
// make sure FindLeafNodesOverlappingWithSpan does not dig into the structured trivia.
var resultList = identExpr.DescendantTokens(t => t.FullSpan.OverlapsWith(new TextSpan(3, 18)));
Assert.Equal(1, resultList.Count());
}
/// <summary>
/// Creates a list of trivia.
/// </summary>
/// <param name="trivias">A sequence of trivia.</param>
public SyntaxTriviaList(IEnumerable <SyntaxTrivia> trivias)
: this(default, SyntaxTriviaListBuilder.Create(trivias).Node, 0, 0)
{
}
