diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs
index 787f2b35096b5b258bed2e4a58a227c7e2dfae8f..29d1fdd2f03bc5bf3596c104e032808c3555cbf0 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs
@@ -26,9 +26,9 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Field),
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                new SymbolKindOrTypeKind(SymbolKind.Field),
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary));
             await VerifyNoModifiers(markup);
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -44,9 +44,9 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Field),
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                new SymbolKindOrTypeKind(SymbolKind.Field),
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary));
             await VerifyNoModifiers(markup);
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.Public);
@@ -62,8 +62,8 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary));
             await VerifyModifiers(markup, new DeclarationModifiers(isVirtual: true));
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.Public);
@@ -79,9 +79,9 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Field),
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                new SymbolKindOrTypeKind(SymbolKind.Field),
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary));
             await VerifyModifiers(markup, new DeclarationModifiers(isStatic: true));
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.Private);
@@ -97,7 +97,7 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Field));
+                new SymbolKindOrTypeKind(SymbolKind.Field));
             await VerifyModifiers(markup, new DeclarationModifiers(isConst: true));
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.Private);
@@ -116,8 +116,8 @@ void goo()
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local),
-                new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction));
+                new SymbolKindOrTypeKind(SymbolKind.Local),
+                new SymbolKindOrTypeKind(MethodKind.LocalFunction));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -136,7 +136,7 @@ void goo()
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local));
+                new SymbolKindOrTypeKind(SymbolKind.Local));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -155,8 +155,8 @@ void goo()
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local),
-                new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction));
+                new SymbolKindOrTypeKind(SymbolKind.Local),
+                new SymbolKindOrTypeKind(MethodKind.LocalFunction));
             await VerifyModifiers(markup, new DeclarationModifiers(isReadOnly: true));
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -175,7 +175,7 @@ void goo()
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local));
+                new SymbolKindOrTypeKind(SymbolKind.Local));
             await VerifyModifiers(markup, new DeclarationModifiers(isReadOnly: true));
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -194,7 +194,7 @@ void M()
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local));
+                new SymbolKindOrTypeKind(SymbolKind.Local));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -213,7 +213,7 @@ void M()
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local));
+                new SymbolKindOrTypeKind(SymbolKind.Local));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -232,7 +232,7 @@ void M()
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local));
+                new SymbolKindOrTypeKind(SymbolKind.Local));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -251,7 +251,7 @@ void M()
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local));
+                new SymbolKindOrTypeKind(SymbolKind.Local));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -270,7 +270,7 @@ void M()
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local));
+                new SymbolKindOrTypeKind(SymbolKind.Local));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "int");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -287,7 +287,7 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Parameter));
+                new SymbolKindOrTypeKind(SymbolKind.Parameter));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "global::C");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -304,7 +304,7 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Parameter));
+                new SymbolKindOrTypeKind(SymbolKind.Parameter));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "global::C");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -321,7 +321,7 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Parameter));
+                new SymbolKindOrTypeKind(SymbolKind.Parameter));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "string");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -338,7 +338,7 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Parameter));
+                new SymbolKindOrTypeKind(SymbolKind.Parameter));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "string");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -356,7 +356,7 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Parameter));
+                new SymbolKindOrTypeKind(SymbolKind.Parameter));
             await VerifyModifiers(markup, new DeclarationModifiers());
             await VerifyTypeName(markup, "global::System.Collections.Generic.List<string>");
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
@@ -371,7 +371,7 @@ class C<$$
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.TypeParameter));
+                new SymbolKindOrTypeKind(SymbolKind.TypeParameter));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -383,7 +383,7 @@ class C<T1, $$
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.TypeParameter));
+                new SymbolKindOrTypeKind(SymbolKind.TypeParameter));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -396,7 +396,7 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Field));
+                new SymbolKindOrTypeKind(SymbolKind.Field));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -409,7 +409,7 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Field));
+                new SymbolKindOrTypeKind(SymbolKind.Field));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -422,8 +422,8 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -436,8 +436,8 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -450,8 +450,8 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -464,8 +464,8 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -478,7 +478,7 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                new SymbolKindOrTypeKind(MethodKind.Ordinary));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -492,9 +492,9 @@ class C
 }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Field),
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                new SymbolKindOrTypeKind(SymbolKind.Field),
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -513,8 +513,8 @@ static void Main(string[] args)
     }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local),
-                new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction));
+                new SymbolKindOrTypeKind(SymbolKind.Local),
+                new SymbolKindOrTypeKind(MethodKind.LocalFunction));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -533,8 +533,8 @@ static void Main(string[] args)
     }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local),
-                new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction));
+                new SymbolKindOrTypeKind(SymbolKind.Local),
+                new SymbolKindOrTypeKind(MethodKind.LocalFunction));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -553,8 +553,8 @@ static void Main(string[] args)
     }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local),
-                new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction));
+                new SymbolKindOrTypeKind(SymbolKind.Local),
+                new SymbolKindOrTypeKind(MethodKind.LocalFunction));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -572,8 +572,8 @@ static void Main(string[] args)
     }
 ";
             await VerifySymbolKinds(markup,
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local),
-                new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction));
+                new SymbolKindOrTypeKind(SymbolKind.Local),
+                new SymbolKindOrTypeKind(MethodKind.LocalFunction));
         }
 
         private async Task VerifyNoType(string markup)
@@ -594,7 +594,7 @@ private async Task VerifyNoModifiers(string markup)
             Assert.Equal(default(DeclarationModifiers), result.Modifiers);
         }
 
