Add special handling of single-member enums to SA1129

Author: nbarbettini

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1129CodeFixProvider.cs

@@ -62,10 +62,19 @@ private static SyntaxNode GetReplacementNode(SyntaxNode node, SemanticModel sema
         {
             var newExpression = (ObjectCreationExpressionSyntax)node;
 
+            var symbolInfo = semanticModel.GetSymbolInfo(newExpression.Type, cancellationToken);
+            var namedTypeSymbol = symbolInfo.Symbol as INamedTypeSymbol;
+
             SyntaxNode replacement = null;
-            if (IsType<CancellationToken>(newExpression.Type, semanticModel, cancellationToken))
+            string memberName = null;
+
+            if (IsType<CancellationToken>(namedTypeSymbol))
+            {
+                replacement = ConstructMemberAccessSyntax(newExpression.Type, nameof(CancellationToken.None));
+            }
+            else if (IsEnumWithDefaultMember(namedTypeSymbol, out memberName))
             {
-                replacement = GetCancellationTokenNoneSyntax(newExpression.Type);
+                replacement = ConstructMemberAccessSyntax(newExpression.Type, memberName);
             }
             else
             {
@@ -77,42 +86,79 @@ private static SyntaxNode GetReplacementNode(SyntaxNode node, SemanticModel sema
                 .WithTrailingTrivia(newExpression.GetTrailingTrivia());
         }
 
-        private static bool IsType<T>(TypeSyntax typeSyntax, SemanticModel semanticModel, CancellationToken cancellationToken)
+        /// <summary>
+        /// Determines whether a symbol is an instance of a given <see cref="Type"/>.
+        /// </summary>
+        /// <typeparam name="T">The type to match.</typeparam>
+        /// <param name="namedTypeSymbol">The symbol.</param>
+        /// <returns><see langword="true"/> if the syntax matches the type; <see langword="false"/> otherwise.</returns>
+        private static bool IsType<T>(INamedTypeSymbol namedTypeSymbol)
         {
-            var expectedType = typeof(T);
-            var symbolInfo = semanticModel.GetSymbolInfo(typeSyntax, cancellationToken);
-            var namedTypeSymbol = symbolInfo.Symbol as INamedTypeSymbol;
-
             if (namedTypeSymbol == null)
             {
                 return false;
             }
 
+            var expectedType = typeof(T);
+
             if (!string.Equals(expectedType.Name, namedTypeSymbol.Name, StringComparison.Ordinal))
             {
                 return false;
             }
 
-            if (!string.Equals(expectedType.Namespace, namedTypeSymbol.ContainingNamespace?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat.WithGlobalNamespaceStyle(SymbolDisplayGlobalNamespaceStyle.Omitted)), StringComparison.Ordinal))
+            if (!string.Equals(
+                expectedType.Namespace,
+                namedTypeSymbol.ContainingNamespace?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat.WithGlobalNamespaceStyle(SymbolDisplayGlobalNamespaceStyle.Omitted)),
+                StringComparison.Ordinal))
             {
                 return false;
             }
-            
+
             return true;
         }
 
         /// <summary>
-        /// Gets a qualified member access expression for <c>CancellationToken.None</c>.
+        /// Determines whether a given enumeration symbol contains a member with value <c>0</c>.
+        /// </summary>
+        /// <param name="namedTypeSymbol">The symbol.</param>
+        /// <param name="foundMemberName">Will be set to the string name of the member, if one is found.</param>
+        /// <returns><see langword="true"/> if the syntax is an enumeration with a value of <c>0</c>; <see langword="false"/> otherwise.</returns>
+        private static bool IsEnumWithDefaultMember(INamedTypeSymbol namedTypeSymbol, out string foundMemberName)
+        {
+            foundMemberName = null;
+
+            if (namedTypeSymbol == null || namedTypeSymbol.TypeKind != TypeKind.Enum)
+            {
+                return false;
+            }
+
+            var foundMembers = namedTypeSymbol
+                .GetMembers()
+                .Where(m => m.Kind == SymbolKind.Field)
+                .OfType<IFieldSymbol>()
+                .Where(fs => fs.ConstantValue.Equals(0))
+                .ToList();
+
+            if (foundMembers.Count != 1)
+            {
+                return false;
+            }
+
+            foundMemberName = foundMembers.Single().Name;
+            return true;
+        }
+
+        /// <summary>
+        /// Gets a qualified member access expression for the given <paramref name="typeSyntax"/>.
         /// </summary>
         /// <param name="typeSyntax">The type syntax from the original constructor.</param>
+        /// <param name="memberName">The member name.</param>
         /// <returns>A new member access expression.</returns>
-        private static SyntaxNode GetCancellationTokenNoneSyntax(TypeSyntax typeSyntax)
-        {
-            return SyntaxFactory.MemberAccessExpression(
+        private static SyntaxNode ConstructMemberAccessSyntax(TypeSyntax typeSyntax, string memberName)
+            => SyntaxFactory.MemberAccessExpression(
                 SyntaxKind.SimpleMemberAccessExpression,
                 typeSyntax,
-                SyntaxFactory.IdentifierName(nameof(CancellationToken.None)));
-        }
+                SyntaxFactory.IdentifierName(memberName));
 
         private class FixAll : DocumentBasedFixAllProvider
         {

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1129UnitTests.cs

@@ -403,6 +403,90 @@ private struct CancellationToken
             await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Verifies that <c>new MyEnum()</c> is replaced by <c>MyEnum.Member</c>
+        /// iff there is one member in <c>MyEnum</c> with a value of <c>0</c>.
+        /// </summary>
+        /// <param name="declarationBody">The injected <c>enum</c> declaration body.</param>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Theory]
+        [InlineData("Member")]
+        [InlineData("Member = 0")]
+        [InlineData("Member = 0, Another = 1")]
+        [InlineData("Another = 1, Member = 0")]
+        public async Task VerifyEnumMemberReplacementBehaviorAsync(string declarationBody)
+        {
+            var testCode = $@"public class TestClass
+{{
+    public void TestMethod()
+    {{
+        var v1 = new MyEnum();
+    }}
+
+    private enum MyEnum {{ {declarationBody} }}
+}}";
+
+            var fixedTestCode = $@"public class TestClass
+{{
+    public void TestMethod()
+    {{
+        var v1 = MyEnum.Member;
+    }}
+
+    private enum MyEnum {{ {declarationBody} }}
+}}";
+
+            DiagnosticResult[] expected =
+            {
+                this.CSharpDiagnostic().WithLocation(5, 18),
+            };
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that <c>new MyEnum()</c> is <b>not</b> replaced by <c>MyEnum.Member</c>
+        /// if there is no member with a value of <c>0</c>, but instead uses the default replacement behavior.
+        /// </summary>
+        /// <param name="declarationBody">The injected <c>enum</c> declaration body.</param>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Theory]
+        [InlineData("Member = 1")]
+        [InlineData("Member = 1, Another = 2")]
+        public async Task VerifyEnumMemberDefaultBehaviorAsync(string declarationBody)
+        {
+            var testCode = $@"public class TestClass
+{{
+    public void TestMethod()
+    {{
+        var v1 = new MyEnum();
+    }}
+
+    private enum MyEnum {{ {declarationBody} }}
+}}";
+
+            var fixedTestCode = $@"public class TestClass
+{{
+    public void TestMethod()
+    {{
+        var v1 = default(MyEnum);
+    }}
+
+    private enum MyEnum {{ {declarationBody} }}
+}}";
+
+            DiagnosticResult[] expected =
+            {
+                this.CSharpDiagnostic().WithLocation(5, 18),
+            };
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
+        }
+
         /// <inheritdoc/>
         protected override IEnumerable<DiagnosticAnalyzer> GetCSharpDiagnosticAnalyzers()
         {