Fix handling of unrecognized naming style values

Related to #20907

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/DeclarationNameCompletionProviderTests.cs

@@ -1546,8 +1546,8 @@ private static NamingStylePreferences NamesEndWithSuffixPreferences()
                     id: null,
                     symbolSpecName: suffix,
                     ImmutableArray.Create(kind),
-                    ImmutableArray<Accessibility>.Empty,
-                    ImmutableArray<ModifierKind>.Empty);
+                    accessibilityList: default,
+                    modifiers: default);
 
                 var namingStyle = new NamingStyle(
                     Guid.NewGuid(),

src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs

@@ -57,8 +57,8 @@ private NamingStylePreferences CreateCustomFieldNamingStylePreference()
                 null,
                 "Name",
                 ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)),
-                ImmutableArray<Accessibility>.Empty,
-                ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
+                accessibilityList: default,
+                modifiers: default);
 
             var namingStyle = new NamingStyle(
                 Guid.NewGuid(),
@@ -89,7 +89,7 @@ private NamingStylePreferences CreateCustomStaticFieldNamingStylePreference()
                 null,
                 "Name",
                 ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field)),
-                ImmutableArray<Accessibility>.Empty,
+                accessibilityList: default,
                 ImmutableArray.Create(new ModifierKind(DeclarationModifiers.Static)));
 
             var namingStyle = new NamingStyle(

src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/EditorConfigNamingStyleParserTests.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
 using Roslyn.Test.Utilities;
+using Roslyn.Utilities;
 using Xunit;
 using static Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles.EditorConfigNamingStyleParser;
 using static Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles.SymbolSpecification;
@@ -90,7 +91,9 @@ public static void TestAsyncMethodsAndLocalFunctionsRule()
             AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
             Assert.Single(symbolSpec.RequiredModifierList);
             Assert.Contains(new ModifierKind(ModifierKindEnum.IsAsync), symbolSpec.RequiredModifierList);
-            Assert.Empty(symbolSpec.ApplicableAccessibilityList);
+            Assert.Equal(
+                new[] { Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal },
+                symbolSpec.ApplicableAccessibilityList);
             Assert.Equal("end_in_async_style", namingStyle.Name);
             Assert.Equal("", namingStyle.Prefix);
             Assert.Equal("Async", namingStyle.Suffix);
@@ -236,7 +239,9 @@ public static void TestParametersAndLocalsAreCamelCaseRule()
                 new SymbolKindOrTypeKind(SymbolKind.Local),
             };
             AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
-            Assert.Empty(symbolSpec.ApplicableAccessibilityList);
+            Assert.Equal(
+                new[] { Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal },
+                symbolSpec.ApplicableAccessibilityList);
             Assert.Empty(symbolSpec.RequiredModifierList);
 
             Assert.Equal("camel_case_style", namingStyle.Name);
@@ -273,7 +278,9 @@ public static void TestLocalFunctionsAreCamelCaseRule()
             Assert.Equal("local_functions", symbolSpec.Name);
             var expectedApplicableSymbolKindList = new[] { new SymbolKindOrTypeKind(MethodKind.LocalFunction) };
             AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
-            Assert.Empty(symbolSpec.ApplicableAccessibilityList);
+            Assert.Equal(
+                new[] { Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal },
+                symbolSpec.ApplicableAccessibilityList);
             Assert.Empty(symbolSpec.RequiredModifierList);
 
             Assert.Equal("camel_case_style", namingStyle.Name);
@@ -298,31 +305,79 @@ public static void TestNoRulesAreReturned()
             Assert.Empty(result.SymbolSpecifications);
         }
 
