public override SyntaxNode VisitIndexerDeclaration(IndexerDeclarationSyntax node)
{
node = (IndexerDeclarationSyntax)base.VisitIndexerDeclaration(node);
if (node.ExpressionBody != null)
{
return(SyntaxHelper.ToStatementBody(node));
}
return(node);
}
public override SyntaxNode VisitOperatorDeclaration(OperatorDeclarationSyntax node)
{
node = (OperatorDeclarationSyntax)base.VisitOperatorDeclaration(node);
if (node.ExpressionBody != null)
{
return(SyntaxHelper.ToStatementBody(node).NormalizeWhitespace());
}
return(node);
}
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node)
{
node = (PropertyDeclarationSyntax)base.VisitPropertyDeclaration(node);
var newNode = node;
if (node.ExpressionBody != null)
{
newNode = SyntaxHelper.ToStatementBody(node).NormalizeWhitespace();
}
return(newNode.Equals(node) ? node : newNode);
}
public override SyntaxNode VisitAccessorList(AccessorListSyntax node)
{
node = (AccessorListSyntax)base.VisitAccessorList(node);
if (node.Accessors.Any(a => a.ExpressionBody != null))
{
var list = new List <AccessorDeclarationSyntax>();
foreach (var accessor in node.Accessors)
{
if (accessor != null && accessor.ExpressionBody != null)
{
list.Add(SyntaxHelper.ToStatementBody(accessor));
}
else
{
list.Add(accessor);
}
}
node = node.WithAccessors(SyntaxFactory.List(list)).NormalizeWhitespace();
}
return(node);
}
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node)
{
node = (PropertyDeclarationSyntax)base.VisitPropertyDeclaration(node);
var newNode = node;
if (node.ExpressionBody != null)
{
newNode = SyntaxHelper.ToStatementBody(node);
}
if (node.IsAutoProperty() && node.AccessorList != null)
{
var setter = node.AccessorList.Accessors.SingleOrDefault(a => a.Keyword.Kind() == SyntaxKind.SetKeyword);
if (setter == null)
{
var getter = node.AccessorList.Accessors.Single(a => a.Keyword.Kind() == SyntaxKind.GetKeyword);
setter = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithModifiers(SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.PrivateKeyword).WithTrailingTrivia(SyntaxFactory.Space)))
.WithBody(null)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
.WithLeadingTrivia(getter.GetLeadingTrivia())
.WithTrailingTrivia(getter.GetTrailingTrivia());
newNode = newNode.AddAccessorListAccessors(setter);
}
if (newNode.Initializer != null)
{
var modifiers = SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.PrivateKeyword).WithTrailingTrivia(SyntaxFactory.Space));
if (node.Modifiers.Any(m => m.Kind() == SyntaxKind.StaticKeyword))
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword).WithTrailingTrivia(SyntaxFactory.Space));
}
var field = SyntaxFactory.FieldDeclaration(SyntaxFactory.List <AttributeListSyntax>(),
modifiers,
SyntaxFactory.VariableDeclaration(
node.Type,
SyntaxFactory.SeparatedList(new[] {
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(AutoInitFieldPrefix + node.Identifier.Text),
null,
newNode.Initializer
)
})
),
SyntaxFactory.Token(SyntaxKind.SemicolonToken)
);
field = field.WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia());
fields.Add(field);
newNode = newNode.ReplaceNode(newNode.Initializer, (SyntaxNode)null);
newNode = SyntaxHelper.RemoveSemicolon(newNode, newNode.SemicolonToken, t => newNode.WithSemicolonToken(t));
}
return(newNode);
}
return(newNode.Equals(node) ? node : newNode);
}
