public static string ToDisplayString(this AccessibilityInfo accessibility) { switch (accessibility) { case AccessibilityInfo.Private: return("private"); case AccessibilityInfo.ProtectedAndInternal: return("private protected"); case AccessibilityInfo.Protected: return("protected"); case AccessibilityInfo.Internal: return("internal"); case AccessibilityInfo.ProtectedOrInternal: return("protected internal"); case AccessibilityInfo.Public: return("public"); default: return(string.Empty); } }
public PropertyMethodNotation MakeAccessibilitySafe(AccessibilityInfo accessibility) { if (accessibility <= Accessibility) { Accessibility = AccessibilityInfo.NotApplicable; } return(this); }
public static AccessibilityInfo ChangeAccessibility( AccessibilityInfo info, Accessibility newAccessibility, IModifierComparer comparer = null) { if (!info.Success) { return(info); } Accessibility accessibility = info.Accessibility; if (accessibility == newAccessibility) { return(info); } comparer = comparer ?? ModifierComparer.Instance; SyntaxNode node = info.Node; if (IsSingleTokenAccessibility(accessibility) && IsSingleTokenAccessibility(newAccessibility)) { int insertIndex = comparer.GetInsertIndex(info.Modifiers, GetKind(newAccessibility)); if (info.TokenIndex == insertIndex || info.TokenIndex == insertIndex - 1) { SyntaxToken newToken = CreateToken(newAccessibility).WithTriviaFrom(info.Token); SyntaxTokenList newModifiers = info.Modifiers.Replace(info.Token, newToken); return(info.WithModifiers(newModifiers)); } } if (accessibility != Accessibility.NotApplicable) { node = Modifier.RemoveAt(node, Math.Max(info.TokenIndex, info.SecondTokenIndex)); if (info.SecondTokenIndex != -1) { node = Modifier.RemoveAt(node, Math.Min(info.TokenIndex, info.SecondTokenIndex)); } } if (newAccessibility != Accessibility.NotApplicable) { node = InsertModifier(node, newAccessibility, comparer); } return(SyntaxInfo.AccessibilityInfo(node)); }
public static TNode ChangeAccessibility <TNode>( TNode node, Accessibility newAccessibility, IModifierComparer comparer = null) where TNode : SyntaxNode { AccessibilityInfo info = SyntaxInfo.AccessibilityInfo(node); AccessibilityInfo newInfo = ChangeAccessibility(info, newAccessibility, comparer); return((TNode)newInfo.Node); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, SyntaxToken modifier) { SyntaxNode node = modifier.Parent; if (!node.IsKind(SyntaxKind.DestructorDeclaration)) { AccessibilityInfo info = AccessibilityInfo.Create(node.GetModifiers()); if (node.IsKind( SyntaxKind.ClassDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.StructDeclaration)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); var symbol = (INamedTypeSymbol)semanticModel.GetDeclaredSymbol(node, context.CancellationToken); ImmutableArray <SyntaxReference> syntaxReferences = symbol.DeclaringSyntaxReferences; if (syntaxReferences.Length > 1) { ImmutableArray <MemberDeclarationSyntax> memberDeclarations = ImmutableArray.CreateRange( syntaxReferences, f => (MemberDeclarationSyntax)f.GetSyntax(context.CancellationToken)); foreach (Accessibility accessibility in _accessibilities) { if (accessibility != info.Accessibility && CSharpUtility.IsAllowedAccessibility(node, accessibility)) { context.RegisterRefactoring( GetTitle(accessibility), cancellationToken => ChangeAccessibilityRefactoring.RefactorAsync(context.Solution, memberDeclarations, accessibility, cancellationToken)); } } return; } } foreach (Accessibility accessibility in _accessibilities) { if (accessibility != info.Accessibility && CSharpUtility.IsAllowedAccessibility(node, accessibility)) { context.RegisterRefactoring( GetTitle(accessibility), cancellationToken => ChangeAccessibilityRefactoring.RefactorAsync(context.Document, node, accessibility, cancellationToken)); } } } }
private static SyntaxNode WithAccessibility(MemberDeclarationSyntax node, Accessibility newAccessibility) { AccessibilityInfo info = SyntaxInfo.AccessibilityInfo(node); if (info.Accessibility == Accessibility.NotApplicable) { return(node); } AccessibilityInfo newInfo = info.WithAccessibility(newAccessibility, ModifierComparer.Instance); return(newInfo.Node); }
public static async Task <Solution> RefactorAsync( Solution solution, ImmutableArray <MemberDeclarationSyntax> memberDeclarations, Accessibility newAccessibility, CancellationToken cancellationToken) { var newDocuments = new List <KeyValuePair <DocumentId, SyntaxNode> >(); foreach (IGrouping <SyntaxTree, MemberDeclarationSyntax> grouping in memberDeclarations .GroupBy(f => f.SyntaxTree)) { Document document = solution.GetDocument(grouping.Key); SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SyntaxNode newRoot = root.ReplaceNodes( grouping, (node, rewrittenNode) => { AccessibilityInfo info = AccessibilityInfo.Create(node.GetModifiers()); if (info.Accessibility == Accessibility.NotApplicable) { return(node); } return(AccessibilityHelper.ChangeAccessibility(node, info, newAccessibility, ModifierComparer.Instance)); }); newDocuments.Add(new KeyValuePair <DocumentId, SyntaxNode>(document.Id, newRoot)); } Solution newSolution = solution; foreach (KeyValuePair <DocumentId, SyntaxNode> kvp in newDocuments) { newSolution = newSolution.WithDocumentSyntaxRoot(kvp.Key, kvp.Value); } return(newSolution); }
public static Task <Solution> RefactorAsync( Solution solution, ImmutableArray <MemberDeclarationSyntax> memberDeclarations, Accessibility newAccessibility, CancellationToken cancellationToken) { return(solution.ReplaceNodesAsync( memberDeclarations, (node, rewrittenNode) => { AccessibilityInfo info = AccessibilityInfo.Create(node.GetModifiers()); if (info.Accessibility == Accessibility.NotApplicable) { return node; } return AccessibilityHelper.ChangeAccessibility(node, info, newAccessibility, ModifierComparer.Instance); }, cancellationToken)); }
public static Task <Solution> RefactorAsync( Solution solution, ImmutableArray <MemberDeclarationSyntax> memberDeclarations, Accessibility newAccessibility, CancellationToken cancellationToken) { return(solution.ReplaceNodesAsync( memberDeclarations, (node, rewrittenNode) => { AccessibilityInfo info = SyntaxInfo.AccessibilityInfo(node); if (info.Accessibility == Accessibility.NotApplicable) { return node; } AccessibilityInfo newInfo = info.WithAccessibility(newAccessibility, ModifierComparer.Instance); return newInfo.Node; }, cancellationToken)); }