-        private async Task VerifySymbolKinds(string markup, params SymbolOrTypeOrMethodKind[] expectedSymbolKinds)
+        private async Task VerifySymbolKinds(string markup, params SymbolKindOrTypeKind[] expectedSymbolKinds)
         {
             var result = await GetResultsAsync(markup);
             Assert.True(expectedSymbolKinds.SequenceEqual(result.PossibleSymbolKinds));
diff --git a/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs b/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs
index 5eec55060001b4bf2682f11cebf8d9f7481832f6..92100628c0385f37283ec0c5fff48fc5a1b43fc0 100644
--- a/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs
+++ b/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs
@@ -56,7 +56,7 @@ private NamingStylePreferences CreateCustomFieldNamingStylePreference()
             var symbolSpecification = new SymbolSpecification(
                 null,
                 "Name",
-                ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Field)),
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
 
@@ -88,7 +88,7 @@ private NamingStylePreferences CreateCustomStaticFieldNamingStylePreference()
             var symbolSpecification = new SymbolSpecification(
                 null,
                 "Name",
-                ImmutableArray.Create(new SymbolOrTypeOrMethodKind(SymbolKind.Field)),
+                ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray.Create(new ModifierKind(DeclarationModifiers.Static)));
 
diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/EditorConfigNamingStyleParserTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/EditorConfigNamingStyleParserTests.cs
index ae73ea26fd730da9ecd1cdd5b495400553aaf294..7da4550cf89d6d97daeee395d968f83cb5400ffb 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/EditorConfigNamingStyleParserTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/EditorConfigNamingStyleParserTests.cs
@@ -37,8 +37,8 @@ public static void TestPascalCaseRule()
             Assert.Equal("method_and_property_symbols", symbolSpec.Name);
             var expectedApplicableSymbolKindList = new[]
             {
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary),
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property)
+                new SymbolKindOrTypeKind(MethodKind.Ordinary),
+                new SymbolKindOrTypeKind(SymbolKind.Property)
             };
             AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
             Assert.Empty(symbolSpec.RequiredModifierList);
@@ -84,8 +84,8 @@ public static void TestAsyncMethodsAndLocalFunctionsRule()
             Assert.Equal("method_symbols", symbolSpec.Name);
             var expectedApplicableSymbolKindList = new[]
             {
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary),
-                new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction)
+                new SymbolKindOrTypeKind(MethodKind.Ordinary),
+                new SymbolKindOrTypeKind(MethodKind.LocalFunction)
             };
             AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
             Assert.Single(symbolSpec.RequiredModifierList);
@@ -140,11 +140,11 @@ public static void TestPublicMembersCapitalizedRule()
             Assert.Equal("public_symbols", symbolSpec.Name);
             var expectedApplicableSymbolKindList = new[]
             {
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary),
-                new SymbolOrTypeOrMethodKind(SymbolKind.Field),
-                new SymbolOrTypeOrMethodKind(SymbolKind.Event),
-                new SymbolOrTypeOrMethodKind(TypeKind.Delegate)
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary),
+                new SymbolKindOrTypeKind(SymbolKind.Field),
+                new SymbolKindOrTypeKind(SymbolKind.Event),
+                new SymbolKindOrTypeKind(TypeKind.Delegate)
             };
             AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
             var expectedApplicableAccessibilityList = new[]
@@ -188,11 +188,11 @@ public static void TestNonPublicMembersLowerCaseRule()
             Assert.Equal("non_public_symbols", symbolSpec.Name);
             var expectedApplicableSymbolKindList = new[]
             {
-                new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                new SymbolOrTypeOrMethodKind(MethodKind.Ordinary),
-                new SymbolOrTypeOrMethodKind(SymbolKind.Field),
-                new SymbolOrTypeOrMethodKind(SymbolKind.Event),
-                new SymbolOrTypeOrMethodKind(TypeKind.Delegate)
+                new SymbolKindOrTypeKind(SymbolKind.Property),
+                new SymbolKindOrTypeKind(MethodKind.Ordinary),
+                new SymbolKindOrTypeKind(SymbolKind.Field),
+                new SymbolKindOrTypeKind(SymbolKind.Event),
+                new SymbolKindOrTypeKind(TypeKind.Delegate)
             };
             AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
             Assert.Single(symbolSpec.ApplicableAccessibilityList);
@@ -232,8 +232,8 @@ public static void TestParametersAndLocalsAreCamelCaseRule()
             Assert.Equal("parameters_and_locals", symbolSpec.Name);
             var expectedApplicableSymbolKindList = new[]
             {
-                new SymbolOrTypeOrMethodKind(SymbolKind.Parameter),
-                new SymbolOrTypeOrMethodKind(SymbolKind.Local),
+                new SymbolKindOrTypeKind(SymbolKind.Parameter),
+                new SymbolKindOrTypeKind(SymbolKind.Local),
             };
             AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
             Assert.Empty(symbolSpec.ApplicableAccessibilityList);
@@ -271,7 +271,7 @@ public static void TestLocalFunctionsAreCamelCaseRule()
             Assert.Equal(DiagnosticSeverity.Info, namingRule.EnforcementLevel);
 
             Assert.Equal("local_functions", symbolSpec.Name);
-            var expectedApplicableSymbolKindList = new[] { new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction) };
+            var expectedApplicableSymbolKindList = new[] { new SymbolKindOrTypeKind(MethodKind.LocalFunction) };
             AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList);
             Assert.Empty(symbolSpec.ApplicableAccessibilityList);
             Assert.Empty(symbolSpec.RequiredModifierList);
