Update SA1129 to validate symbol and full namespace path

Author: nbarbettini

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

@@ -3,6 +3,7 @@
 
 namespace StyleCop.Analyzers.ReadabilityRules
 {
+    using System;
     using System.Collections.Immutable;
     using System.Composition;
     using System.Linq;
@@ -49,22 +50,22 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
         private static async Task<Document> GetTransformedDocumentAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken)
         {
             var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
             var newExpression = syntaxRoot.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
-            var newSyntaxRoot = syntaxRoot.ReplaceNode(newExpression, GetReplacementNode(newExpression));
+            var newSyntaxRoot = syntaxRoot.ReplaceNode(newExpression, GetReplacementNode(newExpression, semanticModel, cancellationToken));
+
             return document.WithSyntaxRoot(newSyntaxRoot);
         }
 
-        private static SyntaxNode GetReplacementNode(SyntaxNode node)
+        private static SyntaxNode GetReplacementNode(SyntaxNode node, SemanticModel semanticModel, CancellationToken cancellationToken)
         {
             var newExpression = (ObjectCreationExpressionSyntax)node;
-            var nameSyntax = newExpression.Type as NameSyntax;
-            var identifierName = NameSyntaxHelpers.ToNormalizedString(nameSyntax);
 
             SyntaxNode replacement = null;
-            if (identifierName.EndsWith(nameof(CancellationToken), System.StringComparison.OrdinalIgnoreCase))
+            if (IsType<CancellationToken>(newExpression.Type, semanticModel, cancellationToken))
             {
-                replacement = GetCancellationTokenNoneSyntax(nameSyntax);
+                replacement = GetCancellationTokenNoneSyntax(newExpression.Type);
             }
             else
             {
@@ -76,11 +77,40 @@ private static SyntaxNode GetReplacementNode(SyntaxNode node)
                 .WithTrailingTrivia(newExpression.GetTrailingTrivia());
         }
 
-        private static SyntaxNode GetCancellationTokenNoneSyntax(NameSyntax nameSyntax)
+        private static bool IsType<T>(TypeSyntax typeSyntax, SemanticModel semanticModel, CancellationToken cancellationToken)
+        {
+            var expectedType = typeof(T);
+            var symbolInfo = semanticModel.GetSymbolInfo(typeSyntax, cancellationToken);
+            var namedTypeSymbol = symbolInfo.Symbol as INamedTypeSymbol;
+
+            if (namedTypeSymbol == null)
+            {
+                return false;
+            }
+
+            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))
+            {
+                return false;
+            }
+            
+            return true;
+        }
+
+        /// <summary>
+        /// Gets a qualified member access expression for <c>CancellationToken.None</c>.
+        /// </summary>
+        /// <param name="typeSyntax">The type syntax from the original constructor.</param>
+        /// <returns>A new member access expression.</returns>
+        private static SyntaxNode GetCancellationTokenNoneSyntax(TypeSyntax typeSyntax)
         {
             return SyntaxFactory.MemberAccessExpression(
                 SyntaxKind.SimpleMemberAccessExpression,
-                nameSyntax,
+                typeSyntax,
                 SyntaxFactory.IdentifierName(nameof(CancellationToken.None)));
         }
 
@@ -101,10 +131,11 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi
                 }
 
                 var syntaxRoot = await document.GetSyntaxRootAsync(fixAllContext.CancellationToken).ConfigureAwait(false);
+                var semanticModel = await document.GetSemanticModelAsync().ConfigureAwait(false);
 
                 var nodes = diagnostics.Select(diagnostic => syntaxRoot.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true));
 
-                return syntaxRoot.ReplaceNodes(nodes, (originalNode, rewrittenNode) => GetReplacementNode(rewrittenNode));
+                return syntaxRoot.ReplaceNodes(nodes, (originalNode, rewrittenNode) => GetReplacementNode(rewrittenNode, semanticModel, CancellationToken.None));
             }
         }
     }

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

@@ -357,6 +357,52 @@ public void TestMethod()
             await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Verifies that <c>new CancellationToken()</c> is <b>not</b> replaced by <c>CancellationToken.None</c>
+        /// if the qualified name is not exactly <c>System.Threading.CancellationToken</c>.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task VerifyCustomCancellationTokenClassIsNotReplacedAsync()
+        {
+            var testCode = @"public class TestClass
+{
+    public void TestMethod()
+    {
+        var ct = new CancellationToken();
+    }
+
+    private struct CancellationToken
+    {
+        public int TestProperty { get; set; }
+    }
+}
+";
+
+            var fixedTestCode = @"public class TestClass
+{
+    public void TestMethod()
+    {
+        var ct = default(CancellationToken);
+    }
+
+    private struct CancellationToken
+    {
+        public int TestProperty { get; set; }
+    }
+}
+";
+
+            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()
         {