public static void ComputeRefactoring(RefactoringContext context, InterfaceDeclarationSyntax interfaceDeclaration) { if (MemberDeclarationSelection.TryCreate(interfaceDeclaration, context.Span, out MemberDeclarationSelection selectedMembers)) { ComputeRefactoring(context, selectedMembers); } }
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationSelection selectedMembers) { int count = 0; foreach (MemberDeclarationSyntax selectedMember in selectedMembers) { if (selectedMember.Kind() != SyntaxKind.FieldDeclaration) { return; } var fieldDeclaration = (FieldDeclarationSyntax)selectedMember; if (fieldDeclaration.Declaration.Variables.Any(f => f.Initializer != null)) { return; } if (!CanRefactor(fieldDeclaration)) { return; } count += fieldDeclaration.Declaration.Variables.Count; } context.RegisterRefactoring( GetTitle(count == 1), cancellationToken => RefactorAsync(context.Document, selectedMembers, cancellationToken)); }
public static Task <Solution> RefactorAsync( Solution solution, MemberDeclarationSelection selectedMembers, Accessibility newAccessibility, SemanticModel semanticModel, CancellationToken cancellationToken) { var members = new HashSet <MemberDeclarationSyntax>(); foreach (MemberDeclarationSyntax member in selectedMembers) { if (member.GetModifiers().Contains(SyntaxKind.PartialKeyword)) { ISymbol symbol = semanticModel.GetDeclaredSymbol(member, cancellationToken); foreach (SyntaxReference reference in symbol.DeclaringSyntaxReferences) { members.Add((MemberDeclarationSyntax)reference.GetSyntax(cancellationToken)); } } else { members.Add(member); } } return(solution.ReplaceNodesAsync( members, (node, rewrittenNode) => node.WithAccessibility(newAccessibility), cancellationToken)); }
public static void ComputeRefactoring(RefactoringContext context, StructDeclarationSyntax structDeclaration) { MemberDeclarationSelection selectedMembers; if (MemberDeclarationSelection.TryCreate(structDeclaration, context.Span, out selectedMembers)) { ComputeRefactoring(context, selectedMembers); } }
public static void ComputeRefactoring(RefactoringContext context, ClassDeclarationSyntax classDeclaration) { if (!MemberDeclarationSelection.TryCreate(classDeclaration, context.Span, out MemberDeclarationSelection selectedMembers)) { return; } ComputeRefactoring(context, selectedMembers); }
public static async Task <Solution> RefactorAsync( Solution solution, MemberDeclarationSelection selectedMembers, Accessibility newAccessibility, SemanticModel semanticModel, CancellationToken cancellationToken) { var members = new HashSet <MemberDeclarationSyntax>(); foreach (MemberDeclarationSyntax member in selectedMembers) { SyntaxTokenList modifiers = member.GetModifiers(); if (modifiers.Contains(SyntaxKind.PartialKeyword)) { ISymbol symbol = semanticModel.GetDeclaredSymbol(member, cancellationToken); foreach (SyntaxReference reference in symbol.DeclaringSyntaxReferences) { members.Add((MemberDeclarationSyntax)reference.GetSyntax(cancellationToken)); } } else if (modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { ISymbol symbol = GetBaseSymbolOrDefault(member, semanticModel, cancellationToken); if (symbol != null) { foreach (MemberDeclarationSyntax member2 in GetMemberDeclarations(symbol, cancellationToken)) { members.Add(member2); } foreach (MemberDeclarationSyntax member2 in await FindOverridingMemberDeclarationsAsync(symbol, solution, cancellationToken).ConfigureAwait(false)) { members.Add(member2); } } else { members.Add(member); } } else { members.Add(member); } } return(await solution.ReplaceNodesAsync( members, (node, _) => node.WithAccessibility(newAccessibility), cancellationToken).ConfigureAwait(false)); }
private static Task <Document> RefactorAsync( Document document, MemberDeclarationSelection selectedMembers, CancellationToken cancellationToken) { ImmutableArray <FieldInfo> fieldInfo = selectedMembers .Select(member => ((FieldDeclarationSyntax)member).Declaration) .SelectMany(declaration => declaration.Variables.Select(declarator => FieldInfo.Create(declaration.Type, declarator))) .ToImmutableArray(); return(RefactorAsync(document, fieldInfo, (TypeDeclarationSyntax)selectedMembers.ContainingMember, cancellationToken)); }
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)); } }
public static Task <Document> RefactorAsync( Document document, MemberDeclarationSelection selectedMembers, Accessibility newAccessibility, CancellationToken cancellationToken) { var members = (SyntaxList <MemberDeclarationSyntax>)selectedMembers.Items; SyntaxList <MemberDeclarationSyntax> newMembers = members .Take(selectedMembers.StartIndex) .Concat(selectedMembers.Select(f => f.WithAccessibility(newAccessibility))) .Concat(members.Skip(selectedMembers.EndIndex + 1)) .ToSyntaxList(); MemberDeclarationSyntax containingMember = selectedMembers.ContainingMember; MemberDeclarationSyntax newNode = containingMember.WithMembers(newMembers); return(document.ReplaceNodeAsync(containingMember, newNode, cancellationToken)); }
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); } } }
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationSelection selectedMembers) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeAccessibility)) { AccessibilityFlags accessibilityFlags = ChangeAccessibilityRefactoring.GetAllowedAccessibilityFlags(selectedMembers, allowOverride: true); if (accessibilityFlags != AccessibilityFlags.None) { bool canHaveMultipleDeclarations = CanHaveMultipleDeclarations(); TryRegisterRefactoring(accessibilityFlags, Accessibility.Public, canHaveMultipleDeclarations); TryRegisterRefactoring(accessibilityFlags, Accessibility.Internal, canHaveMultipleDeclarations); TryRegisterRefactoring(accessibilityFlags, Accessibility.Protected, canHaveMultipleDeclarations); TryRegisterRefactoring(accessibilityFlags, Accessibility.Private, canHaveMultipleDeclarations); } } void TryRegisterRefactoring(AccessibilityFlags accessibilityFlags, Accessibility accessibility, bool canHaveMultipleDeclarations) { if ((accessibilityFlags & accessibility.GetAccessibilityFlag()) != 0) { if (canHaveMultipleDeclarations) { context.RegisterRefactoring( ChangeAccessibilityRefactoring.GetTitle(accessibility), async cancellationToken => { SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); return(await ChangeAccessibilityRefactoring.RefactorAsync(context.Document.Solution(), selectedMembers, accessibility, semanticModel, cancellationToken).ConfigureAwait(false)); }); } else { context.RegisterRefactoring( ChangeAccessibilityRefactoring.GetTitle(accessibility), cancellationToken => ChangeAccessibilityRefactoring.RefactorAsync(context.Document, selectedMembers, accessibility, cancellationToken)); } } } bool CanHaveMultipleDeclarations() { foreach (MemberDeclarationSyntax member in selectedMembers) { switch (member.Kind()) { case SyntaxKind.ClassDeclaration: { if (((ClassDeclarationSyntax)member).Modifiers.Contains(SyntaxKind.PartialKeyword)) { return(true); } break; } case SyntaxKind.InterfaceDeclaration: { if (((InterfaceDeclarationSyntax)member).Modifiers.Contains(SyntaxKind.PartialKeyword)) { return(true); } break; } case SyntaxKind.StructDeclaration: { if (((StructDeclarationSyntax)member).Modifiers.Contains(SyntaxKind.PartialKeyword)) { return(true); } break; } case SyntaxKind.MethodDeclaration: { if (((MethodDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.PartialKeyword, SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { return(true); } break; } case SyntaxKind.PropertyDeclaration: { if (((PropertyDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { return(true); } break; } case SyntaxKind.IndexerDeclaration: { if (((IndexerDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { return(true); } break; } case SyntaxKind.EventDeclaration: { if (((EventDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { return(true); } break; } case SyntaxKind.EventFieldDeclaration: { if (((EventFieldDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { return(true); } break; } } } return(false); } }
public static AccessibilityFlags GetAllowedAccessibilityFlags(MemberDeclarationSelection selectedMembers, bool allowOverride = false) { if (selectedMembers.Count < 2) { return(AccessibilityFlags.None); } var allFlags = AccessibilityFlags.None; AccessibilityFlags allowedFlags = AccessibilityFlags.Public | AccessibilityFlags.Internal | AccessibilityFlags.Protected | AccessibilityFlags.Private; foreach (MemberDeclarationSyntax member in selectedMembers) { Accessibility accessibility = SyntaxInfo.AccessibilityInfo(member).Accessibility; if (accessibility == Accessibility.NotApplicable) { accessibility = member.GetDefaultExplicitAccessibility(); if (accessibility == Accessibility.NotApplicable) { return(AccessibilityFlags.None); } } AccessibilityFlags flag = accessibility.GetAccessibilityFlag(); switch (accessibility) { case Accessibility.Private: case Accessibility.Protected: case Accessibility.ProtectedAndInternal: case Accessibility.ProtectedOrInternal: case Accessibility.Internal: case Accessibility.Public: { allFlags |= flag; break; } default: { Debug.Fail(accessibility.ToString()); return(AccessibilityFlags.None); } } foreach (Accessibility accessibility2 in Accessibilities) { if (accessibility != accessibility2 && !CSharpUtility.IsAllowedAccessibility(member, accessibility2, allowOverride: allowOverride)) { allowedFlags &= ~accessibility2.GetAccessibilityFlag(); } } } switch (allFlags) { case AccessibilityFlags.Private: case AccessibilityFlags.Protected: case AccessibilityFlags.Internal: case AccessibilityFlags.Public: { allowedFlags &= ~allFlags; break; } } return(allowedFlags); }