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