editor config naming style

src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj

@@ -217,6 +217,7 @@
     <Compile Include="CodeActions\Preview\PreviewTests.cs" />
     <Compile Include="CodeActions\ReplaceMethodWithProperty\ReplaceMethodWithPropertyTests.cs" />
     <Compile Include="Diagnostics\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessTests.cs" />
+    <Compile Include="Diagnostics\NamingStyles\EditorConfigNamingStyleParserTests.cs" />
     <Compile Include="Diagnostics\NamingStyles\NamingStylesTests_OptionSets.cs" />
     <Compile Include="Diagnostics\PreferFrameworkType\PreferFrameworkTypeTests.cs" />
     <Compile Include="Diagnostics\PreferFrameworkType\PreferFrameworkTypeTests_FixAllTests.cs" />

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

@@ -0,0 +1,202 @@
+// 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.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
+using Roslyn.Test.Utilities;
+using Xunit;
+using static Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles.EditorConfigNamingStyleParser;
+using static Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles.SymbolSpecification;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.NamingStyles
+{
+    public partial class EditorConfigNamingStyleParserTests
+    {
+        [Fact]
+        public static void TestPascalCaseRule()
+        {
+            var dictionary = new Dictionary<string, object>()
+            {
+                ["dotnet_naming_rule.methods_and_properties_must_be_pascal_case.severity"] = "warning",
+                ["dotnet_naming_rule.methods_and_properties_must_be_pascal_case.symbols"] = "method_and_property_symbols",
+                ["dotnet_naming_rule.methods_and_properties_must_be_pascal_case.style"] = "pascal_case_style",
+                ["dotnet_naming_symbols.method_and_property_symbols.applicable_kinds"] = "method,property",
+                ["dotnet_naming_symbols.method_and_property_symbols.applicable_accessibilities"] = "*",
+                ["dotnet_naming_style.pascal_case_style.capitalization"] = "pascal_case"
+            };
+            var result = ParseDictionary(dictionary);
+            Assert.Single(result.NamingRules);
+            var namingRule = result.NamingRules.Single();
+            Assert.Single(result.NamingStyles);
+            var namingStyle = result.NamingStyles.Single();
+            Assert.Single(result.SymbolSpecifications);
+            var symbolSpec = result.SymbolSpecifications.Single();
+            Assert.Equal(namingStyle.ID, namingRule.NamingStyleID);
+            Assert.Equal(symbolSpec.ID, namingRule.SymbolSpecificationID);
+            Assert.Equal(DiagnosticSeverity.Warning, namingRule.EnforcementLevel);
+            Assert.Equal("method_and_property_symbols", symbolSpec.Name);
+            var expectedApplicableSymbolKindList = new[]
+            {
+                new SymbolKindOrTypeKind(SymbolKind.Method),
+                new SymbolKindOrTypeKind(SymbolKind.Property)
+            };
+            AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
+            Assert.Empty(symbolSpec.RequiredModifierList);
+            var expectedApplicableAccessibilityList = new[]
+            {
+                Accessibility.Public,
+                Accessibility.Internal,
+                Accessibility.Private,
+                Accessibility.Protected,
+                Accessibility.ProtectedOrInternal
+            };
+            AssertEx.SetEqual(expectedApplicableAccessibilityList, symbolSpec.ApplicableAccessibilityList);
+            Assert.Equal("pascal_case_style", namingStyle.Name);
+            Assert.Equal("", namingStyle.Prefix);
+            Assert.Equal("", namingStyle.Suffix);
+            Assert.Equal("", namingStyle.WordSeparator);
+            Assert.Equal(Capitalization.PascalCase, namingStyle.CapitalizationScheme);
+        }
+
+        [Fact]
+        public static void TestAsyncMethodsRule()
+        {
+            var dictionary = new Dictionary<string, object>()
+            {
+                ["dotnet_naming_rule.async_methods_must_end_with_async.severity"] = "error",
+                ["dotnet_naming_rule.async_methods_must_end_with_async.symbols"] = "method_symbols",
+                ["dotnet_naming_rule.async_methods_must_end_with_async.style"] = "end_in_async_style",
+                ["dotnet_naming_symbols.method_symbols.applicable_kinds"] = "method",
+                ["dotnet_naming_symbols.method_symbols.required_modifiers"] = "async",
+                ["dotnet_naming_style.end_in_async_style.capitalization "] = "pascal_case",
+                ["dotnet_naming_style.end_in_async_style.required_suffix"] = "Async",
+            };
+            var result = ParseDictionary(dictionary);
+            Assert.Single(result.NamingRules);
+            var namingRule = result.NamingRules.Single();
+            Assert.Single(result.NamingStyles);
+            var namingStyle = result.NamingStyles.Single();
+            Assert.Single(result.SymbolSpecifications);
+            var symbolSpec = result.SymbolSpecifications.Single();
+            Assert.Equal(namingStyle.ID, namingRule.NamingStyleID);
+            Assert.Equal(symbolSpec.ID, namingRule.SymbolSpecificationID);
+            Assert.Equal(DiagnosticSeverity.Error, namingRule.EnforcementLevel);
+            Assert.Equal("method_symbols", symbolSpec.Name);
+            Assert.Single(symbolSpec.ApplicableSymbolKindList);
+            Assert.Contains(new SymbolKindOrTypeKind(SymbolKind.Method), symbolSpec.ApplicableSymbolKindList);
+            Assert.Single(symbolSpec.RequiredModifierList);
+            Assert.Contains(new ModifierKind(ModifierKindEnum.IsAsync), symbolSpec.RequiredModifierList);
+            Assert.Empty(symbolSpec.ApplicableAccessibilityList);
+            Assert.Equal("end_in_async_style", namingStyle.Name);
+            Assert.Equal("", namingStyle.Prefix);
+            Assert.Equal("Async", namingStyle.Suffix);
+            Assert.Equal("", namingStyle.WordSeparator);
+            Assert.Equal(Capitalization.PascalCase, namingStyle.CapitalizationScheme);
+        }
+
+        [Fact]
+        public static void TestPublicMembersCapitalizedRule()
+        {
+            var dictionary = new Dictionary<string, object>()
+            {
+                ["dotnet_naming_rule.public_members_must_be_capitalized.severity"] = "suggestion",
+                ["dotnet_naming_rule.public_members_must_be_capitalized.symbols"] = "public_symbols",
+                ["dotnet_naming_rule.public_members_must_be_capitalized.style"] = "first_word_upper_case_style",
+                ["dotnet_naming_symbols.public_symbols.applicable_kinds"] = "property,method,field,event,delegate",
+                ["dotnet_naming_symbols.public_symbols.applicable_accessibilities"] = "public,internal,protected,protected_internal",
+                ["dotnet_naming_style.first_word_upper_case_style.capitalization"] = "first_word_upper",
+            };
+            var result = ParseDictionary(dictionary);
+            Assert.Single(result.NamingRules);
+            var namingRule = result.NamingRules.Single();
+            Assert.Single(result.NamingStyles);
+            var namingStyle = result.NamingStyles.Single();
+            Assert.Single(result.SymbolSpecifications);
+            var symbolSpec = result.SymbolSpecifications.Single();
+            Assert.Equal(namingStyle.ID, namingRule.NamingStyleID);
+            Assert.Equal(symbolSpec.ID, namingRule.SymbolSpecificationID);
+            Assert.Equal(DiagnosticSeverity.Info, namingRule.EnforcementLevel);
+            Assert.Equal("public_symbols", symbolSpec.Name);
+            var expectedApplicableSymbolKindList = new[]
+            {
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(SymbolKind.Method),
+                new SymbolKindOrTypeKind(SymbolKind.Field),
+                new SymbolKindOrTypeKind(SymbolKind.Event),
+                new SymbolKindOrTypeKind(TypeKind.Delegate)
+            };
+            AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
+            var expectedApplicableAccessibilityList = new[]
+            {
+                Accessibility.Public,
+                Accessibility.Internal,
+                Accessibility.Protected,
+                Accessibility.ProtectedOrInternal
+            };
+            AssertEx.SetEqual(expectedApplicableAccessibilityList, symbolSpec.ApplicableAccessibilityList);
+            Assert.Empty(symbolSpec.RequiredModifierList);
+            Assert.Equal("first_word_upper_case_style", namingStyle.Name);
+            Assert.Equal("", namingStyle.Prefix);
+            Assert.Equal("", namingStyle.Suffix);
+            Assert.Equal("", namingStyle.WordSeparator);
+            Assert.Equal(Capitalization.FirstUpper, namingStyle.CapitalizationScheme);
+        }
+
+        [Fact]
+        public static void TestNonPublicMembersLowerCaseRule()
+        {
+            var dictionary = new Dictionary<string, object>()
+            {
+                ["dotnet_naming_rule.non_public_members_must_be_lower_case.severity"] = "incorrect",
+                ["dotnet_naming_rule.non_public_members_must_be_lower_case.symbols "] = "non_public_symbols",
+                ["dotnet_naming_rule.non_public_members_must_be_lower_case.style   "] = "all_lower_case_style",
+                ["dotnet_naming_symbols.non_public_symbols.applicable_kinds  "] = "property,method,field,event,delegate",
+                ["dotnet_naming_symbols.non_public_symbols.applicable_accessibilities"] = "private",
+                ["dotnet_naming_style.all_lower_case_style.capitalization"] = "all_lower",
+            };
+            var result = ParseDictionary(dictionary);
+            Assert.Single(result.NamingRules);
+            var namingRule = result.NamingRules.Single();
+            Assert.Single(result.NamingStyles);
+            var namingStyle = result.NamingStyles.Single();
+            Assert.Single(result.SymbolSpecifications);
+            var symbolSpec = result.SymbolSpecifications.Single();
+            Assert.Equal(namingStyle.ID, namingRule.NamingStyleID);
+            Assert.Equal(symbolSpec.ID, namingRule.SymbolSpecificationID);
+            Assert.Equal(DiagnosticSeverity.Hidden, namingRule.EnforcementLevel);
+            Assert.Equal("non_public_symbols", symbolSpec.Name);
+            var expectedApplicableSymbolKindList = new[]
+            {
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(SymbolKind.Method),
+                new SymbolKindOrTypeKind(SymbolKind.Field),
+                new SymbolKindOrTypeKind(SymbolKind.Event),
+                new SymbolKindOrTypeKind(TypeKind.Delegate)
+            };
+            AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
+            Assert.Single(symbolSpec.ApplicableAccessibilityList);
+            Assert.Contains(Accessibility.Private, symbolSpec.ApplicableAccessibilityList);
+            Assert.Empty(symbolSpec.RequiredModifierList);
+            Assert.Equal("all_lower_case_style", namingStyle.Name);
+            Assert.Equal("", namingStyle.Prefix);
+            Assert.Equal("", namingStyle.Suffix);
+            Assert.Equal("", namingStyle.WordSeparator);
+            Assert.Equal(Capitalization.AllLower, namingStyle.CapitalizationScheme);
+        }
+
+        [Fact]
+        public static void TestNoRulesAreReturned()
+        {
+            var dictionary = new Dictionary<string, object>()
+            {
+                ["dotnet_naming_symbols.non_public_symbols.applicable_kinds  "] = "property,method,field,event,delegate",
+                ["dotnet_naming_symbols.non_public_symbols.applicable_accessibilities"] = "private",
+                ["dotnet_naming_style.all_lower_case_style.capitalization"] = "all_lower",
+            };
+            var result = ParseDictionary(dictionary);
+            Assert.Empty(result.NamingRules);
+            Assert.Empty(result.NamingStyles);
+            Assert.Empty(result.SymbolSpecifications);
+        }
+    }
+}

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