diff --git a/src/EditorFeatures/TestUtilities/Diagnostics/NamingStyles/NamingStylesTestOptionSets.cs b/src/EditorFeatures/TestUtilities/Diagnostics/NamingStyles/NamingStylesTestOptionSets.cs
index f3d08d92cc25775d434a2cc98699bf7336d9a3d2..38654e194e18fab1ef0b07ffebe9e32ffc948839 100644
--- a/src/EditorFeatures/TestUtilities/Diagnostics/NamingStyles/NamingStylesTestOptionSets.cs
+++ b/src/EditorFeatures/TestUtilities/Diagnostics/NamingStyles/NamingStylesTestOptionSets.cs
@@ -62,7 +62,7 @@ private static NamingStylePreferences ClassNamesArePascalCaseOption()
             var symbolSpecification = new SymbolSpecification(
                 null,
                 "Name",
-                ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(TypeKind.Class)),
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Class)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
 
@@ -92,7 +92,7 @@ private static NamingStylePreferences MethodNamesArePascalCaseOption()
             var symbolSpecification = new SymbolSpecification(
                 null,
                 "Name",
-                ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(MethodKind.Ordinary)),
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
 
@@ -123,7 +123,7 @@ private static NamingStylePreferences ParameterNamesAreCamelCaseOption()
             var symbolSpecification = new SymbolSpecification(
                 null,
                 "Name",
-                ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Parameter)),
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Parameter)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
 
@@ -155,7 +155,7 @@ private static NamingStylePreferences LocalNamesAreCamelCaseOption()
             var symbolSpecification = new SymbolSpecification(
                 null,
                 "Name",
-                ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Local)),
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
 
@@ -187,7 +187,7 @@ private static NamingStylePreferences LocalFunctionNamesAreCamelCaseOption()
             var symbolSpecification = new SymbolSpecification(
                 null,
                 "Name",
-                ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(MethodKind.LocalFunction)),
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
 
@@ -219,7 +219,7 @@ private static NamingStylePreferences PropertyNamesArePascalCaseOption()
             var symbolSpecification = new SymbolSpecification(
                 null,
                 "Name",
-                ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Property)),
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Property)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
 
@@ -251,7 +251,7 @@ private static NamingStylePreferences InterfacesNamesStartWithIOption()
             var symbolSpecification = new SymbolSpecification(
                 null,
                 "Name",
-                ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(TypeKind.Interface)),
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Interface)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
 
@@ -284,8 +284,8 @@ private static NamingStylePreferences ConstantsAreUpperCaseOption()
                 null,
                 "Name",
                 ImmutableArray.Create(
-                    new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Field),
-                    new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Local)),
+                    new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),
+                    new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsConst)));
 
@@ -317,14 +317,14 @@ private static NamingStylePreferences LocalsAreCamelCaseConstantsAreUpperCaseOpt
             var localsSymbolSpecification = new SymbolSpecification(
                 null,
                 "Locals",
-                ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Local)),
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray<SymbolSpecification.ModifierKind>.Empty);
 
             var constLocalsSymbolSpecification = new SymbolSpecification(
                 null,
                 "Const Locals",
-                ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Local)),
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsConst)));
 
@@ -372,8 +372,8 @@ private static NamingStylePreferences AsyncFunctionNamesEndWithAsyncOption()
                 null,
                 "Name",
                 ImmutableArray.Create(
-                    new SymbolSpecification.SymbolOrTypeOrMethodKind(MethodKind.Ordinary),
-                    new SymbolSpecification.SymbolOrTypeOrMethodKind(MethodKind.LocalFunction)),
+                    new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary),
+                    new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction)),
                 ImmutableArray<Accessibility>.Empty,
                 ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsAsync)));
  
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.DeclarationInfo.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.DeclarationInfo.cs
index f8d0e5354421218d6c8d8a5fac2f4f7d188fad83..9314581a023d3da54ae7786390bfd6dab07eaf56 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.DeclarationInfo.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.DeclarationInfo.cs
@@ -17,11 +17,11 @@ internal partial class DeclarationNameCompletionProvider
     {
         internal struct NameDeclarationInfo
         {
-            private static readonly ImmutableArray<SymbolOrTypeOrMethodKind> s_parameterSyntaxKind =
-                ImmutableArray.Create(new SymbolOrTypeOrMethodKind(SymbolKind.Parameter));
+            private static readonly ImmutableArray<SymbolKindOrTypeKind> s_parameterSyntaxKind =
+                ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Parameter));
 
             public NameDeclarationInfo(
-                ImmutableArray<SymbolOrTypeOrMethodKind> possibleSymbolKinds,
+                ImmutableArray<SymbolKindOrTypeKind> possibleSymbolKinds,
                 Accessibility accessibility,
                 DeclarationModifiers declarationModifiers,
                 ITypeSymbol type,
@@ -34,7 +34,7 @@ internal struct NameDeclarationInfo
                 Alias = alias;
             }
 
-            public ImmutableArray<SymbolOrTypeOrMethodKind> PossibleSymbolKinds { get; }
+            public ImmutableArray<SymbolKindOrTypeKind> PossibleSymbolKinds { get; }
             public DeclarationModifiers Modifiers { get; }
             public ITypeSymbol Type { get; }
             public IAliasSymbol Alias { get; }
@@ -88,7 +88,7 @@ internal static async Task<NameDeclarationInfo> GetDeclarationInfo(Document docu
                 if (type != null)
                 {
                     result = new NameDeclarationInfo(
-                        ImmutableArray.Create(new SymbolOrTypeOrMethodKind(SymbolKind.Local)),
+                        ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Local)),
                         Accessibility.NotApplicable,
                         new DeclarationModifiers(),
                         type,
@@ -109,8 +109,8 @@ internal static async Task<NameDeclarationInfo> GetDeclarationInfo(Document docu
                     e => e.Expression,
                     _ => default,
                     _ => ImmutableArray.Create(
-                        new SymbolOrTypeOrMethodKind(SymbolKind.Local),
-                        new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction)),
+                        new SymbolKindOrTypeKind(SymbolKind.Local),
+                        new SymbolKindOrTypeKind(MethodKind.LocalFunction)),
                     cancellationToken);
                 return result.Type != null;
             }
