Update IEditorConfigStorageLocation to take a Dictionary<string, string>

In practice, everything was either assuming the only keys they cared
about were strings, or they were blindly taking the non-strings and
converting them to strings with .ToString().

This is just a temporary hack to do a lot of mechanical changes in a
single commit -- this will go away in a upcoming commit.

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

@@ -34,7 +34,7 @@ internal static SymbolKindOrTypeKind ToSymbolKindOrTypeKind(object symbolOrTypeK
         [Fact]
         public static void TestPascalCaseRule()
         {
-            var dictionary = new Dictionary<string, object>()
+            var dictionary = new Dictionary<string, string>()
             {
                 ["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",
@@ -82,7 +82,7 @@ public static void TestPascalCaseRule()
         [Fact]
         public static void TestAsyncMethodsAndLocalFunctionsRule()
         {
-            var dictionary = new Dictionary<string, object>()
+            var dictionary = new Dictionary<string, string>()
             {
                 ["dotnet_naming_rule.async_methods_must_end_with_async.severity"] = "error",
                 ["dotnet_naming_rule.async_methods_must_end_with_async.symbols"] = "method_symbols",
@@ -124,7 +124,7 @@ public static void TestAsyncMethodsAndLocalFunctionsRule()
         [Fact]
         public static void TestRuleWithoutCapitalization()
         {
-            var dictionary = new Dictionary<string, object>()
+            var dictionary = new Dictionary<string, string>()
             {
                 ["dotnet_naming_rule.async_methods_must_end_with_async.symbols"] = "any_async_methods",
                 ["dotnet_naming_rule.async_methods_must_end_with_async.style"] = "end_in_async",
@@ -141,7 +141,7 @@ public static void TestRuleWithoutCapitalization()
         [Fact]
         public static void TestPublicMembersCapitalizedRule()
         {
-            var dictionary = new Dictionary<string, object>()
+            var dictionary = new Dictionary<string, string>()
             {
                 ["dotnet_naming_rule.public_members_must_be_capitalized.severity"] = "suggestion",
                 ["dotnet_naming_rule.public_members_must_be_capitalized.symbols"] = "public_symbols",
@@ -189,7 +189,7 @@ public static void TestPublicMembersCapitalizedRule()
         [Fact]
         public static void TestNonPublicMembersLowerCaseRule()
         {
-            var dictionary = new Dictionary<string, object>()
+            var dictionary = new Dictionary<string, string>()
             {
                 ["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",
@@ -231,7 +231,7 @@ public static void TestNonPublicMembersLowerCaseRule()
         [Fact]
         public static void TestParametersAndLocalsAreCamelCaseRule()
         {
-            var dictionary = new Dictionary<string, object>()
+            var dictionary = new Dictionary<string, string>()
             {
                 ["dotnet_naming_rule.parameters_and_locals_are_camel_case.severity"] = "suggestion",
                 ["dotnet_naming_rule.parameters_and_locals_are_camel_case.symbols"] = "parameters_and_locals",
@@ -274,7 +274,7 @@ public static void TestParametersAndLocalsAreCamelCaseRule()
         [Fact]
         public static void TestLocalFunctionsAreCamelCaseRule()
         {
-            var dictionary = new Dictionary<string, object>()
+            var dictionary = new Dictionary<string, string>()
             {
                 ["dotnet_naming_rule.local_functions_are_camel_case.severity"] = "suggestion",
                 ["dotnet_naming_rule.local_functions_are_camel_case.symbols"] = "local_functions",
@@ -313,7 +313,7 @@ public static void TestLocalFunctionsAreCamelCaseRule()
         [Fact]
         public static void TestNoRulesAreReturned()
         {
-            var dictionary = new Dictionary<string, object>()
+            var dictionary = new Dictionary<string, string>()
             {
                 ["dotnet_naming_symbols.non_public_symbols.applicable_kinds  "] = "property,method,field,event,delegate",
                 ["dotnet_naming_symbols.non_public_symbols.applicable_accessibilities"] = "private",
@@ -337,7 +337,7 @@ public static void TestNoRulesAreReturned()
         [WorkItem(20907, "https://github.com/dotnet/roslyn/issues/20907")]
         public static void TestApplicableKindsParse(string specification, object[] typeOrSymbolKinds)
         {
-            var rule = new Dictionary<string, object>()
+            var rule = new Dictionary<string, string>()
             {
                 ["dotnet_naming_rule.kinds_parse.severity"] = "error",
                 ["dotnet_naming_rule.kinds_parse.symbols"] = "kinds",
@@ -368,7 +368,7 @@ public static void TestApplicableKindsParse(string specification, object[] typeO
         [WorkItem(20907, "https://github.com/dotnet/roslyn/issues/20907")]
         public static void TestApplicableAccessibilitiesParse(string specification, Accessibility[] accessibilities)
         {
-            var rule = new Dictionary<string, object>()
+            var rule = new Dictionary<string, string>()
             {
                 ["dotnet_naming_rule.accessibilities_parse.severity"] = "error",
                 ["dotnet_naming_rule.accessibilities_parse.symbols"] = "accessibilities",
@@ -388,7 +388,7 @@ public static void TestApplicableAccessibilitiesParse(string specification, Acce
         [Fact]
         public static void TestRequiredModifiersParse()
         {
-            var charpRule = new Dictionary<string, object>()
+            var charpRule = new Dictionary<string, string>()
             {
                 ["dotnet_naming_rule.modifiers_parse.severity"] = "error",
                 ["dotnet_naming_rule.modifiers_parse.symbols"] = "modifiers",
@@ -396,7 +396,7 @@ public static void TestRequiredModifiersParse()
                 ["dotnet_naming_symbols.modifiers.required_modifiers"] = "abstract,static",
                 ["dotnet_naming_style.pascal_case.capitalization "] = "pascal_case",
             };
-            var vbRule = new Dictionary<string, object>()
+            var vbRule = new Dictionary<string, string>()
             {
                 ["dotnet_naming_rule.modifiers_parse.severity"] = "error",
                 ["dotnet_naming_rule.modifiers_parse.symbols"] = "modifiers",

src/EditorFeatures/Core.Wpf/Options/EditorConfigDocumentOptionsProvider.DocumentOptions.cs

 using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
+using Microsoft.CodeAnalysis.ErrorLogger;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.CodingConventions;
-using Microsoft.CodeAnalysis.ErrorLogger;
-using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.Options
 {
@@ -29,7 +31,8 @@ public bool TryGetDocumentOption(OptionKey option, OptionSet underlyingOptions,
                     return false;
                 }
 
-                var allRawConventions = _codingConventionSnapshot.AllRawConventions;
+                // HACK: temporarly map our old Dictionary<string, object> to a Dictionary<string, string>. This will go away in a future commit.
+                var allRawConventions = ImmutableDictionary.CreateRange(_codingConventionSnapshot.AllRawConventions.Select(c => KeyValuePairUtil.Create(c.Key, c.Value.ToString())));
                 try
                 {
                     var underlyingOption = underlyingOptions.GetOption(option);

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

@@ -14,29 +14,29 @@ internal static partial class EditorConfigNamingStyleParser
         /// <remarks>
         /// The dictionary we get from the VS editorconfig API uses the same dictionary object if there are no changes, so we can cache based on dictionary
         /// </remarks>
-        private static readonly ConditionalWeakTable<IReadOnlyDictionary<string, object>, NamingStylePreferences> _cache = new ConditionalWeakTable<IReadOnlyDictionary<string, object>, NamingStylePreferences>();
+        private static readonly ConditionalWeakTable<IReadOnlyDictionary<string, string>, NamingStylePreferences> _cache = new ConditionalWeakTable<IReadOnlyDictionary<string, string>, NamingStylePreferences>();
         private static readonly object _cacheLock = new object();
 
-        public static NamingStylePreferences GetNamingStylesFromDictionary(IReadOnlyDictionary<string, object> allRawConventions)
+        public static NamingStylePreferences GetNamingStylesFromDictionary(IReadOnlyDictionary<string, string> rawOptions)
         {
-            if (_cache.TryGetValue(allRawConventions, out var value))
+            if (_cache.TryGetValue(rawOptions, out var value))
             {
                 return value;
             }
 
             lock (_cacheLock)
             {
-                if (!_cache.TryGetValue(allRawConventions, out value))
+                if (!_cache.TryGetValue(rawOptions, out value))
                 {
-                    value = ParseDictionary(allRawConventions);
-                    _cache.Add(allRawConventions, value);
+                    value = ParseDictionary(rawOptions);
+                    _cache.Add(rawOptions, value);
                 }
 
                 return value;
             }
         }
 
-        public static NamingStylePreferences ParseDictionary(IReadOnlyDictionary<string, object> allRawConventions)
+        public static NamingStylePreferences ParseDictionary(IReadOnlyDictionary<string, string> allRawConventions)
         {
             var symbolSpecifications = ArrayBuilder<SymbolSpecification>.GetInstance();
             var namingStyles = ArrayBuilder<NamingStyle>.GetInstance();
@@ -62,9 +62,9 @@ public static NamingStylePreferences ParseDictionary(IReadOnlyDictionary<string,
                 namingRules.ToImmutableAndFree());
         }
 
-        private static Dictionary<string, object> TrimDictionary(IReadOnlyDictionary<string, object> allRawConventions)
+        private static Dictionary<string, string> TrimDictionary(IReadOnlyDictionary<string, string> allRawConventions)
         {
-            var trimmedDictionary = new Dictionary<string, object>(allRawConventions.Count);
+            var trimmedDictionary = new Dictionary<string, string>(allRawConventions.Count);
             foreach (var item in allRawConventions)
             {
                 var key = item.Key.Trim();
@@ -75,7 +75,7 @@ public static NamingStylePreferences ParseDictionary(IReadOnlyDictionary<string,
             return trimmedDictionary;
         }
 
-        private static IEnumerable<string> GetRuleTitles(IReadOnlyDictionary<string, object> allRawConventions)
+        private static IEnumerable<string> GetRuleTitles(IReadOnlyDictionary<string, string> allRawConventions)
             => (from kvp in allRawConventions
                 where kvp.Key.Trim().StartsWith("dotnet_naming_rule.", StringComparison.Ordinal)
                 let nameSplit = kvp.Key.Split('.')

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

@@ -11,7 +11,7 @@ internal static partial class EditorConfigNamingStyleParser
             string namingRuleTitle,
             SymbolSpecification symbolSpec,
             NamingStyle namingStyle,
-            IReadOnlyDictionary<string, object> conventionsDictionary,
+            IReadOnlyDictionary<string, string> conventionsDictionary,
             out SerializableNamingRule serializableNamingRule)
         {
             if (!TryGetRuleSeverity(namingRuleTitle, conventionsDictionary, out var severity))
@@ -32,12 +32,12 @@ internal static partial class EditorConfigNamingStyleParser
 
         private static bool TryGetRuleSeverity(
             string namingRuleName,
-            IReadOnlyDictionary<string, object> conventionsDictionary,
+            IReadOnlyDictionary<string, string> conventionsDictionary,
             out ReportDiagnostic severity)
         {
-            if (conventionsDictionary.TryGetValue($"dotnet_naming_rule.{namingRuleName}.severity", out object result))
+            if (conventionsDictionary.TryGetValue($"dotnet_naming_rule.{namingRuleName}.severity", out string result))
             {
-                severity = ParseEnforcementLevel(result as string ?? string.Empty);
+                severity = ParseEnforcementLevel(result ?? string.Empty);
                 return true;
             }
 

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

@@ -10,19 +10,19 @@ internal static partial class EditorConfigNamingStyleParser
     {
         private static bool TryGetNamingStyleData(
             string namingRuleName,
-            IReadOnlyDictionary<string, object> allRawConventions,
+            IReadOnlyDictionary<string, string> rawOptions,
             out NamingStyle namingStyle)
         {
             namingStyle = default;
-            if (!TryGetNamingStyleTitle(namingRuleName, allRawConventions, out string namingStyleTitle))
+            if (!TryGetNamingStyleTitle(namingRuleName, rawOptions, out string namingStyleTitle))
             {
                 return false;
             }
 
-            var requiredPrefix = GetNamingRequiredPrefix(namingStyleTitle, allRawConventions);
-            var requiredSuffix = GetNamingRequiredSuffix(namingStyleTitle, allRawConventions);
-            var wordSeparator = GetNamingWordSeparator(namingStyleTitle, allRawConventions);
-            if (!TryGetNamingCapitalization(namingStyleTitle, allRawConventions, out var capitalization))
+            var requiredPrefix = GetNamingRequiredPrefix(namingStyleTitle, rawOptions);
+            var requiredSuffix = GetNamingRequiredSuffix(namingStyleTitle, rawOptions);
+            var wordSeparator = GetNamingWordSeparator(namingStyleTitle, rawOptions);
+            if (!TryGetNamingCapitalization(namingStyleTitle, rawOptions, out var capitalization))
             {
                 return false;
             }
@@ -40,12 +40,11 @@ internal static partial class EditorConfigNamingStyleParser
 
         private static bool TryGetNamingStyleTitle(
             string namingRuleName,
-            IReadOnlyDictionary<string, object> conventionsDictionary,
+            IReadOnlyDictionary<string, string> conventionsDictionary,
             out string namingStyleName)
         {
-            if (conventionsDictionary.TryGetValue($"dotnet_naming_rule.{namingRuleName}.style", out object result))
+            if (conventionsDictionary.TryGetValue($"dotnet_naming_rule.{namingRuleName}.style", out namingStyleName))
             {
-                namingStyleName = result as string;
                 return namingStyleName != null;
             }
 
@@ -53,29 +52,25 @@ internal static partial class EditorConfigNamingStyleParser
             return false;
         }
 
-        private static string GetNamingRequiredPrefix(string namingStyleName, IReadOnlyDictionary<string, object> conventionsDictionary)
+        private static string GetNamingRequiredPrefix(string namingStyleName, IReadOnlyDictionary<string, string> conventionsDictionary)
             => GetStringFromConventionsDictionary(namingStyleName, "required_prefix", conventionsDictionary);
 
-        private static string GetNamingRequiredSuffix(string namingStyleName, IReadOnlyDictionary<string, object> conventionsDictionary)
+        private static string GetNamingRequiredSuffix(string namingStyleName, IReadOnlyDictionary<string, string> conventionsDictionary)
             => GetStringFromConventionsDictionary(namingStyleName, "required_suffix", conventionsDictionary);
 
-        private static string GetNamingWordSeparator(string namingStyleName, IReadOnlyDictionary<string, object> conventionsDictionary)
+        private static string GetNamingWordSeparator(string namingStyleName, IReadOnlyDictionary<string, string> conventionsDictionary)
             => GetStringFromConventionsDictionary(namingStyleName, "word_separator", conventionsDictionary);
 
-        private static bool TryGetNamingCapitalization(string namingStyleName, IReadOnlyDictionary<string, object> conventionsDictionary, out Capitalization capitalization)
+        private static bool TryGetNamingCapitalization(string namingStyleName, IReadOnlyDictionary<string, string> conventionsDictionary, out Capitalization capitalization)
         {
             var result = GetStringFromConventionsDictionary(namingStyleName, "capitalization", conventionsDictionary);
             return TryParseCapitalizationScheme(result, out capitalization);
         }
 
-        private static string GetStringFromConventionsDictionary(string namingStyleName, string optionName, IReadOnlyDictionary<string, object> conventionsDictionary)
+        private static string GetStringFromConventionsDictionary(string namingStyleName, string optionName, IReadOnlyDictionary<string, string> conventionsDictionary)
         {
-            if (conventionsDictionary.TryGetValue($"dotnet_naming_style.{namingStyleName}.{optionName}", out object result))
-            {
-                return result as string ?? string.Empty;
-            }
-
-            return string.Empty;
+            conventionsDictionary.TryGetValue($"dotnet_naming_style.{namingStyleName}.{optionName}", out string result);
+            return result ?? string.Empty;
         }
 
         private static bool TryParseCapitalizationScheme(string namingStyleCapitalization, out Capitalization capitalization)

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

@@ -12,7 +12,7 @@ internal static partial class EditorConfigNamingStyleParser
     {
         private static bool TryGetSymbolSpec(
             string namingRuleTitle,
-            IReadOnlyDictionary<string, object> conventionsDictionary,
+            IReadOnlyDictionary<string, string> conventionsDictionary,
             out SymbolSpecification symbolSpec)
         {
             symbolSpec = null;
@@ -36,13 +36,12 @@ internal static partial class EditorConfigNamingStyleParser
 
         private static bool TryGetSymbolSpecNameForNamingRule(
             string namingRuleName,
-            IReadOnlyDictionary<string, object> conventionsDictionary,
+            IReadOnlyDictionary<string, string> conventionsDictionary,
             out string symbolSpecName)
         {
             symbolSpecName = null;
-            if (conventionsDictionary.TryGetValue($"dotnet_naming_rule.{namingRuleName}.symbols", out object result))
+            if (conventionsDictionary.TryGetValue($"dotnet_naming_rule.{namingRuleName}.symbols", out symbolSpecName))
             {
-                symbolSpecName = result as string;
                 return symbolSpecName != null;
             }
 
@@ -51,11 +50,11 @@ internal static partial class EditorConfigNamingStyleParser
 
         private static ImmutableArray<SymbolKindOrTypeKind> GetSymbolsApplicableKinds(
             string symbolSpecName,
-            IReadOnlyDictionary<string, object> conventionsDictionary)
+            IReadOnlyDictionary<string, string> conventionsDictionary)
         {
-            if (conventionsDictionary.TryGetValue($"dotnet_naming_symbols.{symbolSpecName}.applicable_kinds", out object result))
+            if (conventionsDictionary.TryGetValue($"dotnet_naming_symbols.{symbolSpecName}.applicable_kinds", out string result))
             {
-                return ParseSymbolKindList(result as string ?? string.Empty);
+                return ParseSymbolKindList(result ?? string.Empty);
             }
 
             return _all;
@@ -161,11 +160,11 @@ private static ImmutableArray<SymbolKindOrTypeKind> ParseSymbolKindList(string s
 
         private static ImmutableArray<Accessibility> GetSymbolsApplicableAccessibilities(
             string symbolSpecName,
-            IReadOnlyDictionary<string, object> conventionsDictionary)
+            IReadOnlyDictionary<string, string> conventionsDictionary)
         {
-            if (conventionsDictionary.TryGetValue($"dotnet_naming_symbols.{symbolSpecName}.applicable_accessibilities", out object result))
+            if (conventionsDictionary.TryGetValue($"dotnet_naming_symbols.{symbolSpecName}.applicable_accessibilities", out string result))
             {
-                return ParseAccessibilityKindList(result as string ?? string.Empty);
+                return ParseAccessibilityKindList(result ?? string.Empty);
             }
 
             return _allAccessibility;
@@ -223,11 +222,11 @@ private static ImmutableArray<Accessibility> ParseAccessibilityKindList(string s
 
         private static ImmutableArray<ModifierKind> GetSymbolsRequiredModifiers(
             string symbolSpecName,
-            IReadOnlyDictionary<string, object> conventionsDictionary)
+            IReadOnlyDictionary<string, string> conventionsDictionary)
         {
-            if (conventionsDictionary.TryGetValue($"dotnet_naming_symbols.{symbolSpecName}.required_modifiers", out object result))
+            if (conventionsDictionary.TryGetValue($"dotnet_naming_symbols.{symbolSpecName}.required_modifiers", out string result))
             {
-                return ParseModifiers(result as string ?? string.Empty);
+                return ParseModifiers(result ?? string.Empty);
             }
 
             return ImmutableArray<ModifierKind>.Empty;

src/Workspaces/Core/Portable/Options/EditorConfig/EditorConfigStorageLocation`1.cs

@@ -50,11 +50,11 @@ public EditorConfigStorageLocation(string keyName, Func<string, Optional<T>> par
             _getEditorConfigStringForValue = getEditorConfigStringForValue ?? throw new ArgumentNullException(nameof(getEditorConfigStringForValue));
         }
 
-        public bool TryGetOption(object underlyingOption, IReadOnlyDictionary<string, object> allRawConventions, Type type, out object result)
+        public bool TryGetOption(object underlyingOption, IReadOnlyDictionary<string, string> rawOptions, Type type, out object result)
         {
-            if (allRawConventions.TryGetValue(KeyName, out object value))
+            if (rawOptions.TryGetValue(KeyName, out string value))
             {
-                var ret = TryGetOption(value.ToString(), type, out var typedResult);
+                var ret = TryGetOption(value, type, out var typedResult);
                 result = typedResult;
                 return ret;
             }

src/Workspaces/Core/Portable/Options/EditorConfig/IEditorConfigStorageLocation.cs

@@ -7,6 +7,6 @@ namespace Microsoft.CodeAnalysis.Options
 {
     internal interface IEditorConfigStorageLocation
     {
-        bool TryGetOption(object underlyingOption, IReadOnlyDictionary<string, object> allRawConventions, Type type, out object value);
+        bool TryGetOption(object underlyingOption, IReadOnlyDictionary<string, string> rawOptions, Type type, out object value);
     }
 }

src/Workspaces/Core/Portable/Options/EditorConfig/NamingStylePreferenceEditorConfigStorageLocation.cs

@@ -11,15 +11,15 @@ namespace Microsoft.CodeAnalysis.Options
 {
     internal sealed class NamingStylePreferenceEditorConfigStorageLocation : OptionStorageLocation, IEditorConfigStorageLocation
     {
-        public bool TryGetOption(object underlyingOption, IReadOnlyDictionary<string, object> allRawConventions, Type type, out object result)
+        public bool TryGetOption(object underlyingOption, IReadOnlyDictionary<string, string> rawOptions, Type type, out object result)
         {
-            var tuple = ParseDictionary(underlyingOption, allRawConventions, type);
+            var tuple = ParseDictionary(underlyingOption, rawOptions, type);
             result = tuple.result;
             return tuple.succeeded;
         }
 
         private static (object result, bool succeeded) ParseDictionary(
-            object underlyingOption, IReadOnlyDictionary<string, object> allRawConventions, Type type)
+            object underlyingOption, IReadOnlyDictionary<string, string> allRawConventions, Type type)
         {
             if (type == typeof(NamingStylePreferences))
             {

src/Workspaces/CoreTest/CodeStyle/EditorConfigCodeStyleParserTests.cs

@@ -79,7 +79,7 @@ public void TestParseEditorConfigAccessibilityModifiers(string args, int value,
             var storageLocation = CodeStyleOptions.RequireAccessibilityModifiers.StorageLocations
                 .OfType<EditorConfigStorageLocation<CodeStyleOption<AccessibilityModifiersRequired>>>()
                 .Single();
-            var allRawConventions = new Dictionary<string, object> { { storageLocation.KeyName, args } };
+            var allRawConventions = new Dictionary<string, string> { { storageLocation.KeyName, args } };
 
             Assert.True(storageLocation.TryGetOption(null, allRawConventions, typeof(CodeStyleOption<AccessibilityModifiersRequired>), out var parsedCodeStyleOption));
             var codeStyleOption = (CodeStyleOption<AccessibilityModifiersRequired>)parsedCodeStyleOption;
@@ -101,7 +101,7 @@ public void TestParseEditorConfigEndOfLine(string configurationString, string ne
             var storageLocation = FormattingOptions.NewLine.StorageLocations
                 .OfType<EditorConfigStorageLocation<string>>()
                 .Single();
-            var allRawConventions = new Dictionary<string, object> { { storageLocation.KeyName, configurationString } };
+            var allRawConventions = new Dictionary<string, string> { { storageLocation.KeyName, configurationString } };
 
             Assert.True(storageLocation.TryGetOption(null, allRawConventions, typeof(string), out var parsedNewLine));
             Assert.Equal(newLine, (string)parsedNewLine);

src/Workspaces/CoreTest/EditorConfigStorageLocation/EditorConfigStorageLocationTests.cs

@@ -17,7 +17,7 @@ public class EditorConfigStorageLocationTests
         public static void TestEmptyDictionaryReturnNoNamingStylePreferencesObjectReturnsFalse()
         {
             var editorConfigStorageLocation = new NamingStylePreferenceEditorConfigStorageLocation();
-            var result = editorConfigStorageLocation.TryGetOption(new object(), new Dictionary<string, object>(), typeof(NamingStylePreferences), out var @object);
+            var result = editorConfigStorageLocation.TryGetOption(new object(), new Dictionary<string, string>(), typeof(NamingStylePreferences), out var @object);
             Assert.False(result, "Expected TryParseReadonlyDictionary to return 'false' for empty dictionary");
         }
 
@@ -32,7 +32,7 @@ public static void TestEmptyDictionaryDefaultNamingStylePreferencesObjectReturns
 
             var result = editorConfigStorageLocation.TryGetOption(
                 existingNamingStylePreferences,
-                new Dictionary<string, object>(),
+                new Dictionary<string, string>(),
                 typeof(NamingStylePreferences),
                 out var @object);
 
@@ -42,7 +42,7 @@ public static void TestEmptyDictionaryDefaultNamingStylePreferencesObjectReturns
         [Fact]
         public static void TestNonEmptyDictionaryReturnsTrue()
         {
-            var initialDictionary = new Dictionary<string, object>()
+            var initialDictionary = new Dictionary<string, string>()
             {
                 ["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",
@@ -54,7 +54,7 @@ public static void TestNonEmptyDictionaryReturnsTrue()
             var existingNamingStylePreferences = ParseDictionary(initialDictionary);
 
             var editorConfigStorageLocation = new NamingStylePreferenceEditorConfigStorageLocation();
-            var newDictionary = new Dictionary<string, object>()
+            var newDictionary = new Dictionary<string, string>()
             {
                 ["dotnet_naming_rule.methods_and_properties_must_be_pascal_case.severity"] = "error",
                 ["dotnet_naming_rule.methods_and_properties_must_be_pascal_case.symbols"] = "method_and_property_symbols",
@@ -82,7 +82,7 @@ public static void TestObjectTypeThrowsInvalidOperationException()
             var editorConfigStorageLocation = new NamingStylePreferenceEditorConfigStorageLocation();
             Assert.Throws<InvalidOperationException>(() =>
             {
-                editorConfigStorageLocation.TryGetOption(new object(), new Dictionary<string, object>(), typeof(object), out var @object);
+                editorConfigStorageLocation.TryGetOption(new object(), new Dictionary<string, string>(), typeof(object), out var @object);
             });
         }
     }