/// <summary> /// Create the syntax for a class constructor. /// </summary> /// <param name="className">Name of the class.</param> /// <param name="body">The generated body of the constructor.</param> /// <param name="parameters">A list with parameters.</param> /// <param name="modifiers">A list with modifiers.</param> /// <param name="attributes">A list with attributes.</param> /// <returns>The declaration syntax for a constructor.</returns> public static ConstructorDeclarationSyntax Create( string className, BlockSyntax body, IEnumerable <Parameter> parameters = null, IEnumerable <Modifiers> modifiers = null, IEnumerable <Attribute> attributes = null) { if (className == null) { throw new ArgumentNullException(nameof(className)); } var constructor = SyntaxFactory.ConstructorDeclaration(SyntaxFactory.Identifier(className)) .WithBody(body); if (parameters != null) { constructor = constructor.WithParameterList(ParameterGenerator.Create(parameters.ToArray())); } if (attributes != null) { constructor = constructor.WithAttributeLists(AttributeGenerator.Create(attributes.ToArray())); } if (modifiers != null) { constructor = constructor.WithModifiers(ModifierGenerator.Create(modifiers.ToArray())); } return(constructor); }
/// <summary> /// Create the syntax for a field of a class. /// </summary> /// <param name="field">Field to create.</param> /// <returns>The declaration syntax for a field.</returns> public static FieldDeclarationSyntax Create(Field field) { if (field == null) { throw new ArgumentNullException(nameof(field)); } var variableDeclarator = VariableDeclarator(Identifier(field.Name)); if (field.InitializeWith != null) { variableDeclarator = variableDeclarator.WithInitializer(EqualsValueClause(field.InitializeWith)); } var fieldDeclaration = FieldDeclaration(VariableDeclaration(TypeGenerator.Create(field.Type), SeparatedList(new[] { variableDeclarator }))); if (field.Modifiers != null) { fieldDeclaration = fieldDeclaration.WithModifiers(ModifierGenerator.Create(field.Modifiers.ToArray())); } if (field.Attributes != null) { fieldDeclaration = fieldDeclaration.WithAttributeLists(AttributeGenerator.Create(field.Attributes.ToArray())); } return(fieldDeclaration); }
/// <summary> /// Create the syntax for a property of a class. /// </summary> /// <param name="property">The property to create.</param> /// <returns>The declaration syntax for a property.</returns> public static PropertyDeclarationSyntax Create(Property property) { if (property == null) { throw new ArgumentNullException(nameof(property)); } PropertyDeclarationSyntax propertyDeclaration; if (property is AutoProperty) { propertyDeclaration = CreateAutoProperty((AutoProperty)property); } else if (property is BodyProperty) { propertyDeclaration = CreateBodyProperty((BodyProperty)property); } else { throw new ArgumentException($"Unknown property type: {property.Type}, could not generate code."); } if (property.Modifiers != null) { propertyDeclaration = propertyDeclaration.WithModifiers(ModifierGenerator.Create(property.Modifiers.ToArray())); } if (property.Attributes != null) { propertyDeclaration = propertyDeclaration.WithAttributeLists(AttributeGenerator.Create(property.Attributes.ToArray())); } return(propertyDeclaration); }
private MethodDeclarationSyntax BuildModifiers(MethodDeclarationSyntax method) { if (_modifiers == null || !_modifiers.Any()) { return(method); } return(method.WithModifiers(ModifierGenerator.Create(_modifiers.ToArray()))); }
private static AccessorDeclarationSyntax CreateAccessDeclaration(SyntaxKind kind, BlockSyntax body, IEnumerable <Modifiers> modifiers) { var accessDeclaration = AccessorDeclaration(kind); if (modifiers != null) { accessDeclaration = accessDeclaration.WithModifiers(ModifierGenerator.Create(modifiers.ToArray())); } accessDeclaration = body != null?accessDeclaration.WithBody(body) : accessDeclaration.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)); return(accessDeclaration); }
/// <summary> /// Create the syntax for a class constructor. /// </summary> /// <param name="className">Name of the class.</param> /// <param name="body">The generated body of the constructor.</param> /// <param name="parameters">A list with parameters.</param> /// <param name="modifiers">A list with modifiers.</param> /// <param name="attributes">A list with attributes.</param> /// <param name="constructorInitializer">The constructor initializer</param> /// <param name="summary">XML documentation summary</param> /// <returns>The declaration syntax for a constructor.</returns> public static ConstructorDeclarationSyntax Create( string className, BlockSyntax body, IEnumerable <Parameter> parameters = null, IEnumerable <Modifiers> modifiers = null, IEnumerable <Attribute> attributes = null, ConstructorInitializer constructorInitializer = null, string summary = null) { if (className == null) { throw new ArgumentNullException(nameof(className)); } var constructor = SyntaxFactory.ConstructorDeclaration(SyntaxFactory.Identifier(className)) .WithBody(body); if (parameters != null) { constructor = constructor.WithParameterList(ParameterGenerator.Create(parameters.ToArray())); } if (constructorInitializer != null) { constructor = constructor.WithInitializer( SyntaxFactory.ConstructorInitializer( constructorInitializer.ConstructorInitializerType == ConstructorInitializerTypes.Base ? SyntaxKind.BaseConstructorInitializer : SyntaxKind.ThisConstructorInitializer, constructorInitializer.Arguments == null ? null : ArgumentGenerator.Create(constructorInitializer.Arguments.ToArray()))); } if (attributes != null) { constructor = constructor.WithAttributeLists(AttributeGenerator.Create(attributes.ToArray())); } if (modifiers != null) { constructor = constructor.WithModifiers(ModifierGenerator.Create(modifiers.ToArray())); } if (!string.IsNullOrEmpty(summary)) { constructor = constructor.WithSummary(summary, parameters); } return(constructor); }
private ClassDeclarationSyntax BuildClassBase() { if (_inheritance.Any()) { var syntaxNodeOrToken = new SyntaxNodeOrToken[(_inheritance.Count * 2) - 1]; for (int n = 0; n < (_inheritance.Count * 2) - 1; n += 2) { syntaxNodeOrToken[n] = SyntaxFactory.SimpleBaseType(TypeGenerator.Create(_inheritance[n])); if (n + 1 < _inheritance.Count - 1) { syntaxNodeOrToken[n + 1] = SyntaxFactory.Token(SyntaxKind.CommaToken); } } return(SyntaxFactory.ClassDeclaration(_name).WithBaseList(SyntaxFactory.BaseList(SyntaxFactory.SeparatedList <BaseTypeSyntax>(syntaxNodeOrToken))).WithModifiers(ModifierGenerator.Create(_modifiers.ToArray()))); } return(SyntaxFactory.ClassDeclaration(_name).WithModifiers(ModifierGenerator.Create(_modifiers.ToArray()))); }
protected SyntaxTokenList CreateModifiers() { return(ModifierGenerator.Create(_modifiers.ToArray())); }
public void Create_WhenCreatingWithMultipleModifier_ShouldGenerateCode() { Assert.AreEqual("publicabstract", ModifierGenerator.Create(Modifiers.Public, Modifiers.Abstract).ToString()); }
public void Create_WhenCreatingWithModifier_ShouldGenerateCode(Modifiers modifier, string expected) { Assert.AreEqual(expected, ModifierGenerator.Create(modifier).ToString()); }
public void TestInitialize() { _generator = new ModifierGenerator(); }
public static IReadOnlyList <ModifierGenerator> AddSet(this IReadOnlyList <ModifierGenerator> orignalList, string modifierFormat, double modifierValue, params string[] modifierNames) { return(orignalList.Concat(ModifierGenerator.GenerateSet(modifierFormat, modifierValue, modifierNames)).ToArray()); }