public static async Task <Document> RefactorAsync(
Document document,
ForStatementSyntax forStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
StatementSyntax statement = forStatement.Statement;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
string identifier = Identifier.EnsureUniqueLocalName(Identifier.DefaultForEachVariableName, statement.SpanStart, semanticModel, cancellationToken);
IdentifierNameSyntax identifierName = IdentifierName(identifier);
var condition = (BinaryExpressionSyntax)forStatement.Condition;
var memberAccessExpression = (MemberAccessExpressionSyntax)condition.Right;
ExpressionSyntax expression = memberAccessExpression.Expression;
ISymbol symbol = semanticModel.GetDeclaredSymbol(forStatement.Declaration.Variables.First(), cancellationToken);
ImmutableArray <SyntaxNode> nodes = await document.FindSymbolNodesAsync(symbol, cancellationToken).ConfigureAwait(false);
StatementSyntax newStatement = statement.ReplaceNodes(
nodes.Select(f => f.Parent.Parent.Parent),
(f, g) => identifierName.WithTriviaFrom(f));
ForEachStatementSyntax forEachStatement = ForEachStatement(
VarType(),
identifier,
expression,
newStatement);
forEachStatement = forEachStatement
.WithTriviaFrom(forStatement)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(forStatement, forEachStatement, cancellationToken).ConfigureAwait(false));
}
public static async Task <Document> RefactorAsync(
Document document,
ForStatementSyntax forStatement,
CancellationToken cancellationToken = default)
{
StatementSyntax statement = forStatement.Statement;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
string name = NameGenerator.Default.EnsureUniqueLocalName(
DefaultNames.ForEachVariable,
semanticModel,
statement.SpanStart,
cancellationToken: cancellationToken);
IdentifierNameSyntax identifierName = IdentifierName(name);
var condition = (BinaryExpressionSyntax)forStatement.Condition;
var memberAccessExpression = (MemberAccessExpressionSyntax)condition.Right;
ExpressionSyntax expression = memberAccessExpression.Expression;
ISymbol symbol = semanticModel.GetDeclaredSymbol(forStatement.Declaration.Variables[0], cancellationToken);
ImmutableArray <SyntaxNode> nodes = await SyntaxFinder.FindReferencesAsync(symbol, document, cancellationToken : cancellationToken).ConfigureAwait(false);
StatementSyntax newStatement = statement.ReplaceNodes(
nodes.Select(f => f.Parent.Parent.Parent),
(f, _) => identifierName.WithTriviaFrom(f));
TypeSyntax type = VarType();
if (semanticModel.GetTypeSymbol(expression, cancellationToken) is INamedTypeSymbol namedType &&
!namedType.OriginalDefinition.Implements(SpecialType.System_Collections_Generic_IEnumerable_T, allInterfaces: true))
{
IPropertySymbol member = namedType.FindMember <IPropertySymbol>(
"this[]",
f => f.Parameters.SingleOrDefault(shouldThrow: false)?.Type.SpecialType == SpecialType.System_Int32,
includeBaseTypes: true);
Debug.Assert(member != null, "");
if (member != null)
{
type = member.Type.ToTypeSyntax().WithSimplifierAnnotation();
}
}
ForEachStatementSyntax forEachStatement = ForEachStatement(
type,
Identifier(name).WithRenameAnnotation(),
expression,
newStatement);
forEachStatement = forEachStatement
.WithTriviaFrom(forStatement)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(forStatement, forEachStatement, cancellationToken).ConfigureAwait(false));
}
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
node = (MemberAccessExpressionSyntax)base.VisitMemberAccessExpression(node);
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression) &&
string.Equals((node.Expression as IdentifierNameSyntax)?.Identifier.ValueText, _name, StringComparison.Ordinal) &&
string.Equals((node.Name as IdentifierNameSyntax)?.Identifier.ValueText, "Current", StringComparison.Ordinal) &&
SymbolEqualityComparer.Default.Equals(_symbol, _semanticModel.GetSymbol(node.Expression, _cancellationToken)))
{
return(_newName.WithTriviaFrom(node));
}
return(node);
}
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 = newPropertyDeclaration
.WithModifiers(newPropertyDeclaration.Modifiers.Replace(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword))
.WithTriviaFrom(propertyDeclaration)
.WithFormatterAnnotation();
MemberDeclarationListInfo info = SyntaxInfo.MemberDeclarationListInfo(propertyDeclaration.Parent);
SyntaxList <MemberDeclarationSyntax> members = info.Members;
int propertyIndex = info.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);
SyntaxNode newParent = info.Parent.ReplaceNodes(nodes, (f, _) =>
{
if (f.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) &&
((MemberAccessExpressionSyntax)f.Parent).Expression.IsKind(SyntaxKind.BaseExpression))
{
return(f);
}
return(newNode.WithTriviaFrom(f));
});
MemberDeclarationListInfo newInfo = SyntaxInfo.MemberDeclarationListInfo(newParent);
members = newInfo.Members;
}
SyntaxList <MemberDeclarationSyntax> newMembers = members.ReplaceAt(propertyIndex, newPropertyDeclaration);
newMembers = MemberDeclarationInserter.Default.Insert(newMembers, fieldDeclaration);
return(await document.ReplaceMembersAsync(info, newMembers, cancellationToken).ConfigureAwait(false));
}
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));
}
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));
}
public static async Task <Document> RefactorAsync(
Document document,
PropertyDeclarationSyntax propertyDeclaration,
bool prefixIdentifierWithUnderscore = true,
CancellationToken cancellationToken = default)
{
string fieldName = StringUtility.ToCamelCase(
propertyDeclaration.Identifier.ValueText,
prefixWithUnderscore: prefixIdentifierWithUnderscore);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
fieldName = NameGenerator.Default.EnsureUniqueName(
fieldName,
semanticModel,
propertyDeclaration.SpanStart);
FieldDeclarationSyntax fieldDeclaration = FieldDeclaration(
(propertyDeclaration.Modifiers.Contains(SyntaxKind.StaticKeyword)) ? Modifiers.Private_Static() : Modifiers.Private(),
propertyDeclaration.Type,
fieldName,
propertyDeclaration.Initializer).WithFormatterAnnotation();
IPropertySymbol propertySymbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, cancellationToken);
PropertyDeclarationSyntax newPropertyDeclaration = ExpandAccessors(document, propertyDeclaration, propertySymbol, fieldName, semanticModel)
.WithModifiers(propertyDeclaration.Modifiers.Replace(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword))
.WithTriviaFrom(propertyDeclaration)
.WithFormatterAnnotation();
MemberDeclarationListInfo membersInfo = SyntaxInfo.MemberDeclarationListInfo(propertyDeclaration.Parent);
SyntaxList <MemberDeclarationSyntax> members = membersInfo.Members;
int propertyIndex = membersInfo.IndexOf(propertyDeclaration);
AccessorListSyntax accessorList = propertyDeclaration.AccessorList;
if (accessorList?.Getter()?.IsAutoImplemented() == true &&
accessorList.Setter() == null)
{
ImmutableArray <SyntaxNode> nodes = await SyntaxFinder.FindReferencesAsync(propertySymbol, document, cancellationToken : cancellationToken).ConfigureAwait(false);
IdentifierNameSyntax newNode = IdentifierName(fieldName);
SyntaxNode newParent = membersInfo.Parent.ReplaceNodes(nodes, (node, _) =>
{
if (node.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) &&
((MemberAccessExpressionSyntax)node.Parent).Expression.IsKind(SyntaxKind.BaseExpression))
{
return(node);
}
return(newNode.WithTriviaFrom(node));
});
MemberDeclarationListInfo newMembersInfo = SyntaxInfo.MemberDeclarationListInfo(newParent);
members = newMembersInfo.Members;
}
SyntaxList <MemberDeclarationSyntax> newMembers = members.ReplaceAt(propertyIndex, newPropertyDeclaration);
newMembers = MemberDeclarationInserter.Default.Insert(newMembers, fieldDeclaration);
return(await document.ReplaceMembersAsync(membersInfo, newMembers, cancellationToken).ConfigureAwait(false));
}