-        [Fact]
-        public static void TestApplicableAccessibilitiesParse()
+        [Theory]
+        [InlineData("property,method", new object[] { SymbolKind.Property, MethodKind.Ordinary })]
+        [InlineData("*", new object[] { TypeKind.Class, TypeKind.Struct, TypeKind.Interface, TypeKind.Enum, SymbolKind.Property, MethodKind.Ordinary, MethodKind.LocalFunction, SymbolKind.Field, SymbolKind.Event, TypeKind.Delegate, SymbolKind.Parameter, SymbolKind.Local })]
+        [InlineData(null, new object[] { TypeKind.Class, TypeKind.Struct, TypeKind.Interface, TypeKind.Enum, SymbolKind.Property, MethodKind.Ordinary, MethodKind.LocalFunction, SymbolKind.Field, SymbolKind.Event, TypeKind.Delegate, SymbolKind.Parameter, SymbolKind.Local })]
+        [InlineData("property,method,invalid", new object[] { SymbolKind.Property, MethodKind.Ordinary })]
+        [InlineData("invalid", new object[] { })]
+        [InlineData("", new object[] { })]
+        [WorkItem(20907, "https://github.com/dotnet/roslyn/issues/20907")]
+        public static void TestApplicableKindsParse(string specification, object[] typeOrSymbolKinds)
         {
-            var charpRule = new Dictionary<string, object>()
+            var rule = new Dictionary<string, object>()
             {
-                ["dotnet_naming_rule.accessibilities_parse.severity"] = "error",
-                ["dotnet_naming_rule.accessibilities_parse.symbols"] = "accessibilities",
-                ["dotnet_naming_rule.accessibilities_parse.style"] = "pascal_case",
-                ["dotnet_naming_symbols.accessibilities.applicable_accessibilities"] = "internal,protected_internal",
+                ["dotnet_naming_rule.kinds_parse.severity"] = "error",
+                ["dotnet_naming_rule.kinds_parse.symbols"] = "kinds",
+                ["dotnet_naming_rule.kinds_parse.style"] = "pascal_case",
                 ["dotnet_naming_style.pascal_case.capitalization "] = "pascal_case",
             };
-            var vbRule = new Dictionary<string, object>()
+
+            if (specification != null)
+            {
+                rule["dotnet_naming_symbols.kinds.applicable_kinds"] = specification;
+            }
+
+            var kinds = typeOrSymbolKinds
+                .Select(typeOrSymbolKind =>
+                {
+                    switch (typeOrSymbolKind)
+                    {
+                    case TypeKind typeKind:
+                        return new SymbolKindOrTypeKind(typeKind);
+
+                    case SymbolKind symbolKind:
+                        return new SymbolKindOrTypeKind(symbolKind);
+
+                    case MethodKind methodKind:
+                        return new SymbolKindOrTypeKind(methodKind);
+
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(typeOrSymbolKind);
+                    }
+                })
+                .ToArray();
+
+            var result = ParseDictionary(rule);
+            Assert.Equal(kinds, result.SymbolSpecifications.SelectMany(x => x.ApplicableSymbolKindList));
+        }
+
+        [Theory]
+        [InlineData("internal,protected_internal", new[] { Accessibility.Internal, Accessibility.ProtectedOrInternal })]
+        [InlineData("friend,protected_friend", new[] { Accessibility.Friend, Accessibility.ProtectedOrFriend })]
+        [InlineData("*", new[] { Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal })]
+        [InlineData(null, new[] { Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal })]
+        [InlineData("internal,protected,invalid", new[] { Accessibility.Internal, Accessibility.Protected })]
+        [InlineData("invalid", new Accessibility[] { })]
+        [InlineData("", new Accessibility[] { })]
+        [WorkItem(20907, "https://github.com/dotnet/roslyn/issues/20907")]
+        public static void TestApplicableAccessibilitiesParse(string specification, Accessibility[] accessibilities)
+        {
+            var rule = new Dictionary<string, object>()
             {
                 ["dotnet_naming_rule.accessibilities_parse.severity"] = "error",
                 ["dotnet_naming_rule.accessibilities_parse.symbols"] = "accessibilities",
                 ["dotnet_naming_rule.accessibilities_parse.style"] = "pascal_case",
-                ["dotnet_naming_symbols.accessibilities.applicable_accessibilities"] = "friend,protected_friend",
                 ["dotnet_naming_style.pascal_case.capitalization "] = "pascal_case",
             };
 
-            var csharpResult = ParseDictionary(charpRule);
-            var vbResult = ParseDictionary(vbRule);
+            if (specification != null)
+            {
+                rule["dotnet_naming_symbols.accessibilities.applicable_accessibilities"] = specification;
+            }
 
-            Assert.Equal(csharpResult.SymbolSpecifications.SelectMany(x => x.ApplicableAccessibilityList),
-                         vbResult.SymbolSpecifications.SelectMany(x => x.ApplicableAccessibilityList));
+            var result = ParseDictionary(rule);
+            Assert.Equal(accessibilities, result.SymbolSpecifications.SelectMany(x => x.ApplicableAccessibilityList));
         }
 
         [Fact]