@@ -147,7 +147,7 @@ internal static async Task<NameDeclarationInfo> GetDeclarationInfo(Document docu
                 SemanticModel semanticModel,
                 Func<TSyntaxNode, SyntaxNode> typeSyntaxGetter,
                 Func<TSyntaxNode, SyntaxTokenList?> modifierGetter,
-                Func<DeclarationModifiers, ImmutableArray<SymbolOrTypeOrMethodKind>> possibleDeclarationComputer,
+                Func<DeclarationModifiers, ImmutableArray<SymbolKindOrTypeKind>> possibleDeclarationComputer,
                 CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
             {
                 if (!IsPossibleTypeToken(token) && !token.IsKind(SyntaxKind.CommaToken))
@@ -200,7 +200,7 @@ internal static async Task<NameDeclarationInfo> GetDeclarationInfo(Document docu
                 SemanticModel semanticModel,
                 Func<TSyntaxNode, SyntaxNode> typeSyntaxGetter,
                 Func<TSyntaxNode, SyntaxTokenList> modifierGetter,
-                Func<DeclarationModifiers, ImmutableArray<SymbolOrTypeOrMethodKind>> possibleDeclarationComputer,
+                Func<DeclarationModifiers, ImmutableArray<SymbolKindOrTypeKind>> possibleDeclarationComputer,
                 CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
             {
                 if (!IsPossibleTypeToken(token))
@@ -266,15 +266,15 @@ internal static async Task<NameDeclarationInfo> GetDeclarationInfo(Document docu
                      cancellationToken);
                 return result.Type != null;
 
-                ImmutableArray<SymbolOrTypeOrMethodKind> GetPossibleKinds()
+                ImmutableArray<SymbolKindOrTypeKind> GetPossibleKinds()
                 {
                     // If we only have a type, this can still end up being a local function.
                     return token.IsKind(SyntaxKind.CommaToken)
                         ? ImmutableArray.Create(
-                            new SymbolOrTypeOrMethodKind(SymbolKind.Local))
+                            new SymbolKindOrTypeKind(SymbolKind.Local))
                         : ImmutableArray.Create(
-                            new SymbolOrTypeOrMethodKind(SymbolKind.Local),
-                            new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction));
+                            new SymbolKindOrTypeKind(SymbolKind.Local),
+                            new SymbolKindOrTypeKind(MethodKind.LocalFunction));
                 }
             }
 
@@ -289,7 +289,7 @@ ImmutableArray<SymbolOrTypeOrMethodKind> GetPossibleKinds()
                         f is ForEachVariableStatementSyntax forEachVariableStatement ? forEachVariableStatement.Variable :
                         null, // Return null to bail out.
                     modifierGetter: f => default,
-                    possibleDeclarationComputer: d => ImmutableArray.Create(new SymbolOrTypeOrMethodKind(SymbolKind.Local)),
+                    possibleDeclarationComputer: d => ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Local)),
                     cancellationToken);
                 return result.Type != null;
             }
@@ -301,7 +301,7 @@ ImmutableArray<SymbolOrTypeOrMethodKind> GetPossibleKinds()
                     token.Parent.IsKind(SyntaxKind.TypeParameterList))
                 {
                     result = new NameDeclarationInfo(
-                        ImmutableArray.Create(new SymbolOrTypeOrMethodKind(SymbolKind.TypeParameter)),
+                        ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.TypeParameter)),
                         Accessibility.NotApplicable,
                         new DeclarationModifiers(),
                         type: null,
@@ -368,28 +368,28 @@ ImmutableArray<SymbolOrTypeOrMethodKind> GetPossibleKinds()
                     SyntaxKind.CloseBracketToken)
                 || token.Parent.IsKind(SyntaxKind.PredefinedType);
 
