Don't emit CA1861 for static ReadOnlyCollections (#6644)

* Don't warn for static ReadOnlyCollections.

* Do not warn on static initializers

---------

Co-authored-by: Buyaa Namnan <[email protected]>

Author: CollinAlpert

src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/AvoidConstArrays.cs

@@ -39,8 +39,9 @@ public override void Initialize(AnalysisContext context)
 
             context.RegisterCompilationStartAction(context =>
             {
-                INamedTypeSymbol? readonlySpanType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemReadOnlySpan1);
-                INamedTypeSymbol? functionType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemFunc2);
+                var knownTypeProvider = WellKnownTypeProvider.GetOrCreate(context.Compilation);
+                INamedTypeSymbol? readonlySpanType = knownTypeProvider.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemReadOnlySpan1);
+                INamedTypeSymbol? functionType = knownTypeProvider.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemFunc2);
 
                 // Analyzes an argument operation
                 context.RegisterOperationAction(context =>
@@ -110,12 +111,7 @@ public override void Initialize(AnalysisContext context)
                     string? paramName = null;
                     if (argumentOperation is not null)
                     {
-                        IFieldInitializerOperation? fieldInitializer = argumentOperation.GetAncestor<IFieldInitializerOperation>(
-                            OperationKind.FieldInitializer, f => f.InitializedFields.Any(x => x.IsReadOnly));
-                        IPropertyInitializerOperation? propertyInitializer = argumentOperation.GetAncestor<IPropertyInitializerOperation>(
-                            OperationKind.PropertyInitializer, p => p.InitializedProperties.Any(x => x.IsReadOnly));
-
-                        if (fieldInitializer is not null || propertyInitializer is not null)
+                        if (IsInitializingStaticOrReadOnlyFieldOrProperty(argumentOperation))
                         {
                             return;
                         }
@@ -149,5 +145,40 @@ public override void Initialize(AnalysisContext context)
                 OperationKind.Invocation);
             });
         }
+
+        private static bool IsInitializingStaticOrReadOnlyFieldOrProperty(IOperation operation)
+        {
+            var ancestor = operation;
+            do
+            {
+                ancestor = ancestor!.Parent;
+            } while (ancestor != null && !(ancestor.Kind == OperationKind.FieldInitializer || ancestor.Kind == OperationKind.PropertyInitializer ||
+                        ancestor.Kind == OperationKind.CoalesceAssignment || ancestor.Kind == OperationKind.SimpleAssignment));
+
+            if (ancestor != null)
+            {
+                switch (ancestor)
+                {
+                    case IFieldInitializerOperation fieldInitializer:
+                        return fieldInitializer.InitializedFields.Any(x => x.IsStatic || x.IsReadOnly);
+                    case IPropertyInitializerOperation propertyInitializer:
+                        return propertyInitializer.InitializedProperties.Any(x => x.IsStatic || x.IsReadOnly);
+                    case IAssignmentOperation assignmentOperation:
+                        if (assignmentOperation.Target is IFieldReferenceOperation fieldReference && fieldReference.Field.IsStatic)
+                        {
+                            return true;
+                        }
+
+                        if (assignmentOperation.Target is IPropertyReferenceOperation propertyReference && propertyReference.Property.IsStatic)
+                        {
+                            return true;
+                        }
+
+                        break;
+                }
+            }
+
+            return false;
+        }
     }
 }

src/NetAnalyzers/UnitTests/Microsoft.NetCore.Analyzers/Runtime/AvoidConstArraysTests.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp;
+using Test.Utilities;
 using Xunit;
 using VerifyCS = Test.Utilities.CSharpCodeFixVerifier<
     Microsoft.NetCore.Analyzers.Runtime.AvoidConstArraysAnalyzer,
@@ -766,6 +768,7 @@ await VerifyCS.VerifyAnalyzerAsync(@"
 
 public class A
 {
+    public readonly List<string> Field1 = GetValues(new string[] { ""close"" });
     public static readonly A Field; 
     public static List<string> Property { get; } = GetValues(new string[] { ""close"" });
     public static string[] Property2 { get; } = new string[] { ""close"" };
@@ -779,5 +782,27 @@ public A(string[] arr) { }
     private static List<string> GetValues(string[] arr) => null;
 }");
         }
+
+        [Fact, WorkItem(6629, "https://github.com/dotnet/roslyn-analyzers/issues/6629")]
+        public Task StaticReadonlyCollection_NoDiagnostic()
+        {
+            return new VerifyCS.Test
+            {
+                TestCode = @"
+#nullable enable
+using System.Collections.ObjectModel;
+
+public class Test
+{
+    private static ReadOnlyCollection<string>? s_errorPayloadNames;
+
+    private void M(string eventName, string msg)
+    {
+        s_errorPayloadNames ??= new ReadOnlyCollection<string>(new string[] { ""message"" });
+    }
+}",
+                LanguageVersion = LanguageVersion.CSharp8
+            }.RunAsync();
+        }
     }
 }