public static void ChangeAccessibility(
CodeFixContext context,
Diagnostic diagnostic,
SyntaxNode node,
Accessibility accessibility)
{
if (!SyntaxAccessibility.IsValidAccessibility(node, accessibility))
{
return;
}
CodeAction codeAction = CodeAction.Create(
$"Change accessibility to '{GetText(accessibility)}'",
cancellationToken => ChangeAccessibilityRefactoring.RefactorAsync(context.Document, node, accessibility, cancellationToken),
GetEquivalenceKey(diagnostic, accessibility.ToString()));
context.RegisterCodeFix(codeAction, diagnostic);
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
Diagnostic diagnostic = context.Diagnostics[0];
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.SynchronizeAccessibility))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out MemberDeclarationSyntax memberDeclaration))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var symbol = (INamedTypeSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
ImmutableArray <MemberDeclarationSyntax> memberDeclarations = ImmutableArray.CreateRange(
symbol.DeclaringSyntaxReferences,
f => (MemberDeclarationSyntax)f.GetSyntax(context.CancellationToken));
foreach (Accessibility accessibility in memberDeclarations
.Select(f => SyntaxAccessibility.GetExplicitAccessibility(f))
.Where(f => f != Accessibility.NotApplicable))
{
if (SyntaxAccessibility.IsValidAccessibility(memberDeclaration, accessibility))
{
CodeAction codeAction = CodeAction.Create(
$"Change accessibility to '{SyntaxFacts.GetText(accessibility)}'",
cancellationToken => ChangeAccessibilityRefactoring.RefactorAsync(context.Solution(), memberDeclarations, accessibility, cancellationToken),
GetEquivalenceKey(CompilerDiagnosticIdentifiers.PartialDeclarationsHaveConfictingAccessibilityModifiers, accessibility.ToString()));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
public static AccessibilityFilter GetValidAccessibilityFilter(
MemberDeclarationListSelection selectedMembers,
SemanticModel semanticModel,
CancellationToken cancellationToken = default(CancellationToken))
{
if (selectedMembers.Count < 2)
{
return(AccessibilityFilter.None);
}
ImmutableArray <Accessibility> avaiableAccessibilities = AvailableAccessibilities;
var all = AccessibilityFilter.None;
AccessibilityFilter valid = AccessibilityFilter.Public
| AccessibilityFilter.Internal
| AccessibilityFilter.Protected
| AccessibilityFilter.Private;
foreach (MemberDeclarationSyntax member in selectedMembers)
{
Accessibility accessibility = SyntaxAccessibility.GetExplicitAccessibility(member);
if (accessibility == Accessibility.NotApplicable)
{
accessibility = SyntaxAccessibility.GetDefaultExplicitAccessibility(member);
if (accessibility == Accessibility.NotApplicable)
{
return(AccessibilityFilter.None);
}
}
switch (accessibility)
{
case Accessibility.Private:
case Accessibility.Protected:
case Accessibility.ProtectedAndInternal:
case Accessibility.ProtectedOrInternal:
case Accessibility.Internal:
case Accessibility.Public:
{
all |= accessibility.GetAccessibilityFilter();
break;
}
default:
{
Debug.Fail(accessibility.ToString());
return(AccessibilityFilter.None);
}
}
ModifierListInfo modifiersInfo = SyntaxInfo.ModifierListInfo(member);
if (modifiersInfo.Modifiers.ContainsAny(
SyntaxKind.AbstractKeyword,
SyntaxKind.VirtualKeyword,
SyntaxKind.OverrideKeyword))
{
valid &= ~AccessibilityFilter.Private;
}
if (modifiersInfo.IsOverride &&
IsBaseDeclarationWithoutSource(member, semanticModel, cancellationToken))
{
switch (accessibility)
{
case Accessibility.Private:
case Accessibility.Protected:
case Accessibility.Internal:
case Accessibility.Public:
{
valid &= accessibility.GetAccessibilityFilter();
if (valid == AccessibilityFilter.None)
{
return(AccessibilityFilter.None);
}
avaiableAccessibilities = _accessibilityArrayMap[accessibility];
continue;
}
default:
{
return(AccessibilityFilter.None);
}
}
}
foreach (Accessibility accessibility2 in avaiableAccessibilities)
{
if (accessibility != accessibility2 &&
!SyntaxAccessibility.IsValidAccessibility(member, accessibility2, ignoreOverride: true))
{
valid &= ~accessibility2.GetAccessibilityFilter();
if (valid == AccessibilityFilter.None)
{
return(AccessibilityFilter.None);
}
}
}
}
switch (all)
{
case AccessibilityFilter.Private:
case AccessibilityFilter.Protected:
case AccessibilityFilter.Internal:
case AccessibilityFilter.Public:
{
valid &= ~all;
break;
}
}
return(valid);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, SyntaxToken modifier)
{
SyntaxNode node = modifier.Parent;
if (node.IsKind(SyntaxKind.DestructorDeclaration))
{
return;
}
ModifierListInfo modifiersInfo = SyntaxInfo.ModifierListInfo(node);
if (node.IsKind(
SyntaxKind.ClassDeclaration,
SyntaxKind.InterfaceDeclaration,
SyntaxKind.StructDeclaration,
SyntaxKind.RecordStructDeclaration))
{
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 AvailableAccessibilities)
{
if (accessibility != modifiersInfo.ExplicitAccessibility &&
SyntaxAccessibility.IsValidAccessibility(node, accessibility))
{
context.RegisterRefactoring(
GetTitle(accessibility),
ct => RefactorAsync(context.Solution, memberDeclarations, accessibility, ct),
RefactoringDescriptors.ChangeAccessibility,
accessibility.ToString());
}
}
return;
}
}
foreach (Accessibility accessibility in AvailableAccessibilities)
{
if (accessibility == modifiersInfo.ExplicitAccessibility)
{
continue;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol symbol = GetBaseSymbolOrDefault(semanticModel, context.CancellationToken);
if (symbol != null)
{
if (SyntaxAccessibility.IsValidAccessibility(node, accessibility, ignoreOverride: true))
{
context.RegisterRefactoring(
GetTitle(accessibility),
ct => RefactorAsync(context.Solution, symbol, accessibility, ct),
RefactoringDescriptors.ChangeAccessibility,
accessibility.ToString());
}
}
else if (SyntaxAccessibility.IsValidAccessibility(node, accessibility))
{
context.RegisterRefactoring(
GetTitle(accessibility),
ct => RefactorAsync(context.Document, node, accessibility, ct),
RefactoringDescriptors.ChangeAccessibility,
accessibility.ToString());
}
}
ISymbol GetBaseSymbolOrDefault(SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (modifiersInfo.GetFilter().HasAnyFlag(ModifierFilter.AbstractVirtualOverride))
{
return(ChangeAccessibilityRefactoring.GetBaseSymbolOrDefault(node, semanticModel, cancellationToken));
}
return(null);
}
}
public static Accessibilities GetValidAccessibilities(MemberDeclarationListSelection selectedMembers, bool allowOverride = false)
{
if (selectedMembers.Count < 2)
{
return(Accessibilities.None);
}
var all = Accessibilities.None;
Accessibilities valid = Accessibilities.Public
| Accessibilities.Internal
| Accessibilities.Protected
| Accessibilities.Private;
foreach (MemberDeclarationSyntax member in selectedMembers)
{
Accessibility accessibility = SyntaxAccessibility.GetExplicitAccessibility(member);
if (accessibility == Accessibility.NotApplicable)
{
accessibility = SyntaxAccessibility.GetDefaultExplicitAccessibility(member);
if (accessibility == Accessibility.NotApplicable)
{
return(Accessibilities.None);
}
}
Accessibilities accessibilities = accessibility.GetAccessibilities();
switch (accessibility)
{
case Accessibility.Private:
case Accessibility.Protected:
case Accessibility.ProtectedAndInternal:
case Accessibility.ProtectedOrInternal:
case Accessibility.Internal:
case Accessibility.Public:
{
all |= accessibilities;
break;
}
default:
{
Debug.Fail(accessibility.ToString());
return(Accessibilities.None);
}
}
foreach (Accessibility accessibility2 in AvailableAccessibilities)
{
if (accessibility != accessibility2 &&
!SyntaxAccessibility.IsValidAccessibility(member, accessibility2, ignoreOverride: allowOverride))
{
valid &= ~accessibility2.GetAccessibilities();
}
}
}
switch (all)
{
case Accessibilities.Private:
case Accessibilities.Protected:
case Accessibilities.Internal:
case Accessibilities.Public:
{
valid &= ~all;
break;
}
}
return(valid);
}