src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/NamingStylesTests.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CodeFixes.NamingStyles;
 using Microsoft.CodeAnalysis.CSharp.Diagnostics.NamingStyles;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.NamingStyles;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Test.Utilities;
@@ -55,6 +57,76 @@ public async Task TestPascalCaseMethod_CorrectName()
 }", new TestParameters(options: options.MethodNamesArePascalCase));
         }
 
+        [Theory, Trait(Traits.Feature, Traits.Features.NamingStyle)]
+        [InlineData("")]
+        [InlineData("public")]
+        [InlineData("protected")]
+        [InlineData("internal")]
+        [InlineData("protected internal")]
+        [InlineData("private")]
+        [InlineData("protected private")]
+        [WorkItem(20907, "https://github.com/dotnet/roslyn/issues/20907")]
+        public async Task TestPascalCaseMethod_NoneAndDefaultAccessibilities(string accessibility)
+        {
+            await TestMissingInRegularAndScriptAsync(
+$@"class C
+{{
+    {accessibility} void [|m|]()
+    {{
+    }}
+}}", new TestParameters(options: options.MethodNamesWithAccessibilityArePascalCase(ImmutableArray<Accessibility>.Empty)));
+
+            await TestInRegularAndScriptAsync(
+$@"class C
+{{
+    {accessibility} void [|m|]()
+    {{
+    }}
+}}",
+$@"class C
+{{
+    {accessibility} void M()
+    {{
+    }}
+}}", options: options.MethodNamesWithAccessibilityArePascalCase(accessibilities: default));
+        }
+
+        [Theory, Trait(Traits.Feature, Traits.Features.NamingStyle)]
+        [InlineData("} namespace [|c2|] {", "} namespace C2 {")]
+        [InlineData("class [|c2|] { }", "class C2 { }")]
+        [InlineData("struct [|c2|] { }", "struct C2 { }")]
+        [InlineData("interface [|c2|] { }", "interface C2 { }")]
+        [InlineData("delegate void [|c2|]();", "delegate void C2();")]
+        [InlineData("enum [|c2|] { }", "enum C2 { }")]
+        [InlineData("class M<[|t|]> {}", "class M<T> {}", Skip = "https://github.com/dotnet/roslyn/issues/18121")]
+        [InlineData("void M<[|t|]>() {}", "void M<T>() {}", Skip = "https://github.com/dotnet/roslyn/issues/18121")]
+        [InlineData("int [|m|] { get; }", "int M { get; }")]
+        [InlineData("void [|m|]() {}", "void M() {}")]
+        [InlineData("void Outer() { void [|m|]() {} }", "void Outer() { void M() {} }")]
+        [InlineData("int [|m|];", "int M;")]
+        [InlineData("event System.EventHandler [|m|];", "event System.EventHandler M;")]
+        [InlineData("void Outer(int [|m|]) {}", "void Outer(int M) {}")]
+        [InlineData("void Outer() { int [|m|]; }", "void Outer() { int M; }")]
+        [WorkItem(20907, "https://github.com/dotnet/roslyn/issues/20907")]
+        public async Task TestPascalCaseSymbol_NoneAndDefaultSymbolKinds(string camelCaseSymbol, string pascalCaseSymbol)
+        {
+            await TestMissingInRegularAndScriptAsync(
+$@"class C
+{{
+    {camelCaseSymbol}
+}}", new TestParameters(options: options.SymbolKindsArePascalCase(ImmutableArray<SymbolSpecification.SymbolKindOrTypeKind>.Empty)));
+
+            await TestInRegularAndScriptAsync(
+$@"class C
+{{
+    {camelCaseSymbol}
+}}",
+$@"class C
+{{
+    {pascalCaseSymbol}
+}}", options: options.SymbolKindsArePascalCase(symbolKinds: default));
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.NamingStyle)]
         public async Task TestPascalCaseMethod_NameGetsCapitalized()
         {

src/EditorFeatures/TestUtilities/Diagnostics/NamingStyles/NamingStylesTestOptionSets.cs

@@ -49,6 +49,12 @@ public NamingStylesTestOptionSets(string languageName)
         public IDictionary<OptionKey, object> AsyncFunctionNamesEndWithAsync =>
             Options(new OptionKey(SimplificationOptions.NamingPreferences, languageName), AsyncFunctionNamesEndWithAsyncOption());
 
+        public IDictionary<OptionKey, object> MethodNamesWithAccessibilityArePascalCase(ImmutableArray<Accessibility> accessibilities) =>
+            Options(new OptionKey(SimplificationOptions.NamingPreferences, languageName), MethodNamesArePascalCaseOption(accessibilities));
+
+        internal IDictionary<OptionKey, object> SymbolKindsArePascalCase(ImmutableArray<SymbolSpecification.SymbolKindOrTypeKind> symbolKinds) =>
+            Options(new OptionKey(SimplificationOptions.NamingPreferences, languageName), SymbolKindsArePascalCaseOption(symbolKinds));
+
         private static IDictionary<OptionKey, object> Options(OptionKey option, object value)
         {
             return new Dictionary<OptionKey, object>
@@ -63,8 +69,8 @@ private static NamingStylePreferences ClassNamesArePascalCaseOption()
                 null,
                 "Name",
                 ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Class)),
-                ImmutableArray<Accessibility>.Empty,
-                ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
+                accessibilityList: default,
+                modifiers: default);
 
             var namingStyle = new NamingStyle(
                 Guid.NewGuid(),
@@ -93,8 +99,70 @@ private static NamingStylePreferences MethodNamesArePascalCaseOption()
                 null,
                 "Name",
                 ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary)),
-                ImmutableArray<Accessibility>.Empty,
-                ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
+                accessibilityList: default,
+                modifiers: default);
+
+            var namingStyle = new NamingStyle(
+                Guid.NewGuid(),
+                capitalizationScheme: Capitalization.PascalCase,
+                name: "Name",
+                prefix: "",
+                suffix: "",
+                wordSeparator: "");
+
+            var namingRule = new SerializableNamingRule()
+            {
+                SymbolSpecificationID = symbolSpecification.ID,
+                NamingStyleID = namingStyle.ID,
+                EnforcementLevel = DiagnosticSeverity.Error
+            };
+            var info = new NamingStylePreferences(
+                ImmutableArray.Create(symbolSpecification),
+                ImmutableArray.Create(namingStyle),
+                ImmutableArray.Create(namingRule));
+
+            return info;
+        }
+
+        private static NamingStylePreferences MethodNamesArePascalCaseOption(ImmutableArray<Accessibility> accessibilities)
+        {
+            var symbolSpecification = new SymbolSpecification(
+                null,
+                "Name",
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary)),
+                accessibilities,
+                modifiers: default);
+
+            var namingStyle = new NamingStyle(
+                Guid.NewGuid(),
+                capitalizationScheme: Capitalization.PascalCase,
+                name: "Name",
+                prefix: "",
+                suffix: "",
+                wordSeparator: "");
+
+            var namingRule = new SerializableNamingRule()
+            {
+                SymbolSpecificationID = symbolSpecification.ID,
+                NamingStyleID = namingStyle.ID,
+                EnforcementLevel = DiagnosticSeverity.Error
+            };
+            var info = new NamingStylePreferences(
+                ImmutableArray.Create(symbolSpecification),
+                ImmutableArray.Create(namingStyle),
+                ImmutableArray.Create(namingRule));
+
+            return info;
+        }
+
+        private static NamingStylePreferences SymbolKindsArePascalCaseOption(ImmutableArray<SymbolSpecification.SymbolKindOrTypeKind> symbolKinds)
+        {
+            var symbolSpecification = new SymbolSpecification(
+                null,
+                "Name",
+                symbolKinds,
+                accessibilityList: default,
+                modifiers: default);
 
             var namingStyle = new NamingStyle(
                 Guid.NewGuid(),
@@ -124,8 +192,8 @@ private static NamingStylePreferences ParameterNamesAreCamelCaseOption()
                 null,
                 "Name",
                 ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Parameter)),
