private static PropertyDeclarationSyntax GetSimpleProperty(PropertyDeclarationSyntax property, VariableDeclaratorSyntax variableDeclarator)
{
var simpleGetSetPropetie = property.WithAccessorList(SyntaxFactory.AccessorList(SyntaxFactory.List(new[] {
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
})));
return variableDeclarator.Initializer == null ?
simpleGetSetPropetie :
simpleGetSetPropetie.WithInitializer(variableDeclarator.Initializer)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
private PropertyDeclarationSyntax ConvertToAutoProperty(PropertyDeclarationSyntax propertyDeclaration)
{
var newProperty = propertyDeclaration
.WithAccessorList(
SyntaxFactory.AccessorList(
SyntaxFactory.List(new[]
{
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)).WithAdditionalAnnotations(Formatter.Annotation),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
})));
return newProperty;
}
private static PropertyDeclarationSyntax ExpandProperty(PropertyDeclarationSyntax original, PropertyDeclarationSyntax updated, string backingFieldName)
{
AccessorDeclarationSyntax getter = original.AccessorList.Accessors.FirstOrDefault(ad => ad.Kind() == SyntaxKind.GetAccessorDeclaration);
var returnFieldStatement = SyntaxFactory.ParseStatement($"return {backingFieldName};");
getter = getter
.WithBody(SyntaxFactory.Block(SyntaxFactory.SingletonList(returnFieldStatement)))
.WithSemicolonToken(default(SyntaxToken));
AccessorDeclarationSyntax setter = original.AccessorList.Accessors.FirstOrDefault(ad => ad.Kind() == SyntaxKind.SetAccessorDeclaration);
var setPropertyStatement = SyntaxFactory.ParseStatement($"{backingFieldName} = value;");
setter = setter
.WithBody(SyntaxFactory.Block(SyntaxFactory.SingletonList(setPropertyStatement)))
.WithSemicolonToken(default(SyntaxToken));
updated = updated
.WithAccessorList(SyntaxFactory.AccessorList(SyntaxFactory.List(new[] { getter, setter })))
.WithAdditionalAnnotations(Formatter.Annotation)
.WithAdditionalAnnotations(UpdatedPropertyAnnotation);
return updated;
}
/// <summary>
/// Normalizes the <paramref name="declaration" />.
/// </summary>
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax declaration)
{
// Nothing to do here for properties with expression bodies
if (declaration.ExpressionBody != null)
return declaration;
// Nothing to do here for properties not defined in fault effects or for properties that are no overrides of some port
var propertySymbol = declaration.GetPropertySymbol(SemanticModel);
if (!propertySymbol.ContainingType.IsFaultEffect(SemanticModel) || !propertySymbol.IsOverride)
return declaration;
// Nothing to do here for required ports
if (propertySymbol.IsExtern)
return declaration;
var getter = (AccessorDeclarationSyntax)Syntax.GetAccessor(declaration, DeclarationKind.GetAccessor);
var setter = (AccessorDeclarationSyntax)Syntax.GetAccessor(declaration, DeclarationKind.SetAccessor);
// Nothing to do here for properties with accessors that have a body
if (getter == null || getter.Body != null || setter?.Body != null)
return declaration;
var fieldName = GetBackingFieldName(propertySymbol);
var fieldIdentifier = (ExpressionSyntax)Syntax.IdentifierName(fieldName);
var fieldModifiers = setter == null
? DeclarationModifiers.Unsafe | DeclarationModifiers.ReadOnly
: DeclarationModifiers.Unsafe;
var fieldDeclaration = Syntax.FieldDeclaration(
name: fieldName,
type: Syntax.TypeExpression(propertySymbol.Type),
accessibility: Accessibility.Private,
modifiers: fieldModifiers,
initializer: declaration.Initializer?.Value);
fieldDeclaration = Syntax.AddAttribute<CompilerGeneratedAttribute>(fieldDeclaration);
fieldDeclaration = Syntax.MarkAsNonDebuggerBrowsable(fieldDeclaration);
AddMembers(propertySymbol.ContainingType, (FieldDeclarationSyntax)fieldDeclaration);
var getterBody = (StatementSyntax)Syntax.ReturnStatement(fieldIdentifier).NormalizeWhitespace();
getterBody = getterBody.AppendLineDirective(-1).PrependLineDirective(-1);
var getterBlock = SyntaxFactory.Block(getterBody).EnsureIndentation(getter).PrependLineDirective(getter.GetLineNumber());
getter = getter.WithStatementBody(getterBlock);
AccessorListSyntax accessors;
if (setter == null)
accessors = declaration.AccessorList.WithAccessors(SyntaxFactory.List(new[] { getter }));
else
{
var assignment = Syntax.AssignmentStatement(fieldIdentifier, Syntax.IdentifierName("value"));
var setterBody = (StatementSyntax)Syntax.ExpressionStatement(assignment);
setterBody = setterBody.AppendLineDirective(-1).PrependLineDirective(-1);
var setterBlock = SyntaxFactory.Block(setterBody).EnsureIndentation(setter).PrependLineDirective(setter.GetLineNumber());
setter = setter.WithStatementBody(setterBlock);
accessors = declaration.AccessorList.WithAccessors(SyntaxFactory.List(new[] { getter, setter }));
}
var originalDeclaration = declaration;
declaration = declaration.WithInitializer(null).WithSemicolonToken(default(SyntaxToken));
return declaration.WithAccessorList(accessors).EnsureLineCount(originalDeclaration);
}
private async Task<Document> TooManyAccessorsAsync(Document document, PropertyDeclarationSyntax declaration, CancellationToken c)
{
SyntaxGenerator generator = SyntaxGenerator.GetGenerator(document);
var allAccessors = declaration.AccessorList.Accessors.OfType<AccessorDeclarationSyntax>();
bool foundGetAccessor = false;
AccessorDeclarationSyntax accessorToKeep = null;
var accessorList = declaration.AccessorList;
foreach (AccessorDeclarationSyntax accessor in allAccessors)
{
var keyword = accessor.Keyword;
if (keyword.IsKind(SyntaxKind.GetKeyword) && !foundGetAccessor)
{
accessorToKeep = accessor;
foundGetAccessor = true;
}
else
{
accessorList = accessorList.RemoveNode(accessor, 0);
}
}
var block = SyntaxFactory.Block(new StatementSyntax[0]);
if (accessorToKeep == null)
{
accessorToKeep = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, block);
}
SyntaxList<SyntaxNode> accessorsToAdd = new SyntaxList<SyntaxNode>();
accessorsToAdd = accessorsToAdd.Add(accessorToKeep);
var newPropertyDeclaration = declaration.WithAccessorList(null);
newPropertyDeclaration = generator.AddAccessors(newPropertyDeclaration, accessorsToAdd) as PropertyDeclarationSyntax;
return await ReplaceNode(declaration, newPropertyDeclaration, document);
}
/// <summary>
/// Normalizes the <paramref name="declaration" />.
/// </summary>
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax declaration)
{
// Nothing to do here for properties without expression bodies
if (declaration.ExpressionBody == null)
return declaration;
// Nothing to do here for properties not defined in fault effects or for properties that are no overrides of some port
var propertySymbol = declaration.GetPropertySymbol(SemanticModel);
if (!propertySymbol.ContainingType.IsFaultEffect(SemanticModel) || !propertySymbol.IsOverride)
return declaration;
var originalDeclaration = declaration;
var statements = AsStatementBody(propertySymbol.GetMethod, declaration.ExpressionBody.Expression);
var getter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, statements);
var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList(getter));
declaration = declaration.WithAccessorList(accessorList);
declaration = declaration.WithExpressionBody(null).WithSemicolonToken(default(SyntaxToken));
return declaration.EnsureLineCount(originalDeclaration);
}
static PropertyDeclarationSyntax CreateNewProperty(PropertyDeclarationSyntax property)
{
// create new auto property
var accessorDeclList = new SyntaxList<AccessorDeclarationSyntax>().Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))).Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(accessorDeclList)).WithTrailingTrivia(property.GetTrailingTrivia()).WithAdditionalAnnotations(Formatter.Annotation);
return newProperty;
}
static PropertyDeclarationSyntax CreateNewProperty(PropertyDeclarationSyntax property)
{
var getter = property.AccessorList.Accessors.FirstOrDefault (a => a.IsKind (SyntaxKind.GetAccessorDeclaration));
var setter = property.AccessorList.Accessors.FirstOrDefault (a => a.IsKind (SyntaxKind.SetAccessorDeclaration));
// create new auto property
var accessorDeclList = new SyntaxList<AccessorDeclarationSyntax>().Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithModifiers (getter.Modifiers).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))
.Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithModifiers (setter.Modifiers).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(accessorDeclList)).WithTrailingTrivia(property.GetTrailingTrivia()).WithAdditionalAnnotations(Formatter.Annotation);
return newProperty;
}
private static PropertyDeclarationSyntax ExpandProperty(PropertyDeclarationSyntax property, string backingFieldName)
{
AccessorDeclarationSyntax getter, setter;
if (!ExpansionChecker.TryGetAccessors(property, out getter, out setter))
{
throw new ArgumentException();
}
if (getter.Body == null)
{
var returnFieldStatement = SyntaxFactory.ParseStatement(string.Format("return {0};", backingFieldName));
getter = getter
.WithBody(SyntaxFactory.Block(SyntaxFactory.SingletonList(returnFieldStatement)));
}
getter = getter
.WithSemicolonToken(default(SyntaxToken));
var setPropertyStatement = SyntaxFactory.ParseStatement(string.Format("SetProperty(ref {0}, value, \"{1}\");", backingFieldName, property.Identifier.ValueText));
setter = setter
.WithBody(SyntaxFactory.Block(SyntaxFactory.SingletonList(setPropertyStatement)))
.WithSemicolonToken(default(SyntaxToken));
var newProperty = property
.WithAccessorList(SyntaxFactory.AccessorList(SyntaxFactory.List(new[] { getter, setter })))
.WithAdditionalAnnotations(Formatter.Annotation);
return newProperty;
}
private static PropertyDeclarationSyntax UseExpressionBodyIfDesired(
Workspace workspace, PropertyDeclarationSyntax declaration, ParseOptions options)
{
if (declaration.ExpressionBody == null)
{
var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties).Value;
if (preferExpressionBody)
{
if (declaration.Initializer == null)
{
var expressionBody = TryGetExpressionBody(declaration.AccessorList, options);
if (expressionBody != null)
{
declaration = declaration.WithAccessorList(null)
.WithExpressionBody(expressionBody)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
}
}
}
return declaration;
}
private async Task<Document> HandlePropertyDeclaration(PropertyDeclarationSyntax declaration, Document document, CancellationToken cancellationToken)
{
var returnStatement = SyntaxFactory.ReturnStatement(
returnKeyword: SyntaxFactory.Token(SyntaxKind.ReturnKeyword),
expression: declaration.ExpressionBody.Expression,
semicolonToken: declaration.SemicolonToken);
var accessorDeclaration = SyntaxFactory.AccessorDeclaration(
kind: SyntaxKind.GetAccessorDeclaration,
body: SyntaxFactory.Block(returnStatement));
var newDeclaration = declaration
.WithAccessorList(
SyntaxFactory.AccessorList(
SyntaxFactory.SingletonList(accessorDeclaration)))
.WithExpressionBody(null)
.WithSemicolonToken(default(SyntaxToken))
.WithAdditionalAnnotations(Formatter.Annotation);
var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = oldRoot.ReplaceNode(declaration, newDeclaration);
return document.WithSyntaxRoot(newRoot);
}
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node)
{
return base.VisitPropertyDeclaration(
node.WithAccessorList(
SyntaxFactory.AccessorList(
SyntaxFactory.List<AccessorDeclarationSyntax>(
new[]
{
SyntaxFactory
.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithBody(SyntaxFactory.Block(SyntaxFactory.List<StatementSyntax>(
new[]
{
SyntaxFactory.ReturnStatement(
SyntaxFactory.MemberAccessExpression(
kind: SyntaxKind.SimpleMemberAccessExpression,
expression: SyntaxFactory.IdentifierName("global::"+_symbol.ContainingType.ToDisplayString()),
name: SyntaxFactory.IdentifierName(_symbol.Name))
)
}
)
)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithBody(SyntaxFactory.Block(SyntaxFactory.List<StatementSyntax>(
new[]
{
SyntaxFactory.ParseStatement("global::"+_symbol.ContainingType.ToDisplayString()+"."+_symbol.Name+" = value;")
}
)
))
}.Where(ad =>
(_symbol.GetMethod != null && ad.IsKind(SyntaxKind.GetAccessorDeclaration)) ||
(_symbol.SetMethod != null && ad.IsKind(SyntaxKind.SetAccessorDeclaration)))
)
)));
}
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node)
{
return base.VisitPropertyDeclaration(
node.WithAccessorList(
SyntaxFactory.AccessorList(
SyntaxFactory.List<AccessorDeclarationSyntax>(
new[]
{
SyntaxFactory
.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithBody(SyntaxFactory.Block(SyntaxFactory.List<StatementSyntax>(
new[]
{
SyntaxFactory.ParseStatement("return _innerWrappedObject."+_symbol.Name + ";")
}
)
)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithBody(SyntaxFactory.Block(SyntaxFactory.List<StatementSyntax>(
new[]
{
SyntaxFactory.ParseStatement("_innerWrappedObject."+_symbol.Name+" = value;")
}
)
))
}.Where(ad =>
(_symbol.GetMethod != null && ad.IsKind(SyntaxKind.GetAccessorDeclaration)) ||
(_symbol.SetMethod != null && ad.IsKind(SyntaxKind.SetAccessorDeclaration)))
)
)));
}
private static PropertyDeclarationSyntax CreateAutoProperty(PropertyDeclarationSyntax property, VariableDeclaratorSyntax variableDeclarator,
IFieldSymbol fieldSymbol, IPropertySymbol propertySymbol)
{
var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(SyntaxFactory.List(new[] {
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
})));
newProperty = variableDeclarator.Initializer == null ?
newProperty :
newProperty.WithInitializer(variableDeclarator.Initializer)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
newProperty = CreatePropertyWithCorrectAccessibility(newProperty, fieldSymbol, propertySymbol);
newProperty = newProperty
.WithTriviaFrom(property)
.WithAdditionalAnnotations(Formatter.Annotation);
return newProperty;
}
Document PerformAction(Document document, SemanticModel model, SyntaxNode root, PropertyDeclarationSyntax propertyDeclaration, bool needsSetter)
{
AccessorDeclarationSyntax accessor = null;
PropertyDeclarationSyntax newProp = null;
if (needsSetter)
{
accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration);
var getter = propertyDeclaration.AccessorList.Accessors.FirstOrDefault(m => m.IsKind(SyntaxKind.GetAccessorDeclaration));
if (getter == null)
{
//get;
accessor = accessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
else
{
var getField = ReplacePropertyWithBackingFieldWithAutoPropertyCodeRefactoringProvider.ScanGetter(model, getter);
if (getField == null && getter.Body == null)
{
//get;
accessor = accessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)).WithTrailingTrivia(getter.GetTrailingTrivia());
}
else if (getField == null || getField.IsReadOnly)
{
//readonly or no field can be found
accessor = accessor.WithBody(GetNotImplementedBlock());
}
else
{
//now we add a 'field = value'.
accessor = accessor.WithBody(SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName(getField.Name), SyntaxFactory.IdentifierName("value")))));
}
}
newProp = propertyDeclaration.WithAccessorList(propertyDeclaration.AccessorList.AddAccessors(accessor));
}
else
{
accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration);
var setter = propertyDeclaration.AccessorList.Accessors.FirstOrDefault(m => m.IsKind(SyntaxKind.SetAccessorDeclaration));
var accessorDeclList = new SyntaxList<AccessorDeclarationSyntax>();
if (setter == null)
{
//set;
accessor = accessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
else
{
var setField = ReplacePropertyWithBackingFieldWithAutoPropertyCodeRefactoringProvider.ScanSetter(model, setter);
if (setField == null && setter.Body == null)
{
//set;
accessor = accessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)).WithTrailingTrivia(setter.GetTrailingTrivia());
}
else if (setField == null)
{
//no field can be found
accessor = accessor.WithBody(GetNotImplementedBlock());
}
else
{
//now we add a 'return field;'.
accessor = accessor.WithBody(SyntaxFactory.Block(
SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(setField.Name))));
}
accessorDeclList = accessorDeclList.Add(propertyDeclaration.AccessorList.Accessors.First(m => m.IsKind(SyntaxKind.SetAccessorDeclaration)));
}
accessorDeclList = accessorDeclList.Insert(0, accessor);
var accessorList = SyntaxFactory.AccessorList(accessorDeclList);
newProp = propertyDeclaration.WithAccessorList(accessorList);
}
var newRoot = root.ReplaceNode((SyntaxNode)propertyDeclaration, newProp).WithAdditionalAnnotations(Formatter.Annotation);
return document.WithSyntaxRoot(newRoot);
}
/// <summary>
/// Normalizes the <paramref name="declaration" />.
/// </summary>
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax declaration)
{
var propertySymbol = declaration.GetPropertySymbol(SemanticModel);
if (!propertySymbol.ContainingType.IsComponent(SemanticModel) || !propertySymbol.IsExtern)
return declaration;
var originalDeclaration = declaration;
var index = declaration.Modifiers.IndexOf(SyntaxKind.ExternKeyword);
declaration = declaration.WithModifiers(declaration.Modifiers.RemoveAt(index)).WithSemicolonToken(default(SyntaxToken));
var accessors = SyntaxFactory.List(NormalizerAccessors(originalDeclaration.AccessorList.Accessors));
return declaration.WithAccessorList(declaration.AccessorList.WithAccessors(accessors)).EnsureLineCount(originalDeclaration);
}