@@ -15,76 +15,78 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.NamingStyle
     public partial class NamingStylesTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
     {
         private IDictionary<OptionKey, object> ClassNamesArePascalCase =>
-            Options(new OptionKey(SimplificationOptions.NamingPreferences, LanguageNames.CSharp), ClassNamesArePascalCaseOptionString());
+            Options(new OptionKey(SimplificationOptions.NamingPreferences, LanguageNames.CSharp), ClassNamesArePascalCaseOption());
 
         private IDictionary<OptionKey, object> MethodNamesArePascalCase =>
-            Options(new OptionKey(SimplificationOptions.NamingPreferences, LanguageNames.CSharp), MethodNamesArePascalCaseOptionString());
+            Options(new OptionKey(SimplificationOptions.NamingPreferences, LanguageNames.CSharp), MethodNamesArePascalCaseOption());
 
         private IDictionary<OptionKey, object> Options(OptionKey option, object value)
         {
-            var options = new Dictionary<OptionKey, object>();
-            options.Add(option, value);
+            var options = new Dictionary<OptionKey, object>
+            {
+                { option, value }
+            };
             return options;
         }
 
-        private string ClassNamesArePascalCaseOptionString()
+        private NamingStylePreferences ClassNamesArePascalCaseOption()
         {
             var symbolSpecification = new SymbolSpecification(
-                Guid.NewGuid(),
                 "Name",
                 SpecializedCollections.SingletonEnumerable(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Class)).ToList(),
-                SpecializedCollections.EmptyList<SymbolSpecification.AccessibilityKind>(),
+                SpecializedCollections.EmptyList<Accessibility>(),
                 SpecializedCollections.EmptyList<SymbolSpecification.ModifierKind>());
 
-            var namingStyle = new NamingStyle();
-            namingStyle.CapitalizationScheme = Capitalization.PascalCase;
-            namingStyle.Name = "Name";
-            namingStyle.Prefix = "";
-            namingStyle.Suffix = "";
-            namingStyle.WordSeparator = "";
-
-
-            var namingRule = new SerializableNamingRule();
-            namingRule.SymbolSpecificationID = symbolSpecification.ID;
-            namingRule.NamingStyleID = namingStyle.ID;
-            namingRule.EnforcementLevel = DiagnosticSeverity.Error;
-
-            var info = new SerializableNamingStylePreferencesInfo();
+            var namingStyle = new NamingStyle()
+            {
+                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();
             info.SymbolSpecifications.Add(symbolSpecification);
             info.NamingStyles.Add(namingStyle);
             info.NamingRules.Add(namingRule);
 
-            return info.CreateXElement().ToString();
+            return info;
         }
 
-        private string MethodNamesArePascalCaseOptionString()
+        private NamingStylePreferences MethodNamesArePascalCaseOption()
         {
             var symbolSpecification = new SymbolSpecification(
-                Guid.NewGuid(),
                 "Name",
                 SpecializedCollections.SingletonEnumerable(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Method)).ToList(),
-                SpecializedCollections.EmptyList<SymbolSpecification.AccessibilityKind>(),
+                SpecializedCollections.EmptyList<Accessibility>(),
                 SpecializedCollections.EmptyList<SymbolSpecification.ModifierKind>());
 
-            var namingStyle = new NamingStyle();
-            namingStyle.CapitalizationScheme = Capitalization.PascalCase;
-            namingStyle.Name = "Name";
-            namingStyle.Prefix = "";
-            namingStyle.Suffix = "";
-            namingStyle.WordSeparator = "";
-
-
-            var namingRule = new SerializableNamingRule();
-            namingRule.SymbolSpecificationID = symbolSpecification.ID;
-            namingRule.NamingStyleID = namingStyle.ID;
-            namingRule.EnforcementLevel = DiagnosticSeverity.Error;
-
-            var info = new SerializableNamingStylePreferencesInfo();
+            var namingStyle = new NamingStyle()
+            {
+                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();
             info.SymbolSpecifications.Add(symbolSpecification);
             info.NamingStyles.Add(namingStyle);
             info.NamingRules.Add(namingRule);
 
-            return info.CreateXElement().ToString();
+            return info;
         }
     }
 }