-                ImmutableArray<Accessibility>.Empty,
-                ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
+                accessibilityList: default,
+                modifiers: default);
 
             var namingStyle = new NamingStyle(
                 Guid.NewGuid(),
@@ -156,8 +224,8 @@ private static NamingStylePreferences LocalNamesAreCamelCaseOption()
                 null,
                 "Name",
                 ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)),
-                ImmutableArray<Accessibility>.Empty,
-                ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
+                accessibilityList: default,
+                modifiers: default);
 
             var namingStyle = new NamingStyle(
                 Guid.NewGuid(),
@@ -188,8 +256,8 @@ private static NamingStylePreferences LocalFunctionNamesAreCamelCaseOption()
                 null,
                 "Name",
                 ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction)),
-                ImmutableArray<Accessibility>.Empty,
-                ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
+                accessibilityList: default,
+                modifiers: default);
 
             var namingStyle = new NamingStyle(
                 Guid.NewGuid(),
@@ -220,8 +288,8 @@ private static NamingStylePreferences PropertyNamesArePascalCaseOption()
                 null,
                 "Name",
                 ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Property)),
-                ImmutableArray<Accessibility>.Empty,
-                ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
+                accessibilityList: default,
+                modifiers: default);
 
             var namingStyle = new NamingStyle(
                 Guid.NewGuid(),
@@ -252,8 +320,8 @@ private static NamingStylePreferences InterfacesNamesStartWithIOption()
                 null,
                 "Name",
                 ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Interface)),
