Remove ECS0200 suppression and update WellKnownTypes to not trigger ECS0600 (#236)

Effective C# rules 0200 and 0600 have violations in
`src/Common/WellKnownTypeNames.cs`. This change updates the members in
`WellKnownTypes` type and their usages

Related to
rjmurillo/EffectiveCSharp.Analyzers#73, see
item for discussion

- Updated constant declarations to static read-only fields for improved
flexibility as referenced in
[ECS0200](https://github.com/rjmurillo/EffectiveCSharp.Analyzers/blob/main/docs/rules/ECS0200.md)
and removed suppression.
- Updated naming conventions for `WellKnownTypes` to avoid triggering
[ECS0600](https://github.com/rjmurillo/EffectiveCSharp.Analyzers/blob/main/docs/rules/ECS0600.md)
- Updated control flow in
`src/Analyzers/ConstructorArgumentsShouldMatchAnalyzer.cs` to move from
switch, which requires compile time constants, to a more traditional
if/else
- Updated names in the former `WellKnownTypeNames` type (now
`WellKnownMoqNames`) with improved names and added documentation

Author: rjmurillo

src/Analyzers/AsShouldBeUsedOnlyForInterfaceAnalyzer.cs

@@ -44,7 +44,7 @@ private static void RegisterCompilationStartAction(CompilationStartAnalysisConte
         // Look for the Mock.As() method and provide it to Analyze to avoid looking it up multiple times.
 #pragma warning disable ECS0900 // Minimize boxing and unboxing
         ImmutableArray<IMethodSymbol> asMethods = mockTypes
-            .SelectMany(mockType => mockType.GetMembers(WellKnownTypeNames.As))
+            .SelectMany(mockType => mockType.GetMembers(WellKnownMoqNames.AsMethodName))
             .OfType<IMethodSymbol>()
             .Where(method => method.IsGenericMethod)
             .ToImmutableArray();

src/Analyzers/ConstructorArgumentsShouldMatchAnalyzer.cs

@@ -78,7 +78,7 @@ private static bool IsExpressionMockBehavior(SyntaxNodeAnalysisContext context,
         if (expression is MemberAccessExpressionSyntax memberAccessExpressionSyntax)
         {
             if (memberAccessExpressionSyntax.Expression is IdentifierNameSyntax identifierNameSyntax
-                && string.Equals(identifierNameSyntax.Identifier.ValueText, WellKnownTypeNames.MockBehavior, StringComparison.Ordinal))
+                && string.Equals(identifierNameSyntax.Identifier.ValueText, WellKnownMoqNames.MockBehaviorTypeName, StringComparison.Ordinal))
             {
                 return true;
             }
@@ -107,14 +107,14 @@ private static bool IsExpressionMockBehavior(SyntaxNodeAnalysisContext context,
             }
 
             if (typeSymbol != null
-                && string.Equals(typeSymbol.Name, WellKnownTypeNames.MockBehavior, StringComparison.Ordinal))
+                && string.Equals(typeSymbol.Name, WellKnownMoqNames.MockBehaviorTypeName, StringComparison.Ordinal))
             {
                 return true;
             }
         }
 
         // Crude fallback to check if the expression is a Moq.MockBehavior enum
-        if (expression.ToString().StartsWith(WellKnownTypeNames.MoqBehavior, StringComparison.Ordinal))
+        if (expression.ToString().StartsWith(WellKnownMoqNames.FullyQualifiedMoqBehaviorTypeName, StringComparison.Ordinal))
         {
             return true;
         }
@@ -205,18 +205,18 @@ private static void AnalyzeInstanceCall(SyntaxNodeAnalysisContext context)
             return;
         }
 
-        switch (genericNameSyntax.Identifier.Value)
+        if (genericNameSyntax.Identifier.Value is not string genericNameSyntaxIdentifierValue)
         {
-            case WellKnownTypeNames.Create:
-                AnalyzeInvocation(context, invocationExpressionSyntax, WellKnownTypeNames.MockFactory, true, true);
-                break;
-
-            case WellKnownTypeNames.Of:
-                AnalyzeInvocation(context, invocationExpressionSyntax, WellKnownTypeNames.MockName, false, true);
-                break;
+            return;
+        }
 
-            default:
-                return;
+        if (string.Equals(genericNameSyntaxIdentifierValue, WellKnownMoqNames.CreateMethodName, StringComparison.Ordinal))
+        {
+            AnalyzeInvocation(context, invocationExpressionSyntax, WellKnownMoqNames.MockFactoryTypeName, true, true);
+        }
+        else if (string.Equals(genericNameSyntaxIdentifierValue, WellKnownMoqNames.OfMethodName, StringComparison.Ordinal))
+        {
+            AnalyzeInvocation(context, invocationExpressionSyntax, WellKnownMoqNames.MockTypeName, false, true);
         }
     }
 
@@ -252,7 +252,7 @@ private static void AnalyzeInvocation(
 
         // We are calling MockRepository.Create<T> or Mock.Of<T>, determine which
         ArgumentListSyntax? argumentList = null;
-        if (WellKnownTypeNames.Of.Equals(method.Name, StringComparison.Ordinal))
+        if (WellKnownMoqNames.OfMethodName.Equals(method.Name, StringComparison.Ordinal))
         {
             // Mock.Of<T> can specify condition for construction and MockBehavior, but
             // cannot specify constructor parameters
@@ -286,7 +286,7 @@ private static void AnalyzeNewObject(SyntaxNodeAnalysisContext context)
         // Quick check
         if (!string.Equals(
                 genericNameSyntax.Identifier.ValueText,
-                WellKnownTypeNames.MockName,
+                WellKnownMoqNames.MockTypeName,
                 StringComparison.Ordinal))
         {
             return;
@@ -297,7 +297,7 @@ private static void AnalyzeNewObject(SyntaxNodeAnalysisContext context)
 
         if (symbolInfo.Symbol is not IMethodSymbol mockConstructorMethod
             || mockConstructorMethod.MethodKind != MethodKind.Constructor
-            || !string.Equals(mockConstructorMethod.ContainingType.ConstructedFrom.ContainingSymbol.Name, WellKnownTypeNames.Moq, StringComparison.Ordinal))
+            || !string.Equals(mockConstructorMethod.ContainingType.ConstructedFrom.ContainingSymbol.Name, WellKnownMoqNames.MoqSymbolName, StringComparison.Ordinal))
         {
             return;
         }

src/Analyzers/SetExplicitMockBehaviorAnalyzer.cs

@@ -42,7 +42,7 @@ private static void RegisterCompilationStartAction(CompilationStartAnalysisConte
         }
 
         // Look for the MockBehavior type and provide it to Analyze to avoid looking it up multiple times.
-        INamedTypeSymbol? mockBehaviorSymbol = context.Compilation.GetTypeByMetadataName(WellKnownTypeNames.MoqBehavior);
+        INamedTypeSymbol? mockBehaviorSymbol = context.Compilation.GetTypeByMetadataName(WellKnownMoqNames.FullyQualifiedMoqBehaviorTypeName);
         if (mockBehaviorSymbol is null)
         {
             return;
@@ -51,7 +51,7 @@ private static void RegisterCompilationStartAction(CompilationStartAnalysisConte
         // Look for the Mock.Of() method and provide it to Analyze to avoid looking it up multiple times.
 #pragma warning disable ECS0900 // Minimize boxing and unboxing
         ImmutableArray<IMethodSymbol> ofMethods = mockTypes
-            .SelectMany(mockType => mockType.GetMembers(WellKnownTypeNames.Of))
+            .SelectMany(mockType => mockType.GetMembers(WellKnownMoqNames.OfMethodName))
             .OfType<IMethodSymbol>()
             .Where(method => method.IsGenericMethod)
             .ToImmutableArray();

src/Common/CompilationExtensions.cs

@@ -34,6 +34,6 @@ public static ImmutableArray<INamedTypeSymbol> GetTypesByMetadataNames(this Comp
     /// </returns>
     public static ImmutableArray<INamedTypeSymbol> GetMoqMock(this Compilation compilation)
     {
-        return compilation.GetTypesByMetadataNames([WellKnownTypeNames.MoqMock, WellKnownTypeNames.MoqMock1, WellKnownTypeNames.MoqRepository]);
+        return compilation.GetTypesByMetadataNames([WellKnownMoqNames.FullyQualifiedMoqMockTypeName, WellKnownMoqNames.FullyQualifiedMoqMock1TypeName, WellKnownMoqNames.FullyQualifiedMoqRepositoryTypeName]);
     }
 }

src/Common/MoqMethodDescriptorBase.cs

@@ -11,8 +11,8 @@
 /// </remarks>
 internal abstract class MoqMethodDescriptorBase
 {
-    private static readonly string ContainingNamespace = WellKnownTypeNames.Moq;
-    private static readonly string ContainingType = WellKnownTypeNames.MockName;
+    private static readonly string ContainingNamespace = WellKnownMoqNames.MoqNamespace;
+    private static readonly string ContainingType = WellKnownMoqNames.MockTypeName;
 
     public abstract bool IsMatch(SemanticModel semanticModel, MemberAccessExpressionSyntax memberAccessSyntax, CancellationToken cancellationToken);
 

src/Common/WellKnownMoqNames.cs

@@ -0,0 +1,74 @@
+namespace Moq.Analyzers.Common;
+
+/// <summary>
+/// Provides well-known names and fully qualified names for commonly used Moq types, namespaces, and members.
+/// </summary>
+internal static class WellKnownMoqNames
+{
+    /// <summary>
+    /// Represents the namespace for the Moq library.
+    /// </summary>
+    internal static readonly string MoqNamespace = "Moq";
+
+    /// <summary>
+    /// Symbol name for Moq.
+    /// </summary>
+    internal static readonly string MoqSymbolName = "Moq";
+
+    /// <summary>
+    /// The name of the 'Moq.Mock' type.
+    /// </summary>
+    internal static readonly string MockTypeName = "Mock";
+
+    /// <summary>
+    /// The name of the 'Moq.MockBehavior' type.
+    /// This type specifies the behavior of the mock (Strict, Loose, etc.).
+    /// </summary>
+    internal static readonly string MockBehaviorTypeName = "MockBehavior";
+
+    /// <summary>
+    /// The name of the 'Moq.MockFactory' type.
+    /// This factory is used for creating multiple mock objects with a shared configuration.
+    /// </summary>
+    internal static readonly string MockFactoryTypeName = "MockFactory";
+
+    /// <summary>
+    /// Fully qualified name for the 'Moq.Mock' type.
+    /// </summary>
+    internal static readonly string FullyQualifiedMoqMockTypeName = $"{MoqNamespace}.{MockTypeName}";
+
+    /// <summary>
+    /// Fully qualified name for the generic version of 'Moq.Mock{T}'.
+    /// Represents mocks for specific types.
+    /// </summary>
+    internal static readonly string FullyQualifiedMoqMock1TypeName = $"{FullyQualifiedMoqMockTypeName}`1";
+
+    /// <summary>
+    /// Fully qualified name for the 'Moq.MockBehavior' type.
+    /// </summary>
+    internal static readonly string FullyQualifiedMoqBehaviorTypeName = $"{MoqNamespace}.{MockBehaviorTypeName}";
+
+    /// <summary>
+    /// Fully qualified name for the 'Moq.MockRepository' type.
+    /// This type acts as a container for multiple mocks and shared mock configurations.
+    /// </summary>
+    internal static readonly string FullyQualifiedMoqRepositoryTypeName = $"{MoqNamespace}.MockRepository";
+
+    /// <summary>
+    /// Represents the method name for the `As` method in Moq.
+    /// This method is used to cast mocks to interfaces.
+    /// </summary>
+    internal static readonly string AsMethodName = "As";
+
+    /// <summary>
+    /// Represents the method name for the `Create` method in Moq.
+    /// This method is used to create instances of mocks.
+    /// </summary>
+    internal static readonly string CreateMethodName = "Create";
+
+    /// <summary>
+    /// Represents the method name for the `Of` method in Moq.
+    /// This method is used to create a mock from a type without directly specifying the constructor.
+    /// </summary>
+    internal static readonly string OfMethodName = "Of";
+}