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);
}
}
}