-                ImmutableArray<Accessibility>.Empty,
-                ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
+                accessibilityList: default,
+                modifiers: default);
 
             var namingStyle = new NamingStyle(
                 Guid.NewGuid(),
@@ -286,7 +354,7 @@ private static NamingStylePreferences ConstantsAreUpperCaseOption()
                 ImmutableArray.Create(
                     new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),
                     new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)),
-                ImmutableArray<Accessibility>.Empty,
+                accessibilityList: default,
                 ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsConst)));
 
             var namingStyle = new NamingStyle(
@@ -318,14 +386,14 @@ private static NamingStylePreferences LocalsAreCamelCaseConstantsAreUpperCaseOpt
                 null,
                 "Locals",
                 ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)),
-                ImmutableArray<Accessibility>.Empty,
-                ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
+                accessibilityList: default,
+                modifiers: default);
 
             var constLocalsSymbolSpecification = new SymbolSpecification(
                 null,
                 "Const Locals",
                 ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)),
-                ImmutableArray<Accessibility>.Empty,
+                accessibilityList: default,
                 ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsConst)));
 
             var camelCaseNamingStyle = new NamingStyle(
@@ -374,7 +442,7 @@ private static NamingStylePreferences AsyncFunctionNamesEndWithAsyncOption()
                 ImmutableArray.Create(
                     new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary),
                     new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction)),
