Reduce the number of memory allocations in SA1404 (CodeAnalysisSuppressionMustHaveJustification)

StyleCop.Analyzers/StyleCop.Analyzers.Test/MaintainabilityRules/SA1404UnitTests.cs

@@ -20,6 +20,22 @@ public async Task TestSuppressionWithStringLiteralAsync()
     public void Bar()
     {
 
+    }
+}";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestSuppressionWithStringLiteralAndUsingAliasDirectiveAsync()
+        {
+            var testCode = @"using SuppressMessageAttribute = System.Diagnostics.CodeAnalysis.SuppressMessageAttribute;
+public class Foo
+{
+    [SuppressMessage(null, null, Justification = ""a justification"")]
+    public void Bar()
+    {
+
     }
 }";
 
@@ -43,6 +59,42 @@ public void Bar()
             await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestSuppressionWithUsingAliasDirectiveAndNoJustificationAsync()
+        {
+            var testCode = @"using SuppressMessageAttribute = System.Diagnostics.CodeAnalysis.SuppressMessageAttribute;
+public class Foo
+{
+    [SuppressMessage(null, null)]
+    public void Bar()
+    {
+
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(4, 6);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestSuppressionWithUsingDifferentAliasDirectiveAndNoJustificationAsync()
+        {
+            var testCode = @"using MySuppressionAttribute = System.Diagnostics.CodeAnalysis.SuppressMessageAttribute;
+public class Foo
+{
+    [MySuppression(null, null)]
+    public void Bar()
+    {
+
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(4, 6);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestSuppressionWithEmptyJustificationAsync()
         {

StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1404CodeAnalysisSuppressionMustHaveJustification.cs

@@ -2,6 +2,7 @@
 {
     using System.Collections.Immutable;
     using System.Diagnostics.CodeAnalysis;
+    using Helpers;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -54,25 +55,61 @@ public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
         /// <inheritdoc/>
         public override void Initialize(AnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(this.HandleAttributeNode, SyntaxKind.Attribute);
+            context.RegisterCompilationStartAction(HandleCompilationStart);
         }
 
-        private void HandleAttributeNode(SyntaxNodeAnalysisContext context)
+        private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            var attribute = context.Node as AttributeSyntax;
-            if (attribute != null)
+            AnalyzerInstance instance = new AnalyzerInstance();
+            context.RegisterSyntaxNodeActionHonorExclusions(instance.HandleAttributeNode, SyntaxKind.Attribute);
+        }
+
+        /// <summary>
+        /// This class holds analyzer state information for analysis within a particular <see cref="Compilation"/>.
+        /// </summary>
+        private sealed class AnalyzerInstance
+        {
+            /// <summary>
+            /// A lazily-initialized reference to <see cref="SuppressMessageAttribute"/> within the context of a
+            /// particular <see cref="Compilation"/>.
+            /// </summary>
+            private INamedTypeSymbol suppressMessageAttribute;
+
+            public void HandleAttributeNode(SyntaxNodeAnalysisContext context)
             {
+                var attribute = (AttributeSyntax)context.Node;
+
+                // Return fast if the name doesn't match and the file doesn't contain any using alias directives
+                if (!attribute.SyntaxTree.ContainsUsingAlias())
+                {
+                    SimpleNameSyntax simpleNameSyntax = attribute.Name as SimpleNameSyntax;
+                    if (simpleNameSyntax == null)
+                    {
+                        QualifiedNameSyntax qualifiedNameSyntax = attribute.Name as QualifiedNameSyntax;
+                        simpleNameSyntax = qualifiedNameSyntax.Right;
+                    }
+
+                    if (simpleNameSyntax.Identifier.ValueText != nameof(SuppressMessageAttribute)
+                        && simpleNameSyntax.Identifier.ValueText != "SuppressMessage")
+                    {
+                        return;
+                    }
+                }
+
                 SymbolInfo symbolInfo = context.SemanticModel.GetSymbolInfo(attribute);
                 ISymbol symbol = symbolInfo.Symbol;
                 if (symbol != null)
                 {
-                    var suppressMessageType = context.SemanticModel.Compilation.GetTypeByMetadataName(typeof(SuppressMessageAttribute).FullName);
-                    if (symbol.ContainingType == suppressMessageType)
+                    if (this.suppressMessageAttribute == null)
+                    {
+                        this.suppressMessageAttribute = context.SemanticModel.Compilation.GetTypeByMetadataName(typeof(SuppressMessageAttribute).FullName);
+                    }
+
+                    if (symbol.ContainingType == this.suppressMessageAttribute)
                     {
-                        foreach (var argument in attribute.ArgumentList.ChildNodes())
+                        foreach (var attributeArgument in attribute.ArgumentList.Arguments)
                         {
-                            var attributeArgument = argument as AttributeArgumentSyntax;
-                            if (attributeArgument?.NameEquals?.Name?.Identifier.ValueText == nameof(SuppressMessageAttribute.Justification))
+                            if (attributeArgument.NameEquals?.Name?.Identifier.ValueText == nameof(SuppressMessageAttribute.Justification))
                             {
                                 // Check if the justification is not empty
                                 var value = context.SemanticModel.GetConstantValue(attributeArgument.Expression);