Merge pull request #5252 from Youssef1313/cleanup

mavasani · web-flow · commit a4ffd4f27aa2 · 2021-11-21T21:59:03.000-08:00
General cleanup
diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/EquatableAnalyzer.cs b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/EquatableAnalyzer.cs
@@ -49,9 +49,8 @@ public override void Initialize(AnalysisContext context)
 
         private static void OnCompilationStart(CompilationStartAnalysisContext context)
         {
-            INamedTypeSymbol? objectType = context.Compilation.GetSpecialType(SpecialType.System_Object);
             INamedTypeSymbol? equatableType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemIEquatable1);
-            if (objectType != null && equatableType != null)
+            if (equatableType != null)
             {
                 context.RegisterSymbolAction(c => AnalyzeSymbol(c, equatableType), SymbolKind.NamedType);
             }
diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/PassSystemUriObjectsInsteadOfStrings.cs b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/PassSystemUriObjectsInsteadOfStrings.cs
@@ -43,15 +43,14 @@ public override void Initialize(AnalysisContext context)
 
             context.RegisterCompilationStartAction(c =>
             {
-                INamedTypeSymbol? @string = c.Compilation.GetSpecialType(SpecialType.System_String);
                 INamedTypeSymbol? uri = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemUri);
-                if (@string == null || uri == null)
+                if (uri == null)
                 {
                     // we don't have required types
                     return;
                 }
 
-                var analyzer = new PerCompilationAnalyzer(c.Compilation, @string, uri, GetInvocationExpression);
+                var analyzer = new PerCompilationAnalyzer(c.Compilation, uri, GetInvocationExpression);
                 c.RegisterOperationAction(analyzer.Analyze, OperationKind.Invocation);
             });
         }
@@ -62,18 +61,15 @@ private sealed class PerCompilationAnalyzer
         {
             // this type will be created per compilation
             private readonly Compilation _compilation;
-            private readonly INamedTypeSymbol _string;
             private readonly INamedTypeSymbol _uri;
             private readonly Func<SyntaxNode, SyntaxNode?> _expressionGetter;
 
             public PerCompilationAnalyzer(
                 Compilation compilation,
-                INamedTypeSymbol @string,
                 INamedTypeSymbol uri,
                 Func<SyntaxNode, SyntaxNode?> expressionGetter)
             {
                 _compilation = compilation;
-                _string = @string;
                 _uri = uri;
                 _expressionGetter = expressionGetter;
             }
@@ -105,7 +101,7 @@ public void Analyze(OperationAnalysisContext context)
                     return;
                 }
 
-                var stringParameters = method.Parameters.GetParametersOfType(_string);
+                var stringParameters = method.Parameters.GetParametersOfType(SpecialType.System_String);
                 if (!stringParameters.Any())
                 {
                     // no string parameter. not interested.
diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/UriParametersShouldNotBeStrings.cs b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/UriParametersShouldNotBeStrings.cs
@@ -41,29 +41,26 @@ public override void Initialize(AnalysisContext context)
 
             context.RegisterCompilationStartAction(c =>
             {
-                var @string = c.Compilation.GetSpecialType(SpecialType.System_String);
                 var uri = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemUri);
                 var attribute = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemAttribute);
-                if (@string == null || uri == null || attribute == null)
+                if (uri == null || attribute == null)
                 {
                     // we don't have required types
                     return;
                 }
 
-                var analyzer = new PerCompilationAnalyzer(@string, uri, attribute);
+                var analyzer = new PerCompilationAnalyzer(uri, attribute);
                 c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Method);
             });
         }
 
         private class PerCompilationAnalyzer
         {
-            private readonly INamedTypeSymbol _string;
             private readonly INamedTypeSymbol _uri;
             private readonly INamedTypeSymbol _attribute;
 
-            public PerCompilationAnalyzer(INamedTypeSymbol @string, INamedTypeSymbol uri, INamedTypeSymbol attribute)
+            public PerCompilationAnalyzer(INamedTypeSymbol uri, INamedTypeSymbol attribute)
             {
-                _string = @string;
                 _uri = uri;
                 _attribute = attribute;
             }
@@ -87,7 +84,7 @@ public void Analyze(SymbolAnalysisContext context)
                     return;
                 }
 
