private async Task <Document> SortMembersAsync(Document document, TypeDeclarationSyntax clsDecl, CancellationToken cancellationToken) { // Sort Fields var fieldsOld = clsDecl.ChildNodes().OfType <FieldDeclarationSyntax>().ToArray(); var fieldsNew = fieldsOld.OrderBy(m => m.Declaration.Variables.First().Identifier.Value).ToArray(); // Sort Properties var allProperties = clsDecl.ChildNodes().OfType <PropertyDeclarationSyntax>().ToArray(); var propOld = allProperties.Where(p => p.ExpressionBody != null || p.AccessorList.Accessors.All(a => a.ChildNodes().OfType <BlockSyntax>().Any())).ToArray(); var propNew = propOld.OrderBy(m => m.Identifier.Value).ToArray(); var autoPropOld = allProperties.Except(propNew).ToArray(); var autoPropNew = autoPropOld.OrderBy(m => m.Identifier.Value).ToArray(); // Sort Events var eventsOld = clsDecl.ChildNodes().OfType <EventFieldDeclarationSyntax>().ToArray(); var eventsNew = eventsOld.OrderBy(m => m.Declaration.Variables.First().Identifier.Value).ToArray(); // Sort Constructors var ctorsOld = clsDecl.ChildNodes().OfType <ConstructorDeclarationSyntax>().ToArray(); var ctorsNew = ctorsOld.OrderBy(m => m.ParameterList.Parameters.Count).ToArray(); // Sort Methods var methodsOld = clsDecl.ChildNodes().OfType <MethodDeclarationSyntax>().ToArray(); var methodsNew = methodsOld.OrderBy(m => m.Identifier.Value).ThenBy(m => m.ParameterList.Parameters.Count).ToArray(); // Append members var oldMembers = new List <MemberDeclarationSyntax>(); oldMembers.AddRange(fieldsOld); oldMembers.AddRange(autoPropOld); oldMembers.AddRange(eventsOld); oldMembers.AddRange(ctorsOld); oldMembers.AddRange(propOld); oldMembers.AddRange(methodsOld); var newMembers = new List <MemberDeclarationSyntax>(); newMembers.AddRange(fieldsNew); newMembers.AddRange(autoPropNew); newMembers.AddRange(eventsNew); newMembers.AddRange(ctorsNew); newMembers.AddRange(propNew); newMembers.AddRange(methodsNew); // Replace old with new var oldRoot = await document.GetSyntaxRootAsync(cancellationToken) .ConfigureAwait(false); var index = 0; var newRoot = oldRoot.ReplaceNodes(oldMembers, (o, n) => newMembers[index++] ); return(document.WithSyntaxRoot(newRoot)); }
private static SyntaxNode FindInsertionPointBelowFieldGroup(TypeDeclarationSyntax typeDeclaration) { SyntaxNode insertionPoint = null; var tracking = false; foreach (var node in typeDeclaration.ChildNodes()) { if (tracking) { if (node is FieldDeclarationSyntax) { insertionPoint = node; continue; } break; } else if (node is FieldDeclarationSyntax) { insertionPoint = node; tracking = true; } } return(insertionPoint); }
private ClassModel ExtractClassModel(TypeDeclarationSyntax syntax) { var allowedModifiers = GetAllowedModifiers(syntax); var model = new ClassModel(syntax, SemanticModel, false); AddModels <ConstructorDeclarationSyntax, IConstructorModel>(syntax, x => x.Modifiers, ExtractConstructorModel, allowedModifiers, model.Constructors); AddModels <OperatorDeclarationSyntax, IOperatorModel>(syntax, x => x.Modifiers, ExtractOperatorModel, allowedModifiers, model.Operators); AddModels <MethodDeclarationSyntax, IMethodModel>(syntax, x => x.Modifiers, ExtractMethodModel, allowedModifiers, model.Methods); AddModels <PropertyDeclarationSyntax, IPropertyModel>(syntax, x => x.Modifiers, ExtractPropertyModel, allowedModifiers, model.Properties); AddModels <IndexerDeclarationSyntax, IIndexerModel>(syntax, x => x.Modifiers, ExtractIndexerModel, allowedModifiers, model.Indexers); foreach (var methodModel in syntax.ChildNodes().OfType <MethodDeclarationSyntax>().Where(x => x.ExplicitInterfaceSpecifier != null).Select(ExtractMethodModel)) { model.Methods.Add(methodModel); } model.DefaultConstructor = model.Constructors.OrderByDescending(x => x.Parameters.Count).FirstOrDefault(); // populate interface models if (syntax is ClassDeclarationSyntax classDeclaration) { var declaredSymbol = SemanticModel.GetDeclaredSymbol(classDeclaration); foreach (var declaredSymbolInterface in declaredSymbol.Interfaces) { model.Interfaces.Add(new InterfaceModel(declaredSymbolInterface)); } } return(model); }
private void AddModels <TIn, TOut>(TypeDeclarationSyntax type, Func <TIn, SyntaxTokenList> modifiersSelector, Func <TIn, TOut> converter, ICollection <SyntaxKind> allowedModifiers, ICollection <TOut> target) { foreach (var model in type.ChildNodes().OfType <TIn>().Where(x => modifiersSelector(x).Any(m => allowedModifiers.Contains(m.Kind()))).Select(converter)) { target.Add(model); } }
private void AddObject(TypeDeclarationSyntax node, CSharpSyntaxTree syntaxTree, SemanticModel semanticModel, SyntaxTokenList modifiers, AddObjectCallbackMethod callback) { var symbol = semanticModel.GetDeclaredSymbol(node); string fullname = Tools.GetFullTypeName(symbol); bool addNew = false; if (Tools.HasKind(modifiers, SyntaxKind.PartialKeyword)) { ObjectType obj; if (DoesPartialObjectExist(fullname, out obj)) { obj.MergePartial(node, semanticModel); } else { addNew = true; } } else { addNew = true; } if (addNew) { callback?.Invoke(); } AddObjects(node.ChildNodes(), syntaxTree, semanticModel); }
private async Task <Document> AllowMembersOrderingAsync(Document document, TypeDeclarationSyntax typeDeclarationSyntax, CancellationToken cancellationToken) { var membersDeclaration = typeDeclarationSyntax .ChildNodes() .OfType <MemberDeclarationSyntax>(); var root = await document.GetSyntaxRootAsync(cancellationToken) as CompilationUnitSyntax; TypeDeclarationSyntax newTypeDeclarationSyntax; var orderChanged = TryReplaceTypeMembers( typeDeclarationSyntax, membersDeclaration, membersDeclaration.OrderBy(member => member, GetMemberDeclarationComparer(document, cancellationToken)), out newTypeDeclarationSyntax); if (!orderChanged) { return(null); } var newDocument = document.WithSyntaxRoot(root .ReplaceNode(typeDeclarationSyntax, newTypeDeclarationSyntax) .WithAdditionalAnnotations(Formatter.Annotation) ); return(newDocument); }
private TypeDeclarationSyntax GetNewTypeDeclaration() { var oldBuilder = _type .ChildNodes() .OfType <TypeDeclarationSyntax>() .Where(t => t.Identifier.Text == "Builder") .FirstOrDefault(); var newBuilder = GetBuilderClass(); if (oldBuilder != null) { return(_type.ReplaceNode(oldBuilder, newBuilder)); } else { return(_type.InsertAfter(_type.ChildNodes().Last(), newBuilder)); } }
public RootTypeNode Convert(TypeDeclarationSyntax type) => new RootTypeNode( name: type.Identifier.Text, fields: ConvertProperties( type.ChildNodes() .OfType <PropertyDeclarationSyntax>() .Where(property => IsSerializable(property, type))), genericTypeParameters: type.TypeParameterList?.Parameters .Select(p => p.Identifier.Text) .Where(p => !string.IsNullOrWhiteSpace(p)) ?? Enumerable.Empty <string>(), baseTypes: ConvertBaseTypes( type.BaseList?.Types ?? Enumerable.Empty <BaseTypeSyntax>(), type));
private static TypeDeclarationSyntax WithBackingField(this TypeDeclarationSyntax node, ITypeSymbol typeSymbol, string backingFieldName, SemanticModel model, Workspace workspace) { PropertyDeclarationSyntax property = node.ChildNodes().Where(n => n.HasAnnotation(UpdatedPropertyAnnotation)).FirstOrDefault() as PropertyDeclarationSyntax; if (property == null) { return(null); } MemberDeclarationSyntax fieldDecl = GenerateBackingField(typeSymbol, backingFieldName, workspace); node = node.InsertNodesBefore(property, new[] { fieldDecl }); return(node); }
public TypeDeclarationSyntax AddGeneratedCodeAttributeOnMembers( TypeDeclarationSyntax typeDeclaration) { var nodesToBeReplaced = typeDeclaration .ChildNodes() .Where(node => Updates.Keys.Any(key => key.IsAssignableFrom(node.GetType()))); SyntaxNode calculateReplacement(SyntaxNode rootNode, SyntaxNode toBeReplacedNode) { var context = new MemberReplacementContext(toBeReplacedNode, this, attributeGenerator); var updater = Updates[toBeReplacedNode.GetType()]; return(updater(context)); } return(typeDeclaration.ReplaceNodes(nodesToBeReplaced, calculateReplacement)); }
/// <summary> /// Warning, this method does not hanlde Partial classes /// </summary> /// <param name="type"></param> /// <returns></returns> public static MemberDeclarationSyntax[] GetFieldAndPropertyDeclarations( this TypeDeclarationSyntax type, bool aknowledgePartialDeclarationLimitation = false) { if (type.IsPartial() && !aknowledgePartialDeclarationLimitation) { throw new ArgumentException($"Type {type.Identifier.TrimmedText()} is partial, " + $"its members are contained in multiple graphs in multiple files. " + $"To aknowledge this limitation and allow method to proceed, " + $"pass true to {nameof(aknowledgePartialDeclarationLimitation)}"); } return(type .ChildNodes() .Where(node => node.Fits(SyntaxKind.PropertyDeclaration, SyntaxKind.FieldDeclaration)) .OfType <MemberDeclarationSyntax>() .ToArray()); }
public static IEnumerable <ConstructorDeclarationSyntax> GetConstructors(this TypeDeclarationSyntax typeDecl) { return(typeDecl.ChildNodes().OfType <ConstructorDeclarationSyntax>()); }
public static bool TypeDeclarationIncludesParameterlessConstructor(this TypeDeclarationSyntax typeDeclaration) { return(typeDeclaration.ChildNodes().OfType <ConstructorDeclarationSyntax>().Cast <ConstructorDeclarationSyntax>().Any(x => !x.ParameterList.Parameters.Any())); }