public override SyntaxNode VisitPropertyBlock(PropertyBlockSyntax node) { if (generator.GetAttributes(node).Any(attr => generator.GetName(attr) == "CompilerGenerated")) { return(base.VisitPropertyBlock(node)); } var implements = node.PropertyStatement?.ImplementsClause?.InterfaceMembers.FirstOrDefault(); (var canRead, var canWrite) = generator.InspectProperty(node); var type = (TypeSyntax)generator.GetType(node); if (canRead) { node = (PropertyBlockSyntax)generator.WithGetAccessorStatements(node, new[] { generator.ReturnStatement(generator.ExecutePipeline(type, generator.GetParameters(node))) }); } if (canWrite) { node = (PropertyBlockSyntax)generator.WithSetAccessorStatements(node, new[] { generator.ExecutePipeline(null, generator .GetParameters(node) .Concat(new [] { Parameter(ModifiedIdentifier("value")).WithAsClause(SimpleAsClause(type)) })) }); } return(base.VisitPropertyBlock(node)); }
private static async Task <Solution> GenerateRegisterProperty(string registerPropertyMethodName, Document document, PropertyBlockSyntax propertyDeclaration, IPropertySymbol propertySymbol, bool returnsMounter, CancellationToken ct) { var staticConstructor = await GetStaticConstructor(propertySymbol, ct); ClassBlockSyntax classDeclaration; if (staticConstructor != null) { document = document.Project.GetDocument(staticConstructor.SyntaxTree); classDeclaration = staticConstructor.FirstAncestor <ClassBlockSyntax>(); } else { classDeclaration = propertyDeclaration.FirstAncestor <ClassBlockSyntax>(); } var editor = await DocumentEditor.CreateAsync(document, ct); if (returnsMounter) { GenerateMounterFieldDeclaration(editor, registerPropertyMethodName, classDeclaration, propertySymbol, ct); } else if (staticConstructor == null) { GenerateStaticConstructor(editor, classDeclaration, registerPropertyMethodName, propertySymbol, returnsMounter, ct); } else { GenerateRegistrationStatement(editor, classDeclaration, staticConstructor, registerPropertyMethodName, propertySymbol, returnsMounter, ct); } return(editor.GetChangedDocument().Project.Solution); }
public override SyntaxNode VisitPropertyBlock(PropertyBlockSyntax node) { var implements = node.PropertyStatement?.ImplementsClause?.InterfaceMembers.FirstOrDefault(); if (implements != null && implements.ToString() == $"{nameof(IProxy)}.{nameof(IProxy.Behaviors)}") { node = (PropertyBlockSyntax)rewriter.VisitBehaviorsProperty( // Make the property private (== explicit interface implementation in C#) node.WithPropertyStatement( node.PropertyStatement.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword))))); } else { (var canRead, var canWrite) = generator.InspectProperty(node); var type = (TypeSyntax)generator.GetType(node); if (canRead) { node = (PropertyBlockSyntax)generator.WithGetAccessorStatements(node, new[] { generator.ReturnStatement(generator.ExecutePipeline(type, generator.GetParameters(node))) }); } if (canWrite) { node = (PropertyBlockSyntax)generator.WithSetAccessorStatements(node, new[] { generator.ExecutePipeline(null, generator .GetParameters(node) .Concat(new [] { Parameter(ModifiedIdentifier("value")).WithAsClause(SimpleAsClause(type)) })) }); } } return(base.VisitPropertyBlock(node)); }
internal static IFieldSymbol GetBackingField(SemanticModel model, PropertyBlockSyntax property) { var getter = property.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorBlock)); var setter = property.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.SetAccessorBlock)); // automatic properties always need getter & setter if (property == null || getter == null || setter == null || !getter.Statements.Any() || !setter.Statements.Any()) { return(null); } if (property.PropertyStatement.Modifiers.Any(m => m.IsKind(SyntaxKind.MustInheritKeyword)) || property.Parent is InterfaceBlockSyntax) { return(null); } var getterField = getter.ScanGetter(model); if (getterField == null) { return(null); } var setterField = setter.ScanSetter(model); if (setterField == null) { return(null); } if (!getterField.Equals(setterField)) { return(null); } return(getterField); }
private VariableState VisitPropertyBlock(PropertyBlockSyntax propertyBlockSyntax, ExecutionState state) { foreach (var accessor in propertyBlockSyntax.Accessors) { VisitBlock(accessor, state); } return(new VariableState(propertyBlockSyntax, VariableTaint.Unknown)); }
public override SyntaxNode VisitPropertyBlock(PropertyBlockSyntax node) { if (generator.GetAttributes(node).Any(attr => generator.GetName(attr) == "CompilerGenerated")) { return(base.VisitPropertyBlock(node)); } return(base.VisitPropertyBlock((PropertyBlockSyntax)AddAttributes(node))); }
public override void VisitPropertyBlock(PropertyBlockSyntax node) { var startLength = node.Span.Start; var endLength = node.Span.End; var statementNode = node.ChildNodes().OfType <PropertyStatementSyntax>().FirstOrDefault(); WalkPropertyBlockOrPropertyStatement(statementNode, startLength, endLength); base.VisitPropertyBlock(node); }
static EventStatementSyntax CreateChangedEventDeclaration(PropertyBlockSyntax propertyDeclaration) { bool isNonInheritable = propertyDeclaration.PropertyStatement.Modifiers.Any(m => m.IsKind(SyntaxKind.SharedKeyword)); return(SyntaxFactory.EventStatement( SyntaxFactory.List <AttributeListSyntax>(), isNonInheritable ? SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.SharedKeyword)) : SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), SyntaxFactory.Identifier(propertyDeclaration.PropertyStatement.Identifier + "Changed"), null, SyntaxFactory.SimpleAsClause(SyntaxFactory.ParseTypeName("System.EventHandler").WithAdditionalAnnotations(Simplifier.Annotation)), null)); }
public override SyntaxNode VisitPropertyBlock(PropertyBlockSyntax node) { var type = (TypeSyntax)generator.GetType(node); var name = generator.GetName(node); if (type.ToString() == nameof(IMock) && name == nameof(IMocked.Mock)) { node = (PropertyBlockSyntax)generator.WithGetAccessorStatements(node, new[] { generator.ReturnStatement(IdentifierName("_mock")) }); } return(base.VisitPropertyBlock(node)); }
private static async Task <Solution> GenerateRegisterChildModel(Document document, SemanticModel semanticModel, PropertyBlockSyntax propertyDeclaration, IPropertySymbol childProperty, IPropertySymbol foreignKey, CancellationToken ct) { var staticConstructor = await GetStaticConstructor(childProperty, ct); ClassBlockSyntax classDeclaration; if (staticConstructor != null) { document = document.Project.GetDocument(staticConstructor.SyntaxTree); classDeclaration = staticConstructor.FirstAncestor <ClassBlockSyntax>(); } else { classDeclaration = propertyDeclaration.FirstAncestor <ClassBlockSyntax>(); } var editor = await DocumentEditor.CreateAsync(document, ct); GenerateRegisterChildModel(editor, staticConstructor, classDeclaration, semanticModel, childProperty, foreignKey); return(editor.GetChangedDocument().Project.Solution); }
static EventStatementSyntax CreateChangedEventDeclaration(PropertyBlockSyntax propertyDeclaration) { bool isNonInheritable = propertyDeclaration.PropertyStatement.Modifiers.Any(m => m.IsKind(SyntaxKind.SharedKeyword)); return SyntaxFactory.EventStatement( SyntaxFactory.List<AttributeListSyntax>(), isNonInheritable ? SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.SharedKeyword)) : SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), SyntaxFactory.Identifier(propertyDeclaration.PropertyStatement.Identifier + "Changed"), null, SyntaxFactory.SimpleAsClause(SyntaxFactory.ParseTypeName("System.EventHandler").WithAdditionalAnnotations(Simplifier.Annotation)), null); }
public override void VisitPropertyBlock(PropertyBlockSyntax node) { AddBlockData(node); base.VisitPropertyBlock(node); }
Document PerformAction(Document document, SemanticModel model, SyntaxNode root, PropertyBlockSyntax propertyDeclaration, bool needsSetter) { AccessorBlockSyntax accessor = null; PropertyBlockSyntax newProp = null; if (needsSetter) { accessor = SyntaxFactory.AccessorBlock( SyntaxKind.SetAccessorBlock, SyntaxFactory.AccessorStatement(SyntaxKind.SetAccessorStatement, SyntaxFactory.Token(SyntaxKind.SetKeyword)) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Parameter(SyntaxFactory.List<AttributeListSyntax>(), SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword)), SyntaxFactory.ModifiedIdentifier("value"), SyntaxFactory.SimpleAsClause(propertyDeclaration.PropertyStatement.AsClause.Type().WithoutTrailingTrivia()), null) }))), SyntaxFactory.EndBlockStatement(SyntaxKind.EndSetStatement, SyntaxFactory.Token(SyntaxKind.SetKeyword))); var getter = propertyDeclaration.Accessors.FirstOrDefault(m => m.IsKind(SyntaxKind.GetAccessorBlock)); if (getter != null) { var getField = getter.ScanGetter(model); if (getField == null || getField.IsReadOnly) { // Readonly or no field can be found accessor = accessor.WithStatements(SyntaxFactory.List<StatementSyntax>(new[] { GetNotImplementedThrowStatement() })); } else { // Now we add a 'field = value'. accessor = accessor.WithStatements(SyntaxFactory.List<StatementSyntax>(new[] { SyntaxFactory.AssignmentStatement(SyntaxKind.SimpleAssignmentStatement, SyntaxFactory.IdentifierName(getField.Name), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.IdentifierName("value")) })); } } var modifierList = SyntaxFactory.TokenList(propertyDeclaration.PropertyStatement.Modifiers.Where(m => !m.IsKind(SyntaxKind.ReadOnlyKeyword))); newProp = propertyDeclaration .WithAccessors(propertyDeclaration.Accessors.Add(accessor)) .WithPropertyStatement(propertyDeclaration.PropertyStatement.WithModifiers(modifierList)); } else { accessor = SyntaxFactory.AccessorBlock(SyntaxKind.GetAccessorBlock, SyntaxFactory.AccessorStatement(SyntaxKind.GetAccessorStatement, SyntaxFactory.Token(SyntaxKind.GetKeyword)), SyntaxFactory.EndBlockStatement(SyntaxKind.EndGetStatement, SyntaxFactory.Token(SyntaxKind.GetKeyword))); var setter = propertyDeclaration.Accessors.FirstOrDefault(m => m.IsKind(SyntaxKind.SetAccessorBlock)); var accessorDeclList = new SyntaxList<AccessorBlockSyntax>(); if (setter != null) { var setField = setter.ScanSetter(model); if (setField == null) { // No field can be found accessor = accessor.WithStatements(SyntaxFactory.List<StatementSyntax>(new[] { GetNotImplementedThrowStatement() })); } else { // Add a 'Return field'. accessor = accessor.WithStatements(SyntaxFactory.List<StatementSyntax>( new[] { SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(setField.Name)) })); } accessorDeclList = accessorDeclList.Add(propertyDeclaration.Accessors.First(m => m.IsKind(SyntaxKind.SetAccessorBlock))); } accessorDeclList = accessorDeclList.Insert(0, accessor); var accessorList = SyntaxFactory.List(accessorDeclList); var modifierList = SyntaxFactory.TokenList(propertyDeclaration.PropertyStatement.Modifiers.Where(m => !m.IsKind(SyntaxKind.WriteOnlyKeyword))); newProp = propertyDeclaration .WithAccessors(accessorList) .WithPropertyStatement(propertyDeclaration.PropertyStatement.WithModifiers(modifierList)); } var newRoot = root.ReplaceNode(propertyDeclaration, newProp).WithAdditionalAnnotations(Formatter.Annotation); return document.WithSyntaxRoot(newRoot); }
internal static IFieldSymbol GetBackingField(SemanticModel model, PropertyBlockSyntax property) { var getter = property.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorBlock)); var setter = property.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.SetAccessorBlock)); // automatic properties always need getter & setter if (property == null || getter == null || setter == null || !getter.Statements.Any() || !setter.Statements.Any()) return null; if (property.PropertyStatement.Modifiers.Any(m => m.IsKind(SyntaxKind.MustInheritKeyword)) || property.Parent is InterfaceBlockSyntax) return null; var getterField = getter.ScanGetter(model); if (getterField == null) return null; var setterField = setter.ScanSetter(model); if (setterField == null) return null; if (!getterField.Equals(setterField)) return null; return getterField; }
public override void VisitPropertyBlock(PropertyBlockSyntax node) { LogicalLineCount++; base.VisitPropertyBlock(node); }
private Property TraverseProperties(PropertyBlockSyntax pbs) { Property retProperty = new Property(); return retProperty; }
Document PerformAction(Document document, SemanticModel model, SyntaxNode root, PropertyBlockSyntax propertyDeclaration, bool needsSetter) { AccessorBlockSyntax accessor = null; PropertyBlockSyntax newProp = null; if (needsSetter) { accessor = SyntaxFactory.AccessorBlock( SyntaxKind.SetAccessorBlock, SyntaxFactory.AccessorStatement(SyntaxKind.SetAccessorStatement, SyntaxFactory.Token(SyntaxKind.SetKeyword)) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Parameter(SyntaxFactory.List <AttributeListSyntax>(), SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword)), SyntaxFactory.ModifiedIdentifier("value"), SyntaxFactory.SimpleAsClause(propertyDeclaration.PropertyStatement.AsClause.Type().WithoutTrailingTrivia()), null) }))), SyntaxFactory.EndBlockStatement(SyntaxKind.EndSetStatement, SyntaxFactory.Token(SyntaxKind.SetKeyword))); var getter = propertyDeclaration.Accessors.FirstOrDefault(m => m.IsKind(SyntaxKind.GetAccessorBlock)); if (getter != null) { var getField = getter.ScanGetter(model); if (getField == null || getField.IsReadOnly) { // Readonly or no field can be found accessor = accessor.WithStatements(SyntaxFactory.List <StatementSyntax>(new[] { GetNotImplementedThrowStatement() })); } else { // Now we add a 'field = value'. accessor = accessor.WithStatements(SyntaxFactory.List <StatementSyntax>(new[] { SyntaxFactory.AssignmentStatement(SyntaxKind.SimpleAssignmentStatement, SyntaxFactory.IdentifierName(getField.Name), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.IdentifierName("value")) })); } } var modifierList = SyntaxFactory.TokenList(propertyDeclaration.PropertyStatement.Modifiers.Where(m => !m.IsKind(SyntaxKind.ReadOnlyKeyword))); newProp = propertyDeclaration .WithAccessors(propertyDeclaration.Accessors.Add(accessor)) .WithPropertyStatement(propertyDeclaration.PropertyStatement.WithModifiers(modifierList)); } else { accessor = SyntaxFactory.AccessorBlock(SyntaxKind.GetAccessorBlock, SyntaxFactory.AccessorStatement(SyntaxKind.GetAccessorStatement, SyntaxFactory.Token(SyntaxKind.GetKeyword)), SyntaxFactory.EndBlockStatement(SyntaxKind.EndGetStatement, SyntaxFactory.Token(SyntaxKind.GetKeyword))); var setter = propertyDeclaration.Accessors.FirstOrDefault(m => m.IsKind(SyntaxKind.SetAccessorBlock)); var accessorDeclList = new SyntaxList <AccessorBlockSyntax>(); if (setter != null) { var setField = setter.ScanSetter(model); if (setField == null) { // No field can be found accessor = accessor.WithStatements(SyntaxFactory.List <StatementSyntax>(new[] { GetNotImplementedThrowStatement() })); } else { // Add a 'Return field'. accessor = accessor.WithStatements(SyntaxFactory.List <StatementSyntax>( new[] { SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(setField.Name)) })); } accessorDeclList = accessorDeclList.Add(propertyDeclaration.Accessors.First(m => m.IsKind(SyntaxKind.SetAccessorBlock))); } accessorDeclList = accessorDeclList.Insert(0, accessor); var accessorList = SyntaxFactory.List(accessorDeclList); var modifierList = SyntaxFactory.TokenList(propertyDeclaration.PropertyStatement.Modifiers.Where(m => !m.IsKind(SyntaxKind.WriteOnlyKeyword))); newProp = propertyDeclaration .WithAccessors(accessorList) .WithPropertyStatement(propertyDeclaration.PropertyStatement.WithModifiers(modifierList)); } var newRoot = root.ReplaceNode(propertyDeclaration, newProp).WithAdditionalAnnotations(Formatter.Annotation); return(document.WithSyntaxRoot(newRoot)); }