public static IFieldSymbol ScanSetter(this AccessorBlockSyntax setter, SemanticModel model)
{
if (setter == null || setter.Statements.Count != 1) //no getter/get;/get we can't easily work out
{
return(null);
}
var setAssignment = setter.Statements.OfType <StatementSyntax>().FirstOrDefault();
var assignment = setAssignment != null ? setAssignment as AssignmentStatementSyntax : null;
if (assignment == null || !assignment.OperatorToken.IsKind(SyntaxKind.EqualsToken))
{
return(null);
}
var id = assignment.Right as IdentifierNameSyntax;
if (id == null || id.Identifier.ValueText != "value")
{
return(null);
}
if (!IsPossibleExpression(assignment.Left))
{
return(null);
}
var retSymbol = model.GetSymbolInfo(assignment.Left).Symbol;
return((IFieldSymbol)retSymbol);
}
public static IFieldSymbol ScanGetter(this AccessorBlockSyntax getter, SemanticModel model)
{
if (getter == null || getter.Statements.Count != 1)
{
return(null);
}
var retStatement = getter.Statements.First() as ReturnStatementSyntax;
if (retStatement == null)
{
return(null);
}
if (!IsPossibleExpression(retStatement.Expression))
{
return(null);
}
var retSymbol = model.GetSymbolInfo(retStatement.Expression).Symbol;
return((IFieldSymbol)retSymbol);
}
/*
* 以下が含まれているか？
* Property(GetAccessorBlock, SetAccessorBlock)
* Custom Event(AddHandlerAccessorBlock, RemoveHandlerAccessorBlock, RaiseEventAccessorBlock)
*
*
*/
public override void VisitAccessorBlock(AccessorBlockSyntax node)
{
AddBlockData(node);
base.VisitAccessorBlock(node);
}
public override void VisitAccessorBlock(AccessorBlockSyntax node)
{
LogicalLineCount++;
base.VisitAccessorBlock(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));
}
