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); } } }