private void DoTestAddInsertRemoveReplaceOnEmptyList(SyntaxNodeOrTokenList list)
{
Assert.Equal(0, list.Count);
SyntaxNodeOrToken tokenD = SyntaxFactory.ParseToken("D ");
SyntaxNodeOrToken nodeE = SyntaxFactory.ParseExpression("E ");
var newList = list.Add(tokenD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.AddRange(new[] { tokenD, nodeE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Insert(0, tokenD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.InsertRange(0, new[] { tokenD, nodeE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Remove(tokenD);
Assert.Equal(0, newList.Count);
Assert.Equal(-1, list.IndexOf(tokenD));
Assert.Throws <ArgumentOutOfRangeException>(() => list.RemoveAt(0));
Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(1, tokenD));
Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(-1, tokenD));
Assert.Throws <ArgumentOutOfRangeException>(() => list.InsertRange(1, new[] { tokenD }));
Assert.Throws <ArgumentOutOfRangeException>(
() => list.InsertRange(-1, new[] { tokenD })
);
Assert.Throws <ArgumentOutOfRangeException>(() => list.Add(default(SyntaxNodeOrToken)));
Assert.Throws <ArgumentOutOfRangeException>(
() => list.Insert(0, default(SyntaxNodeOrToken))
);
Assert.Throws <ArgumentNullException>(
() => list.AddRange((IEnumerable <SyntaxNodeOrToken>)null)
);
Assert.Throws <ArgumentNullException>(
() => list.InsertRange(0, (IEnumerable <SyntaxNodeOrToken>)null)
);
}
public static TypeArgumentListSyntax AsList(params TypeSyntax[] types)
{
SyntaxNodeOrTokenList list = new SyntaxNodeOrTokenList();
var last = types.Length > 0 ? types.Last() : null;
foreach (var type in types)
{
list = list.Add(type);
if (!type.Equals(last))
{
list = list.Add(Token.Comma);
}
}
return SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList<TypeSyntax>(list))
.WithLessThanToken(Token.LessThan)
.WithGreaterThanToken(Token.GreaterThan);
}
public static ArgumentListSyntax AsList(params ArgumentSyntax[] arguments)
{
SyntaxNodeOrTokenList list = new SyntaxNodeOrTokenList();
var last = arguments.Length > 0 ? arguments.Last() : null;
foreach (var argument in arguments)
{
list = list.Add(argument);
if (!argument.Equals(last))
{
list = list.Add(Token.Comma);
}
}
return SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList<ArgumentSyntax>(list))
.WithOpenParenToken(Token.OpenParen)
.WithCloseParenToken(Token.CloseParen);
}
/**
* start a new procedure/function
*/
private static MethodDeclarationSyntax StartFunction([NotNull] FunctionDeclaration functionDeclaration)
{
var method =
SyntaxFactory.MethodDeclaration(GetTypeName(functionDeclaration.ReturnType), functionDeclaration.Name);
if (!functionDeclaration.Block.Declarations.Any(x => x is ProcedureParameterDeclaration))
{
return(method);
}
var list = new SyntaxNodeOrTokenList();
bool first = true;
foreach (var declaration in functionDeclaration.Block.Declarations.OfType <ProcedureParameterDeclaration>())
{
if (!first)
{
list = list.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
first = false;
var param = SyntaxFactory.Parameter(MapIdentifier(declaration.Name))
.WithType(AddTypeSyntaxSpecification(declaration));
if (declaration.IsVar)
{
param = param.WithModifiers(SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.RefKeyword)));
}
list = list.Add(param);
}
if (list.Any())
{
method = method.WithParameterList(SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList <ParameterSyntax>(list)));
}
return(method);
}
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 void DoTestAddInsertRemoveReplaceOnEmptyList(SyntaxNodeOrTokenList list)
{
Assert.Equal(0, list.Count);
SyntaxNodeOrToken tokenD = SyntaxFactory.ParseToken("D ");
SyntaxNodeOrToken nodeE = SyntaxFactory.ParseExpression("E ");
var newList = list.Add(tokenD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.AddRange(new[] { tokenD, nodeE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Insert(0, tokenD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.InsertRange(0, new[] { tokenD, nodeE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Remove(tokenD);
Assert.Equal(0, newList.Count);
Assert.Equal(-1, list.IndexOf(tokenD));
Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(0));
Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(1, tokenD));
Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(-1, tokenD));
Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(1, new[] { tokenD }));
Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(-1, new[] { tokenD }));
Assert.Throws<ArgumentException>(() => list.Add(default(SyntaxNodeOrToken)));
Assert.Throws<ArgumentException>(() => list.Insert(0, default(SyntaxNodeOrToken)));
Assert.Throws<ArgumentNullException>(() => list.AddRange((IEnumerable<SyntaxNodeOrToken>)null));
Assert.Throws<ArgumentNullException>(() => list.InsertRange(0, (IEnumerable<SyntaxNodeOrToken>)null));
}
