private static void ComputeRefactoring(RefactoringContext context, MemberDeclarationSyntax memberDeclaration, SyntaxTokenList modifiers) { if (modifiers.Contains(SyntaxKind.AbstractKeyword) && !modifiers.Contains(SyntaxKind.StaticKeyword)) { SyntaxNode parent = memberDeclaration.Parent; Debug.Assert(parent?.IsKind(SyntaxKind.ClassDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.StructDeclaration) == true, parent?.Kind().ToString()); if (parent?.IsKind(SyntaxKind.ClassDeclaration) == true) { var classDeclaration = (ClassDeclarationSyntax)parent; if (CanBeMarkedAsAbstract(classDeclaration)) { context.RegisterRefactoring( "Mark containing class as abstract", cancellationToken => { return(InsertModifierRefactoring.RefactorAsync( context.Document, classDeclaration, SyntaxKind.AbstractKeyword, cancellationToken)); }); } } } }
public static void AnalyzeIndexerDeclaration(SyntaxNodeAnalysisContext context) { var indexerDeclaration = (IndexerDeclarationSyntax)context.Node; if (!indexerDeclaration.ContainsDirectives && !indexerDeclaration.ContainsDiagnostics) { SyntaxTokenList modifiers = indexerDeclaration.Modifiers; if (modifiers.Contains(SyntaxKind.OverrideKeyword) && !modifiers.Contains(SyntaxKind.SealedKeyword) && !indexerDeclaration.HasDocumentationComment() && indexerDeclaration.DescendantTrivia(indexerDeclaration.Span).All(f => f.IsWhitespaceOrEndOfLineTrivia()) && indexerDeclaration .AccessorList? .Accessors .All(accessor => CanRefactor(indexerDeclaration, accessor, context.SemanticModel, context.CancellationToken)) == true) { context.ReportDiagnostic( DiagnosticDescriptors.RemoveRedundantOverridingMember, indexerDeclaration, indexerDeclaration.GetTitle()); } } }
public static async Task <Document> RefactorAsync( Document document, ClassDeclarationSyntax classDeclaration, SyntaxKind modifierKind, CancellationToken cancellationToken = default(CancellationToken)) { if (document == null) { throw new ArgumentNullException(nameof(document)); } if (classDeclaration == null) { throw new ArgumentNullException(nameof(classDeclaration)); } SyntaxTokenList modifiers = classDeclaration.Modifiers; Debug.Assert(!modifiers.Contains(modifierKind), modifierKind.ToString()); if (!modifiers.Contains(modifierKind)) { SyntaxToken modifier = Token(modifierKind); ClassDeclarationSyntax newClassDeclaration = Inserter.InsertModifier(classDeclaration, modifier); return(await document.ReplaceNodeAsync(classDeclaration, newClassDeclaration, cancellationToken).ConfigureAwait(false)); } else { return(document); } }
public static void Analyze(SyntaxNodeAnalysisContext context, ConstructorDeclarationSyntax constructor) { if (constructor.ParameterList?.Parameters.Any() == false && constructor.Body?.Statements.Any() == false) { SyntaxTokenList modifiers = constructor.Modifiers; if (modifiers.Contains(SyntaxKind.PublicKeyword) && !modifiers.Contains(SyntaxKind.StaticKeyword)) { ConstructorInitializerSyntax initializer = constructor.Initializer; if (initializer == null || initializer.ArgumentList?.Arguments.Any() == false) { if (IsSingleInstanceConstructor(constructor) && constructor .DescendantTrivia(constructor.Span) .All(f => f.IsWhitespaceOrEndOfLineTrivia())) { context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantConstructor, constructor); } } } } }
private static bool CanBeMarkedAsAbstract(ClassDeclarationSyntax classDeclaration) { SyntaxTokenList modifiers = classDeclaration.Modifiers; return(!modifiers.Contains(SyntaxKind.AbstractKeyword) && !modifiers.Contains(SyntaxKind.StaticKeyword) && !modifiers.Contains(SyntaxKind.SealedKeyword)); }
public static bool CanRefactor(IndexerDeclarationSyntax indexerDeclaration) { SyntaxTokenList modifiers = indexerDeclaration.Modifiers; return(!modifiers.Contains(SyntaxKind.AbstractKeyword) && !modifiers.Contains(SyntaxKind.StaticKeyword) && IsAbstractClass(indexerDeclaration.Parent)); }
public static bool CanRefactor(FieldDeclarationSyntax fieldDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken) { SyntaxTokenList modifiers = fieldDeclaration.Modifiers; return(modifiers.Contains(SyntaxKind.StaticKeyword) && modifiers.Contains(SyntaxKind.ReadOnlyKeyword) && !modifiers.Contains(SyntaxKind.NewKeyword) && SupportsConstant(fieldDeclaration.Declaration, semanticModel, cancellationToken)); }
private static void AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context) { var constructor = (ConstructorDeclarationSyntax)context.Node; if (constructor.ContainsDiagnostics) { return; } if (constructor.ParameterList?.Parameters.Any() != false) { return; } if (constructor.Body?.Statements.Any() != false) { return; } SyntaxTokenList modifiers = constructor.Modifiers; if (!modifiers.Contains(SyntaxKind.PublicKeyword)) { return; } if (modifiers.Contains(SyntaxKind.StaticKeyword)) { return; } ConstructorInitializerSyntax initializer = constructor.Initializer; if (initializer != null && initializer.ArgumentList?.Arguments.Any() != false) { return; } if (!IsSingleInstanceConstructor(constructor)) { return; } if (constructor.HasDocumentationComment()) { return; } if (!constructor.DescendantTrivia(constructor.Span).All(f => f.IsWhitespaceOrEndOfLineTrivia())) { return; } DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.RemoveRedundantConstructor, constructor); }
private static void ComputeRefactoring( RefactoringContext context, MemberDeclarationSyntax memberDeclaration, SyntaxTokenList modifiers, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SemanticModel semanticModel) { if (!modifiers.Contains(SyntaxKind.PublicKeyword)) { return; } if (modifiers.Contains(SyntaxKind.StaticKeyword)) { return; } BaseListSyntax baseList = GetBaseList(memberDeclaration.Parent); if (baseList == null) { return; } SeparatedSyntaxList <BaseTypeSyntax> types = baseList.Types; if (!types.Any()) { return; } NameSyntax explicitInterfaceName = explicitInterfaceSpecifier?.Name; ITypeSymbol explicitInterfaceSymbol = (explicitInterfaceName != null) ? semanticModel.GetTypeSymbol(explicitInterfaceName, context.CancellationToken)?.OriginalDefinition : null; ISymbol memberSymbol = (memberDeclaration is EventFieldDeclarationSyntax eventFieldDeclaration) ? semanticModel.GetDeclaredSymbol(eventFieldDeclaration.Declaration.Variables.First()) : semanticModel.GetDeclaredSymbol(memberDeclaration); if (memberSymbol == null) { return; } foreach (BaseTypeSyntax baseType in types) { ComputeRefactoring(context, memberDeclaration, baseType, explicitInterfaceSymbol, memberSymbol, semanticModel); } }
internal static void Analyze(SyntaxNodeAnalysisContext context, MethodDeclarationSyntax methodDeclaration) { SyntaxTokenList modifiers = methodDeclaration.Modifiers; if (modifiers.Contains(SyntaxKind.OverrideKeyword) && !modifiers.Contains(SyntaxKind.SealedKeyword) && !modifiers.Contains(SyntaxKind.PartialKeyword)) { ExpressionSyntax expression = GetMethodExpression(methodDeclaration); if (expression?.IsKind(SyntaxKind.InvocationExpression) == true) { var invocation = (InvocationExpressionSyntax)expression; ExpressionSyntax invocationExpression = invocation.Expression; if (invocationExpression?.IsKind(SyntaxKind.SimpleMemberAccessExpression) == true) { var memberAccess = (MemberAccessExpressionSyntax)invocationExpression; if (memberAccess.Expression?.IsKind(SyntaxKind.BaseExpression) == true) { SimpleNameSyntax simpleName = memberAccess.Name; IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken); if (methodSymbol != null) { IMethodSymbol overriddenMethod = methodSymbol.OverriddenMethod; if (overriddenMethod != null) { ISymbol symbol = context.SemanticModel.GetSymbol(simpleName, context.CancellationToken); if (overriddenMethod.Equals(symbol) && CheckDefaultValues(methodSymbol, overriddenMethod) && !methodDeclaration.ContainsDirectives) { context.ReportDiagnostic( DiagnosticDescriptors.RemoveRedundantOverridingMember, methodDeclaration, methodDeclaration.GetTitle()); } } } } } } } }
public static ConstructorDeclarationSyntax AddStaticModifier(ConstructorDeclarationSyntax constructorDeclaration) { SyntaxTokenList modifiers = constructorDeclaration.Modifiers; if (!modifiers.Contains(SyntaxKind.StaticKeyword)) { SyntaxTokenList newModifiers = modifiers; if (modifiers.ContainsAccessModifier()) { newModifiers = modifiers.RemoveAccessModifiers(); if (newModifiers.Any()) { newModifiers = newModifiers.ReplaceAt(0, newModifiers[0].WithLeadingTrivia(modifiers[0].LeadingTrivia)); newModifiers = Inserter.InsertModifier(newModifiers, SyntaxKind.StaticKeyword); } else { newModifiers = Inserter.InsertModifier(newModifiers, CSharpFactory.StaticKeyword().WithLeadingTrivia(modifiers[0].LeadingTrivia)); } } else { newModifiers = Inserter.InsertModifier(newModifiers, SyntaxKind.StaticKeyword); } return(constructorDeclaration.WithModifiers(newModifiers)); } else { return(constructorDeclaration); } }
public static void AnalyzeEventFieldDeclaration(SyntaxNodeAnalysisContext context) { var eventFieldDeclaration = (EventFieldDeclarationSyntax)context.Node; SyntaxTokenList modifiers = eventFieldDeclaration.Modifiers; if (modifiers.Contains(SyntaxKind.OverrideKeyword)) { VariableDeclarationSyntax declaration = eventFieldDeclaration.Declaration; if (declaration != null) { SeparatedSyntaxList <VariableDeclaratorSyntax> declarators = declaration.Variables; for (int i = 0; i < declarators.Count; i++) { SyntaxToken identifier = declarators[i].Identifier; if (ContainsDiagnostic(identifier, context.SemanticModel, context.CancellationToken)) { if (declarators.Count == 1 || CheckOtherEvents(declarators, i, context.SemanticModel, context.CancellationToken)) { ReportDiagnostic(context, eventFieldDeclaration, modifiers, identifier); } break; } } } } }
private static bool IsMainMethod(MethodDeclarationSyntax methodDeclaration, SyntaxTokenList modifiers, string methodName) { return string.Equals(methodName, "Main", StringComparison.Ordinal) && modifiers.Contains(SyntaxKind.StaticKeyword) && methodDeclaration.TypeParameterList == null && methodDeclaration.ParameterList?.Parameters.Count <= 1; }
public override Accessibility GetAccessibility(MethodDeclarationSyntax declaration) { if (declaration == null) { throw new ArgumentNullException(nameof(declaration)); } SyntaxTokenList modifiers = declaration.Modifiers; if (modifiers.Contains(SyntaxKind.PartialKeyword)) { return(Accessibility.Private); } if (declaration.ExplicitInterfaceSpecifier != null) { return(Accessibility.Private); } if (declaration.IsParentKind(SyntaxKind.InterfaceDeclaration)) { return(Accessibility.Public); } Accessibility accessibility = SyntaxAccessibility.GetExplicitAccessibility(declaration.Modifiers); return((accessibility != Accessibility.NotApplicable) ? accessibility : GetDefaultAccessibility(declaration)); }
public static bool CanRefactor(MethodDeclarationSyntax methodDeclaration) { if (methodDeclaration.ReturnType?.IsVoid() == false && methodDeclaration.ParameterList?.Parameters.Count == 0 && methodDeclaration.TypeParameterList == null) { SyntaxTokenList modifiers = methodDeclaration.Modifiers; if (!modifiers.Contains(SyntaxKind.OverrideKeyword) && !modifiers.Contains(SyntaxKind.AsyncKeyword)) { return(true); } } return(false); }
private static void AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context) { var declaration = (ConstructorDeclarationSyntax)context.Node; SyntaxTokenList modifiers = declaration.Modifiers; if (modifiers.Contains(SyntaxKind.StaticKeyword)) { foreach (SyntaxToken modifier in modifiers) { switch (modifier.Kind()) { case SyntaxKind.NewKeyword: case SyntaxKind.PublicKeyword: case SyntaxKind.ProtectedKeyword: case SyntaxKind.InternalKeyword: case SyntaxKind.PrivateKeyword: case SyntaxKind.ConstKeyword: case SyntaxKind.VirtualKeyword: case SyntaxKind.SealedKeyword: case SyntaxKind.OverrideKeyword: case SyntaxKind.AbstractKeyword: case SyntaxKind.ReadOnlyKeyword: case SyntaxKind.VolatileKeyword: case SyntaxKind.AsyncKeyword: case SyntaxKind.PartialKeyword: { ReportDiagnostic(context, modifier); break; } } } } else { foreach (SyntaxToken modifier in modifiers) { switch (modifier.Kind()) { case SyntaxKind.NewKeyword: case SyntaxKind.ConstKeyword: case SyntaxKind.VirtualKeyword: case SyntaxKind.SealedKeyword: case SyntaxKind.OverrideKeyword: case SyntaxKind.AbstractKeyword: case SyntaxKind.ReadOnlyKeyword: case SyntaxKind.VolatileKeyword: case SyntaxKind.AsyncKeyword: case SyntaxKind.PartialKeyword: { ReportDiagnostic(context, modifier); break; } } } } }
internal static void Analyze(SyntaxNodeAnalysisContext context, IndexerDeclarationSyntax indexerDeclaration) { SyntaxTokenList modifiers = indexerDeclaration.Modifiers; if (modifiers.Contains(SyntaxKind.OverrideKeyword) && !modifiers.Contains(SyntaxKind.SealedKeyword) && indexerDeclaration .AccessorList? .Accessors .All(accessor => CanRefactor(indexerDeclaration, accessor, context.SemanticModel, context.CancellationToken)) == true && !indexerDeclaration.ContainsDirectives) { context.ReportDiagnostic( DiagnosticDescriptors.RemoveRedundantOverridingMember, indexerDeclaration, indexerDeclaration.GetTitle()); } }
private static SyntaxTokenList AddAbstractKeywordIfNotPresent(SyntaxTokenList modifiers) { if (!modifiers.Contains(SyntaxKind.AbstractKeyword)) { modifiers = modifiers.Add(AbstractKeyword()); } return(modifiers); }
public static async Task <Solution> RefactorAsync( Solution solution, MemberDeclarationSelection selectedMembers, Accessibility newAccessibility, SemanticModel semanticModel, CancellationToken cancellationToken) { var members = new HashSet <MemberDeclarationSyntax>(); foreach (MemberDeclarationSyntax member in selectedMembers) { SyntaxTokenList modifiers = member.GetModifiers(); if (modifiers.Contains(SyntaxKind.PartialKeyword)) { ISymbol symbol = semanticModel.GetDeclaredSymbol(member, cancellationToken); foreach (SyntaxReference reference in symbol.DeclaringSyntaxReferences) { members.Add((MemberDeclarationSyntax)reference.GetSyntax(cancellationToken)); } } else if (modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { ISymbol symbol = GetBaseSymbolOrDefault(member, semanticModel, cancellationToken); if (symbol != null) { foreach (MemberDeclarationSyntax member2 in GetMemberDeclarations(symbol, cancellationToken)) { members.Add(member2); } foreach (MemberDeclarationSyntax member2 in await FindOverridingMemberDeclarationsAsync(symbol, solution, cancellationToken).ConfigureAwait(false)) { members.Add(member2); } } else { members.Add(member); } } else { members.Add(member); } } return(await solution.ReplaceNodesAsync( members, (node, _) => node.WithAccessibility(newAccessibility), cancellationToken).ConfigureAwait(false)); }
private static TNode UpdateModifiers <TNode>(TNode node, SyntaxTokenList modifiers) where TNode : SyntaxNode { if (!modifiers.Contains(SyntaxKind.AbstractKeyword)) { modifiers = modifiers.InsertModifier(SyntaxKind.AbstractKeyword, ModifierComparer.Instance); node = (TNode)node.WithModifiers(modifiers); } return(node.RemoveModifier(SyntaxKind.VirtualKeyword)); }
public static void Analyze(SymbolAnalysisContext context, INamedTypeSymbol symbol) { if (symbol.IsClass() && symbol.IsStatic && !symbol.IsImplicitClass && !symbol.IsImplicitlyDeclared) { ImmutableArray <SyntaxReference> syntaxReferences = symbol.DeclaringSyntaxReferences; if (syntaxReferences.Length > 1) { bool isStatic = false; List <ClassDeclarationSyntax> classDeclarations = null; foreach (SyntaxReference syntaxReference in syntaxReferences) { SyntaxNode node = syntaxReference.GetSyntax(context.CancellationToken); Debug.Assert(node.IsKind(SyntaxKind.ClassDeclaration), node.Kind().ToString()); if (node.IsKind(SyntaxKind.ClassDeclaration)) { var classDeclaration = (ClassDeclarationSyntax)node; SyntaxTokenList modifiers = classDeclaration.Modifiers; if (modifiers.Contains(SyntaxKind.StaticKeyword)) { isStatic = true; } else if (!classDeclaration.ContainsDirectives(modifiers.Span)) { if (classDeclarations == null) { classDeclarations = new List <ClassDeclarationSyntax>(); } classDeclarations.Add(classDeclaration); } } } if (isStatic && classDeclarations != null) { foreach (ClassDeclarationSyntax classDeclaration in classDeclarations) { context.ReportDiagnostic( DiagnosticDescriptors.AddStaticModifierToAllPartialClassDeclarations, classDeclaration.Identifier); } } } } }
public static MethodDeclarationSyntax AddStaticModifier(MethodDeclarationSyntax methodDeclaration) { SyntaxTokenList modifiers = methodDeclaration.Modifiers; if (!modifiers.Contains(SyntaxKind.StaticKeyword)) { return(Inserter.InsertModifier(methodDeclaration, SyntaxKind.StaticKeyword)); } else { return(methodDeclaration); } }
public static PropertyDeclarationSyntax AddStaticModifier(PropertyDeclarationSyntax propertyDeclaration) { SyntaxTokenList modifiers = propertyDeclaration.Modifiers; if (!modifiers.Contains(SyntaxKind.StaticKeyword)) { return(Inserter.InsertModifier(propertyDeclaration, SyntaxKind.StaticKeyword)); } else { return(propertyDeclaration); } }
public static EventFieldDeclarationSyntax AddStaticModifier(EventFieldDeclarationSyntax eventFieldDeclaration) { SyntaxTokenList modifiers = eventFieldDeclaration.Modifiers; if (!modifiers.Contains(SyntaxKind.StaticKeyword)) { return(Inserter.InsertModifier(eventFieldDeclaration, SyntaxKind.StaticKeyword)); } else { return(eventFieldDeclaration); } }
private static void AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context) { if (!context.Node.IsParentKind(SyntaxKind.ClassDeclaration)) { return; } var constructorDeclaration = (ConstructorDeclarationSyntax)context.Node; if (SyntaxAccessibility <ConstructorDeclarationSyntax> .Instance.GetExplicitAccessibility(constructorDeclaration) != Accessibility.Public) { return; } var classDeclaration = (ClassDeclarationSyntax)constructorDeclaration.Parent; SyntaxTokenList modifiers = classDeclaration.Modifiers; bool isAbstract = modifiers.Contains(SyntaxKind.AbstractKeyword); if (!isAbstract && modifiers.Contains(SyntaxKind.PartialKeyword)) { INamedTypeSymbol classSymbol = context.SemanticModel.GetDeclaredSymbol(classDeclaration, context.CancellationToken); if (classSymbol != null) { isAbstract = classSymbol.IsAbstract; } } if (isAbstract) { DiagnosticHelpers.ReportDiagnostic( context, DiagnosticRules.AbstractTypeShouldNotHavePublicConstructors, constructorDeclaration.Identifier); } }
public static void AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context) { var constructorDeclaration = (ConstructorDeclarationSyntax)context.Node; if (!SyntaxAccessibility.GetExplicitAccessibility(constructorDeclaration).Is(Accessibility.Public, Accessibility.ProtectedOrInternal)) { return; } if (!constructorDeclaration.IsParentKind(SyntaxKind.ClassDeclaration)) { return; } var classDeclaration = (ClassDeclarationSyntax)constructorDeclaration.Parent; SyntaxTokenList modifiers = classDeclaration.Modifiers; bool isAbstract = modifiers.Contains(SyntaxKind.AbstractKeyword); if (!isAbstract && modifiers.Contains(SyntaxKind.PartialKeyword)) { INamedTypeSymbol classSymbol = context.SemanticModel.GetDeclaredSymbol(classDeclaration, context.CancellationToken); if (classSymbol != null) { isAbstract = classSymbol.IsAbstract; } } if (!isAbstract) { return; } context.ReportDiagnostic(DiagnosticDescriptors.AbstractTypeShouldNotHavePublicConstructors, constructorDeclaration.Identifier); }
private static bool ComputeRefactoring(MemberDeclarationSyntax memberDeclaration, SyntaxTokenList modifiers) { if (modifiers.Contains(SyntaxKind.AbstractKeyword) && !modifiers.Contains(SyntaxKind.StaticKeyword)) { SyntaxNode parent = memberDeclaration.Parent; Debug.Assert(parent?.IsKind(SyntaxKind.ClassDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.StructDeclaration) == true, parent?.Kind().ToString()); if (parent?.IsKind(SyntaxKind.ClassDeclaration) == true) { var classDeclaration = (ClassDeclarationSyntax)parent; SyntaxTokenList classModifiers = classDeclaration.Modifiers; return(!classModifiers.Contains(SyntaxKind.AbstractKeyword) && !classModifiers.Contains(SyntaxKind.StaticKeyword) && !classModifiers.Contains(SyntaxKind.SealedKeyword)); } } return(false); }
public static void AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context) { var constructorDeclaration = (ConstructorDeclarationSyntax)context.Node; if (constructorDeclaration.Modifiers.Contains(SyntaxKind.PublicKeyword)) { SyntaxNode parent = constructorDeclaration.Parent; if (parent?.IsKind(SyntaxKind.ClassDeclaration) == true) { var classDeclaration = (ClassDeclarationSyntax)parent; SyntaxTokenList modifiers = classDeclaration.Modifiers; bool isAbstract = modifiers.Contains(SyntaxKind.AbstractKeyword); if (!isAbstract && modifiers.Contains(SyntaxKind.PartialKeyword)) { INamedTypeSymbol classSymbol = context.SemanticModel.GetDeclaredSymbol(classDeclaration, context.CancellationToken); if (classSymbol != null) { isAbstract = classSymbol.IsAbstract; } } if (isAbstract) { context.ReportDiagnostic( DiagnosticDescriptors.AbstractTypeShouldNotHavePublicConstructors, constructorDeclaration.Identifier); } } } }
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 AnalyzeEventDeclaration(SyntaxNodeAnalysisContext context) { var eventDeclaration = (EventDeclarationSyntax)context.Node; SyntaxTokenList modifiers = eventDeclaration.Modifiers; if (modifiers.Contains(SyntaxKind.OverrideKeyword)) { SyntaxToken identifier = eventDeclaration.Identifier; if (ContainsDiagnostic(identifier, context.SemanticModel, context.CancellationToken)) { ReportDiagnostic(context, eventDeclaration, modifiers, identifier); } } }