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); }