-                var stringParameters = method.Parameters.GetParametersOfType(_string);
+                var stringParameters = method.Parameters.GetParametersOfType(SpecialType.System_String);
                 if (!stringParameters.Any())
                 {
                     // no string parameter. not interested.
diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/UriPropertiesShouldNotBeStrings.cs b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/UriPropertiesShouldNotBeStrings.cs
@@ -40,27 +40,24 @@ public override void Initialize(AnalysisContext context)
 
             context.RegisterCompilationStartAction(c =>
             {
-                var @string = c.Compilation.GetSpecialType(SpecialType.System_String);
                 var attribute = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemAttribute);
-                if (@string == null || attribute == null)
+                if (attribute == null)
                 {
                     // we don't have required types
                     return;
                 }
 
-                var analyzer = new PerCompilationAnalyzer(@string, attribute);
+                var analyzer = new PerCompilationAnalyzer(attribute);
                 c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Property);
             });
         }
 
         private class PerCompilationAnalyzer
         {
-            private readonly INamedTypeSymbol _string;
             private readonly INamedTypeSymbol _attribute;
 
-            public PerCompilationAnalyzer(INamedTypeSymbol @string, INamedTypeSymbol attribute)
+            public PerCompilationAnalyzer(INamedTypeSymbol attribute)
             {
-                _string = @string;
                 _attribute = attribute;
             }
 
@@ -83,7 +80,7 @@ public void Analyze(SymbolAnalysisContext context)
                     return;
                 }
 
-                if (property.Type?.Equals(_string) != true)
+                if (property.Type?.SpecialType != SpecialType.System_String)
                 {
                     // not expected type
                     return;
diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/UriReturnValuesShouldNotBeStrings.cs b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/UriReturnValuesShouldNotBeStrings.cs
@@ -40,27 +40,24 @@ public override void Initialize(AnalysisContext context)
 
             context.RegisterCompilationStartAction(c =>
             {
-                var @string = c.Compilation.GetSpecialType(SpecialType.System_String);
                 var uri = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemUri);
-                if (@string == null || uri == null)
+                if (uri == null)
                 {
                     // we don't have required types
                     return;
                 }
 
-                var analyzer = new PerCompilationAnalyzer(@string, uri);
+                var analyzer = new PerCompilationAnalyzer(uri);
                 c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Method);
             });
         }
 
         private class PerCompilationAnalyzer
         {
-            private readonly INamedTypeSymbol _string;
             private readonly INamedTypeSymbol _uri;
 
-            public PerCompilationAnalyzer(INamedTypeSymbol @string, INamedTypeSymbol uri)
+            public PerCompilationAnalyzer(INamedTypeSymbol uri)
             {
-                _string = @string;
                 _uri = uri;
             }
 
@@ -83,7 +80,7 @@ public void Analyze(SymbolAnalysisContext context)
                     return;
                 }
 
