private static AccessorDeclarationSyntax CreateSetAccessorWorker( SemanticModel semanticModel, SyntaxGenerator generator, GetAndSetMethods getAndSetMethods) { var setMethodDeclaration = getAndSetMethods.SetMethodDeclaration as MethodDeclarationSyntax; var setMethod = getAndSetMethods.SetMethod; if (setMethodDeclaration == null || setMethod?.Parameters.Length != 1) { return(null); } var getMethod = getAndSetMethods.GetMethod; var accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration); if (getMethod.DeclaredAccessibility != setMethod.DeclaredAccessibility) { accessor = (AccessorDeclarationSyntax)generator.WithAccessibility(accessor, setMethod.DeclaredAccessibility); } if (setMethodDeclaration.ExpressionBody != null) { var oldExpressionBody = setMethodDeclaration.ExpressionBody; var expression = ReplaceReferencesToParameterWithValue( semanticModel, setMethod.Parameters[0], oldExpressionBody.Expression); return(accessor.WithExpressionBody(oldExpressionBody.WithExpression(expression)) .WithSemicolonToken(setMethodDeclaration.SemicolonToken)); } if (setMethodDeclaration.SemicolonToken.Kind() != SyntaxKind.None) { return(accessor.WithSemicolonToken(setMethodDeclaration.SemicolonToken)); } if (setMethodDeclaration.Body != null) { var body = ReplaceReferencesToParameterWithValue(semanticModel, setMethod.Parameters[0], setMethodDeclaration.Body); return(accessor.WithBody(body.WithAdditionalAnnotations(Formatter.Annotation))); } return(accessor); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IAccessor; var parentProperty = item.Parent as RDomProperty; // .NET specific if (itemAsT == null || parentProperty == null) { throw new InvalidOperationException(); } var kind = (itemAsT.AccessorType == AccessorType.Get) ? SyntaxKind.GetAccessorDeclaration : SyntaxKind.SetAccessorDeclaration; AccessorDeclarationSyntax node; if (itemAsT.Statements.Any() || !parentProperty.CanBeAutoProperty) { var statementBlock = (BlockSyntax)RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup); node = SyntaxFactory.AccessorDeclaration(kind, statementBlock); } else { node = SyntaxFactory.AccessorDeclaration(kind).WithSemicolonToken( SyntaxFactory.Token( SyntaxKind.SemicolonToken)); } if (itemAsT.AccessModifier != parentProperty.AccessModifier) { var modifiers = item.BuildModfierSyntax(); node = node.WithModifiers(modifiers); } node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); var attributeList = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes); if (attributeList.Any()) { node = node.WithAttributeLists(attributeList); } return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
/// <summary> /// 创建新属性 /// </summary> /// <param name="property"></param> /// <returns></returns> public PropertyDeclarationSyntax CreateProperty(CsharpProperty property) { var documentcomment = GeneratorComment(property.PropertyComment); var propertyDeclaration = SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName(property.PropertyType), property.PropertyName) // .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddAccessorListAccessors( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))).WithModifiers( SyntaxFactory.TokenList( new[] { SyntaxFactory.Token( SyntaxFactory.TriviaList( SyntaxFactory.Trivia(documentcomment)), // xmldoc SyntaxKind.PublicKeyword, // original 1st token SyntaxFactory.TriviaList()) //, SyntaxFactory.Token(SyntaxKind.PrivateKeyword) })); return(propertyDeclaration); }
public string CreateSettingsInterface(CodeGenerationConfiguration configuration) { SyntaxNode compilationUnitSyntax = SyntaxFactory.CompilationUnit() .AddMembers( SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(configuration.CoreNamespace)) .AddMembers( SyntaxFactory.InterfaceDeclaration("IDatabaseSettings") .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddMembers( SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName("string"), configuration.ConnectionStringName) .AddAccessorListAccessors( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))) ) )); var syntaxNode = Formatter.Format(compilationUnitSyntax, WorkSpace); return(syntaxNode.ToFullString()); }
public static IEnumerable <MemberDeclarationSyntax> Properties(SqModelMeta meta, IReadOnlyDictionary <string, SyntaxList <AttributeListSyntax> >?oldAttributes) { return(meta.Properties.Select(p => { var res = SyntaxFactory.PropertyDeclaration( SyntaxFactory.ParseTypeName(p.FinalType), p.Name) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddAccessorListAccessors( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) ); if (oldAttributes != null && oldAttributes.TryGetValue(p.Name, out var attributeList)) { res = res.WithAttributeLists(attributeList); } return res; })); }
public CSharpSyntaxNode Convert(SetAccessor node) { PropertyDeclarationSyntax csProperty = SyntaxFactory .PropertyDeclaration(node.Parameters[0].Type.ToCsNode <TypeSyntax>(), node.Name.Text) .AddModifiers(node.Modifiers.ToCsNodes <SyntaxToken>()); if (node.JsDoc.Count > 0) { csProperty = csProperty.WithLeadingTrivia(SyntaxFactory.Trivia(node.JsDoc[0].ToCsNode <DocumentationCommentTriviaSyntax>())); } AccessorDeclarationSyntax csSetAccess = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration); if (node.Body != null) { csSetAccess = csSetAccess.WithBody(node.Body.ToCsNode <BlockSyntax>()); } return(csProperty.AddAccessorListAccessors(csSetAccess)); }
static PropertyDeclarationSyntax GeneratePropertyDeclaration(FieldDeclarationSyntax field, VariableDeclaratorSyntax initializer) { var modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); if (field.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword))) { modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); } string propertyName = NameProposalService.GetNameProposal(initializer.Identifier.ValueText, SyntaxKind.PropertyDeclaration); var block = SyntaxFactory.Block(SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(initializer.Identifier))); return(SyntaxFactory.PropertyDeclaration(field.Declaration.Type, propertyName) .WithModifiers(modifiers) .WithAccessorList( SyntaxFactory.AccessorList(SyntaxFactory.SingletonList( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, block) )) ).WithAdditionalAnnotations(Formatter.Annotation)); }
private ClassDeclarationSyntax GenerateProperty( GraphQLObjectTypeDefinition objectType, ClassDeclarationSyntax classDeclaration, GraphQLFieldDefinition field, IEnumerable <ASTNode> allDefinitions) { var member = SyntaxFactory.PropertyDeclaration( this.GetCSharpTypeFromGraphQLType(field.Type, allDefinitions), PickFieldName(objectType, field, allDefinitions)) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)) .AddAttributeLists(GetFieldAttributes(field)) .AddAccessorListAccessors( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); return(classDeclaration.AddMembers(member)); }
private static SyntaxNode FixWithTrackNode(SyntaxNode root, PropertyDeclarationSyntax property, VariableDeclaratorSyntax fieldVariableDeclaratorSyntax, IEnumerable <SyntaxNode> nodesToUpdate) { var newRoot = root.TrackNodes(nodesToUpdate); var fieldReferences = nodesToUpdate.OfType <IdentifierNameSyntax>(); foreach (var identifier in fieldReferences) { var trackedIdentifierNode = newRoot.GetCurrentNode(identifier); var newIdentifierExpression = SyntaxFactory.IdentifierName(property.Identifier.Text); newIdentifierExpression = newIdentifierExpression.WithLeadingTrivia(trackedIdentifierNode.GetLeadingTrivia()).WithTrailingTrivia(trackedIdentifierNode.GetTrailingTrivia()).WithAdditionalAnnotations(Formatter.Annotation); newRoot = newRoot.ReplaceNode(trackedIdentifierNode, newIdentifierExpression); } var prop = newRoot.GetCurrentNode(nodesToUpdate.OfType <PropertyDeclarationSyntax>().Single()); var fieldInitilization = GetFieldInitialization(fieldVariableDeclaratorSyntax); var getter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); var accessorList = SyntaxFactory.AccessorList( SyntaxFactory.List(new[] { getter })); var newProp = prop.WithAccessorList(accessorList); if (fieldInitilization != null) { newProp = newProp.WithInitializer(fieldInitilization).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); } newProp = newProp.WithLeadingTrivia(prop.GetLeadingTrivia()).WithTrailingTrivia(prop.GetTrailingTrivia()).WithAdditionalAnnotations(Formatter.Annotation); newRoot = newRoot.ReplaceNode(prop, newProp); var variableDeclarator = newRoot.GetCurrentNode(nodesToUpdate.OfType <VariableDeclaratorSyntax>().Single()); var declaration = variableDeclarator.AncestorsAndSelf().OfType <VariableDeclarationSyntax>().First(); if (declaration.Variables.Count == 1) { var fieldDeclaration = declaration.AncestorsAndSelf().OfType <FieldDeclarationSyntax>().First(); newRoot = newRoot.RemoveNode(fieldDeclaration, SyntaxRemoveOptions.KeepUnbalancedDirectives); } else { newRoot = newRoot.RemoveNode(variableDeclarator, SyntaxRemoveOptions.KeepUnbalancedDirectives); } return(newRoot); }
protected override async Task <SyntaxNode> UpdatePropertyAsync( Document propertyDocument, Compilation compilation, IFieldSymbol fieldSymbol, IPropertySymbol propertySymbol, PropertyDeclarationSyntax propertyDeclaration, bool isWrittenOutsideOfConstructor, CancellationToken cancellationToken) { var project = propertyDocument.Project; var trailingTrivia = propertyDeclaration.GetTrailingTrivia(); var updatedProperty = propertyDeclaration.WithAccessorList(UpdateAccessorList(propertyDeclaration.AccessorList)) .WithExpressionBody(null) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)); // We may need to add a setter if the field is written to outside of the constructor // of it's class. if (NeedsSetter(compilation, propertyDeclaration, isWrittenOutsideOfConstructor)) { var accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); var generator = SyntaxGenerator.GetGenerator(project); if (fieldSymbol.DeclaredAccessibility != propertySymbol.DeclaredAccessibility) { accessor = (AccessorDeclarationSyntax)generator.WithAccessibility(accessor, fieldSymbol.DeclaredAccessibility); } var modifiers = SyntaxFactory.TokenList( updatedProperty.Modifiers.Where(token => !token.IsKind(SyntaxKind.ReadOnlyKeyword))); updatedProperty = updatedProperty.WithModifiers(modifiers) .AddAccessorListAccessors(accessor); } var fieldInitializer = await GetFieldInitializerAsync(fieldSymbol, cancellationToken).ConfigureAwait(false); if (fieldInitializer != null) { updatedProperty = updatedProperty.WithInitializer(SyntaxFactory.EqualsValueClause(fieldInitializer)) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); } return(updatedProperty.WithTrailingTrivia(trailingTrivia).WithAdditionalAnnotations(SpecializedFormattingAnnotation)); }
private void ProccessNode(CSharpSyntaxNode node) { var modifiers = GetModifiers(Command.Modifiers, Command.Abstract, Command.Static); var newGetAccessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithModifiers(Command.GetModifier) .WithExpressionBody(Command.GetExpression) .WithBody(Command.GetStatements); if (newGetAccessor.Body is null) { newGetAccessor = newGetAccessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); } var newSetAccessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithModifiers(Command.SetModifier) .WithExpressionBody(Command.SetExpression) .WithBody(Command.SetStatements); if (newSetAccessor.Body is null) { newSetAccessor = newSetAccessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); } var Accesors = new SyntaxList <AccessorDeclarationSyntax>().Add(newGetAccessor).Add(newSetAccessor); var property = SyntaxFactory.PropertyDeclaration(Command.ReturnType ?? SyntaxFactory.ParseTypeName("object"), Command.Name) .WithAttributeLists(Command.Attributes) .WithModifiers(modifiers) .WithAdditionalAnnotations(new SyntaxAnnotation($"{Id}")) .WithAccessorList(SyntaxFactory.AccessorList(Accesors)); if (Command.InitializerExpression != null) { property = property.WithInitializer(SyntaxFactory.EqualsValueClause(Command.InitializerExpression)) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); } DocumentEditor.InsertMembers(node, 0, new[] { property }); }
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax propertyDeclaration) { // Check each node until we find the property in question. When we have it, we'll replace it with an Auto Property if (propertyDeclaration == this._fullProperty) { // Create Empty getters and setters. var emptyGetter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); var emptySetter = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); if (propertyDeclaration.HasGetter()) { // Put the original Get modifier on the Auto property emptyGetter = emptyGetter.WithModifiers(propertyDeclaration.GetGetter().Modifiers); } else { // Full property didn't have a getter, but no get in a Auto property makes no sense... We'll keep a get, but make it private emptyGetter = emptyGetter.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword))); } if (propertyDeclaration.HasSetter()) { // Put the original Set modifier on the Auto property emptySetter = emptySetter.WithModifiers(propertyDeclaration.GetSetter().Modifiers); } else { // Full property didn't have a setter, but no set in an Auto property makes no sense... We'll keep a set, but make it private emptySetter = emptySetter.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword))); } // Create a new auto property (without a body) var newProperty = _fullProperty.WithAccessorList( SyntaxFactory.AccessorList( SyntaxFactory.List(new[] { emptyGetter, emptySetter }))); return(newProperty); } return(base.VisitPropertyDeclaration(propertyDeclaration)); }
private static List <PropertyDeclarationSyntax> CreateProperties(MethodDeclarationSyntax method) { var newGetSyntax = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); var newSetSyntax = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); var acessorSyntax = SyntaxFactory.AccessorList( SyntaxFactory.Token(SyntaxKind.OpenBraceToken), SyntaxFactory.List(new[] { newGetSyntax, newSetSyntax }), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); var properties = new List <PropertyDeclarationSyntax>(); foreach (ParameterSyntax param in method.ParameterList.Parameters) { var property = SyntaxFactory.PropertyDeclaration(param.Type, FirstLetteToUpper(param.Identifier.Text)) .WithModifiers(SyntaxFactory.TokenList(new[] { SyntaxFactory.Token(SyntaxKind.PublicKeyword) })) .WithAccessorList(acessorSyntax); properties.Add(property); } return(properties); }
private static AccessorDeclarationSyntax GenerateAccessorDeclaration( IPropertySymbol property, IMethodSymbol accessor, SyntaxKind kind, bool hasBody, CodeGenerationOptions options, ParseOptions parseOptions ) { var declaration = SyntaxFactory .AccessorDeclaration(kind) .WithModifiers(GenerateAccessorModifiers(property, accessor, options)) .WithBody(hasBody ? GenerateBlock(accessor) : null) .WithSemicolonToken( hasBody ? default : SyntaxFactory.Token(SyntaxKind.SemicolonToken) ); declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions); return(AddAnnotationsTo(accessor, declaration)); }
public PropertyDeclarationSyntax GetPropertyDeclaration(bool allowGet = true, bool allowSet = false) { var declaration = SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName(_typeName), PropertyName) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); if (allowGet) { declaration = declaration.AddAccessorListAccessors(SyntaxFactory .AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); } if (allowSet) { declaration = declaration.AddAccessorListAccessors(SyntaxFactory .AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); } return(declaration); }
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node) { node = (PropertyDeclarationSyntax)base.VisitPropertyDeclaration(node); if (node.ExpressionBody != null) { var block = SyntaxFactory.Block( SyntaxFactory.ReturnStatement(node.ExpressionBody.Expression) ); return(node.WithExpressionBody(null) .WithSemicolonToken(default(SyntaxToken)) .WithAccessorList( SyntaxFactory.AccessorList( SyntaxFactory.List(new[] { SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, block) }) ) )); } return(node); }
protected virtual MemberDeclarationSyntax CreatePropertyDeclaration(ILocatedOpenApiElement <OpenApiSchema> property, string ownerName) { string propertyName = Context.NameFormatterSelector.GetFormatter(NameKind.Property).Format(property.Key); if (propertyName == ownerName) { // Properties can't have the same name as the class/interface propertyName += "Value"; } var typeName = Context.TypeNameProvider.GetName(property); return(SyntaxFactory.PropertyDeclaration(typeName, propertyName) .AddElementAnnotation(property, Context.ElementRegistry) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddAccessorListAccessors( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))); }
public static PropertyDeclarationSyntax GenProperty(string type, string name, bool setter, string initializer = null) { var accessors = setter ? new[] { SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) } : new[] { SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) }; return(SyntaxFactory.PropertyDeclaration( attributeLists: SyntaxFactory.List <AttributeListSyntax>(), modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), type: SyntaxFactory.ParseTypeName(type), explicitInterfaceSpecifier: null, identifier: SyntaxFactory.Identifier(name), accessorList: SyntaxFactory.AccessorList(SyntaxFactory.List(accessors)), expressionBody: null, initializer: initializer == null ? null : SyntaxFactory.EqualsValueClause(SyntaxFactory.ParseExpression(initializer)), semicolonToken: initializer == null ? SyntaxFactory.Token(SyntaxKind.None) : SyntaxFactory.Token(SyntaxKind.SemicolonToken))); }
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node) { List <PropertyDeclarationSyntax> newDeclarations = new List <PropertyDeclarationSyntax>(); foreach (var prop in this.propertiesToAdd) { var newDeclaration = SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName(prop.Value), prop.Key) .WithAccessorList(SyntaxFactory.AccessorList(new SyntaxList <AccessorDeclarationSyntax>(new AccessorDeclarationSyntax[] { SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) }))) .WithModifiers(new SyntaxTokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword))); newDeclaration = newDeclaration.WithAdditionalAnnotations(new SyntaxAnnotation(this.AnnotationKey)); newDeclarations.Add(newDeclaration); } var changedClass = node.AddMembers(newDeclarations.ToArray()); return(base.VisitClassDeclaration(changedClass)); }
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node) { var changedClass = node; var declaredSymbol = this.semanticModel.GetDeclaredSymbol(node); var typeName = declaredSymbol.GetFullMetadataName(); if (parameters.TypePropertyNames.ContainsKey(typeName)) { foreach (var name in parameters.TypePropertyNames[typeName]) { changedClass = changedClass.AddMembers(SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName("int"), name) .WithAccessorList(SyntaxFactory.AccessorList(new SyntaxList <AccessorDeclarationSyntax>(new AccessorDeclarationSyntax[] { SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) }))) .WithModifiers(new SyntaxTokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)))); } } return(changedClass); }
private PropertyDeclarationSyntax GenerateProperty(FieldType metaData, PropertyConfiguration propertyConfiguration, RoslynGeneratorUtils roslynGeneratorUtils, IGeneratorConfiguration config) { var propertyName = propertyConfiguration.PropertyName ?? roslynGeneratorUtils.NormalizeIdentifiers(metaData.Term, config.PascalCase); var propertyDeclaration = SyntaxFactory .PropertyDeclaration(SyntaxFactory.ParseTypeName(propertyConfiguration.TypeName), propertyName) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddAccessorListAccessors( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); if (config.TermAttribute != TermAttributeType.none) { AttributeListSyntax attributeList = GenerateTermAttribute(metaData, config); propertyDeclaration = propertyDeclaration.AddAttributeLists(attributeList); } return(propertyDeclaration); }
private CSharpSyntaxNode ToGetSet(PropertyDeclaration node) { List <Node> modifiers = node.Modifiers.FindAll(n => n.Kind != NodeKind.ReadonlyKeyword); PropertyDeclarationSyntax csProperty = SyntaxFactory .PropertyDeclaration(node.Type.ToCsNode <TypeSyntax>(), node.Name.Text) .AddModifiers(modifiers.ToCsNodes <SyntaxToken>()); if (node.JsDoc.Count > 0) { csProperty = csProperty.WithLeadingTrivia(SyntaxFactory.Trivia(node.JsDoc[0].ToCsNode <DocumentationCommentTriviaSyntax>())); } //GetAccess AccessorDeclarationSyntax csGetAccess = SyntaxFactory .AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); // if (node.Initializer != null) // { // csGetAccess = csGetAccess.WithBody(SyntaxFactory.Block(SyntaxFactory.ReturnStatement(node.Initializer.ToCsNode<ExpressionSyntax>()))); // } csProperty = csProperty.AddAccessorListAccessors(csGetAccess); //SetsAccess if ((node.IsReadonly && !node.IsAbstract) || (!node.IsReadonly)) { AccessorDeclarationSyntax csSetAccess = SyntaxFactory .AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); if (node.IsReadonly) { csSetAccess = csSetAccess.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)); } csProperty = csProperty.AddAccessorListAccessors(csSetAccess); } return(csProperty); }
public override PropertyDeclarationSyntax EmitSyntax() { OutputSyntax = SyntaxFactory.PropertyDeclaration( Member.PropertyType.GetTypeNameSyntax(), SyntaxFactory.Identifier(Member.Name) ); OutputSyntax = OutputSyntax.WithModifiers(EmitMemberModifiers()); OutputSyntax = OutputSyntax.WithAccessorList( SyntaxFactory.AccessorList( SyntaxFactory.List <AccessorDeclarationSyntax>(new[] { SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) }) ) ); return(OutputSyntax); }
public ClassEventPropertyWithCodeAnalysis( ClassMemberVisibilityModifier visibility, DelegateReferenceWithCodeAnalysis type, string name, MethodBodyWithCodeAnalysis addAccessor, MethodBodyWithCodeAnalysis removeAccessor) : this() { IEnumerable <AccessorDeclarationSyntax> accessors = new AccessorDeclarationSyntax[] { SyntaxFactory.AccessorDeclaration(SyntaxKind.AddKeyword, addAccessor.Syntax), SyntaxFactory.AccessorDeclaration(SyntaxKind.RemoveKeyword, removeAccessor.Syntax) }; Syntax = SyntaxFactory.EventDeclaration( default(SyntaxList <AttributeListSyntax>), default(SyntaxTokenList).WithClassMemberVisibilityModifier(visibility), type.Syntax, null, SyntaxFactory.Identifier(name), SyntaxFactory.AccessorList(SyntaxFactory.List(accessors))); }
public PropertyDeclarationSyntax GetPropertyDeclarationSyntax(string propertyName, SyntaxKind syntaxKind) { var typeSyntax = ListPropertyDeclarationSyntaxGenerator.GetTypeSyntax(propertyName, syntaxKind); return(SyntaxFactory.PropertyDeclaration( typeSyntax, SyntaxFactory.Identifier( SyntaxFactory.TriviaList(), propertyName, SyntaxFactory.TriviaList( SyntaxFactory.Space))) .WithModifiers( SyntaxFactory.TokenList( SyntaxFactory.Token( SyntaxFactory.TriviaList(), SyntaxKind.PublicKeyword, SyntaxFactory.TriviaList( SyntaxFactory.Space)))) .WithAccessorList( SyntaxFactory.AccessorList( SyntaxFactory.List <AccessorDeclarationSyntax>( new AccessorDeclarationSyntax[] { SyntaxFactory.AccessorDeclaration( SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken( SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration( SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken( SyntaxFactory.Token(SyntaxKind.SemicolonToken)) })) .WithCloseBraceToken( SyntaxFactory.Token( SyntaxFactory.TriviaList(), SyntaxKind.CloseBraceToken, SyntaxFactory.TriviaList( new[] { SyntaxFactory.Space, SyntaxFactory.LineFeed }))))); }
protected override async Task <SyntaxNode> UpdatePropertyAsync( Document propertyDocument, Compilation compilation, IFieldSymbol fieldSymbol, IPropertySymbol propertySymbol, PropertyDeclarationSyntax propertyDeclaration, bool isWrittenOutsideOfConstructor, CancellationToken cancellationToken) { var project = propertyDocument.Project; var sourceText = await propertyDocument.GetTextAsync(cancellationToken).ConfigureAwait(false); var getAccessor = propertyDeclaration.AccessorList.Accessors.First(d => d.IsKind(SyntaxKind.GetAccessorDeclaration)); var updatedProperty = propertyDeclaration.WithAccessorList(UpdateAccessorList(propertyDeclaration.AccessorList)); // We may need to add a setter if the field is written to outside of the constructor // of it's class. if (NeedsSetter(compilation, propertyDeclaration, isWrittenOutsideOfConstructor)) { var accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); var generator = SyntaxGenerator.GetGenerator(project); if (fieldSymbol.DeclaredAccessibility != propertySymbol.DeclaredAccessibility) { accessor = (AccessorDeclarationSyntax)generator.WithAccessibility(accessor, fieldSymbol.DeclaredAccessibility); } updatedProperty = updatedProperty.AddAccessorListAccessors(accessor); } var fieldInitializer = await GetFieldInitializerAsync(fieldSymbol, cancellationToken).ConfigureAwait(false); if (fieldInitializer != null) { updatedProperty = updatedProperty.WithInitializer(SyntaxFactory.EqualsValueClause(fieldInitializer)) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); } updatedProperty = updatedProperty.WithAdditionalAnnotations(SpecializedFormattingAnnotation); return(updatedProperty); }
public string GetClassDefinition(CodeViewModel m) { var classDeclaration = SyntaxFactory.ClassDeclaration(m.Name) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); var propertyDeclarations = new List <MemberDeclarationSyntax>(); foreach (var p in m.Fields) { var propertyDeclaration = SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName(p.Type), p.Name) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddAccessorListAccessors(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))) .AddAccessorListAccessors(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); propertyDeclarations.Add(propertyDeclaration); } classDeclaration = classDeclaration.AddMembers(propertyDeclarations.ToArray()); return(classDeclaration.NormalizeWhitespace() .ToFullString()); }
public static PropertyDeclarationSyntax Create(IProperty element) { var propertyDeclaration = SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName(element.Type), element.Name) .AddModifiers(SyntaxFactory.ParseToken(element.ModifierDeclaration)); if (element.SetAccessor) { propertyDeclaration = propertyDeclaration.AddAccessorListAccessors(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); } if (element.GetAccessor) { propertyDeclaration = propertyDeclaration.AddAccessorListAccessors(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); } if (element.Attributes?.Any() ?? false) { propertyDeclaration = propertyDeclaration.AddAttributeLists(element.Attributes.Select(item => ConstructAttribute.Create(item)).ToArray()); } return(propertyDeclaration); }
private static SyntaxNode WithBlockBody(SyntaxNode node, BlockSyntax body) { switch (node) { case BasePropertyDeclarationSyntax baseProperty: var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, body))); return(baseProperty .TryWithExpressionBody(null) .WithAccessorList(accessorList) .TryWithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)) .WithTriviaFrom(baseProperty)); case AccessorDeclarationSyntax accessor: return(accessor .WithExpressionBody(null) .WithBody(body) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)) .WithTriviaFrom(accessor)); case BaseMethodDeclarationSyntax baseMethod: return(baseMethod .WithExpressionBody(null) .WithBody(body) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)) .WithTriviaFrom(baseMethod)); case LocalFunctionStatementSyntax localFunction: return(localFunction .WithExpressionBody(null) .WithBody(body) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)) .WithTriviaFrom(localFunction)); default: throw ExceptionUtilities.UnexpectedValue(node); } }
/// <summary> /// Generates a class declaration for a record schema. /// </summary> /// <param name="schema"> /// The schema to generate a class for. /// </param> /// <returns> /// A class declaration with a property for each field of the record schema. /// </returns> /// <throws cref="UnsupportedSchemaException"> /// Thrown when a field schema is not recognized. /// </throws> public virtual ClassDeclarationSyntax GenerateClass(RecordSchema schema) { var declaration = SyntaxFactory.ClassDeclaration(schema.Name) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddMembers(schema.Fields .Select(field => { var child = SyntaxFactory .PropertyDeclaration( GetPropertyType(field.Type), field.Name ) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddAccessorListAccessors( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) ); if (!string.IsNullOrEmpty(field.Documentation)) { child = AddSummaryComment(child, field.Documentation); } return(child); }) .Where(field => field != null) .ToArray() ); if (!string.IsNullOrEmpty(schema.Documentation)) { declaration = AddSummaryComment(declaration, schema.Documentation); } return(declaration); }