private static async Task <List <MemberDeclarationSyntax> > GetAssignableMembersAsync(
RefactoringContext context,
MemberDeclarationSyntax declaration)
{
if (declaration.IsKind(SyntaxKind.PropertyDeclaration, SyntaxKind.FieldDeclaration))
{
if (await CanBeAssignedFromConstructorAsync(context, declaration).ConfigureAwait(false))
{
return(new List <MemberDeclarationSyntax>()
{
declaration
});
}
}
else if (declaration.IsKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration))
{
List <MemberDeclarationSyntax> list = null;
foreach (MemberDeclarationSyntax member in declaration.GetMembers())
{
if (await CanBeAssignedFromConstructorAsync(context, member).ConfigureAwait(false))
{
(list ?? (list = new List <MemberDeclarationSyntax>())).Add(member);
}
}
return(list);
}
return(null);
}
private static async Task <bool> CanFieldBeAssignedFromConstructorAsync(
RefactoringContext context,
FieldDeclarationSyntax fieldDeclaration)
{
VariableDeclaratorSyntax variable = fieldDeclaration.Declaration?.SingleVariableOrDefault();
if (variable != null)
{
MemberDeclarationSyntax parentMember = GetContainingMember(fieldDeclaration);
if (parentMember != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol symbol = semanticModel.GetDeclaredSymbol(variable, context.CancellationToken);
return(symbol?.IsStatic == false &&
!parentMember
.GetMembers()
.Any(member => IsBackingField(member, symbol, context, semanticModel)));
}
}
return(false);
}
private async Task <Document> RefactorAsync(
Document document,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
ConstructorDeclarationSyntax constructor = Constructor;
MemberDeclarationSyntax containingMember = constructor.GetParentMember();
SyntaxList <MemberDeclarationSyntax> members = containingMember.GetMembers();
SyntaxList <MemberDeclarationSyntax> newMembers = members.Replace(
constructor,
constructor.AddBodyStatements(CreateAssignments().ToArray()));
newMembers = newMembers.InsertRange(
GetDeclarationIndex(members),
CreateDeclarations());
SyntaxNode newRoot = root.ReplaceNode(
containingMember,
containingMember.SetMembers(newMembers));
return(document.WithSyntaxRoot(newRoot));
}
private static async Task <bool> CanFieldBeAssignedFromConstructorAsync(
RefactoringContext context,
FieldDeclarationSyntax fieldDeclaration)
{
if (fieldDeclaration.Declaration != null &&
fieldDeclaration.Declaration.Variables.Count == 1)
{
MemberDeclarationSyntax parentMember = GetContainingMember(fieldDeclaration);
if (parentMember != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol symbol = semanticModel.GetDeclaredSymbol(fieldDeclaration.Declaration.Variables[0], context.CancellationToken);
return(symbol != null &&
!symbol.IsStatic &&
!parentMember
.GetMembers()
.Any(member => IsBackingField(member, symbol, context, semanticModel)));
}
}
return(false);
}
public static async Task <Document> RefactorAsync(
Document document,
InvocationExpressionSyntax invocationExpression,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
MemberDeclarationSyntax memberDeclaration = invocationExpression.FirstAncestor <MemberDeclarationSyntax>();
Debug.Assert(memberDeclaration != null, "");
if (memberDeclaration != null)
{
BaseTypeDeclarationSyntax typeDeclaration = memberDeclaration.FirstAncestor <BaseTypeDeclarationSyntax>();
Debug.Assert(typeDeclaration != null, "");
if (typeDeclaration != null)
{
MemberInvocationExpression memberInvocation = MemberInvocationExpression.Create(invocationExpression);
string fieldName = NameGenerator.Default.EnsureUniqueLocalName("_regex", semanticModel, invocationExpression.SpanStart, cancellationToken: cancellationToken);
MemberAccessExpressionSyntax newMemberAccess = memberInvocation.MemberAccessExpression.WithExpression(IdentifierName(Identifier(fieldName).WithRenameAnnotation()));
ArgumentListPair pair = RewriteArgumentLists(memberInvocation.ArgumentList, semanticModel, cancellationToken);
InvocationExpressionSyntax newInvocationExpression = invocationExpression
.WithExpression(newMemberAccess)
.WithArgumentList(pair.ArgumentList1);
MemberDeclarationSyntax newTypeDeclaration = typeDeclaration.ReplaceNode(invocationExpression, newInvocationExpression);
TypeSyntax regexType = semanticModel.GetTypeByMetadataName(MetadataNames.System_Text_RegularExpressions_Regex).ToMinimalTypeSyntax(semanticModel, typeDeclaration.SpanStart);
FieldDeclarationSyntax fieldDeclaration = FieldDeclaration(
(ShouldBeStatic(memberDeclaration, semanticModel, cancellationToken))
? Modifiers.PrivateStaticReadOnly()
: Modifiers.PrivateReadOnly(),
regexType,
Identifier(fieldName),
EqualsValueClause(
ObjectCreationExpression(regexType, pair.ArgumentList2)));
SyntaxList <MemberDeclarationSyntax> newMembers = newTypeDeclaration
.GetMembers()
.InsertMember(fieldDeclaration, MemberDeclarationComparer.ByKind);
newTypeDeclaration = newTypeDeclaration.WithMembers(newMembers);
return(await document.ReplaceNodeAsync(typeDeclaration, newTypeDeclaration, cancellationToken).ConfigureAwait(false));
}
}
return(document);
}
public static async Task <Document> RefactorAsync(
Document document,
PropertyDeclarationSyntax propertyDeclaration,
bool prefixIdentifierWithUnderscore = true,
CancellationToken cancellationToken = default(CancellationToken))
{
string fieldName = StringUtility.ToCamelCase(
propertyDeclaration.Identifier.ValueText,
prefixWithUnderscore: prefixIdentifierWithUnderscore);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
fieldName = NameGenerator.Default.EnsureUniqueMemberName(
fieldName,
semanticModel,
propertyDeclaration.SpanStart,
cancellationToken: cancellationToken);
FieldDeclarationSyntax fieldDeclaration = CreateBackingField(propertyDeclaration, fieldName)
.WithFormatterAnnotation();
PropertyDeclarationSyntax newPropertyDeclaration = ExpandPropertyAndAddBackingField(propertyDeclaration, fieldName);
newPropertyDeclaration = ExpandPropertyRefactoring.ReplaceAbstractWithVirtual(newPropertyDeclaration);
newPropertyDeclaration = newPropertyDeclaration
.WithTriviaFrom(propertyDeclaration)
.WithFormatterAnnotation();
var parentMember = (MemberDeclarationSyntax)propertyDeclaration.Parent;
SyntaxList <MemberDeclarationSyntax> members = parentMember.GetMembers();
int propertyIndex = members.IndexOf(propertyDeclaration);
if (IsReadOnlyAutoProperty(propertyDeclaration))
{
IPropertySymbol propertySymbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, cancellationToken);
ImmutableArray <SyntaxNode> nodes = await SyntaxFinder.FindReferencesAsync(propertySymbol, document, cancellationToken : cancellationToken).ConfigureAwait(false);
IdentifierNameSyntax newNode = IdentifierName(fieldName);
MemberDeclarationSyntax newParentMember = parentMember.ReplaceNodes(nodes, (f, g) => newNode.WithTriviaFrom(f));
members = newParentMember.GetMembers();
}
SyntaxList <MemberDeclarationSyntax> newMembers = members.ReplaceAt(propertyIndex, newPropertyDeclaration);
newMembers = newMembers.InsertMember(fieldDeclaration, MemberDeclarationComparer.ByKind);
return(await document.ReplaceNodeAsync(parentMember, parentMember.WithMembers(newMembers), cancellationToken).ConfigureAwait(false));
}
private static Task <Document> RefactorAsync(
Document document,
MemberDeclarationSyntax declaration,
List <MemberDeclarationSyntax> assignableMembers,
CancellationToken cancellationToken = default(CancellationToken))
{
MemberDeclarationSyntax parentMember = GetContainingMember(declaration);
SyntaxList <MemberDeclarationSyntax> members = parentMember.GetMembers();
SyntaxList <MemberDeclarationSyntax> newMembers = members.InsertMember(
CreateConstructor(GetConstructorIdentifierText(parentMember), assignableMembers),
MemberDeclarationComparer.ByKind);
MemberDeclarationSyntax newNode = parentMember.WithMembers(newMembers)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(parentMember, 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 async Task <Document> RefactorAsync(
Document document,
SelectedMemberDeclarationCollection selectedMembers,
MemberDeclarationSortMode sortMode,
CancellationToken cancellationToken)
{
var comparer = new MemberDeclarationComparer(sortMode);
MemberDeclarationSyntax containingMember = selectedMembers.ContainingMember;
SyntaxList <MemberDeclarationSyntax> members = containingMember.GetMembers();
SyntaxList <MemberDeclarationSyntax> newMembers = members
.Take(selectedMembers.FirstIndex)
.Concat(selectedMembers.OrderBy(f => f, comparer))
.Concat(members.Skip(selectedMembers.LastIndex + 1))
.ToSyntaxList();
MemberDeclarationSyntax newNode = containingMember.SetMembers(newMembers);
return(await document.ReplaceNodeAsync(containingMember, newNode, cancellationToken).ConfigureAwait(false));
}
private static async Task <Document> RefactorAsync(
Document document,
MemberDeclarationSyntax declaration,
List <MemberDeclarationSyntax> assignableMembers,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
MemberDeclarationSyntax parentMember = GetContainingMember(declaration);
SyntaxList <MemberDeclarationSyntax> members = parentMember.GetMembers();
SyntaxList <MemberDeclarationSyntax> newMembers = members.Insert(
IndexOfLastConstructorOrField(members) + 1,
CreateConstructor(GetConstructorIdentifierText(parentMember), assignableMembers));
MemberDeclarationSyntax newNode = parentMember.SetMembers(newMembers)
.WithFormatterAnnotation();
SyntaxNode newRoot = oldRoot.ReplaceNode(parentMember, newNode);
return(document.WithSyntaxRoot(newRoot));
}
public static async Task <Document> RefactorAsync(
Document document,
PropertyDeclarationSyntax property,
CancellationToken cancellationToken)
{
var parentMember = (MemberDeclarationSyntax)property.Parent;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ISymbol fieldSymbol = GetFieldSymbol(property, semanticModel, cancellationToken);
var declarator = (VariableDeclaratorSyntax)await fieldSymbol.DeclaringSyntaxReferences[0].GetSyntaxAsync(cancellationToken).ConfigureAwait(false);
var variableDeclaration = (VariableDeclarationSyntax)declarator.Parent;
SyntaxList <MemberDeclarationSyntax> members = parentMember.GetMembers();
int propertyIndex = members.IndexOf(property);
int fieldIndex = members.IndexOf((FieldDeclarationSyntax)variableDeclaration.Parent);
ImmutableArray <SyntaxNode> oldNodes = await document.FindSymbolNodesAsync(fieldSymbol, cancellationToken).ConfigureAwait(false);
IdentifierNameSyntax newNode = IdentifierName(property.Identifier);
MemberDeclarationSyntax newParentMember = parentMember.ReplaceNodes(oldNodes, (f, g) => newNode.WithTriviaFrom(f));
members = newParentMember.GetMembers();
if (variableDeclaration.Variables.Count == 1)
{
newParentMember = newParentMember.RemoveNode(
newParentMember.GetMemberAt(fieldIndex),
SyntaxRemoveOptions.KeepUnbalancedDirectives);
if (propertyIndex > fieldIndex)
{
propertyIndex--;
}
}
else
{
var field = (FieldDeclarationSyntax)members[fieldIndex];
FieldDeclarationSyntax newField = field.RemoveNode(
field.Declaration.Variables[variableDeclaration.Variables.IndexOf(declarator)],
SyntaxRemoveOptions.KeepUnbalancedDirectives);
members = members.Replace(field, newField.WithFormatterAnnotation());
newParentMember = newParentMember.SetMembers(members);
}
members = newParentMember.GetMembers();
property = (PropertyDeclarationSyntax)members[propertyIndex];
PropertyDeclarationSyntax newProperty = CreateAutoProperty(property, declarator.Initializer);
members = members.Replace(property, newProperty);
newParentMember = newParentMember.SetMembers(members);
return(await document.ReplaceNodeAsync(parentMember, newParentMember, cancellationToken).ConfigureAwait(false));
}