-            private static ImmutableArray<SymbolOrTypeOrMethodKind> GetPossibleMemberDeclarations(DeclarationModifiers modifiers)
+            private static ImmutableArray<SymbolKindOrTypeKind> GetPossibleMemberDeclarations(DeclarationModifiers modifiers)
             {
                 if (modifiers.IsConst || modifiers.IsReadOnly)
                 {
-                    return ImmutableArray.Create(new SymbolOrTypeOrMethodKind(SymbolKind.Field));
+                    return ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field));
                 }
 
                 var possibleTypes = ImmutableArray.Create(
-                    new SymbolOrTypeOrMethodKind(SymbolKind.Field),
-                    new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                    new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+                    new SymbolKindOrTypeKind(SymbolKind.Field),
+                    new SymbolKindOrTypeKind(SymbolKind.Property),
+                    new SymbolKindOrTypeKind(MethodKind.Ordinary));
 
                 if (modifiers.IsAbstract || modifiers.IsVirtual || modifiers.IsSealed || modifiers.IsOverride)
                 {
-                    possibleTypes = possibleTypes.Remove(new SymbolOrTypeOrMethodKind(SymbolKind.Field));
+                    possibleTypes = possibleTypes.Remove(new SymbolKindOrTypeKind(SymbolKind.Field));
                 }
 
                 if (modifiers.IsAsync || modifiers.IsPartial)
                 {
                     // Fields and properties cannot be async or partial.
-                    possibleTypes = possibleTypes.Remove(new SymbolOrTypeOrMethodKind(SymbolKind.Field));
-                    possibleTypes = possibleTypes.Remove(new SymbolOrTypeOrMethodKind(SymbolKind.Property));
+                    possibleTypes = possibleTypes.Remove(new SymbolKindOrTypeKind(SymbolKind.Field));
+                    possibleTypes = possibleTypes.Remove(new SymbolKindOrTypeKind(SymbolKind.Property));
                 }
 
                 return possibleTypes;
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider_BuiltInStyles.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider_BuiltInStyles.cs
index 6fe477f52a01d0d70631a5ea5d5ebcf314f01424..4f30effdd734ffd9e36da61886eb5221424b0e11 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider_BuiltInStyles.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider_BuiltInStyles.cs
@@ -23,7 +23,7 @@ static DeclarationNameCompletionProvider()
 
         private static NamingRule CreateGetAsyncRule()
         {
-            var kinds = ImmutableArray.Create(new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+            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),
@@ -33,7 +33,7 @@ private static NamingRule CreateGetAsyncRule()
 
         private static NamingRule CreateCamelCaseFieldsAndParametersRule()
         {
-            var kinds = ImmutableArray.Create(new SymbolOrTypeOrMethodKind(SymbolKind.Field), new SymbolOrTypeOrMethodKind(SymbolKind.Parameter), new SymbolOrTypeOrMethodKind(SymbolKind.Local));
+            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),
@@ -43,7 +43,7 @@ private static NamingRule CreateCamelCaseFieldsAndParametersRule()
 
         private static NamingRule CreateEndWithAsyncRule()
         {
-            var kinds = ImmutableArray.Create(new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+            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),
@@ -53,7 +53,7 @@ private static NamingRule CreateEndWithAsyncRule()
 
         private static NamingRule CreateMethodStartsWithGetRule()
         {
-            var kinds = ImmutableArray.Create(new SymbolOrTypeOrMethodKind(MethodKind.Ordinary));
+            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),
diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs
index d83d44814328156b46ab9767caaad169867462f2..1ec35406a13b6b099d10b4f671c28a998d963567 100644
--- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs
@@ -87,7 +87,7 @@ internal override async Task<string> GetFieldNameAsync(Document document, IPrope
                     new SymbolSpecification(
                         Guid.NewGuid(),
                         "Field",
-                        ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Field)),
+                        ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)),
                         modifiers: modifiers),
                     new NamingStyles.NamingStyle(
                         Guid.NewGuid(),
@@ -103,7 +103,7 @@ private string GenerateFieldName(IPropertySymbol property, ImmutableArray<Naming
             foreach (var rule in rules)
             {
                 if (rule.SymbolSpecification.AppliesTo(
-                    new SymbolOrTypeOrMethodKind(SymbolKind.Field),
+                    new SymbolKindOrTypeKind(SymbolKind.Field),
                     property.IsStatic ? DeclarationModifiers.Static : DeclarationModifiers.None,
                     Accessibility.Private))
                 {
diff --git a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs
index 38cc84c422aaadaf110afd407738a821aa36fb43..190d12419f3488ef92311903f01cd1c9fedd3421 100644
--- a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs
+++ b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs
@@ -45,17 +45,17 @@ internal abstract partial class AbstractInitializeMemberFromParameterCodeRefacto
         private static readonly ImmutableArray<NamingRule> s_builtInRules = ImmutableArray.Create(
                 new NamingRule(new SymbolSpecification(
                     Guid.NewGuid(), "Property",
-                    ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Property))),
+                    ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Property))),
                     new NamingStyles.NamingStyle(Guid.NewGuid(), capitalizationScheme: Capitalization.PascalCase),
                     enforcementLevel: DiagnosticSeverity.Hidden),
                 new NamingRule(new SymbolSpecification(
                     Guid.NewGuid(), "Field",
-                    ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Field))),
+                    ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field))),
                     new NamingStyles.NamingStyle(Guid.NewGuid(), capitalizationScheme: Capitalization.CamelCase),
                     enforcementLevel: DiagnosticSeverity.Hidden),
                 new NamingRule(new SymbolSpecification(
                     Guid.NewGuid(), "FieldWithUnderscore",
-                    ImmutableArray.Create(new SymbolSpecification.SymbolOrTypeOrMethodKind(SymbolKind.Field))),
+                    ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field))),
                     new NamingStyles.NamingStyle(Guid.NewGuid(), prefix: "_", capitalizationScheme: Capitalization.CamelCase),
                     enforcementLevel: DiagnosticSeverity.Hidden));
 
diff --git a/src/VisualStudio/Core/Impl/Options/Style/NamingPreferences/SymbolSpecification/SymbolSpecificationViewModel.cs b/src/VisualStudio/Core/Impl/Options/Style/NamingPreferences/SymbolSpecification/SymbolSpecificationViewModel.cs
index 475ad89c972772dfd50df9e270d1f8323342ddba..4070c17f9adcc92392a2587cb2a54717feca1e0f 100644
--- a/src/VisualStudio/Core/Impl/Options/Style/NamingPreferences/SymbolSpecification/SymbolSpecificationViewModel.cs
+++ b/src/VisualStudio/Core/Impl/Options/Style/NamingPreferences/SymbolSpecification/SymbolSpecificationViewModel.cs
@@ -192,12 +192,12 @@ public SymbolKindViewModel(MethodKind methodKind, string name, SymbolSpecificati
                 IsChecked = specification.ApplicableSymbolKindList.Any(k => k.MethodKind == methodKind);
             }
 
