private static void FadeOut(SyntaxNodeAnalysisContext context, PropertyDeclarationSyntax property) { DiagnosticDescriptor descriptor = DiagnosticDescriptors.ReplacePropertyWithAutoImplementedPropertyFadeOut; if (property.ExpressionBody != null) { context.FadeOutNode(descriptor, property.ExpressionBody); } else { AccessorDeclarationSyntax getter = property.Getter(); if (getter != null) { context.FadeOutNode(descriptor, getter.Body); } AccessorDeclarationSyntax setter = property.Setter(); if (setter != null) { context.FadeOutNode(descriptor, setter.Body); } } }
private static ISymbol GetFieldSymbol(PropertyDeclarationSyntax property, SemanticModel semanticModel, CancellationToken cancellationToken) { ArrowExpressionClauseSyntax expressionBody = property.ExpressionBody; if (expressionBody != null) { return(semanticModel.GetSymbol(expressionBody.Expression, cancellationToken)); } else { AccessorDeclarationSyntax getter = property.Getter(); BlockSyntax body = getter.Body; if (body != null) { var returnStatement = (ReturnStatementSyntax)body.Statements[0]; return(semanticModel.GetSymbol(returnStatement.Expression, cancellationToken)); } else { return(semanticModel.GetSymbol(getter.ExpressionBody.Expression, cancellationToken)); } } }
private static SyntaxToken GetPropertyIdentifier(PropertyDeclarationSyntax propertyDeclaration) { if (propertyDeclaration.ExpressionBody != null) { ExpressionSyntax expression = propertyDeclaration.ExpressionBody?.Expression; if (expression?.IsKind(SyntaxKind.IdentifierName) == true) { return(((IdentifierNameSyntax)expression).Identifier); } } else { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter?.Body != null) { var returnStatement = (ReturnStatementSyntax)getter.Body.Statements[0]; return(((IdentifierNameSyntax)returnStatement.Expression).Identifier); } } return(propertyDeclaration.Identifier); }
private static MemberDeclarationSyntax MakeAbstract(PropertyDeclarationSyntax propertyDeclaration) { AccessorListSyntax accessorList = AccessorList(); if (propertyDeclaration.ExpressionBody != null) { accessorList = accessorList .AddAccessors(AutoGetAccessorDeclaration()); } else { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { accessorList = accessorList.AddAccessors(getter .WithBody(null) .WithSemicolonToken(SemicolonToken())); } AccessorDeclarationSyntax setter = propertyDeclaration.Setter(); if (setter != null) { accessorList = accessorList.AddAccessors(setter .WithBody(null) .WithSemicolonToken(SemicolonToken())); } } propertyDeclaration = propertyDeclaration .WithExpressionBody(null) .WithSemicolonToken(default(SyntaxToken)) .WithAccessorList(accessorList); return(UpdateModifiers(propertyDeclaration, propertyDeclaration.Modifiers)); }
public static Task <Document> RefactorAsync( Document document, PropertyDeclarationSyntax propertyDeclaration, CancellationToken cancellationToken = default(CancellationToken)) { AccessorListSyntax accessorList = AccessorList(); if (propertyDeclaration.ExpressionBody != null) { accessorList = accessorList .AddAccessors(AutoGetAccessorDeclaration()); } else { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { if (SyntaxAccessibility.GetExplicitAccessibility(getter) == Accessibility.Private) { getter = SyntaxAccessibility.WithExplicitAccessibility(getter, Accessibility.Protected); } accessorList = accessorList.AddAccessors(getter .WithBody(null) .WithSemicolonToken(SemicolonToken())); } AccessorDeclarationSyntax setter = propertyDeclaration.Setter(); if (setter != null) { if (SyntaxAccessibility.GetExplicitAccessibility(setter) == Accessibility.Private) { setter = SyntaxAccessibility.WithExplicitAccessibility(setter, Accessibility.Protected); } accessorList = accessorList.AddAccessors(setter .WithBody(null) .WithSemicolonToken(SemicolonToken())); } } PropertyDeclarationSyntax newNode = propertyDeclaration .WithExpressionBody(null) .WithSemicolonToken(default(SyntaxToken)) .WithAccessorList(accessorList) .InsertModifier(SyntaxKind.AbstractKeyword) .RemoveModifier(SyntaxKind.VirtualKeyword) .WithTriviaFrom(propertyDeclaration) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(propertyDeclaration, newNode, cancellationToken)); }
private static ISymbol GetFieldSymbol(PropertyDeclarationSyntax property, SemanticModel semanticModel, CancellationToken cancellationToken) { if (property.ExpressionBody != null) { return(semanticModel.GetSymbol(property.ExpressionBody.Expression, cancellationToken)); } else { var returnStatement = (ReturnStatementSyntax)property.Getter().Body.Statements[0]; return(semanticModel.GetSymbol(returnStatement.Expression, cancellationToken)); } }
public static bool IsGetOnlyAutoProperty(this IPropertySymbol property, PropertyDeclarationSyntax propertyDeclaration) { Contract.Requires(property != null); Contract.Requires(propertyDeclaration != null); var getter = propertyDeclaration.Getter(); if (getter == null) { return(false); } return(property.IsReadOnly && getter.SemicolonToken.IsKind(SyntaxKind.SemicolonToken)); }
private static MemberDeclarationSyntax MakeAbstract(PropertyDeclarationSyntax propertyDeclaration) { if (propertyDeclaration == null) { throw new ArgumentNullException(nameof(propertyDeclaration)); } AccessorListSyntax accessorList = AccessorList(); if (propertyDeclaration.ExpressionBody != null) { accessorList = accessorList .AddAccessors( AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } else { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { accessorList = accessorList.AddAccessors(getter .WithBody(null) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } AccessorDeclarationSyntax setter = propertyDeclaration.Setter(); if (setter != null) { accessorList = accessorList.AddAccessors(setter .WithBody(null) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } } SyntaxTokenList modifiers = propertyDeclaration.Modifiers; if (!modifiers.Contains(SyntaxKind.AbstractKeyword)) { modifiers = modifiers.Add(Token(SyntaxKind.AbstractKeyword)); } return(propertyDeclaration .WithExpressionBody(null) .WithSemicolonToken(Token(SyntaxKind.None)) .WithAccessorList(accessorList) .WithModifiers(modifiers)); }
public static void Analyze(SyntaxNodeAnalysisContext context, PropertyDeclarationSyntax property) { IFieldSymbol fieldSymbol = GetBackingFieldSymbol(property, context.SemanticModel, context.CancellationToken); if (fieldSymbol != null) { var declarator = (VariableDeclaratorSyntax)fieldSymbol.DeclaringSyntaxReferences[0].GetSyntax(context.CancellationToken); if (declarator.SyntaxTree.Equals(property.SyntaxTree)) { IPropertySymbol propertySymbol = context .SemanticModel .GetDeclaredSymbol(property, context.CancellationToken); if (propertySymbol != null && propertySymbol.IsStatic == fieldSymbol.IsStatic && propertySymbol.Type == fieldSymbol.Type && propertySymbol.ContainingType?.Equals(fieldSymbol.ContainingType) == true && CheckPreprocessorDirectives(property, declarator)) { context.ReportDiagnostic( DiagnosticDescriptors.UseAutoImplementedProperty, property); if (property.ExpressionBody != null) { context.ReportNode(FadeOutDescriptor, property.ExpressionBody); } else { AccessorDeclarationSyntax getter = property.Getter(); if (getter != null) { FadeOutBodyOrExpressionBody(context, getter); } AccessorDeclarationSyntax setter = property.Setter(); if (setter != null) { FadeOutBodyOrExpressionBody(context, setter); } } } } } }
private static bool CanPropertyBeAssignedFromConstructor( PropertyDeclarationSyntax propertyDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken) { ISymbol symbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, cancellationToken); if (symbol == null) { return(false); } if (symbol.IsStatic) { return(false); } if (!propertyDeclaration.IsParentKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration)) { return(false); } ArrowExpressionClauseSyntax expressionBody = propertyDeclaration.ExpressionBody; if (expressionBody != null) { ExpressionSyntax expression = expressionBody?.Expression; if (expression != null) { return(GetBackingFieldSymbol(expression, semanticModel, cancellationToken) != null); } } else { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { return(CanPropertyBeAssignedFromConstructor(getter, semanticModel, cancellationToken)); } } return(false); }
private static PropertyDeclarationSyntax ExpandPropertyAndAddBackingField(PropertyDeclarationSyntax propertyDeclaration, string name) { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { AccessorDeclarationSyntax newGetter = getter .WithBody( Block( SingletonList <StatementSyntax>( ReturnStatement(IdentifierName(name))))) .WithSemicolonToken(Token(SyntaxKind.None)); propertyDeclaration = propertyDeclaration .WithInitializer(null) .WithAccessorList( propertyDeclaration.AccessorList.ReplaceNode(getter, newGetter)); } AccessorDeclarationSyntax setter = propertyDeclaration.Setter(); if (setter != null) { AccessorDeclarationSyntax newSetter = setter .WithBody( Block( SingletonList <StatementSyntax>( ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, IdentifierName(name), IdentifierName("value")))))) .WithSemicolonToken(Token(SyntaxKind.None)); propertyDeclaration = propertyDeclaration .WithAccessorList( propertyDeclaration.AccessorList.ReplaceNode(setter, newSetter)); } AccessorListSyntax accessorList = WhitespaceOrEndOfLineRemover.RemoveFrom(propertyDeclaration.AccessorList) .WithCloseBraceToken(propertyDeclaration.AccessorList.CloseBraceToken.WithLeadingTrivia(SyntaxHelper.NewLine)); return(propertyDeclaration .WithAccessorList(accessorList)); }
public static MethodDeclarationSyntax ToMethodDeclaration(PropertyDeclarationSyntax property) { AccessorDeclarationSyntax getter = property.Getter(); BlockSyntax getterBody = getter.Body; BlockSyntax methodBody; if (getterBody != null) { methodBody = Block(getterBody.Statements); } else { ArrowExpressionClauseSyntax getterExpressionBody = getter.ExpressionBody; if (getterExpressionBody != null) { methodBody = Block(ReturnStatement(getterExpressionBody.Expression)); } else { methodBody = Block(ReturnStatement(property.Initializer.Value)); } } methodBody = methodBody.WithTrailingTrivia(property.GetTrailingTrivia()); MethodDeclarationSyntax method = MethodDeclaration( property.AttributeLists, property.Modifiers, property.Type, property.ExplicitInterfaceSpecifier, Identifier(GetMethodName(property)).WithLeadingTrivia(property.Identifier.LeadingTrivia), default(TypeParameterListSyntax), ParameterList().WithTrailingTrivia(property.Identifier.TrailingTrivia), default(SyntaxList <TypeParameterConstraintClauseSyntax>), methodBody, default(ArrowExpressionClauseSyntax)); return(method .WithLeadingTrivia(property.GetLeadingTrivia()) .WithFormatterAnnotation()); }
private static async Task <bool> CanPropertyBeAssignedFromConstructorAsync( RefactoringContext context, PropertyDeclarationSyntax propertyDeclaration) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ISymbol symbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, context.CancellationToken); if (symbol != null && !symbol.IsStatic && propertyDeclaration.Parent != null && propertyDeclaration.Parent.IsKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration)) { if (propertyDeclaration.ExpressionBody != null) { ExpressionSyntax expression = propertyDeclaration.ExpressionBody?.Expression; if (expression != null) { return(GetBackingFieldSymbol(expression, semanticModel, context.CancellationToken) != null); } } else { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { if (getter.Body == null) { return(true); } if (getter.Body.Statements.Count == 1) { return(GetBackingFieldSymbol(getter.Body.Statements[0], semanticModel, context.CancellationToken) != null); } } } } return(false); }
public static async Task <Document> RefactorAsync( Document document, PropertyDeclarationSyntax propertyDeclaration, bool prefixIdentifierWithUnderscore = true, CancellationToken cancellationToken = default) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); string fieldName = StringUtility.ToCamelCase( propertyDeclaration.Identifier.ValueText, prefixWithUnderscore: prefixIdentifierWithUnderscore); fieldName = NameGenerator.Default.EnsureUniqueName( fieldName, semanticModel, propertyDeclaration.SpanStart); FieldDeclarationSyntax fieldDeclaration = FieldDeclaration( (propertyDeclaration.Modifiers.Contains(SyntaxKind.StaticKeyword)) ? Modifiers.Private_Static() : Modifiers.Private(), propertyDeclaration.Type, fieldName, propertyDeclaration.Initializer) .WithFormatterAnnotation(); IPropertySymbol propertySymbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, cancellationToken); PropertyDeclarationSyntax newPropertyDeclaration = propertyDeclaration; AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { AccessorDeclarationSyntax newGetter = getter.Update( getter.AttributeLists, getter.Modifiers, getter.Keyword, Block(ReturnStatement(IdentifierName(fieldName))), default(SyntaxToken)); newPropertyDeclaration = newPropertyDeclaration .ReplaceAccessor(getter, newGetter.RemoveWhitespace()) .WithInitializer(null) .WithSemicolonToken(default);
private static IFieldSymbol GetBackingFieldSymbol( PropertyDeclarationSyntax property, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken)) { ArrowExpressionClauseSyntax expressionBody = property.ExpressionBody; if (expressionBody != null) { NameSyntax identifier = GetIdentifierFromExpression(expressionBody.Expression); if (identifier != null) { return(GetBackingFieldSymbol(identifier, semanticModel, cancellationToken)); } } else { AccessorDeclarationSyntax getter = property.Getter(); if (getter != null) { AccessorDeclarationSyntax setter = property.Setter(); if (setter != null) { return(GetBackingFieldSymbol(getter, setter, semanticModel, cancellationToken)); } else { NameSyntax identifier = GetIdentifierFromGetter(getter); if (identifier != null) { return(GetBackingFieldSymbol(identifier, semanticModel, cancellationToken)); } } } } return(null); }
private static SyntaxToken GetPropertyIdentifier(PropertyDeclarationSyntax propertyDeclaration) { ArrowExpressionClauseSyntax expressionBody = propertyDeclaration.ExpressionBody; if (expressionBody != null) { ExpressionSyntax expression = expressionBody.Expression; if (expression?.Kind() == SyntaxKind.IdentifierName) { return(((IdentifierNameSyntax)expression).Identifier); } } else { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { BlockSyntax getterBody = getter.Body; if (getterBody != null) { var returnStatement = (ReturnStatementSyntax)getterBody.Statements[0]; return(GetIdentifier(returnStatement.Expression)); } else { ArrowExpressionClauseSyntax getterExpressionBody = getter.ExpressionBody; if (getterExpressionBody != null) { return(GetIdentifier(getterExpressionBody.Expression)); } } } } return(propertyDeclaration.Identifier); }
private static bool CanBeAssignedFromConstructor( PropertyDeclarationSyntax propertyDeclaration, CodeRefactoringContext context, SemanticModel semanticModel) { ISymbol symbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, context.CancellationToken); if (symbol == null || symbol.IsStatic || propertyDeclaration.Parent == null || !propertyDeclaration.Parent.IsAnyKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration)) { return(false); } AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { if (getter.Body == null) { return(true); } if (getter.Body.Statements.Count == 1) { return(GetBackingFieldSymbol(getter.Body.Statements[0], semanticModel, context.CancellationToken) != null); } } else { ExpressionSyntax expression = propertyDeclaration.ExpressionBody?.Expression; if (expression != null) { return(GetBackingFieldSymbol(expression, semanticModel, context.CancellationToken) != null); } } return(false); }
private static PropertyDeclarationSyntax ExpandAccessors( Document document, PropertyDeclarationSyntax propertyDeclaration, IPropertySymbol propertySymbol, string fieldName, SemanticModel semanticModel) { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { AccessorDeclarationSyntax newGetter = getter.Update( getter.AttributeLists, getter.Modifiers, getter.Keyword, Block(ReturnStatement(IdentifierName(fieldName))), default(SyntaxToken)); propertyDeclaration = propertyDeclaration .ReplaceNode(getter, newGetter.RemoveWhitespace()) .WithInitializer(null) .WithSemicolonToken(default);
private static IFieldSymbol GetBackingFieldSymbol(SyntaxNodeAnalysisContext context, PropertyDeclarationSyntax property) { if (property.ExpressionBody != null) { NameSyntax identifier = GetIdentifierFromExpression(property.ExpressionBody.Expression); if (identifier != null) { return(GetBackingFieldSymbol(context, identifier)); } } else { AccessorDeclarationSyntax getter = property.Getter(); if (getter != null) { AccessorDeclarationSyntax setter = property.Setter(); if (setter != null) { return(GetBackingFieldSymbol(context, getter, setter)); } else { NameSyntax identifier = GetIdentifierFromGetter(getter); if (identifier != null) { return(GetBackingFieldSymbol(context, identifier)); } } } } return(null); }
private static PropertyDeclarationSyntax ExpandPropertyAndAddBackingField(PropertyDeclarationSyntax propertyDeclaration, string name) { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { AccessorDeclarationSyntax newGetter = getter .WithBody(Block(ReturnStatement(IdentifierName(name)))) .WithSemicolonToken(default(SyntaxToken)); propertyDeclaration = propertyDeclaration .ReplaceNode(getter, newGetter) .WithInitializer(null) .WithSemicolonToken(default(SyntaxToken)); } AccessorDeclarationSyntax setter = propertyDeclaration.Setter(); if (setter != null) { AccessorDeclarationSyntax newSetter = setter .WithBody(Block( SimpleAssignmentStatement( IdentifierName(name), IdentifierName("value")))) .WithSemicolonToken(default(SyntaxToken)); propertyDeclaration = propertyDeclaration.ReplaceNode(setter, newSetter); } AccessorListSyntax accessorList = propertyDeclaration.AccessorList .RemoveWhitespace() .WithCloseBraceToken(propertyDeclaration.AccessorList.CloseBraceToken.WithLeadingTrivia(NewLine())); return(propertyDeclaration .WithAccessorList(accessorList)); }
private static async Task <bool> CanPropertyBeAssignedFromConstructorAsync( RefactoringContext context, PropertyDeclarationSyntax propertyDeclaration) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); CancellationToken cancellationToken = context.CancellationToken; ISymbol symbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, cancellationToken); if (symbol?.IsStatic == false && propertyDeclaration.IsParentKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration)) { ArrowExpressionClauseSyntax expressionBody = propertyDeclaration.ExpressionBody; if (expressionBody != null) { ExpressionSyntax expression = expressionBody?.Expression; if (expression != null) { return(GetBackingFieldSymbol(expression, semanticModel, cancellationToken) != null); } } else { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { return(CanPropertyBeAssignedFromConstructor(getter, semanticModel, cancellationToken)); } } } return(false); }
public static async Task <Document> ConvertToMethodAsync( Document document, PropertyDeclarationSyntax propertyDeclaration, CancellationToken cancellationToken) { if (document == null) { throw new ArgumentNullException(nameof(document)); } if (propertyDeclaration == null) { throw new ArgumentNullException(nameof(propertyDeclaration)); } SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken); MethodDeclarationSyntax methodDeclaration = MethodDeclaration( propertyDeclaration.AttributeLists, propertyDeclaration.Modifiers, propertyDeclaration.Type, propertyDeclaration.ExplicitInterfaceSpecifier, propertyDeclaration.Identifier.WithTrailingTrivia(), null, ParameterList(SeparatedList <ParameterSyntax>()), List <TypeParameterConstraintClauseSyntax>(), Block(propertyDeclaration.Getter().Body?.Statements), null); methodDeclaration = methodDeclaration .WithTriviaFrom(propertyDeclaration) .WithAdditionalAnnotations(Formatter.Annotation); SyntaxNode newRoot = oldRoot.ReplaceNode(propertyDeclaration, methodDeclaration); return(document.WithSyntaxRoot(newRoot)); }
private static MemberDeclarationSyntax MakeAbstract(PropertyDeclarationSyntax propertyDeclaration) { AccessorListSyntax accessorList = AccessorList(); if (propertyDeclaration.ExpressionBody != null) { accessorList = accessorList .AddAccessors( AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } else { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { accessorList = accessorList.AddAccessors(getter .WithBody(null) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } AccessorDeclarationSyntax setter = propertyDeclaration.Setter(); if (setter != null) { accessorList = accessorList.AddAccessors(setter .WithBody(null) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } } return(propertyDeclaration .WithExpressionBody(null) .WithSemicolonToken(Token(SyntaxKind.None)) .WithAccessorList(accessorList) .WithModifiers(CreateModifiers(propertyDeclaration.Modifiers))); }