public override void VisitAccessorDeclaration(AccessorDeclarationSyntax node)
{
base.VisitAccessorDeclaration(node);
}
public void AddFunction(AccessorDeclarationSyntax node)
{
int nFunction = FunctionsByNumber.Count;
Function f = new Function(this, nFunction, Model, Model.GetDeclaredSymbol(node));
Functions.Add(f.MethodSymbol, f);
FunctionsByNumber.Add(f);
}
private Symbol GetBackingField(AccessorDeclarationSyntax getter, NamedTypeSymbol containingType)
{
var statements = getter.Body.Statements;
if (statements.Count == 1)
{
var returnStatement = statements.FirstOrDefault() as ReturnStatementSyntax;
if (returnStatement != null && returnStatement.Expression != null)
{
var symbolInfo = document.GetSemanticModel().GetSymbolInfo(returnStatement.Expression);
var fieldSymbol = symbolInfo.Symbol as FieldSymbol;
if (fieldSymbol != null && fieldSymbol.OriginalDefinition.ContainingType == containingType)
{
return fieldSymbol;
}
}
}
return null;
}
public void AddFunction(AccessorDeclarationSyntax node, SemanticModel Model)
{
MethodSymbol ms = Model.GetDeclaredSymbol(node);
AddFunction(ms, Model);
}
private static bool IsExpandableSetterPattern3(
AccessorDeclarationSyntax setter,
IFieldSymbol backingField,
ISemanticModel semanticModel)
{
// Pattern: if (field == value) return; field = value;
Debug.Assert(setter.Body != null);
var statements = setter.Body.Statements;
if (statements.Count != 2)
{
return false;
}
var ifStatement = statements[0] as IfStatementSyntax;
if (ifStatement == null)
{
return false;
}
var statement = ifStatement.Statement;
if (statement is BlockSyntax)
{
var blockStatements = ((BlockSyntax)statement).Statements;
if (blockStatements.Count != 1)
{
return false;
}
statement = blockStatements[0];
}
var returnStatement = statement as ReturnStatementSyntax;
if (returnStatement == null ||
returnStatement.Expression != null)
{
return false;
}
var expressionStatement = statements[1] as ExpressionStatementSyntax;
if (expressionStatement == null)
{
return false;
}
if (!IsAssignmentOfPropertyValueParameterToBackingField(expressionStatement.Expression, backingField, semanticModel))
{
return false;
}
var condition = ifStatement.Condition as BinaryExpressionSyntax;
if (condition == null ||
condition.Kind != SyntaxKind.EqualsExpression)
{
return false;
}
return ComparesPropertyValueParameterAndBackingField(condition, backingField, semanticModel);
}
public override void VisitAccessorDeclaration(AccessorDeclarationSyntax node)
{
base.VisitAccessorDeclaration(node);
Chunk.AddFunction(node, Model);
}
private static bool IsExpandableSetterPattern1(
AccessorDeclarationSyntax setter,
IFieldSymbol backingField,
ISemanticModel semanticModel)
{
// Pattern: field = value
Debug.Assert(setter.Body != null);
var statements = setter.Body.Statements;
if (statements.Count != 1)
{
return false;
}
var expressionStatement = statements[0] as ExpressionStatementSyntax;
return expressionStatement != null
&& IsAssignmentOfPropertyValueParameterToBackingField(expressionStatement.Expression, backingField, semanticModel);
}
private static bool IsExpandableSetter(AccessorDeclarationSyntax setter, ISemanticModel semanticModel, IFieldSymbol backingField)
{
// The setter should have a body containing one of the following heuristic patterns or
// no body at all.
//
// Patterns:
// field = value;
// if (field != value) field = value;
// if (field == value) return; field = value;
if (setter.Body == null)
{
return false;
}
return IsExpandableSetterPattern1(setter, backingField, semanticModel)
|| IsExpandableSetterPattern2(setter, backingField, semanticModel)
|| IsExpandableSetterPattern3(setter, backingField, semanticModel);
}
private static bool IsExpandableGetter(
AccessorDeclarationSyntax getter,
ISemanticModel semanticModel,
out IFieldSymbol backingField)
{
backingField = GetBackingFieldFromGetter(getter, semanticModel);
return backingField != null;
}
private static IFieldSymbol GetBackingFieldFromGetter(
AccessorDeclarationSyntax getter,
ISemanticModel semanticModel)
{
// The getter should have a body containing a single return of a backing field.
if (getter.Body == null)
{
return null;
}
var statements = getter.Body.Statements;
if (statements.Count != 1)
{
return null;
}
var returnStatement = statements.Single() as ReturnStatementSyntax;
if (returnStatement == null || returnStatement.Expression == null)
{
return null;
}
return semanticModel.GetSymbolInfo(returnStatement.Expression).Symbol as IFieldSymbol;
}
/// <summary>
/// Retrieves the get and set accessor declarations of the specified property.
/// Returns true if both get and set accessors exist; otherwise false.
/// </summary>
internal static bool TryGetAccessors(
PropertyDeclarationSyntax property,
out AccessorDeclarationSyntax getter,
out AccessorDeclarationSyntax setter)
{
var accessors = property.AccessorList.Accessors;
getter = accessors.FirstOrDefault(ad => ad.Kind == SyntaxKind.GetAccessorDeclaration);
setter = accessors.FirstOrDefault(ad => ad.Kind == SyntaxKind.SetAccessorDeclaration);
return accessors.Count == 2 && getter != null && setter != null;
}