-            internal SymbolOrTypeOrMethodKind CreateSymbolOrTypeOrMethodKind()
+            internal SymbolKindOrTypeKind CreateSymbolOrTypeOrMethodKind()
             {
                 return
-                    _symbolKind.HasValue ? new SymbolOrTypeOrMethodKind(_symbolKind.Value) :
-                    _typeKind.HasValue ? new SymbolOrTypeOrMethodKind(_typeKind.Value) :
-                    _methodKind.HasValue ? new SymbolOrTypeOrMethodKind(_methodKind.Value) :
+                    _symbolKind.HasValue ? new SymbolKindOrTypeKind(_symbolKind.Value) :
+                    _typeKind.HasValue ? new SymbolKindOrTypeKind(_typeKind.Value) :
+                    _methodKind.HasValue ? new SymbolKindOrTypeKind(_methodKind.Value) :
                     throw ExceptionUtilities.Unreachable;
             }
         }
diff --git a/src/Workspaces/Core/Portable/NamingStyles/EditorConfig/EditorConfigNamingStyleParser_SymbolSpec.cs b/src/Workspaces/Core/Portable/NamingStyles/EditorConfig/EditorConfigNamingStyleParser_SymbolSpec.cs
index f928256d0b94b5da9c236eacc9f4767122bbf3e4..85bccee13b2deb5d108ecaaef9cdbe153dbddb89 100644
--- a/src/Workspaces/Core/Portable/NamingStyles/EditorConfig/EditorConfigNamingStyleParser_SymbolSpec.cs
+++ b/src/Workspaces/Core/Portable/NamingStyles/EditorConfig/EditorConfigNamingStyleParser_SymbolSpec.cs
@@ -50,7 +50,7 @@ internal static partial class EditorConfigNamingStyleParser
             return false;
         }
 
-        private static ImmutableArray<SymbolOrTypeOrMethodKind> GetSymbolsApplicableKinds(
+        private static ImmutableArray<SymbolKindOrTypeKind> GetSymbolsApplicableKinds(
             string symbolSpecName,
             IReadOnlyDictionary<string, object> conventionsDictionary)
         {
@@ -59,22 +59,22 @@ internal static partial class EditorConfigNamingStyleParser
                 return ParseSymbolKindList(result as string ?? string.Empty);
             }
 
-            return ImmutableArray<SymbolOrTypeOrMethodKind>.Empty;
+            return ImmutableArray<SymbolKindOrTypeKind>.Empty;
         }
 
-        private static readonly SymbolOrTypeOrMethodKind _class = new SymbolOrTypeOrMethodKind(TypeKind.Class);
-        private static readonly SymbolOrTypeOrMethodKind _struct = new SymbolOrTypeOrMethodKind(TypeKind.Struct);
-        private static readonly SymbolOrTypeOrMethodKind _interface = new SymbolOrTypeOrMethodKind(TypeKind.Interface);
-        private static readonly SymbolOrTypeOrMethodKind _enum = new SymbolOrTypeOrMethodKind(TypeKind.Enum);
-        private static readonly SymbolOrTypeOrMethodKind _property = new SymbolOrTypeOrMethodKind(SymbolKind.Property);
-        private static readonly SymbolOrTypeOrMethodKind _method = new SymbolOrTypeOrMethodKind(MethodKind.Ordinary);
-        private static readonly SymbolOrTypeOrMethodKind _localFunction = new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction);
-        private static readonly SymbolOrTypeOrMethodKind _field = new SymbolOrTypeOrMethodKind(SymbolKind.Field);
-        private static readonly SymbolOrTypeOrMethodKind _event = new SymbolOrTypeOrMethodKind(SymbolKind.Event);
-        private static readonly SymbolOrTypeOrMethodKind _delegate = new SymbolOrTypeOrMethodKind(TypeKind.Delegate);
-        private static readonly SymbolOrTypeOrMethodKind _parameter = new SymbolOrTypeOrMethodKind(SymbolKind.Parameter);
-        private static readonly SymbolOrTypeOrMethodKind _local = new SymbolOrTypeOrMethodKind(SymbolKind.Local);
-        private static readonly ImmutableArray<SymbolOrTypeOrMethodKind> _all =
+        private static readonly SymbolKindOrTypeKind _class = new SymbolKindOrTypeKind(TypeKind.Class);
+        private static readonly SymbolKindOrTypeKind _struct = new SymbolKindOrTypeKind(TypeKind.Struct);
+        private static readonly SymbolKindOrTypeKind _interface = new SymbolKindOrTypeKind(TypeKind.Interface);
+        private static readonly SymbolKindOrTypeKind _enum = new SymbolKindOrTypeKind(TypeKind.Enum);
+        private static readonly SymbolKindOrTypeKind _property = new SymbolKindOrTypeKind(SymbolKind.Property);
+        private static readonly SymbolKindOrTypeKind _method = new SymbolKindOrTypeKind(MethodKind.Ordinary);
+        private static readonly SymbolKindOrTypeKind _localFunction = new SymbolKindOrTypeKind(MethodKind.LocalFunction);
+        private static readonly SymbolKindOrTypeKind _field = new SymbolKindOrTypeKind(SymbolKind.Field);
+        private static readonly SymbolKindOrTypeKind _event = new SymbolKindOrTypeKind(SymbolKind.Event);
+        private static readonly SymbolKindOrTypeKind _delegate = new SymbolKindOrTypeKind(TypeKind.Delegate);
+        private static readonly SymbolKindOrTypeKind _parameter = new SymbolKindOrTypeKind(SymbolKind.Parameter);
+        private static readonly SymbolKindOrTypeKind _local = new SymbolKindOrTypeKind(SymbolKind.Local);
+        private static readonly ImmutableArray<SymbolKindOrTypeKind> _all =
             ImmutableArray.Create(
                 _class,
                 _struct,
@@ -89,11 +89,11 @@ internal static partial class EditorConfigNamingStyleParser
                 _parameter,
                 _local);
 