src/EditorFeatures/Next/Options/EditorConfigDocumentOptionsProvider.DocumentOptions.cs

@@ -2,6 +2,8 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.CodingConventions;
+using Microsoft.CodeAnalysis.ErrorLogger;
+using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
 
 namespace Microsoft.CodeAnalysis.Editor.Options
 {
@@ -10,37 +12,32 @@ internal sealed partial class EditorConfigDocumentOptionsProvider : IDocumentOpt
         private class DocumentOptions : IDocumentOptions
         {
             private ICodingConventionsSnapshot _codingConventionSnapshot;
+            private readonly IErrorLoggerService _errorLogger;
 
-            public DocumentOptions(ICodingConventionsSnapshot codingConventionSnapshot)
+            public DocumentOptions(ICodingConventionsSnapshot codingConventionSnapshot, IErrorLoggerService errorLogger)
             {
                 _codingConventionSnapshot = codingConventionSnapshot;
+                _errorLogger = errorLogger;
             }
 
             public bool TryGetDocumentOption(Document document, OptionKey option, out object value)
             {
                 var editorConfigPersistence = option.Option.StorageLocations.OfType<EditorConfigStorageLocation>().SingleOrDefault();
-
                 if (editorConfigPersistence == null)
                 {
                     value = null;
                     return false;
                 }
 
-                if (_codingConventionSnapshot.TryGetConventionValue(editorConfigPersistence.KeyName, out value))
+                var allRawConventions = _codingConventionSnapshot.AllRawConventions;
+                try
                 {
-                    try
-                    {
-                        value = editorConfigPersistence.ParseValue(value.ToString(), option.Option.Type);
-                        return true;
-                    }
-                    catch (Exception)
-                    {
-                        // TODO: report this somewhere?
-                        return false;
-                    }
+                    return editorConfigPersistence.TryParseReadonlyDictionary(allRawConventions, option.Option.Type, out value);
                 }
-                else
+                catch (Exception ex)
                 {
+                    _errorLogger?.LogException(this, ex);
+                    value = null;
                     return false;
                 }
             }