public static SyntaxNode InsertPropInTopOfClass(SyntaxNode rootNode, string className, PropertyDeclarationSyntax property)
{
ClassDeclarationSyntax classNode = rootNode
.DescendantNodes()
.OfType <ClassDeclarationSyntax>()
.FirstOrDefault(n => n.Identifier.ValueText == className);
PropertyDeclarationSyntax firstProp = classNode
.DescendantNodes()
.OfType <PropertyDeclarationSyntax>()
.FirstOrDefault();
// Если в классе есть свойство, новое добавляется перед ним
if (firstProp != null)
{
rootNode = rootNode.InsertNodesBefore(
firstProp,
new List <PropertyDeclarationSyntax>()
{
property.WithTrailingTrivia(property.GetTrailingTrivia())
});
}
else
{
rootNode = rootNode.ReplaceNode(
classNode,
classNode.WithMembers(List(
new List <MemberDeclarationSyntax>()
{
property
})));
}
return(rootNode);
}
public static PropertyDeclarationSyntax GeneratePropWithRegion(PropertyDeclarationSyntax property, SyntaxKind directiveKind, string directiveName, int depth)
{
return(property
.WithLeadingTrivia(
TriviaList(
new List <SyntaxTrivia>()
{
Trivia(
RegionDirectiveTrivia(
Token(HashToken).WithLeadingTrivia(GenerateTabs(depth)),
Token(directiveKind).WithTrailingTrivia(Whitespace(" ")),
Token(EndOfDirectiveToken)
.WithLeadingTrivia(PreprocessingMessage(directiveName))
.WithTrailingTrivia(LineFeed),
true))
}.Concat(property.GetLeadingTrivia())))
.WithTrailingTrivia(
TriviaList(
new List <SyntaxTrivia>()
{
Trivia(
EndRegionDirectiveTrivia(
Token(HashToken).WithLeadingTrivia(
TriviaList(
Whitespace("\n"),
GenerateTabs(depth))),
Token(GetEndOfDirectiveKind(directiveKind)),
Token(EndOfDirectiveToken),
true))
}.Concat(property.GetTrailingTrivia()))));
}
public override void VisitPropertyDeclaration(PropertyDeclarationSyntax node)
{
var trivia = node.HasLeadingTrivia
? node.GetLeadingTrivia()
: default(SyntaxTriviaList);
if (node.ShouldBeHidden(trivia))
{
return;
}
// multiline comment on property
AddMultiLineDocumentationComment(trivia);
// allow derived types to determine if this method should be json serialized
if (SerializePropertyDeclarationToJson(node))
{
return;
}
var memberName = node.Identifier.Text;
// decide whether we should strip the modifier/accessor and return type, based on if
// this is a property on the top level class
if (ClassDepth == 1)
{
var arrowExpressionClauseSyntax =
node.ChildNodes().OfType <ArrowExpressionClauseSyntax>().FirstOrDefault();
if (arrowExpressionClauseSyntax != null)
{
var firstChildNode = arrowExpressionClauseSyntax.ChildNodes().First();
Blocks.Add(new CSharpBlock(firstChildNode, ClassDepth, memberName));
}
else
{
// property getter
var blockNode = node.DescendantNodes().OfType <BlockSyntax>().FirstOrDefault();
if (blockNode != null)
{
AddBlockChildNodes(blockNode, memberName);
}
}
}
else
{
// assume this is a nested class' property
Blocks.Add(new CSharpBlock(node, ClassDepth, memberName));
}
if (node.HasTrailingTrivia)
{
trivia = node.GetTrailingTrivia();
AddMultiLineDocumentationComment(trivia);
}
}
public DependentProperty(PropertyDeclarationSyntax d, IEnumerable <SimpleProperty> simpleProperties, CodeGenerationOptions options)
{
Type = d.Type;
Name = d.Identifier.Text;
LeadingTrivia = d.GetLeadingTrivia();
TrailingTrivia = d.GetTrailingTrivia();
DependsOn = GetDependsOn(d, simpleProperties).ToArray();
Options = options;
}
private SyntaxNode CreateFullProperty(PropertyDeclarationSyntax property, char?backingFiledPrefix, string methodNameToNotifyThatPropertyWasChanged, SyntaxGenerator syntaxGenerator)
{
string propertyName = property.Identifier.ValueText;
string fieldName = FieldNameGenerator.Generate(propertyName, backingFiledPrefix);
var leadingTrivia = property.GetLeadingTrivia();
var trailingTrivia = property.GetTrailingTrivia();
return(syntaxGenerator.FullPropertyDeclaration(propertyName, property.Type, property.AttributeLists, leadingTrivia, trailingTrivia, fieldName, methodNameToNotifyThatPropertyWasChanged));
}
public static MethodDeclarationSyntax ReplacePropertyWithMethod(PropertyDeclarationSyntax property, string methodName)
{
AccessorDeclarationSyntax getter = property.Getter();
BlockSyntax getterBody = getter.Body;
BlockSyntax methodBody = null;
if (getterBody != null)
{
methodBody = Block(getterBody.Statements)
.WithTrailingTrivia(property.GetTrailingTrivia());
}
else
{
methodBody = Block(
ReturnStatement(property.Initializer.Value)
.WithTrailingTrivia(property.GetTrailingTrivia()));
}
MethodDeclarationSyntax method = MethodDeclaration(
property.AttributeLists,
property.Modifiers,
property.Type,
property.ExplicitInterfaceSpecifier,
Identifier(methodName).WithLeadingTrivia(property.Identifier.LeadingTrivia),
default(TypeParameterListSyntax),
ParameterList().WithTrailingTrivia(property.Identifier.TrailingTrivia),
default(SyntaxList <TypeParameterConstraintClauseSyntax>),
methodBody,
default(ArrowExpressionClauseSyntax));
return(method
.WithLeadingTrivia(property.GetLeadingTrivia())
.WithFormatterAnnotation());
}
private static bool CheckTrivia(
PropertyDeclarationSyntax property,
VariableDeclaratorSyntax declarator,
CancellationToken cancellationToken)
{
if (property
.DescendantTrivia(TextSpan.FromBounds(property.Identifier.Span.Start, property.Span.End))
.Any(f => !f.IsWhitespaceOrEndOfLine()))
{
return(false);
}
var variableDeclaration = (VariableDeclarationSyntax)declarator.Parent;
if (variableDeclaration.Variables.Count == 1)
{
if (variableDeclaration
.Parent
.DescendantTrivia(variableDeclaration.Span)
.Any(f => !f.IsWhitespaceOrEndOfLine()))
{
return(false);
}
}
else if (declarator
.DescendantTrivia(declarator.Span)
.Any(f => !f.IsWhitespaceOrEndOfLine()))
{
return(false);
}
if (declarator.Initializer != null)
{
foreach (SyntaxTrivia trivia in property.GetTrailingTrivia())
{
if (trivia.IsKind(SyntaxKind.EndOfLineTrivia))
{
return(true);
}
else if (!trivia.IsKind(SyntaxKind.WhitespaceTrivia))
{
return(false);
}
}
}
return(true);
}
public static PropertyDeclarationSyntax ToStatementBody(PropertyDeclarationSyntax property)
{
var accessor = SyntaxFactory
.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithBody(SyntaxFactory.Block(SyntaxFactory.ReturnStatement(property.ExpressionBody.Expression.WithLeadingTrivia(SyntaxFactory.Space))));
var accessorDeclList = new SyntaxList <AccessorDeclarationSyntax>();
accessorDeclList = accessorDeclList.Add(accessor);
return(property
.WithAccessorList(SyntaxFactory.AccessorList(accessorDeclList))
.WithExpressionBody(null)
.WithSemicolonToken(SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken))
.WithTrailingTrivia(property.GetTrailingTrivia()));
}
public static PropertyDeclarationSyntax Apply(PropertyDeclarationSyntax node, Func <PropertyDeclarationSyntax, SyntaxTrivia, PropertyDeclarationSyntax> builder)
{
var leadingTrivia = node.GetLeadingTrivia();
var trailingTrivia = node.GetTrailingTrivia();
node = node.WithoutLeadingTrivia();
node = node.WithoutTrailingTrivia();
var wp = leadingTrivia.FirstOrDefault(w => w.Kind() == SyntaxKind.WhitespaceTrivia);
node = builder?.Invoke(node, wp);
node = node.WithLeadingTrivia(leadingTrivia);
node = node.WithTrailingTrivia(trailingTrivia);
return(node);
}
static void HandlePropertyCase(CodeRefactoringContext context, SyntaxNode root, SyntaxToken token, PropertyDeclarationSyntax property)
{
ExpressionSyntax expr;
if (!IsExpressionBody(null, property.ExpressionBody, out expr))
{
return;
}
context.RegisterRefactoring(
CodeActionFactory.Create(
token.Span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("To statement body"),
t2 =>
{
var accessor =
SyntaxFactory
.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithBody(SyntaxFactory.Block(SyntaxFactory.ReturnStatement(expr)))
.WithAdditionalAnnotations(Formatter.Annotation);
var accessorDeclList = new SyntaxList <AccessorDeclarationSyntax>();
accessorDeclList = accessorDeclList.Add(accessor);
var newRoot = root.ReplaceNode((SyntaxNode)
property,
property
.WithAccessorList(SyntaxFactory.AccessorList(accessorDeclList))
.WithExpressionBody(null)
.WithSemicolonToken(SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken))
.WithAdditionalAnnotations(Formatter.Annotation)
.WithTrailingTrivia(property.GetTrailingTrivia())
);
return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot)));
}
)
);
}
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node) => node.NormalizeWhitespace(indentation: "", eol: " ") .WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia());
static PropertyDeclarationSyntax CreateNewProperty(PropertyDeclarationSyntax property)
{
var getter = property.AccessorList.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration));
var setter = property.AccessorList.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.SetAccessorDeclaration));
// create new auto property
var accessorDeclList = new SyntaxList <AccessorDeclarationSyntax>().Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithModifiers(getter.Modifiers).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))
.Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithModifiers(setter.Modifiers).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(accessorDeclList)).WithTrailingTrivia(property.GetTrailingTrivia()).WithAdditionalAnnotations(Formatter.Annotation);
return(newProperty);
}
private async Task <Document> ChangePropertySetAsync(Document document, PropertyDeclarationSyntax propertyStatement, CancellationToken cancellationToken, FixType fixType)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var getAcessor = (propertyStatement.AccessorList.Accessors[0].Keyword.Text == "get") ? propertyStatement.AccessorList.Accessors[0] : propertyStatement.AccessorList.Accessors[1];
var setAcessor = (propertyStatement.AccessorList.Accessors[0].Keyword.Text == "set") ? propertyStatement.AccessorList.Accessors[0] : propertyStatement.AccessorList.Accessors[1];
var privateprotectedModifier = SyntaxFactory.Token(fixType == FixType.PrivateFix ? SyntaxKind.PrivateKeyword : SyntaxKind.ProtectedKeyword)
.WithAdditionalAnnotations(Formatter.Annotation);
var modifiers = setAcessor.Modifiers.Add(privateprotectedModifier);
setAcessor = setAcessor.WithModifiers(modifiers);
var newProperty = SyntaxFactory.PropertyDeclaration(propertyStatement.Type, propertyStatement.Identifier)
.WithModifiers(propertyStatement.Modifiers)
.WithAccessorList(SyntaxFactory.AccessorList(SyntaxFactory.List <AccessorDeclarationSyntax>(new AccessorDeclarationSyntax[] { getAcessor, setAcessor })))
.WithLeadingTrivia(propertyStatement.GetLeadingTrivia()).WithTrailingTrivia(propertyStatement.GetTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
var root = await document.GetSyntaxRootAsync();
var newRoot = root.ReplaceNode(propertyStatement, newProperty);
var newDocument = document.WithSyntaxRoot(newRoot);
return(newDocument);
}
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);
}
static PropertyDeclarationSyntax CreateNewProperty(PropertyDeclarationSyntax property)
{
// create new auto property
var accessorDeclList = new SyntaxList <AccessorDeclarationSyntax>().Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))).Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(accessorDeclList)).WithTrailingTrivia(property.GetTrailingTrivia()).WithAdditionalAnnotations(Formatter.Annotation);
return(newProperty);
}
