public override SyntaxList <TNode> VisitList <TNode>(SyntaxList <TNode> list)
{
if (_originalNode is TNode)
{
var index = list.IndexOf((TNode)_originalNode);
if (index >= 0 && index < list.Count)
{
switch (this.editKind)
{
case ListEditKind.Replace:
return(list.ReplaceRange(
(TNode)_originalNode,
_newNodes.Cast <TNode>()
));
case ListEditKind.InsertAfter:
return(list.InsertRange(index + 1, _newNodes.Cast <TNode>()));
case ListEditKind.InsertBefore:
return(list.InsertRange(index, _newNodes.Cast <TNode>()));
}
}
}
return(base.VisitList <TNode>(list));
}
protected static int DetermineConstantInsertPosition(
SyntaxList<MemberDeclarationSyntax> oldMembers,
SyntaxList<MemberDeclarationSyntax> newMembers)
{
// 1) Place the constant after the last constant.
//
// 2) If there is no constant, place it before the first field
//
// 3) If the first change is before either of those, then place before the first
// change
//
// 4) Otherwise, place it at the start.
var index = 0;
var lastConstantIndex = oldMembers.LastIndexOf(IsConstantField);
if (lastConstantIndex >= 0)
{
index = lastConstantIndex + 1;
}
else
{
var firstFieldIndex = oldMembers.IndexOf(member => member is FieldDeclarationSyntax);
if (firstFieldIndex >= 0)
{
index = firstFieldIndex;
}
}
var firstChangeIndex = DetermineFirstChange(oldMembers, newMembers);
if (firstChangeIndex >= 0)
{
index = Math.Min(index, firstChangeIndex);
}
return index;
}
private void DoTestAddInsertRemoveReplaceOnEmptyList(SyntaxList<SyntaxNode> list)
{
Assert.Equal(0, list.Count);
SyntaxNode nodeD = SyntaxFactory.ParseExpression("D ");
SyntaxNode nodeE = SyntaxFactory.ParseExpression("E ");
var newList = list.Add(nodeD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.AddRange(new[] { nodeD, nodeE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Insert(0, nodeD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.InsertRange(0, new[] { nodeD, nodeE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Remove(nodeD);
Assert.Equal(0, newList.Count);
Assert.Equal(-1, list.IndexOf(nodeD));
Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(0));
Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(1, nodeD));
Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(-1, nodeD));
Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(1, new[] { nodeD }));
Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(-1, new[] { nodeD }));
Assert.Throws<ArgumentException>(() => list.Replace(nodeD, nodeE));
Assert.Throws<ArgumentException>(() => list.ReplaceRange(nodeD, new[] { nodeE }));
Assert.Throws<ArgumentNullException>(() => list.Add(null));
Assert.Throws<ArgumentNullException>(() => list.AddRange((IEnumerable<SyntaxNode>)null));
Assert.Throws<ArgumentNullException>(() => list.Insert(0, null));
Assert.Throws<ArgumentNullException>(() => list.InsertRange(0, (IEnumerable<SyntaxNode>)null));
}
private static SyntaxNode OrderMember(MemberOrderHelper memberOrder, SyntaxList<MemberDeclarationSyntax> members, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
var memberIndex = members.IndexOf(memberOrder.Member);
MemberOrderHelper target = default(MemberOrderHelper);
for (var i = memberIndex - 1; i >= 0; --i)
{
var orderHelper = new MemberOrderHelper(members[i], checks);
if (orderHelper.Priority < memberOrder.Priority)
{
target = orderHelper;
}
else
{
break;
}
}
return target.Member != null ? MoveMember(syntaxRoot, memberOrder.Member, target.Member, indentationOptions) : syntaxRoot;
}
