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