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 static SyntaxTriviaList FixTriviaList(SyntaxTriviaList triviaList, IEnumerable <SyntaxTrivia> commentTrivias)
{
foreach (var singleLineComment in commentTrivias)
{
var index = triviaList.IndexOf(singleLineComment);
if (index == -1)
{
continue;
}
index--;
while (index >= 0)
{
switch (triviaList[index].Kind())
{
case SyntaxKind.WhitespaceTrivia:
index--;
break;
default:
triviaList = triviaList.ReplaceRange(triviaList[index], new[] { triviaList[index], SyntaxFactory.CarriageReturnLineFeed });
// We found the trivia so we don't have to loop any longer
index = -2;
break;
}
}
if (index == -1)
{
triviaList = triviaList.ReplaceRange(triviaList[0], new[] { SyntaxFactory.CarriageReturnLineFeed, triviaList[0] });
}
}
return(triviaList);
}
public override SyntaxTriviaList VisitList(SyntaxTriviaList list)
{
var index = list.IndexOf(_originalTrivia);
if (index >= 0 && index < list.Count)
{
switch (editKind)
{
case ListEditKind.Replace:
return(list.ReplaceRange(_originalTrivia, _newTrivia));
case ListEditKind.InsertAfter:
return(list.InsertRange(index + 1, _newTrivia));
case ListEditKind.InsertBefore:
return(list.InsertRange(index, _newTrivia));
}
}
return(base.VisitList(list));
}
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 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));
}
private static SyntaxTriviaList FixTriviaList(SyntaxTriviaList triviaList, IEnumerable<SyntaxTrivia> commentTrivias)
{
foreach (var singleLineComment in commentTrivias)
{
var index = triviaList.IndexOf(singleLineComment);
if (index == -1)
{
continue;
}
index--;
while (index >= 0)
{
switch (triviaList[index].Kind())
{
case SyntaxKind.WhitespaceTrivia:
index--;
break;
default:
triviaList = triviaList.ReplaceRange(triviaList[index], new[] { triviaList[index], SyntaxFactory.CarriageReturnLineFeed });
// We found the trivia so we don't have to loop any longer
index = -2;
break;
}
}
if (index == -1)
{
triviaList = triviaList.ReplaceRange(triviaList[0], new[] { SyntaxFactory.CarriageReturnLineFeed, triviaList[0] });
}
}
return triviaList;
}