-                ImmutableArray<Accessibility>.Empty,
+                accessibilityList: default,
                 ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsAsync)));
  
             var namingStyle = new NamingStyle(

src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider_BuiltInStyles.cs

@@ -26,7 +26,7 @@ private static NamingRule CreateGetAsyncRule()
             var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary));
             var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync));
             return new NamingRule(
-                new SymbolSpecification(Guid.NewGuid(), "endswithasync", kinds, ImmutableArray.Create<Accessibility>(), modifiers),
+                new SymbolSpecification(Guid.NewGuid(), "endswithasync", kinds, accessibilityList: default, modifiers),
                 new NamingStyles.NamingStyle(Guid.NewGuid(), prefix: "Get", suffix: "Async"),
                 DiagnosticSeverity.Info);
         }
@@ -34,9 +34,8 @@ private static NamingRule CreateGetAsyncRule()
         private static NamingRule CreateCamelCaseFieldsAndParametersRule()
         {
             var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field), new SymbolKindOrTypeKind(SymbolKind.Parameter), new SymbolKindOrTypeKind(SymbolKind.Local));
-            var modifiers = ImmutableArray.Create<ModifierKind>();
             return new NamingRule(
-                new SymbolSpecification(Guid.NewGuid(), "camelcasefields", kinds, ImmutableArray.Create<Accessibility>(), modifiers),
+                new SymbolSpecification(Guid.NewGuid(), "camelcasefields", kinds, accessibilityList: default, modifiers: default),
                 new NamingStyles.NamingStyle(Guid.NewGuid(), capitalizationScheme: Capitalization.CamelCase),
                 DiagnosticSeverity.Info);
         }
@@ -46,7 +45,7 @@ private static NamingRule CreateEndWithAsyncRule()
             var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary));
             var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync));
             return new NamingRule(
-                new SymbolSpecification(Guid.NewGuid(), "endswithasynct", kinds, ImmutableArray.Create<Accessibility>(), modifiers),
+                new SymbolSpecification(Guid.NewGuid(), "endswithasynct", kinds, accessibilityList: default, modifiers),
                 new NamingStyles.NamingStyle(Guid.NewGuid(), suffix: "Async"),
                 DiagnosticSeverity.Info);
         }
@@ -54,9 +53,8 @@ private static NamingRule CreateEndWithAsyncRule()
         private static NamingRule CreateMethodStartsWithGetRule()
         {
             var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary));
-            var modifiers = ImmutableArray.Create<ModifierKind>();
             return new NamingRule(
-                new SymbolSpecification(Guid.NewGuid(), "startswithget", kinds, ImmutableArray.Create<Accessibility>(), modifiers),
+                new SymbolSpecification(Guid.NewGuid(), "startswithget", kinds, accessibilityList: default, modifiers: default),
                 new NamingStyles.NamingStyle(Guid.NewGuid(), prefix: "Get"),
                 DiagnosticSeverity.Info);
         }

src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs

@@ -74,7 +74,7 @@ internal override async Task<string> GetFieldNameAsync(Document document, IPrope
             var namingPreferencesOption = optionSet.GetOption(SimplificationOptions.NamingPreferences);
             var rules = namingPreferencesOption.CreateRules().NamingRules
                 .AddRange(CreateNewRule(ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsStatic)), defaultStaticFieldPrefix))
-                .AddRange(CreateNewRule(ImmutableArray.Create<ModifierKind>(), defaultFieldPrefix));
+                .AddRange(CreateNewRule(modifiers: default, defaultFieldPrefix));
             return rules;
         }
 

src/Workspaces/Core/Portable/NamingStyles/EditorConfig/EditorConfigNamingStyleParser_SymbolSpec.cs

@@ -59,7 +59,7 @@ internal static partial class EditorConfigNamingStyleParser
                 return ParseSymbolKindList(result as string ?? string.Empty);
             }
 