-        private static ImmutableArray<SymbolOrTypeOrMethodKind> ParseSymbolKindList(string symbolSpecApplicableKinds)
+        private static ImmutableArray<SymbolKindOrTypeKind> ParseSymbolKindList(string symbolSpecApplicableKinds)
         {
             if (symbolSpecApplicableKinds == null)
             {
-                return ImmutableArray<SymbolOrTypeOrMethodKind>.Empty;
+                return ImmutableArray<SymbolKindOrTypeKind>.Empty;
             }
 
             if (symbolSpecApplicableKinds.Trim() == "*")
@@ -101,7 +101,7 @@ private static ImmutableArray<SymbolOrTypeOrMethodKind> ParseSymbolKindList(stri
                 return _all;
             }
 
-            var builder = ArrayBuilder<SymbolOrTypeOrMethodKind>.GetInstance();
+            var builder = ArrayBuilder<SymbolKindOrTypeKind>.GetInstance();
             foreach (var symbolSpecApplicableKind in symbolSpecApplicableKinds.Split(',').Select(x => x.Trim()))
             {
                 switch (symbolSpecApplicableKind)
diff --git a/src/Workspaces/Core/Portable/NamingStyles/Serialization/SymbolSpecification.cs b/src/Workspaces/Core/Portable/NamingStyles/Serialization/SymbolSpecification.cs
index b0c51f11a73e43b280acccd3fac4de64af4686ad..dd40ff649f30794796df36a598877cb4296f017e 100644
--- a/src/Workspaces/Core/Portable/NamingStyles/Serialization/SymbolSpecification.cs
+++ b/src/Workspaces/Core/Portable/NamingStyles/Serialization/SymbolSpecification.cs
@@ -17,13 +17,13 @@ internal class SymbolSpecification
         public Guid ID { get; }
         public string Name { get; }
 
-        public ImmutableArray<SymbolOrTypeOrMethodKind> ApplicableSymbolKindList { get; }
+        public ImmutableArray<SymbolKindOrTypeKind> ApplicableSymbolKindList { get; }
         public ImmutableArray<Accessibility> ApplicableAccessibilityList { get; }
         public ImmutableArray<ModifierKind> RequiredModifierList { get; }
 
         public SymbolSpecification(
             Guid? id, string symbolSpecName,
-            ImmutableArray<SymbolOrTypeOrMethodKind> symbolKindList,
+            ImmutableArray<SymbolKindOrTypeKind> symbolKindList,
             ImmutableArray<Accessibility> accessibilityList = default,
             ImmutableArray<ModifierKind> modifiers = default)
         {
@@ -44,22 +44,22 @@ public static SymbolSpecification CreateDefaultSymbolSpecification()
                 id: Guid.NewGuid(),
                 symbolSpecName: null,
                 symbolKindList: ImmutableArray.Create(
-                    new SymbolOrTypeOrMethodKind(SymbolKind.Namespace),
-                    new SymbolOrTypeOrMethodKind(TypeKind.Class),
-                    new SymbolOrTypeOrMethodKind(TypeKind.Struct),
-                    new SymbolOrTypeOrMethodKind(TypeKind.Interface),
-                    new SymbolOrTypeOrMethodKind(TypeKind.Delegate),
-                    new SymbolOrTypeOrMethodKind(TypeKind.Enum),
-                    new SymbolOrTypeOrMethodKind(TypeKind.Module),
-                    new SymbolOrTypeOrMethodKind(TypeKind.Pointer),
-                    new SymbolOrTypeOrMethodKind(TypeKind.TypeParameter),
-                    new SymbolOrTypeOrMethodKind(SymbolKind.Property),
-                    new SymbolOrTypeOrMethodKind(MethodKind.Ordinary),
-                    new SymbolOrTypeOrMethodKind(MethodKind.LocalFunction),
-                    new SymbolOrTypeOrMethodKind(SymbolKind.Field),
-                    new SymbolOrTypeOrMethodKind(SymbolKind.Event),
-                    new SymbolOrTypeOrMethodKind(SymbolKind.Parameter),
-                    new SymbolOrTypeOrMethodKind(SymbolKind.Local)),
+                    new SymbolKindOrTypeKind(SymbolKind.Namespace),
+                    new SymbolKindOrTypeKind(TypeKind.Class),
+                    new SymbolKindOrTypeKind(TypeKind.Struct),
+                    new SymbolKindOrTypeKind(TypeKind.Interface),
+                    new SymbolKindOrTypeKind(TypeKind.Delegate),
+                    new SymbolKindOrTypeKind(TypeKind.Enum),
+                    new SymbolKindOrTypeKind(TypeKind.Module),
+                    new SymbolKindOrTypeKind(TypeKind.Pointer),
+                    new SymbolKindOrTypeKind(TypeKind.TypeParameter),
+                    new SymbolKindOrTypeKind(SymbolKind.Property),
+                    new SymbolKindOrTypeKind(MethodKind.Ordinary),
+                    new SymbolKindOrTypeKind(MethodKind.LocalFunction),
+                    new SymbolKindOrTypeKind(SymbolKind.Field),
+                    new SymbolKindOrTypeKind(SymbolKind.Event),
+                    new SymbolKindOrTypeKind(SymbolKind.Parameter),
+                    new SymbolKindOrTypeKind(SymbolKind.Local)),
                 accessibilityList: ImmutableArray.Create(
                     Accessibility.Public,
                     Accessibility.Internal,
@@ -78,9 +78,9 @@ internal bool AppliesTo(ISymbol symbol)
         }
 
         internal bool AppliesTo(SymbolKind symbolKind, Accessibility accessibility)
-            => this.AppliesTo(new SymbolOrTypeOrMethodKind(symbolKind), new DeclarationModifiers(), accessibility);
+            => this.AppliesTo(new SymbolKindOrTypeKind(symbolKind), new DeclarationModifiers(), accessibility);
 
-        internal bool AppliesTo(SymbolOrTypeOrMethodKind kind, DeclarationModifiers modifiers, Accessibility accessibility)
+        internal bool AppliesTo(SymbolKindOrTypeKind kind, DeclarationModifiers modifiers, Accessibility accessibility)
         {
             if (ApplicableSymbolKindList.Any() && !ApplicableSymbolKindList.Any(k => k.Equals(kind)))
             {
@@ -240,22 +240,22 @@ internal static SymbolSpecification FromXElement(XElement symbolSpecificationEle
                 accessibilityList: GetAccessibilityListFromXElement(symbolSpecificationElement.Element(nameof(ApplicableAccessibilityList))),
                 modifiers: GetModifierListFromXElement(symbolSpecificationElement.Element(nameof(RequiredModifierList))));
 
-        private static ImmutableArray<SymbolOrTypeOrMethodKind> GetSymbolKindListFromXElement(XElement symbolKindListElement)
+        private static ImmutableArray<SymbolKindOrTypeKind> GetSymbolKindListFromXElement(XElement symbolKindListElement)
         {
-            var applicableSymbolKindList = ArrayBuilder<SymbolOrTypeOrMethodKind>.GetInstance();
+            var applicableSymbolKindList = ArrayBuilder<SymbolKindOrTypeKind>.GetInstance();
             foreach (var symbolKindElement in symbolKindListElement.Elements(nameof(SymbolKind)))
             {
-                applicableSymbolKindList.Add(SymbolOrTypeOrMethodKind.AddSymbolKindFromXElement(symbolKindElement));
+                applicableSymbolKindList.Add(SymbolKindOrTypeKind.AddSymbolKindFromXElement(symbolKindElement));
             }
 
             foreach (var typeKindElement in symbolKindListElement.Elements(nameof(TypeKind)))
             {
-                applicableSymbolKindList.Add(SymbolOrTypeOrMethodKind.AddTypeKindFromXElement(typeKindElement));
+                applicableSymbolKindList.Add(SymbolKindOrTypeKind.AddTypeKindFromXElement(typeKindElement));
             }
 
             foreach (var methodKindElement in symbolKindListElement.Elements(nameof(MethodKind)))
             {
-                applicableSymbolKindList.Add(SymbolOrTypeOrMethodKind.AddMethodKindFromXElement(methodKindElement));
+                applicableSymbolKindList.Add(SymbolKindOrTypeKind.AddMethodKindFromXElement(methodKindElement));
             }
 
             return applicableSymbolKindList.ToImmutableAndFree();
@@ -287,27 +287,27 @@ private interface ISymbolMatcher
             bool MatchesSymbol(ISymbol symbol);
         }
 
-        public struct SymbolOrTypeOrMethodKind : IEquatable<SymbolOrTypeOrMethodKind>, ISymbolMatcher
+        public struct SymbolKindOrTypeKind : IEquatable<SymbolKindOrTypeKind>, ISymbolMatcher
         {
             public SymbolKind? SymbolKind { get; }
             public TypeKind? TypeKind { get; }
             public MethodKind? MethodKind { get; }
 
-            public SymbolOrTypeOrMethodKind(SymbolKind symbolKind) : this()
+            public SymbolKindOrTypeKind(SymbolKind symbolKind) : this()
             {
                 SymbolKind = symbolKind;
                 TypeKind = null;
                 MethodKind = null;
             }
 
-            public SymbolOrTypeOrMethodKind(TypeKind typeKind) : this()
+            public SymbolKindOrTypeKind(TypeKind typeKind) : this()
             {
                 SymbolKind = null;
                 TypeKind = typeKind;
                 MethodKind = null;
             }
 
-            public SymbolOrTypeOrMethodKind(MethodKind methodKind) : this()
+            public SymbolKindOrTypeKind(MethodKind methodKind) : this()
             {
                 SymbolKind = null;
                 TypeKind = null;
@@ -326,19 +326,19 @@ internal XElement CreateXElement()
                    MethodKind.HasValue ? new XElement(nameof(MethodKind), MethodKind) :
                    throw ExceptionUtilities.Unreachable;
 
-            internal static SymbolOrTypeOrMethodKind AddSymbolKindFromXElement(XElement symbolKindElement)
-                => new SymbolOrTypeOrMethodKind((SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value));
+            internal static SymbolKindOrTypeKind AddSymbolKindFromXElement(XElement symbolKindElement)
+                => new SymbolKindOrTypeKind((SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value));
 
-            internal static SymbolOrTypeOrMethodKind AddTypeKindFromXElement(XElement typeKindElement)
-                => new SymbolOrTypeOrMethodKind((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value));
+            internal static SymbolKindOrTypeKind AddTypeKindFromXElement(XElement typeKindElement)
+                => new SymbolKindOrTypeKind((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value));
 
-            internal static SymbolOrTypeOrMethodKind AddMethodKindFromXElement(XElement methodKindElement)
-                => new SymbolOrTypeOrMethodKind((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value));
+            internal static SymbolKindOrTypeKind AddMethodKindFromXElement(XElement methodKindElement)
+                => new SymbolKindOrTypeKind((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value));
 
             public override bool Equals(object obj)
-                => Equals((SymbolOrTypeOrMethodKind)obj);
+                => Equals((SymbolKindOrTypeKind)obj);
 
-            public bool Equals(SymbolOrTypeOrMethodKind other)
+            public bool Equals(SymbolKindOrTypeKind other)
                 => this.SymbolKind == other.SymbolKind && this.TypeKind == other.TypeKind && this.MethodKind == other.MethodKind;
 
             public override int GetHashCode()