Address comments round 1

Author: CristianAmbrosini

analyzers/src/SonarAnalyzer.CSharp/Helpers/CSharpSymbolUsageCollector.cs

@@ -159,9 +159,7 @@ static bool IsValueNameOrType(AttributeArgumentSyntax a) =>
 
         public override void VisitIdentifierName(IdentifierNameSyntax node)
         {
-            if (IsKnownIdentifier(node.Identifier)
-                || knownSymbolNames.Contains($"get_{node.Identifier.ValueText}")
-                || knownSymbolNames.Contains($"set_{node.Identifier.ValueText}"))
+            if (IsKnownIdentifier(node.Identifier))
             {
                 var symbols = GetSymbols(node);
                 TryStoreFieldAccess(node, symbols);
@@ -250,17 +248,6 @@ public override void VisitPropertyDeclaration(PropertyDeclarationSyntax node)
             base.VisitPropertyDeclaration(node);
         }
 
-        public override void VisitAccessorDeclaration(AccessorDeclarationSyntax node)
-        {
-            if (semanticModel.GetDeclaredSymbol(node) is { } symbol
-                && knownSymbolNames.Contains(symbol.Name))
-            {
-                var usage = GetFieldSymbolUsage(symbol);
-                usage.Declaration = node;
-            }
-            base.VisitAccessorDeclaration(node);
-        }
-
         private SymbolAccess ParentAccessType(SyntaxNode node) =>
             node.Parent switch
             {

analyzers/src/SonarAnalyzer.CSharp/Rules/UnusedPrivateMember.cs

@@ -84,7 +84,7 @@ private static void NamedSymbolAction(SonarSymbolReportingContext context, HashS
             var fieldLikeSymbols = new BidirectionalDictionary<ISymbol, SyntaxNode>();
             if (GatherSymbols(namedType, context.Compilation, privateSymbols, removableInternalTypes, fieldLikeSymbols, context)
                 && privateSymbols.Any()
-                && new CSharpSymbolUsageCollector(context.Compilation, privateSymbols) is var usageCollector
+                && new CSharpSymbolUsageCollector(context.Compilation, AssociatedSymbols(privateSymbols)) is var usageCollector
                 && VisitDeclaringReferences(namedType, usageCollector, context, includeGeneratedFile: true))
             {
                 foreach (var diagnostic in DiagnosticsForUnusedPrivateMembers(usageCollector, privateSymbols, SyntaxConstants.Private, fieldLikeSymbols))
@@ -98,6 +98,9 @@ private static void NamedSymbolAction(SonarSymbolReportingContext context, HashS
             }
         }
 
+        private static IEnumerable<ISymbol> AssociatedSymbols(IEnumerable<ISymbol> privateSymbols) =>
+            privateSymbols.Select(x => x is IMethodSymbol { AssociatedSymbol: IPropertySymbol property } ? property : x);
+
         private static bool GatherSymbols(INamedTypeSymbol namedType,
                                           Compilation compilation,
                                           HashSet<ISymbol> privateSymbols,
@@ -184,8 +187,8 @@ private static bool IsAccessorUsed(ISymbol symbol, CSharpSymbolUsageCollector us
             symbol is IMethodSymbol { } accessor
                 && accessor.AssociatedSymbol is IPropertySymbol { } property
                 && usageCollector.PropertyAccess.TryGetValue(property, out var access)
-                && ((access is AccessorAccess.Get or AccessorAccess.Both && accessor.MethodKind == MethodKind.PropertyGet)
-                    || (access is AccessorAccess.Set or AccessorAccess.Both && accessor.MethodKind == MethodKind.PropertySet));
+                && ((access.HasFlag(AccessorAccess.Get) && accessor.MethodKind == MethodKind.PropertyGet)
+                    || (access.HasFlag(AccessorAccess.Set) && accessor.MethodKind == MethodKind.PropertySet));
 
         private static string GetFieldAccessibilityForMessage(ISymbol symbol) =>
             symbol.DeclaredAccessibility == Accessibility.Private ? SyntaxConstants.Private : "private class";
@@ -436,11 +439,12 @@ public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
 
                 base.VisitMethodDeclaration(node);
             }
+
             public override void VisitAccessorDeclaration(AccessorDeclarationSyntax node)
             {
                 if (node.Modifiers.Any(SyntaxKind.PrivateKeyword))
                 {
-                    ConditionalStore(GetDeclaredSymbol(node), IsRemovableMember);
+                    ConditionalStore(GetDeclaredSymbol(node), IsRemovable);
                 }
 
                 base.VisitAccessorDeclaration(node);

analyzers/tests/SonarAnalyzer.Test/Rules/UnusedPrivateMemberTest.Properties.cs

@@ -148,14 +148,16 @@ public class PropertyUsages
     public int BProperty { get; private set; } // Noncompliant {{Remove the unused private setter 'set_BProperty'.}}
     public int CProperty { internal get; set; } // Compliant
     public int DProperty { get; internal set; } // Compliant
-    protected int EProperty { private get; set; } // Noncompliant {{Remove the unused private getter 'get_EProperty'.}}
+    public int EProperty { protected get; set; } // Compliant
+    public int E2Property { get; protected set; } // Compliant
     public int FProperty { get; private set; } // Compliant
     public int GProperty { private get; set; } // Noncompliant {{Remove the unused private getter 'get_GProperty'.}}
     public int HProperty { get; private set; } // Noncompliant {{Remove the unused private setter 'set_HProperty'.}}
     public int IProperty { private get; set; } // Compliant
     public int JProperty { get; private set; } // Compliant: both read and write
     public int KProperty { private get; set; } // Compliant: both read and write
     public int LProperty { get; private set; } // FN: private set is used in the constructor, not necessary
+    protected int MProperty { private get; set; } // Noncompliant {{Remove the unused private getter 'get_MProperty'.}}
 
     public PropertyUsages()
     {
@@ -174,11 +176,12 @@ public void Method()
     public interface ISomeInterface
     {
         string Something { get; }
+        string SomethingElse { get; }
     }
 
     public class SomeClass : ISomeInterface
     {
-        public string Something { get; private set; }
+        public string Something { get; private set; } // Compliant
         public string SomethingElse { get; private set; } // Noncompliant
 
         public void Method(string str)