-            return ImmutableArray<SymbolKindOrTypeKind>.Empty;
+            return _all;
         }
 
         private static readonly SymbolKindOrTypeKind _class = new SymbolKindOrTypeKind(TypeKind.Class);
@@ -159,7 +159,7 @@ private static ImmutableArray<SymbolKindOrTypeKind> ParseSymbolKindList(string s
                 return ParseAccessibilityKindList(result as string ?? string.Empty);
             }
 
-            return ImmutableArray<Accessibility>.Empty;
+            return _allAccessibility;
         }
 
         private static readonly ImmutableArray<Accessibility> _allAccessibility = ImmutableArray.Create(Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal);

src/Workspaces/Core/Portable/NamingStyles/Serialization/SymbolSpecification.cs

@@ -14,6 +14,8 @@ namespace Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles
 {
     internal class SymbolSpecification
     {
+        private static readonly SymbolSpecification DefaultSymbolSpecificationTemplate = CreateDefaultSymbolSpecification();
+
         public Guid ID { get; }
         public string Name { get; }
 
@@ -29,9 +31,9 @@ internal class SymbolSpecification
         {
             ID = id ?? Guid.NewGuid();
             Name = symbolSpecName;
-            ApplicableSymbolKindList = symbolKindList;
-            ApplicableAccessibilityList = accessibilityList.NullToEmpty();
-            RequiredModifierList = modifiers.NullToEmpty();
+            ApplicableSymbolKindList = symbolKindList.IsDefault ? DefaultSymbolSpecificationTemplate.ApplicableSymbolKindList : symbolKindList;
+            ApplicableAccessibilityList = accessibilityList.IsDefault ? DefaultSymbolSpecificationTemplate.ApplicableAccessibilityList : accessibilityList;
+            RequiredModifierList = modifiers.IsDefault ? DefaultSymbolSpecificationTemplate.RequiredModifierList : modifiers;
         }
 
         public static SymbolSpecification CreateDefaultSymbolSpecification()
@@ -82,7 +84,7 @@ internal bool AppliesTo(SymbolKind symbolKind, Accessibility accessibility)
 
         internal bool AppliesTo(SymbolKindOrTypeKind kind, DeclarationModifiers modifiers, Accessibility accessibility)
         {
-            if (ApplicableSymbolKindList.Any() && !ApplicableSymbolKindList.Any(k => k.Equals(kind)))
+            if (!ApplicableSymbolKindList.Any(k => k.Equals(kind)))
             {
                 return false;
             }
@@ -93,8 +95,7 @@ internal bool AppliesTo(SymbolKindOrTypeKind kind, DeclarationModifiers modifier
                 return false;
             }
 
-            if (ApplicableAccessibilityList.Any() &&
-                accessibility != Accessibility.NotApplicable &&
+            if (accessibility != Accessibility.NotApplicable &&
                 !ApplicableAccessibilityList.Any(k => k == accessibility))
             {
                 return false;
@@ -138,11 +139,6 @@ private DeclarationModifiers CollapseModifiers(ImmutableArray<ModifierKind> requ
         private bool AnyMatches<TSymbolMatcher>(ImmutableArray<TSymbolMatcher> matchers, ISymbol symbol)
             where TSymbolMatcher : ISymbolMatcher
         {
-            if (!matchers.Any())
-            {
-                return true;
-            }
-
             foreach (var matcher in matchers)
             {
                 if (matcher.MatchesSymbol(symbol))
@@ -156,7 +152,7 @@ private bool AnyMatches<TSymbolMatcher>(ImmutableArray<TSymbolMatcher> matchers,
 
         private bool AnyMatches(ImmutableArray<Accessibility> matchers, ISymbol symbol)
         {
-            if (!matchers.Any())
+            if (symbol.DeclaredAccessibility == Accessibility.NotApplicable)
             {
                 return true;
             }