private static bool IsListUnsorted(
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members,
SemanticModel semanticModel,
CancellationToken cancellationToken = default)
{
int count = members.Count;
if (count > 1)
{
IFieldSymbol firstField = semanticModel.GetDeclaredSymbol(members[0], cancellationToken);
if (firstField?.HasConstantValue == true)
{
SpecialType enumSpecialType = firstField.ContainingType.EnumUnderlyingType.SpecialType;
object previousValue = firstField.ConstantValue;
for (int i = 1; i < count - 1; i++)
{
IFieldSymbol field = semanticModel.GetDeclaredSymbol(members[i], cancellationToken);
if (field?.HasConstantValue != true)
{
return(false);
}
object value = field.ConstantValue;
if (EnumValueComparer.GetInstance(enumSpecialType).Compare(previousValue, value) > 0)
{
i++;
while (i < count)
{
if (semanticModel.GetDeclaredSymbol(members[i], cancellationToken)?.HasConstantValue != true)
{
return(false);
}
i++;
}
return(true);
}
previousValue = value;
}
}
}
return(false);
}
public static bool IsSorted(
IEnumerable <EnumMemberDeclarationSyntax> enumMembers,
SemanticModel semanticModel,
CancellationToken cancellationToken = default)
{
if (enumMembers == null)
{
throw new ArgumentNullException(nameof(enumMembers));
}
if (semanticModel == null)
{
throw new ArgumentNullException(nameof(semanticModel));
}
using (IEnumerator <EnumMemberDeclarationSyntax> en = enumMembers.GetEnumerator())
{
if (en.MoveNext())
{
IFieldSymbol fieldSymbol1 = semanticModel.GetDeclaredSymbol(en.Current, cancellationToken);
SpecialType enumSpecialType = fieldSymbol1.ContainingType.EnumUnderlyingType.SpecialType;
IComparer <object> comparer = EnumValueComparer.GetInstance(enumSpecialType);
while (en.MoveNext())
{
IFieldSymbol fieldSymbol2 = semanticModel.GetDeclaredSymbol(en.Current, cancellationToken);
if (Compare(fieldSymbol1, fieldSymbol2, comparer) > 0)
{
return(false);
}
fieldSymbol1 = fieldSymbol2;
}
}
}
return(true);
}
private static async Task <Document> SortByValueAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selectedMembers,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SpecialType enumSpecialType = semanticModel.GetDeclaredSymbol(enumDeclaration, cancellationToken).EnumUnderlyingType.SpecialType;
var comparer = new EnumMemberDeclarationValueComparer(EnumValueComparer.GetInstance(enumSpecialType), semanticModel, cancellationToken);
IEnumerable <EnumMemberDeclarationSyntax> sorted = selectedMembers.OrderBy(f => f, comparer);
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = enumDeclaration
.Members
.ReplaceRange(selectedMembers.FirstIndex, selectedMembers.Count, sorted);
MemberDeclarationSyntax newNode = enumDeclaration.WithMembers(newMembers);
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
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));
}
public static async Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SpecialType enumSpecialType = semanticModel.GetDeclaredSymbol(enumDeclaration).EnumUnderlyingType.SpecialType;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = enumDeclaration.Members
.OrderBy(f => GetConstantValue(f, semanticModel, cancellationToken), EnumValueComparer.GetInstance(enumSpecialType))
.ToSeparatedSyntaxList();
MemberDeclarationSyntax newNode = enumDeclaration
.WithMembers(newMembers)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