-                if (method.IsAccessorMethod() || method.ReturnType?.Equals(_string) != true)
+                if (method.IsAccessorMethod() || method.ReturnType?.SpecialType != SpecialType.System_String)
                 {
                     // return type must be string and it must be not an accessor method
                     return;
diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/AvoidZeroLengthArrayAllocations.Fixer.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/AvoidZeroLengthArrayAllocations.Fixer.cs
@@ -6,7 +6,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Analyzer.Utilities;
-using Analyzer.Utilities.Extensions;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.Editing;
@@ -51,7 +50,7 @@ private static async Task<Document> ConvertToArrayEmptyAsync(Document document,
             SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             SyntaxGenerator generator = editor.Generator;
 
-            INamedTypeSymbol? arrayTypeSymbol = semanticModel.Compilation.GetOrCreateTypeByMetadataName(AvoidZeroLengthArrayAllocationsAnalyzer.ArrayTypeName);
+            INamedTypeSymbol? arrayTypeSymbol = semanticModel.Compilation.GetSpecialType(SpecialType.System_Array);
             if (arrayTypeSymbol == null)
             {
                 return document;
diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/AvoidZeroLengthArrayAllocations.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/AvoidZeroLengthArrayAllocations.cs
@@ -18,9 +18,6 @@ public abstract class AvoidZeroLengthArrayAllocationsAnalyzer : DiagnosticAnalyz
     {
         internal const string RuleId = "CA1825";
 
-        /// <summary>The name of the array type.</summary>
-        internal const string ArrayTypeName = "System.Array"; // using instead of GetSpecialType to make more testable
-
         /// <summary>The name of the Empty method on System.Array.</summary>
         internal const string ArrayEmptyMethodName = "Empty";
 
@@ -52,24 +49,24 @@ public sealed override void Initialize(AnalysisContext context)
             // Only if it is, register the syntax node action provided by the derived implementations.
             context.RegisterCompilationStartAction(ctx =>
             {
-                INamedTypeSymbol? typeSymbol = ctx.Compilation.GetOrCreateTypeByMetadataName(ArrayTypeName);
-                if (typeSymbol != null && typeSymbol.DeclaredAccessibility == Accessibility.Public)
+                INamedTypeSymbol typeSymbol = ctx.Compilation.GetSpecialType(SpecialType.System_Array);
+                if (typeSymbol.DeclaredAccessibility == Accessibility.Public)
                 {
                     if (typeSymbol.GetMembers(ArrayEmptyMethodName).FirstOrDefault() is IMethodSymbol methodSymbol && methodSymbol.DeclaredAccessibility == Accessibility.Public &&
-    methodSymbol.IsStatic && methodSymbol.Arity == 1 && methodSymbol.Parameters.IsEmpty)
+                        methodSymbol.IsStatic && methodSymbol.Arity == 1 && methodSymbol.Parameters.IsEmpty)
                     {
-                        ctx.RegisterOperationAction(AnalyzeOperation, OperationKind.ArrayCreation);
+                        ctx.RegisterOperationAction(c => AnalyzeOperation(c, methodSymbol), OperationKind.ArrayCreation);
                     }
                 }
             });
         }
 
-        private void AnalyzeOperation(OperationAnalysisContext context)
+        private void AnalyzeOperation(OperationAnalysisContext context, IMethodSymbol arrayEmptyMethodSymbol)
         {
-            AnalyzeOperation(context, IsAttributeSyntax);
+            AnalyzeOperation(context, arrayEmptyMethodSymbol, IsAttributeSyntax);
         }
 
-        private static void AnalyzeOperation(OperationAnalysisContext context, Func<SyntaxNode, bool> isAttributeSytnax)
+        private static void AnalyzeOperation(OperationAnalysisContext context, IMethodSymbol arrayEmptyMethodSymbol, Func<SyntaxNode, bool> isAttributeSytnax)
         {
             IArrayCreationOperation arrayCreationExpression = (IArrayCreationOperation)context.Operation;
 
@@ -108,14 +105,7 @@ private static void AnalyzeOperation(OperationAnalysisContext context, Func<Synt
 
                     if (elementType.TypeKind != TypeKind.Pointer)
                     {
-                        var arrayType = context.Compilation.GetOrCreateTypeByMetadataName(ArrayTypeName);
-                        if (arrayType == null)
-                        {
-                            return;
-                        }
-
-                        IMethodSymbol emptyMethod = (IMethodSymbol)arrayType.GetMembers(ArrayEmptyMethodName).First();
-                        var constructed = emptyMethod.Construct(elementType);
+                        var constructed = arrayEmptyMethodSymbol.Construct(elementType);
 
                         string typeName = constructed.ToDisplayString(ReportFormat);
                         context.ReportDiagnostic(arrayCreationExpression.Syntax.CreateDiagnostic(UseArrayEmptyDescriptor, typeName));
diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/DoNotUseReferenceEqualsWithValueTypes.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/DoNotUseReferenceEqualsWithValueTypes.cs
@@ -53,11 +53,6 @@ public override void Initialize(AnalysisContext context)
             {
                 var objectType = compilationStartContext.Compilation.GetSpecialType(SpecialType.System_Object);
 
-                if (objectType == null)
-                {
-                    return;
-                }
-
                 var objectObjectParameters = new[]
                 {
                     ParameterInfo.GetParameterInfo(objectType),
diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/NormalizeStringsToUppercase.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/NormalizeStringsToUppercase.cs
@@ -41,10 +41,6 @@ public sealed class NormalizeStringsToUppercaseAnalyzer : AbstractGlobalizationD
         protected override void InitializeWorker(CompilationStartAnalysisContext context)
         {
             var stringType = context.Compilation.GetSpecialType(SpecialType.System_String);
-            if (stringType == null)
-            {
-                return;
-            }
 
             var cultureInfo = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemGlobalizationCultureInfo);
             var invariantCulture = cultureInfo?.GetMembers("InvariantCulture").OfType<IPropertySymbol>().FirstOrDefault();
diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/PreferStringContainsOverIndexOfAnalyzer.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/PreferStringContainsOverIndexOfAnalyzer.cs
@@ -38,8 +38,8 @@ public override void Initialize(AnalysisContext context)
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
             context.RegisterCompilationStartAction(context =>
             {
-                if (!context.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemString, out INamedTypeSymbol? stringType) ||
-                    !context.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemChar, out INamedTypeSymbol? charType) ||
+                if (context.Compilation.GetSpecialType(SpecialType.System_String) is not INamedTypeSymbol stringType ||
+                    context.Compilation.GetSpecialType(SpecialType.System_Char) is not INamedTypeSymbol charType ||
                     !context.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemStringComparison, out INamedTypeSymbol? stringComparisonType))
                 {
                     return;
diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/SpecifyIFormatProvider.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/SpecifyIFormatProvider.cs
@@ -82,10 +82,6 @@ protected override void InitializeWorker(CompilationStartAnalysisContext context
 
             var objectType = context.Compilation.GetSpecialType(SpecialType.System_Object);
             var stringType = context.Compilation.GetSpecialType(SpecialType.System_String);
-            if (objectType == null || stringType == null)
-            {
-                return;
-            }
 
             var charType = context.Compilation.GetSpecialType(SpecialType.System_Char);
             var boolType = context.Compilation.GetSpecialType(SpecialType.System_Boolean);
diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/SpecifyStringComparison.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/SpecifyStringComparison.cs
@@ -54,7 +54,7 @@ protected override void InitializeWorker(CompilationStartAnalysisContext context
             var stringType = context.Compilation.GetSpecialType(SpecialType.System_String);
 
             // Without these symbols the rule cannot run
-            if (stringComparisonType == null || stringType == null)
+            if (stringComparisonType == null)
             {
                 return;
             }
diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/TestForNaNCorrectly.Fixer.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/TestForNaNCorrectly.Fixer.cs
@@ -37,16 +37,7 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
             }
 
             SemanticModel model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
-
-            INamedTypeSymbol? systemSingleType = model.Compilation.GetSpecialType(SpecialType.System_Single);
-            INamedTypeSymbol? systemDoubleType = model.Compilation.GetSpecialType(SpecialType.System_Double);
-
-            if (systemSingleType == null || systemDoubleType == null)
-            {
-                return;
-            }
-
-            FixResolution? resolution = TryGetFixResolution(binaryExpressionSyntax, model, systemSingleType, systemDoubleType, context.CancellationToken);
+            FixResolution? resolution = TryGetFixResolution(binaryExpressionSyntax, model, context.CancellationToken);
 
             if (resolution != null)
             {
@@ -58,19 +49,19 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
             }
         }
 
-        private FixResolution? TryGetFixResolution(SyntaxNode binaryExpressionSyntax, SemanticModel model, INamedTypeSymbol systemSingleType, INamedTypeSymbol systemDoubleType, CancellationToken cancellationToken)
+        private FixResolution? TryGetFixResolution(SyntaxNode binaryExpressionSyntax, SemanticModel model, CancellationToken cancellationToken)
         {
             bool isEqualsOperator = IsEqualsOperator(binaryExpressionSyntax);
             SyntaxNode leftOperand = GetLeftOperand(binaryExpressionSyntax);
             SyntaxNode rightOperand = GetRightOperand(binaryExpressionSyntax);
 
-            ITypeSymbol? systemTypeLeft = TryGetSystemTypeForNanConstantExpression(leftOperand, model, systemSingleType, systemDoubleType, cancellationToken);
+            ITypeSymbol? systemTypeLeft = TryGetSystemTypeForNanConstantExpression(leftOperand, model, cancellationToken);
             if (systemTypeLeft != null)
             {
                 return new FixResolution(binaryExpressionSyntax, systemTypeLeft, rightOperand, isEqualsOperator);
             }
 
-            ITypeSymbol? systemTypeRight = TryGetSystemTypeForNanConstantExpression(rightOperand, model, systemSingleType, systemDoubleType, cancellationToken);
+            ITypeSymbol? systemTypeRight = TryGetSystemTypeForNanConstantExpression(rightOperand, model, cancellationToken);
             if (systemTypeRight != null)
             {
                 return new FixResolution(binaryExpressionSyntax, systemTypeRight, leftOperand, isEqualsOperator);
@@ -79,17 +70,12 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
             return null;
         }
 
-        private static ITypeSymbol? TryGetSystemTypeForNanConstantExpression(SyntaxNode expressionSyntax, SemanticModel model, INamedTypeSymbol systemSingleType, INamedTypeSymbol systemDoubleType, CancellationToken cancellationToken)
+        private static ITypeSymbol? TryGetSystemTypeForNanConstantExpression(SyntaxNode expressionSyntax, SemanticModel model, CancellationToken cancellationToken)
         {
-            if (model.GetSymbolInfo(expressionSyntax, cancellationToken).Symbol is IFieldSymbol fieldSymbol)
+            var symbol = model.GetSymbolInfo(expressionSyntax, cancellationToken).Symbol;
+            if (symbol is IFieldSymbol { HasConstantValue: true, Name: "NaN", Type: { SpecialType: SpecialType.System_Single or SpecialType.System_Double } type })
             {
-                if (fieldSymbol.Type.Equals(systemSingleType) || fieldSymbol.Type.Equals(systemDoubleType))
-                {
-                    if (fieldSymbol.HasConstantValue && fieldSymbol.Name == "NaN")
-                    {
-                        return fieldSymbol.Type;
-                    }
-                }
+                return type;
             }
 
             return null;
diff --git a/src/PerformanceSensitiveAnalyzers/CSharp/CodeFixes/AvoidAllocationWithArrayEmptyCodeFix.cs b/src/PerformanceSensitiveAnalyzers/CSharp/CodeFixes/AvoidAllocationWithArrayEmptyCodeFix.cs
diff --git a/src/Utilities/Compiler/Extensions/ISymbolExtensions.cs b/src/Utilities/Compiler/Extensions/ISymbolExtensions.cs
diff --git a/src/Utilities/Compiler/FxCopWellKnownDiagnosticTags.cs b/src/Utilities/Compiler/FxCopWellKnownDiagnosticTags.cs
diff --git a/src/Utilities/Compiler/WellKnownTypeNames.cs b/src/Utilities/Compiler/WellKnownTypeNames.cs

Original file line number	Diff line number	Diff line change
`@@ -49,9 +49,8 @@ public override void Initialize(AnalysisContext context)`
`49`	`49`
`50`	`50`	`private static void OnCompilationStart(CompilationStartAnalysisContext context)`
`51`	`51`	`{`
`52`		`- INamedTypeSymbol? objectType = context.Compilation.GetSpecialType(SpecialType.System_Object);`
`53`	`52`	`INamedTypeSymbol? equatableType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemIEquatable1);`
`54`		`- if (objectType != null && equatableType != null)`
	`53`	`+ if (equatableType != null)`
`55`	`54`	`{`
`56`	`55`	`context.RegisterSymbolAction(c => AnalyzeSymbol(c, equatableType), SymbolKind.NamedType);`
`57`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,15 +43,14 @@ public override void Initialize(AnalysisContext context)`
`43`	`43`
`44`	`44`	`context.RegisterCompilationStartAction(c =>`
`45`	`45`	`{`
`46`		`- INamedTypeSymbol? @string = c.Compilation.GetSpecialType(SpecialType.System_String);`
`47`	`46`	`INamedTypeSymbol? uri = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemUri);`
`48`		`- if (@string == null \|\| uri == null)`
	`47`	`+ if (uri == null)`
`49`	`48`	`{`
`50`	`49`	`// we don't have required types`
`51`	`50`	`return;`
`52`	`51`	`}`
`53`	`52`
`54`		`- var analyzer = new PerCompilationAnalyzer(c.Compilation, @string, uri, GetInvocationExpression);`
	`53`	`+ var analyzer = new PerCompilationAnalyzer(c.Compilation, uri, GetInvocationExpression);`
`55`	`54`	`c.RegisterOperationAction(analyzer.Analyze, OperationKind.Invocation);`
`56`	`55`	`});`
`57`	`56`	`}`
`@@ -62,18 +61,15 @@ private sealed class PerCompilationAnalyzer`
`62`	`61`	`{`
`63`	`62`	`// this type will be created per compilation`
`64`	`63`	`private readonly Compilation _compilation;`
`65`		`- private readonly INamedTypeSymbol _string;`
`66`	`64`	`private readonly INamedTypeSymbol _uri;`
`67`	`65`	`private readonly Func<SyntaxNode, SyntaxNode?> _expressionGetter;`
`68`	`66`
`69`	`67`	`public PerCompilationAnalyzer(`
`70`	`68`	`Compilation compilation,`
`71`		`- INamedTypeSymbol @string,`
`72`	`69`	`INamedTypeSymbol uri,`
`73`	`70`	`Func<SyntaxNode, SyntaxNode?> expressionGetter)`
`74`	`71`	`{`
`75`	`72`	`_compilation = compilation;`
`76`		`- _string = @string;`
`77`	`73`	`_uri = uri;`
`78`	`74`	`_expressionGetter = expressionGetter;`
`79`	`75`	`}`
`@@ -105,7 +101,7 @@ public void Analyze(OperationAnalysisContext context)`
`105`	`101`	`return;`
`106`	`102`	`}`
`107`	`103`
`108`		`- var stringParameters = method.Parameters.GetParametersOfType(_string);`
	`104`	`+ var stringParameters = method.Parameters.GetParametersOfType(SpecialType.System_String);`
`109`	`105`	`if (!stringParameters.Any())`
`110`	`106`	`{`
`111`	`107`	`// no string parameter. not interested.`
Original file line number	Diff line number	Diff line change
`@@ -41,29 +41,26 @@ public override void Initialize(AnalysisContext context)`
`41`	`41`
`42`	`42`	`context.RegisterCompilationStartAction(c =>`
`43`	`43`	`{`
`44`		`- var @string = c.Compilation.GetSpecialType(SpecialType.System_String);`
`45`	`44`	`var uri = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemUri);`
`46`	`45`	`var attribute = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemAttribute);`
`47`		`- if (@string == null \|\| uri == null \|\| attribute == null)`
	`46`	`+ if (uri == null \|\| attribute == null)`
`48`	`47`	`{`
`49`	`48`	`// we don't have required types`
`50`	`49`	`return;`
`51`	`50`	`}`
`52`	`51`
`53`		`- var analyzer = new PerCompilationAnalyzer(@string, uri, attribute);`
	`52`	`+ var analyzer = new PerCompilationAnalyzer(uri, attribute);`
`54`	`53`	`c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Method);`
`55`	`54`	`});`
`56`	`55`	`}`
`57`	`56`
`58`	`57`	`private class PerCompilationAnalyzer`
`59`	`58`	`{`
`60`		`- private readonly INamedTypeSymbol _string;`
`61`	`59`	`private readonly INamedTypeSymbol _uri;`
`62`	`60`	`private readonly INamedTypeSymbol _attribute;`
`63`	`61`
`64`		`- public PerCompilationAnalyzer(INamedTypeSymbol @string, INamedTypeSymbol uri, INamedTypeSymbol attribute)`
	`62`	`+ public PerCompilationAnalyzer(INamedTypeSymbol uri, INamedTypeSymbol attribute)`
`65`	`63`	`{`
`66`		`- _string = @string;`
`67`	`64`	`_uri = uri;`
`68`	`65`	`_attribute = attribute;`
`69`	`66`	`}`
`@@ -87,7 +84,7 @@ public void Analyze(SymbolAnalysisContext context)`
`87`	`84`	`return;`
`88`	`85`	`}`
`89`	`86`
`90`		`- var stringParameters = method.Parameters.GetParametersOfType(_string);`
	`87`	`+ var stringParameters = method.Parameters.GetParametersOfType(SpecialType.System_String);`
`91`	`88`	`if (!stringParameters.Any())`
`92`	`89`	`{`
`93`	`90`	`// no string parameter. not interested.`
Original file line number	Diff line number	Diff line change
`@@ -40,27 +40,24 @@ public override void Initialize(AnalysisContext context)`
`40`	`40`
`41`	`41`	`context.RegisterCompilationStartAction(c =>`
`42`	`42`	`{`
`43`		`- var @string = c.Compilation.GetSpecialType(SpecialType.System_String);`
`44`	`43`	`var attribute = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemAttribute);`
`45`		`- if (@string == null \|\| attribute == null)`
	`44`	`+ if (attribute == null)`
`46`	`45`	`{`
`47`	`46`	`// we don't have required types`
`48`	`47`	`return;`
`49`	`48`	`}`
`50`	`49`
`51`		`- var analyzer = new PerCompilationAnalyzer(@string, attribute);`
	`50`	`+ var analyzer = new PerCompilationAnalyzer(attribute);`
`52`	`51`	`c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Property);`
`53`	`52`	`});`
`54`	`53`	`}`
`55`	`54`
`56`	`55`	`private class PerCompilationAnalyzer`
`57`	`56`	`{`
`58`		`- private readonly INamedTypeSymbol _string;`
`59`	`57`	`private readonly INamedTypeSymbol _attribute;`
`60`	`58`
`61`		`- public PerCompilationAnalyzer(INamedTypeSymbol @string, INamedTypeSymbol attribute)`
	`59`	`+ public PerCompilationAnalyzer(INamedTypeSymbol attribute)`
`62`	`60`	`{`
`63`		`- _string = @string;`
`64`	`61`	`_attribute = attribute;`
`65`	`62`	`}`
`66`	`63`
`@@ -83,7 +80,7 @@ public void Analyze(SymbolAnalysisContext context)`
`83`	`80`	`return;`
`84`	`81`	`}`
`85`	`82`
`86`		`- if (property.Type?.Equals(_string) != true)`
	`83`	`+ if (property.Type?.SpecialType != SpecialType.System_String)`
`87`	`84`	`{`
`88`	`85`	`// not expected type`
`89`	`86`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -18,9 +18,6 @@ public abstract class AvoidZeroLengthArrayAllocationsAnalyzer : DiagnosticAnalyz`
`18`	`18`	`{`
`19`	`19`	`internal const string RuleId = "CA1825";`
`20`	`20`
`21`		`- /// <summary>The name of the array type.</summary>`
`22`		`- internal const string ArrayTypeName = "System.Array"; // using instead of GetSpecialType to make more testable`
`23`		`-`
`24`	`21`	`/// <summary>The name of the Empty method on System.Array.</summary>`
`25`	`22`	`internal const string ArrayEmptyMethodName = "Empty";`
`26`	`23`
`@@ -52,24 +49,24 @@ public sealed override void Initialize(AnalysisContext context)`
`52`	`49`	`// Only if it is, register the syntax node action provided by the derived implementations.`
`53`	`50`	`context.RegisterCompilationStartAction(ctx =>`
`54`	`51`	`{`
`55`		`- INamedTypeSymbol? typeSymbol = ctx.Compilation.GetOrCreateTypeByMetadataName(ArrayTypeName);`
`56`		`- if (typeSymbol != null && typeSymbol.DeclaredAccessibility == Accessibility.Public)`
	`52`	`+ INamedTypeSymbol typeSymbol = ctx.Compilation.GetSpecialType(SpecialType.System_Array);`
	`53`	`+ if (typeSymbol.DeclaredAccessibility == Accessibility.Public)`
`57`	`54`	`{`
`58`	`55`	`if (typeSymbol.GetMembers(ArrayEmptyMethodName).FirstOrDefault() is IMethodSymbol methodSymbol && methodSymbol.DeclaredAccessibility == Accessibility.Public &&`
`59`		`- methodSymbol.IsStatic && methodSymbol.Arity == 1 && methodSymbol.Parameters.IsEmpty)`
	`56`	`+ methodSymbol.IsStatic && methodSymbol.Arity == 1 && methodSymbol.Parameters.IsEmpty)`
`60`	`57`	`{`
`61`		`- ctx.RegisterOperationAction(AnalyzeOperation, OperationKind.ArrayCreation);`
	`58`	`+ ctx.RegisterOperationAction(c => AnalyzeOperation(c, methodSymbol), OperationKind.ArrayCreation);`
`62`	`59`	`}`
`63`	`60`	`}`
`64`	`61`	`});`
`65`	`62`	`}`
`66`	`63`
`67`		`- private void AnalyzeOperation(OperationAnalysisContext context)`
	`64`	`+ private void AnalyzeOperation(OperationAnalysisContext context, IMethodSymbol arrayEmptyMethodSymbol)`
`68`	`65`	`{`
`69`		`- AnalyzeOperation(context, IsAttributeSyntax);`
	`66`	`+ AnalyzeOperation(context, arrayEmptyMethodSymbol, IsAttributeSyntax);`
`70`	`67`	`}`
`71`	`68`
`72`		`- private static void AnalyzeOperation(OperationAnalysisContext context, Func<SyntaxNode, bool> isAttributeSytnax)`
	`69`	`+ private static void AnalyzeOperation(OperationAnalysisContext context, IMethodSymbol arrayEmptyMethodSymbol, Func<SyntaxNode, bool> isAttributeSytnax)`
`73`	`70`	`{`
`74`	`71`	`IArrayCreationOperation arrayCreationExpression = (IArrayCreationOperation)context.Operation;`
`75`	`72`
`@@ -108,14 +105,7 @@ private static void AnalyzeOperation(OperationAnalysisContext context, Func<Synt`
`108`	`105`
`109`	`106`	`if (elementType.TypeKind != TypeKind.Pointer)`
`110`	`107`	`{`
`111`		`- var arrayType = context.Compilation.GetOrCreateTypeByMetadataName(ArrayTypeName);`
`112`		`- if (arrayType == null)`
`113`		`- {`
`114`		`- return;`
`115`		`- }`
`116`		`-`
`117`		`- IMethodSymbol emptyMethod = (IMethodSymbol)arrayType.GetMembers(ArrayEmptyMethodName).First();`
`118`		`- var constructed = emptyMethod.Construct(elementType);`
	`108`	`+ var constructed = arrayEmptyMethodSymbol.Construct(elementType);`
`119`	`109`
`120`	`110`	`string typeName = constructed.ToDisplayString(ReportFormat);`
`121`	`111`	`context.ReportDiagnostic(arrayCreationExpression.Syntax.CreateDiagnostic(UseArrayEmptyDescriptor, typeName));`
Original file line number	Diff line number	Diff line change
`@@ -53,11 +53,6 @@ public override void Initialize(AnalysisContext context)`
`53`	`53`	`{`
`54`	`54`	`var objectType = compilationStartContext.Compilation.GetSpecialType(SpecialType.System_Object);`
`55`	`55`
`56`		`- if (objectType == null)`
`57`		`- {`
`58`		`- return;`
`59`		`- }`
`60`		`-`
`61`	`56`	`var objectObjectParameters = new[]`
`62`	`57`	`{`
`63`	`58`	`ParameterInfo.GetParameterInfo(objectType),`
Original file line number	Diff line number	Diff line change
`@@ -38,8 +38,8 @@ public override void Initialize(AnalysisContext context)`
`38`	`38`	`context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);`
`39`	`39`	`context.RegisterCompilationStartAction(context =>`
`40`	`40`	`{`
`41`		`- if (!context.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemString, out INamedTypeSymbol? stringType) \|\|`
`42`		`- !context.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemChar, out INamedTypeSymbol? charType) \|\|`
	`41`	`+ if (context.Compilation.GetSpecialType(SpecialType.System_String) is not INamedTypeSymbol stringType \|\|`
	`42`	`+ context.Compilation.GetSpecialType(SpecialType.System_Char) is not INamedTypeSymbol charType \|\|`
`43`	`43`	`!context.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemStringComparison, out INamedTypeSymbol? stringComparisonType))`
`44`	`44`	`{`
`45`	`45`	`return;`