public static void ComputeRefactoring(RefactoringContext context, InterfaceDeclarationSyntax interfaceDeclaration)
{
if (MemberDeclarationListSelection.TryCreate(interfaceDeclaration, context.Span, out MemberDeclarationListSelection selectedMembers))
{
ComputeRefactoring(context, selectedMembers);
}
}
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationListSelection selectedMembers)
{
if (selectedMembers.Count == 1)
{
return;
}
int start = selectedMembers.First().Span.End;
SyntaxTree syntaxTree = selectedMembers.Parent.SyntaxTree;
for (int i = selectedMembers.FirstIndex + 1; i <= selectedMembers.LastIndex; i++)
{
MemberDeclarationSyntax member = selectedMembers.UnderlyingList[i];
SyntaxTrivia documentationCommentTrivia = member.GetDocumentationCommentTrivia();
TextSpan span = (documentationCommentTrivia.IsDocumentationCommentTrivia())
? documentationCommentTrivia.Span
: member.Span;
if (syntaxTree.GetLineCount(TextSpan.FromBounds(start, span.Start), context.CancellationToken) != 2)
{
return;
}
start = member.Span.End;
}
context.RegisterRefactoring(
"Add empty line between declarations",
ct => RefactorAsync(context.Document, selectedMembers, ct),
RefactoringIdentifiers.AddEmptyLineBetweenDeclarations);
}
public static async Task <Document> RefactorAsync(
Document document,
MemberDeclarationListSelection selectedMembers,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
IEnumerable <MemberDeclarationSyntax> newMembers = selectedMembers
.UnderlyingList
.ModifyRange(
selectedMembers.FirstIndex,
selectedMembers.Count,
member =>
{
ArrowExpressionClauseSyntax expressionBody = CSharpUtility.GetExpressionBody(member);
if (expressionBody != null &&
ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
{
return((MemberDeclarationSyntax)Refactor(expressionBody, semanticModel, cancellationToken)
.WithFormatterAnnotation());
}
return(member);
});
return(await document.ReplaceMembersAsync(SyntaxInfo.MemberDeclarationListInfo(selectedMembers.Parent), newMembers, cancellationToken).ConfigureAwait(false));
}
private static void ComputeRefactoring(RefactoringContext context, MemberDeclarationListSelection selectedMembers)
{
if (selectedMembers.Count <= 1)
{
return;
}
SyntaxKind kind = GetSingleKindOrDefault(selectedMembers);
if (kind != SyntaxKind.None)
{
if (MemberDeclarationComparer.CanBeSortedByName(kind))
{
ComputeRefactoring(
context,
MemberDeclarationComparer.ByKindThenByName,
"Sort members by name",
selectedMembers);
}
}
else
{
ComputeRefactoring(
context,
MemberDeclarationComparer.ByKind,
"Sort members by kind",
selectedMembers);
ComputeRefactoring(
context,
MemberDeclarationComparer.ByKindThenByName,
"Sort members by kind then by name",
selectedMembers);
}
}
public static Task <Document> RefactorAsync(
Document document,
MemberDeclarationListSelection selectedMembers,
CancellationToken cancellationToken)
{
IEnumerable <MemberDeclarationSyntax> newMembers = selectedMembers
.UnderlyingList
.ModifyRange(
selectedMembers.FirstIndex,
selectedMembers.Count,
member =>
{
if (CanRefactor(member))
{
var newMember = (MemberDeclarationSyntax)Refactor(member);
return(newMember
.WithTrailingTrivia(member.GetTrailingTrivia())
.WithFormatterAnnotation());
}
return(member);
});
return(document.ReplaceMembersAsync(SyntaxInfo.MemberDeclarationListInfo(selectedMembers.Parent), newMembers, cancellationToken));
}
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationListSelection 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 async Task <Solution> RefactorAsync(
Solution solution,
MemberDeclarationListSelection selectedMembers,
Accessibility newAccessibility,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
var members = new HashSet <MemberDeclarationSyntax>();
foreach (MemberDeclarationSyntax member in selectedMembers)
{
ModifierFilter filter = SyntaxInfo.ModifierListInfo(member).GetFilter();
if (filter.HasAnyFlag(ModifierFilter.Partial))
{
ISymbol symbol = semanticModel.GetDeclaredSymbol(member, cancellationToken);
foreach (SyntaxReference reference in symbol.DeclaringSyntaxReferences)
{
members.Add((MemberDeclarationSyntax)reference.GetSyntax(cancellationToken));
}
}
else if (filter.HasAnyFlag(ModifierFilter.AbstractVirtualOverride))
{
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, _) => SyntaxAccessibility.WithExplicitAccessibility(node, newAccessibility),
cancellationToken)
.ConfigureAwait(false));
}
private static Task <Document> RefactorAsync(
Document document,
MemberDeclarationListSelection 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.Parent, cancellationToken));
}
public static Task <Document> RefactorAsync(
Document document,
MemberDeclarationListSelection selectedMembers,
Accessibility newAccessibility,
CancellationToken cancellationToken)
{
SyntaxList <MemberDeclarationSyntax> newMembers = selectedMembers
.UnderlyingList
.ReplaceRange(selectedMembers.FirstIndex, selectedMembers.Count, selectedMembers.Select(f => SyntaxAccessibility.WithExplicitAccessibility(f, newAccessibility)));
MemberDeclarationListInfo info = SyntaxInfo.MemberDeclarationListInfo(selectedMembers);
return(document.ReplaceMembersAsync(info, newMembers, cancellationToken));
}
private static void ComputeRefactoring(
RefactoringContext context,
MemberDeclarationComparer comparer,
string title,
MemberDeclarationListSelection selectedMembers)
{
if (selectedMembers.IsSorted(comparer))
{
return;
}
context.RegisterRefactoring(
title,
cancellationToken => RefactorAsync(context.Document, selectedMembers, comparer, cancellationToken));
}
private static Task <Document> RefactorAsync(
Document document,
MemberDeclarationListSelection selectedMembers,
CancellationToken cancellationToken)
{
SyntaxList <MemberDeclarationSyntax> members = selectedMembers.UnderlyingList;
IEnumerable <MemberDeclarationSyntax> newMembers = members.ModifyRange(
selectedMembers.FirstIndex,
selectedMembers.Count - 1,
member => member.AppendToTrailingTrivia(CSharpFactory.NewLine()));
MemberDeclarationListInfo membersInfo = SyntaxInfo.MemberDeclarationListInfo(selectedMembers);
return(document.ReplaceMembersAsync(membersInfo, newMembers, cancellationToken));
}
private static Task <Document> RefactorAsync(
Document document,
MemberDeclarationListSelection selectedMembers,
MemberDeclarationComparer comparer,
CancellationToken cancellationToken)
{
IEnumerable <MemberDeclarationSyntax> sorted = selectedMembers.OrderBy(f => f, comparer);
MemberDeclarationListInfo info = SyntaxInfo.MemberDeclarationListInfo(selectedMembers);
SyntaxList <MemberDeclarationSyntax> newMembers = info
.Members
.ReplaceRange(selectedMembers.FirstIndex, selectedMembers.Count, sorted);
return(document.ReplaceMembersAsync(info, newMembers, cancellationToken));
}
public static async Task <Document> RefactorAsync(
Document document,
MemberDeclarationListSelection selectedMembers,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
IEnumerable <MemberDeclarationSyntax> newMembers = selectedMembers
.UnderlyingList
.ModifyRange(
selectedMembers.FirstIndex,
selectedMembers.Count,
f => (MemberDeclarationSyntax)Refactor(CSharpUtility.GetExpressionBody(f), semanticModel, cancellationToken).WithFormatterAnnotation());
return(await document.ReplaceMembersAsync(SyntaxInfo.MemberDeclarationListInfo(selectedMembers.Parent), newMembers, cancellationToken).ConfigureAwait(false));
}
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationListSelection selectedMembers)
{
if (selectedMembers.Count <= 1)
{
return;
}
SyntaxListSelection <MemberDeclarationSyntax> .Enumerator en = selectedMembers.GetEnumerator();
if (!en.MoveNext())
{
return;
}
TextSpan span = context.Span;
string refactoringId = GetRefactoringId(en.Current);
if (refactoringId == null)
{
return;
}
while (en.MoveNext())
{
if (refactoringId != GetRefactoringId(en.Current))
{
return;
}
}
if (refactoringId == RefactoringIdentifiers.UseExpressionBodiedMember &&
context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember))
{
context.RegisterRefactoring(
UseExpressionBodiedMemberRefactoring.Title,
ct => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, selectedMembers, ct),
RefactoringIdentifiers.UseExpressionBodiedMember);
}
else if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandExpressionBody))
{
context.RegisterRefactoring(
ExpandExpressionBodyRefactoring.Title,
ct => ExpandExpressionBodyRefactoring.RefactorAsync(context.Document, selectedMembers, ct),
RefactoringIdentifiers.ExpandExpressionBody);
}
}
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationListSelection selectedMembers)
{
if (selectedMembers.Count <= 1)
{
return;
}
TextSpan span = context.Span;
string refactoringId = GetRefactoringId(selectedMembers.First());
if (refactoringId == null)
{
return;
}
if (refactoringId != GetRefactoringId(selectedMembers.Last()))
{
return;
}
if (refactoringId == RefactoringIdentifiers.UseExpressionBodiedMember &&
context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember))
{
context.RegisterRefactoring(
UseExpressionBodiedMemberRefactoring.Title,
ct => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, selectedMembers, ct),
RefactoringIdentifiers.UseExpressionBodiedMember);
}
else if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandExpressionBody))
{
context.RegisterRefactoring(
ExpandExpressionBodyRefactoring.Title,
ct => ExpandExpressionBodyRefactoring.RefactorAsync(context.Document, selectedMembers, ct),
RefactoringIdentifiers.ExpandExpressionBody);
}
}
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationListSelection selectedMembers)
{
if (selectedMembers.Count <= 1)
{
return;
}
TextSpan span = context.Span;
RefactoringDescriptor refactoring = GetRefactoringDescriptor(selectedMembers.First());
if (refactoring.Id == null)
{
return;
}
if (!RefactoringDescriptorComparer.Id.Equals(refactoring, GetRefactoringDescriptor(selectedMembers.Last())))
{
return;
}
if (RefactoringDescriptorComparer.Id.Equals(refactoring, RefactoringDescriptors.ConvertBlockBodyToExpressionBody) &&
context.IsRefactoringEnabled(RefactoringDescriptors.ConvertBlockBodyToExpressionBody))
{
context.RegisterRefactoring(
ConvertBlockBodyToExpressionBodyRefactoring.Title,
ct => ConvertBlockBodyToExpressionBodyRefactoring.RefactorAsync(context.Document, selectedMembers, ct),
RefactoringDescriptors.ConvertBlockBodyToExpressionBody);
}
else if (context.IsRefactoringEnabled(RefactoringDescriptors.ConvertExpressionBodyToBlockBody))
{
context.RegisterRefactoring(
ConvertExpressionBodyToBlockBodyRefactoring.Title,
ct => ConvertExpressionBodyToBlockBodyRefactoring.RefactorAsync(context.Document, selectedMembers, ct),
RefactoringDescriptors.ConvertExpressionBodyToBlockBody);
}
}
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationListSelection selectedMembers)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeAccessibility))
{
Accessibilities validAccessibilities = ChangeAccessibilityAnalysis.GetValidAccessibilities(selectedMembers, allowOverride: true);
if (validAccessibilities != Accessibilities.None)
{
bool canHaveMultipleDeclarations = CanHaveMultipleDeclarations();
TryRegisterRefactoring(validAccessibilities, Accessibility.Public, canHaveMultipleDeclarations);
TryRegisterRefactoring(validAccessibilities, Accessibility.Internal, canHaveMultipleDeclarations);
TryRegisterRefactoring(validAccessibilities, Accessibility.Protected, canHaveMultipleDeclarations);
TryRegisterRefactoring(validAccessibilities, Accessibility.Private, canHaveMultipleDeclarations);
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.InitializeFieldFromConstructor))
{
InitializeFieldFromConstructorRefactoring.ComputeRefactoring(context, selectedMembers);
}
void TryRegisterRefactoring(Accessibilities accessibilities, Accessibility accessibility, bool canHaveMultipleDeclarations)
{
if ((accessibilities & accessibility.GetAccessibilities()) != 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);
}
}
internal static MemberDeclarationListInfo Create(MemberDeclarationListSelection selectedMembers)
{
return(new MemberDeclarationListInfo(selectedMembers.Parent, selectedMembers.UnderlyingList));
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MemberDeclarationSyntax member)
{
SyntaxKind kind = member.Kind();
switch (kind)
{
case SyntaxKind.MethodDeclaration:
case SyntaxKind.IndexerDeclaration:
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.OperatorDeclaration:
case SyntaxKind.ConversionOperatorDeclaration:
case SyntaxKind.ConstructorDeclaration:
case SyntaxKind.EventDeclaration:
case SyntaxKind.NamespaceDeclaration:
case SyntaxKind.ClassDeclaration:
case SyntaxKind.StructDeclaration:
case SyntaxKind.InterfaceDeclaration:
case SyntaxKind.EnumDeclaration:
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.RemoveMember,
RefactoringIdentifiers.DuplicateMember,
RefactoringIdentifiers.CommentOutMember) &&
BraceContainsSpan(member, context.Span))
{
if (member.IsParentKind(
SyntaxKind.NamespaceDeclaration,
SyntaxKind.ClassDeclaration,
SyntaxKind.StructDeclaration,
SyntaxKind.InterfaceDeclaration,
SyntaxKind.CompilationUnit))
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveMember))
{
context.RegisterRefactoring(CodeActionFactory.RemoveMemberDeclaration(context.Document, member, equivalenceKey: RefactoringIdentifiers.RemoveMember));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.DuplicateMember))
{
context.RegisterRefactoring(
$"Duplicate {CSharpFacts.GetTitle(member)}",
cancellationToken => DuplicateMemberDeclarationRefactoring.RefactorAsync(context.Document, member, cancellationToken),
RefactoringIdentifiers.DuplicateMember);
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CommentOutMember))
{
CommentOutRefactoring.RegisterRefactoring(context, member);
}
}
break;
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveAllStatements))
{
RemoveAllStatementsRefactoring.ComputeRefactoring(context, member);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveAllMemberDeclarations))
{
RemoveAllMemberDeclarationsRefactoring.ComputeRefactoring(context, member);
}
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.SwapMemberDeclarations,
RefactoringIdentifiers.RemoveMemberDeclarations) &&
!member.Span.IntersectsWith(context.Span))
{
MemberDeclarationsRefactoring.ComputeRefactoring(context, member);
}
switch (kind)
{
case SyntaxKind.NamespaceDeclaration:
{
var namespaceDeclaration = (NamespaceDeclarationSyntax)member;
NamespaceDeclarationRefactoring.ComputeRefactorings(context, namespaceDeclaration);
if (MemberDeclarationListSelection.TryCreate(namespaceDeclaration, context.Span, out MemberDeclarationListSelection selectedMembers))
{
await SelectedMemberDeclarationsRefactoring.ComputeRefactoringAsync(context, selectedMembers).ConfigureAwait(false);
}
break;
}
case SyntaxKind.ClassDeclaration:
{
var classDeclaration = (ClassDeclarationSyntax)member;
await ClassDeclarationRefactoring.ComputeRefactoringsAsync(context, classDeclaration).ConfigureAwait(false);
if (MemberDeclarationListSelection.TryCreate(classDeclaration, context.Span, out MemberDeclarationListSelection selectedMembers))
{
await SelectedMemberDeclarationsRefactoring.ComputeRefactoringAsync(context, selectedMembers).ConfigureAwait(false);
}
break;
}
case SyntaxKind.StructDeclaration:
{
var structDeclaration = (StructDeclarationSyntax)member;
await StructDeclarationRefactoring.ComputeRefactoringsAsync(context, structDeclaration).ConfigureAwait(false);
if (MemberDeclarationListSelection.TryCreate(structDeclaration, context.Span, out MemberDeclarationListSelection selectedMembers))
{
await SelectedMemberDeclarationsRefactoring.ComputeRefactoringAsync(context, selectedMembers).ConfigureAwait(false);
}
break;
}
case SyntaxKind.InterfaceDeclaration:
{
var interfaceDeclaration = (InterfaceDeclarationSyntax)member;
InterfaceDeclarationRefactoring.ComputeRefactorings(context, interfaceDeclaration);
if (MemberDeclarationListSelection.TryCreate(interfaceDeclaration, context.Span, out MemberDeclarationListSelection selectedMembers))
{
await SelectedMemberDeclarationsRefactoring.ComputeRefactoringAsync(context, selectedMembers).ConfigureAwait(false);
}
break;
}
case SyntaxKind.EnumDeclaration:
{
await EnumDeclarationRefactoring.ComputeRefactoringAsync(context, (EnumDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.EnumMemberDeclaration:
{
await EnumMemberDeclarationRefactoring.ComputeRefactoringAsync(context, (EnumMemberDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.DelegateDeclaration:
{
DelegateDeclarationRefactoring.ComputeRefactorings(context, (DelegateDeclarationSyntax)member);
break;
}
case SyntaxKind.MethodDeclaration:
{
await MethodDeclarationRefactoring.ComputeRefactoringsAsync(context, (MethodDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.ConstructorDeclaration:
{
await ConstructorDeclarationRefactoring.ComputeRefactoringsAsync(context, (ConstructorDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.DestructorDeclaration:
{
DestructorDeclarationRefactoring.ComputeRefactorings(context, (DestructorDeclarationSyntax)member);
break;
}
case SyntaxKind.IndexerDeclaration:
{
await IndexerDeclarationRefactoring.ComputeRefactoringsAsync(context, (IndexerDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.PropertyDeclaration:
{
await PropertyDeclarationRefactoring.ComputeRefactoringsAsync(context, (PropertyDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.OperatorDeclaration:
{
ComputeRefactorings(context, (OperatorDeclarationSyntax)member);
break;
}
case SyntaxKind.ConversionOperatorDeclaration:
{
ComputeRefactorings(context, (ConversionOperatorDeclarationSyntax)member);
break;
}
case SyntaxKind.FieldDeclaration:
{
await FieldDeclarationRefactoring.ComputeRefactoringsAsync(context, (FieldDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.EventDeclaration:
{
await EventDeclarationRefactoring.ComputeRefactoringsAsync(context, (EventDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.EventFieldDeclaration:
{
await EventFieldDeclarationRefactoring.ComputeRefactoringsAsync(context, (EventFieldDeclarationSyntax)member).ConfigureAwait(false);
break;
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MoveUnsafeContextToContainingDeclaration))
{
MoveUnsafeContextToContainingDeclarationRefactoring.ComputeRefactoring(context, member);
}
}
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, MemberDeclarationSyntax member)
{
SyntaxKind kind = member.Kind();
switch (kind)
{
case SyntaxKind.MethodDeclaration:
case SyntaxKind.IndexerDeclaration:
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.OperatorDeclaration:
case SyntaxKind.ConversionOperatorDeclaration:
case SyntaxKind.ConstructorDeclaration:
case SyntaxKind.EventDeclaration:
case SyntaxKind.NamespaceDeclaration:
case SyntaxKind.ClassDeclaration:
case SyntaxKind.RecordDeclaration:
case SyntaxKind.StructDeclaration:
case SyntaxKind.RecordStructDeclaration:
case SyntaxKind.InterfaceDeclaration:
case SyntaxKind.EnumDeclaration:
{
if (context.IsAnyRefactoringEnabled(
RefactoringDescriptors.RemoveMemberDeclaration,
RefactoringDescriptors.CopyMemberDeclaration,
RefactoringDescriptors.CommentOutMemberDeclaration))
{
(SyntaxToken openBrace, SyntaxToken closeBrace) = GetBraces(member);
if ((!openBrace.IsKind(SyntaxKind.None) &&
openBrace.Span.Contains(context.Span)) ||
(!closeBrace.IsKind(SyntaxKind.None) &&
closeBrace.Span.Contains(context.Span)))
{
if (member.Parent != null &&
CSharpFacts.CanHaveMembers(member.Parent.Kind()))
{
if (context.IsRefactoringEnabled(RefactoringDescriptors.RemoveMemberDeclaration))
{
context.RegisterRefactoring(CodeActionFactory.RemoveMemberDeclaration(context.Document, member, equivalenceKey: EquivalenceKey.Create(RefactoringDescriptors.RemoveMemberDeclaration)));
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.CopyMemberDeclaration))
{
context.RegisterRefactoring(
$"Copy {CSharpFacts.GetTitle(member)}",
ct => CopyMemberDeclarationRefactoring.RefactorAsync(
context.Document,
member,
copyAfter: closeBrace.Span.Contains(context.Span),
ct),
RefactoringDescriptors.CopyMemberDeclaration);
}
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.CommentOutMemberDeclaration))
{
CommentOutRefactoring.RegisterRefactoring(context, member);
}
}
}
break;
}
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.RemoveAllStatements))
{
RemoveAllStatementsRefactoring.ComputeRefactoring(context, member);
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.RemoveAllMemberDeclarations))
{
RemoveAllMemberDeclarationsRefactoring.ComputeRefactoring(context, member);
}
if (context.IsAnyRefactoringEnabled(
RefactoringDescriptors.SwapMemberDeclarations,
RefactoringDescriptors.RemoveMemberDeclarations) &&
!member.Span.IntersectsWith(context.Span))
{
MemberDeclarationsRefactoring.ComputeRefactoring(context, member);
}
switch (kind)
{
case SyntaxKind.NamespaceDeclaration:
{
var namespaceDeclaration = (NamespaceDeclarationSyntax)member;
NamespaceDeclarationRefactoring.ComputeRefactorings(context, namespaceDeclaration);
if (MemberDeclarationListSelection.TryCreate(namespaceDeclaration, context.Span, out MemberDeclarationListSelection selectedMembers))
{
await SelectedMemberDeclarationsRefactoring.ComputeRefactoringAsync(context, selectedMembers).ConfigureAwait(false);
}
break;
}
case SyntaxKind.ClassDeclaration:
{
var classDeclaration = (ClassDeclarationSyntax)member;
await ClassDeclarationRefactoring.ComputeRefactoringsAsync(context, classDeclaration).ConfigureAwait(false);
if (MemberDeclarationListSelection.TryCreate(classDeclaration, context.Span, out MemberDeclarationListSelection selectedMembers))
{
await SelectedMemberDeclarationsRefactoring.ComputeRefactoringAsync(context, selectedMembers).ConfigureAwait(false);
}
break;
}
case SyntaxKind.RecordDeclaration:
case SyntaxKind.RecordStructDeclaration:
{
var recordDeclaration = (RecordDeclarationSyntax)member;
await RecordDeclarationRefactoring.ComputeRefactoringsAsync(context, recordDeclaration).ConfigureAwait(false);
if (MemberDeclarationListSelection.TryCreate(recordDeclaration, context.Span, out MemberDeclarationListSelection selectedMembers))
{
await SelectedMemberDeclarationsRefactoring.ComputeRefactoringAsync(context, selectedMembers).ConfigureAwait(false);
}
break;
}
case SyntaxKind.StructDeclaration:
{
var structDeclaration = (StructDeclarationSyntax)member;
await StructDeclarationRefactoring.ComputeRefactoringsAsync(context, structDeclaration).ConfigureAwait(false);
if (MemberDeclarationListSelection.TryCreate(structDeclaration, context.Span, out MemberDeclarationListSelection selectedMembers))
{
await SelectedMemberDeclarationsRefactoring.ComputeRefactoringAsync(context, selectedMembers).ConfigureAwait(false);
}
break;
}
case SyntaxKind.InterfaceDeclaration:
{
var interfaceDeclaration = (InterfaceDeclarationSyntax)member;
InterfaceDeclarationRefactoring.ComputeRefactorings(context, interfaceDeclaration);
if (MemberDeclarationListSelection.TryCreate(interfaceDeclaration, context.Span, out MemberDeclarationListSelection selectedMembers))
{
await SelectedMemberDeclarationsRefactoring.ComputeRefactoringAsync(context, selectedMembers).ConfigureAwait(false);
}
break;
}
case SyntaxKind.EnumDeclaration:
{
await EnumDeclarationRefactoring.ComputeRefactoringAsync(context, (EnumDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.EnumMemberDeclaration:
{
await EnumMemberDeclarationRefactoring.ComputeRefactoringAsync(context, (EnumMemberDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.DelegateDeclaration:
{
DelegateDeclarationRefactoring.ComputeRefactorings(context, (DelegateDeclarationSyntax)member);
break;
}
case SyntaxKind.MethodDeclaration:
{
await MethodDeclarationRefactoring.ComputeRefactoringsAsync(context, (MethodDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.ConstructorDeclaration:
{
await ConstructorDeclarationRefactoring.ComputeRefactoringsAsync(context, (ConstructorDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.DestructorDeclaration:
{
DestructorDeclarationRefactoring.ComputeRefactorings(context, (DestructorDeclarationSyntax)member);
break;
}
case SyntaxKind.IndexerDeclaration:
{
await IndexerDeclarationRefactoring.ComputeRefactoringsAsync(context, (IndexerDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.PropertyDeclaration:
{
await PropertyDeclarationRefactoring.ComputeRefactoringsAsync(context, (PropertyDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.OperatorDeclaration:
{
ComputeRefactorings(context, (OperatorDeclarationSyntax)member);
break;
}
case SyntaxKind.ConversionOperatorDeclaration:
{
ComputeRefactorings(context, (ConversionOperatorDeclarationSyntax)member);
break;
}
case SyntaxKind.FieldDeclaration:
{
await FieldDeclarationRefactoring.ComputeRefactoringsAsync(context, (FieldDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.EventDeclaration:
{
await EventDeclarationRefactoring.ComputeRefactoringsAsync(context, (EventDeclarationSyntax)member).ConfigureAwait(false);
break;
}
case SyntaxKind.EventFieldDeclaration:
{
await EventFieldDeclarationRefactoring.ComputeRefactoringsAsync(context, (EventFieldDeclarationSyntax)member).ConfigureAwait(false);
break;
}
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.MoveUnsafeContextToContainingDeclaration))
{
MoveUnsafeContextToContainingDeclarationRefactoring.ComputeRefactoring(context, member);
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, MemberDeclarationListSelection selectedMembers)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeAccessibility) &&
!selectedMembers.Parent.IsKind(SyntaxKind.InterfaceDeclaration))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
AccessibilityFilter validAccessibilities = ChangeAccessibilityAnalysis.GetValidAccessibilityFilter(selectedMembers, semanticModel, context.CancellationToken);
if (validAccessibilities != AccessibilityFilter.None)
{
bool canHaveMultipleDeclarations = CanHaveMultipleDeclarations();
TryRegisterRefactoring(validAccessibilities, Accessibility.Public, canHaveMultipleDeclarations);
TryRegisterRefactoring(validAccessibilities, Accessibility.Internal, canHaveMultipleDeclarations);
TryRegisterRefactoring(validAccessibilities, Accessibility.Protected, canHaveMultipleDeclarations);
TryRegisterRefactoring(validAccessibilities, Accessibility.Private, canHaveMultipleDeclarations);
}
}
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ConvertBlockBodyToExpressionBody,
RefactoringIdentifiers.ConvertExpressionBodyToBlockBody))
{
ConvertBodyAndExpressionBodyRefactoring.ComputeRefactoring(context, selectedMembers);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.InitializeFieldFromConstructor) &&
!selectedMembers.Parent.IsKind(SyntaxKind.InterfaceDeclaration))
{
InitializeFieldFromConstructorRefactoring.ComputeRefactoring(context, selectedMembers);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddEmptyLineBetweenDeclarations))
{
AddEmptyLineBetweenDeclarationsRefactoring.ComputeRefactoring(context, selectedMembers);
}
void TryRegisterRefactoring(AccessibilityFilter accessibilities, Accessibility accessibility, bool canHaveMultipleDeclarations)
{
if ((accessibilities & accessibility.GetAccessibilityFilter()) != 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));
},
_accessiblityIdentifierMap[accessibility]);
}
else
{
context.RegisterRefactoring(
ChangeAccessibilityRefactoring.GetTitle(accessibility),
cancellationToken => ChangeAccessibilityRefactoring.RefactorAsync(context.Document, selectedMembers, accessibility, cancellationToken),
EquivalenceKey.Join(RefactoringIdentifiers.ChangeAccessibility, accessibility.ToString()));
}
}
}
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.RecordDeclaration:
{
if (((RecordDeclarationSyntax)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 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);
}
