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