public static void InitializedWithOther(MemberDeclarationSyntax x, MemberDeclarationSyntax y)
{
Assert.AreEqual(-1, MemberDeclarationComparer.Compare(x, y));
Assert.AreEqual(1, MemberDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(y, y));
}
public void MemberDeclarationComparerCompare(MethodDeclarationSyntax x, MethodDeclarationSyntax y)
{
Assert.AreEqual(-1, MemberDeclarationComparer.Compare(x, y));
Assert.AreEqual(1, MemberDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(y, y));
}
public static void MemberDeclarationComparerCompare(PropertyDeclarationSyntax x, PropertyDeclarationSyntax y)
{
Assert.AreEqual(-1, MemberDeclarationComparer.Compare(x, y));
Assert.AreEqual(1, MemberDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(y, y));
}
private static void ComputeRefactoring(RefactoringContext context, MemberDeclarationListSelection selectedMembers)
{
if (selectedMembers.Count <= 1)
{
return;
}
SyntaxKind kind = GetSingleKindOrDefault(selectedMembers);
if (kind != SyntaxKind.None)
{
if (MemberDeclarationComparer.CanBeSortedByName(kind))
{
ComputeRefactoring(
context,
MemberDeclarationComparer.ByKindThenByName,
"Sort members by name",
selectedMembers);
}
}
else
{
ComputeRefactoring(
context,
MemberDeclarationComparer.ByKind,
"Sort members by kind",
selectedMembers);
ComputeRefactoring(
context,
MemberDeclarationComparer.ByKindThenByName,
"Sort members by kind then by name",
selectedMembers);
}
}
public static void AttachedProperty(FieldDeclarationSyntax x, FieldDeclarationSyntax y)
{
Assert.AreEqual(-1, FieldDeclarationComparer.Compare(x, y));
Assert.AreEqual(1, FieldDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, FieldDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, FieldDeclarationComparer.Compare(y, y));
Assert.AreEqual(-1, MemberDeclarationComparer.Compare(x, y));
Assert.AreEqual(1, MemberDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(y, y));
}
public static void BackingField(FieldDeclarationSyntax x, FieldDeclarationSyntax y)
{
Assert.AreEqual(-1, FieldDeclarationComparer.Compare(x, y));
Assert.AreEqual(1, FieldDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, FieldDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, FieldDeclarationComparer.Compare(y, y));
Assert.AreEqual(-1, MemberDeclarationComparer.Compare(x, y));
Assert.AreEqual(1, MemberDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(y, y));
}
public static void CompareAttachedPropertyMethods(MethodDeclarationSyntax x, MethodDeclarationSyntax y)
{
Assert.AreEqual(-1, MethodDeclarationComparer.Compare(x, y));
Assert.AreEqual(1, MethodDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, MethodDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, MethodDeclarationComparer.Compare(y, y));
Assert.AreEqual(-1, MemberDeclarationComparer.Compare(x, y));
Assert.AreEqual(1, MemberDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(y, y));
}
private static SyntaxList <MemberDeclarationSyntax> WithMoved(SyntaxList <MemberDeclarationSyntax> members, MemberDeclarationSyntax member)
{
members = members.Remove(member);
for (var i = 0; i < members.Count; i++)
{
var current = members[i];
if (MemberDeclarationComparer.Compare(member, current) < 0)
{
return(RemoveLeadingEndOfLine(members.Insert(i, UpdateLineFeed(member))));
}
}
return(RemoveLeadingEndOfLine(members.Add(UpdateLineFeed(member))));
}
private static void ComputeRefactoring(
RefactoringContext context,
MemberDeclarationSortMode sortMode,
string title,
MemberDeclarationSelection selectedMembers,
ImmutableArray <MemberDeclarationSyntax> members)
{
if (!MemberDeclarationComparer.GetInstance(sortMode).IsSorted(members))
{
context.RegisterRefactoring(
title,
cancellationToken => RefactorAsync(context.Document, selectedMembers, sortMode, cancellationToken));
}
}
private static void ComputeRefactoring(
RefactoringContext context,
MemberDeclarationComparer comparer,
string title,
MemberDeclarationListSelection selectedMembers)
{
if (selectedMembers.IsSorted(comparer))
{
return;
}
context.RegisterRefactoring(
title,
cancellationToken => RefactorAsync(context.Document, selectedMembers, comparer, cancellationToken));
}
private static Task <Document> RefactorAsync(
Document document,
MemberDeclarationListSelection selectedMembers,
MemberDeclarationComparer comparer,
CancellationToken cancellationToken)
{
IEnumerable <MemberDeclarationSyntax> sorted = selectedMembers.OrderBy(f => f, comparer);
MemberDeclarationListInfo info = SyntaxInfo.MemberDeclarationListInfo(selectedMembers);
SyntaxList <MemberDeclarationSyntax> newMembers = info
.Members
.ReplaceRange(selectedMembers.FirstIndex, selectedMembers.Count, sorted);
return(document.ReplaceMembersAsync(info, newMembers, cancellationToken));
}
public static void InitializedWithOther()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace N
{
class C
{
public static int PublicStatic1 { get; } = PublicStatic2;
public static int PublicStatic2 { get; } = 3;
}
}");
var x = syntaxTree.FindPropertyDeclaration("public static int PublicStatic1 { get; } = PublicStatic2");
var y = syntaxTree.FindPropertyDeclaration("public static int PublicStatic2 { get; } = 3");
Assert.AreEqual(1, MemberDeclarationComparer.Compare(x, y));
Assert.AreEqual(-1, MemberDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(y, y));
}
private static TypeDeclarationSyntax AddSorted(
SyntaxGenerator generator,
TypeDeclarationSyntax containingType,
FieldDeclarationSyntax field)
{
foreach (var member in containingType.Members)
{
if (member.IsEquivalentTo(field))
{
return(containingType);
}
if (MemberDeclarationComparer.Compare(field, member) < 0)
{
return((TypeDeclarationSyntax)generator.InsertNodesBefore(containingType, member, new[] { field }));
}
}
return((TypeDeclarationSyntax)generator.AddMembers(containingType, field));
}
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (context.IsExcludedFromAnalysis())
{
return;
}
if (context.Node is BasePropertyDeclarationSyntax propertyDeclaration &&
propertyDeclaration.TryFirstAncestor <TypeDeclarationSyntax>(out var typeDeclaration))
{
var index = typeDeclaration.Members.IndexOf(propertyDeclaration);
if (typeDeclaration.Members.TryElementAt(index + 1, out var after) &&
(after is PropertyDeclarationSyntax || after is IndexerDeclarationSyntax))
{
if (MemberDeclarationComparer.Compare(propertyDeclaration, after) > 0)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, context.Node.GetLocation()));
}
}
}
}
private static async Task <Document> RefactorAsync(
Document document,
SelectedMemberDeclarationCollection selectedMembers,
MemberDeclarationSortMode sortMode,
CancellationToken cancellationToken)
{
var comparer = new MemberDeclarationComparer(sortMode);
MemberDeclarationSyntax containingMember = selectedMembers.ContainingMember;
SyntaxList <MemberDeclarationSyntax> members = containingMember.GetMembers();
SyntaxList <MemberDeclarationSyntax> newMembers = members
.Take(selectedMembers.FirstIndex)
.Concat(selectedMembers.OrderBy(f => f, comparer))
.Concat(members.Skip(selectedMembers.LastIndex + 1))
.ToSyntaxList();
MemberDeclarationSyntax newNode = containingMember.SetMembers(newMembers);
return(await document.ReplaceNodeAsync(containingMember, newNode, cancellationToken).ConfigureAwait(false));
}
private static Task <Document> RefactorAsync(
Document document,
MemberDeclarationSelection selectedMembers,
MemberDeclarationSortMode sortMode,
CancellationToken cancellationToken)
{
MemberDeclarationComparer comparer = MemberDeclarationComparer.GetInstance(sortMode);
MemberDeclarationSyntax containingMember = selectedMembers.ContainingMember;
SyntaxList <MemberDeclarationSyntax> members = containingMember.GetMembers();
SyntaxList <MemberDeclarationSyntax> newMembers = members
.Take(selectedMembers.StartIndex)
.Concat(selectedMembers.OrderBy(f => f, comparer))
.Concat(members.Skip(selectedMembers.EndIndex + 1))
.ToSyntaxList();
MemberDeclarationSyntax newNode = containingMember.WithMembers(newMembers);
return(document.ReplaceNodeAsync(containingMember, newNode, cancellationToken));
}
private static void ComputeRefactoring(RefactoringContext context, MemberDeclarationSelection selectedMembers)
{
if (selectedMembers.Count > 1)
{
ImmutableArray <MemberDeclarationSyntax> members = selectedMembers.Nodes;
SyntaxKind kind = GetSingleKindOrDefault(members);
if (kind != SyntaxKind.None)
{
if (MemberDeclarationComparer.CanBeSortedAlphabetically(kind))
{
ComputeRefactoring(
context,
MemberDeclarationSortMode.ByKindThenByName,
"Sort members by name",
selectedMembers,
members);
}
}
else
{
ComputeRefactoring(
context,
MemberDeclarationSortMode.ByKind,
"Sort members by kind",
selectedMembers,
members);
ComputeRefactoring(
context,
MemberDeclarationSortMode.ByKindThenByName,
"Sort members by kind then by name",
selectedMembers,
members);
}
}
}
