diff --git a/Tests/Identifiers/CSharpIdentifiers/Access/Types/ClassType.cs b/Tests/Identifiers/CSharpIdentifiers/Access/Types/ClassType.cs
new file mode 100644
index 0000000..17b3ec7
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Access/Types/ClassType.cs
@@ -0,0 +1,10 @@
+namespace CSharpIdentifiers.Access.Types
+{
+    internal class ClassType
+    {
+        private void Method()
+        {
+            var value = new ClassType();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/Access/Types/DelegateType.cs b/Tests/Identifiers/CSharpIdentifiers/Access/Types/DelegateType.cs
new file mode 100644
index 0000000..035cf1a
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Access/Types/DelegateType.cs
@@ -0,0 +1,9 @@
+namespace CSharpIdentifiers.Access.Types
+{
+    internal class DelegateType
+    {
+        internal delegate void Handle();
+
+        public Handle Handler;
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/Access/Types/EnumType.cs b/Tests/Identifiers/CSharpIdentifiers/Access/Types/EnumType.cs
new file mode 100644
index 0000000..c7a645a
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Access/Types/EnumType.cs
@@ -0,0 +1,11 @@
+namespace CSharpIdentifiers.Access.Types
+{
+    internal class EnumType
+    {
+        internal enum MyEnum
+        {
+        }
+
+        private readonly MyEnum value;
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/Access/Types/InterfaceType.cs b/Tests/Identifiers/CSharpIdentifiers/Access/Types/InterfaceType.cs
new file mode 100644
index 0000000..677ab77
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Access/Types/InterfaceType.cs
@@ -0,0 +1,11 @@
+namespace CSharpIdentifiers.Access.Types
+{
+    internal interface IInterfaceType
+    {
+    }
+
+    internal class InterfaceType
+    {
+        private readonly IInterfaceType value;
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/Access/Types/StructureType.cs b/Tests/Identifiers/CSharpIdentifiers/Access/Types/StructureType.cs
new file mode 100644
index 0000000..9c216f1
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Access/Types/StructureType.cs
@@ -0,0 +1,10 @@
+namespace CSharpIdentifiers.Access.Types
+{
+    internal struct StructureType
+    {
+        private void Method()
+        {
+            var value = new StructureType();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/Access/Types/TypeParameter.cs b/Tests/Identifiers/CSharpIdentifiers/Access/Types/TypeParameter.cs
new file mode 100644
index 0000000..557fb16
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Access/Types/TypeParameter.cs
@@ -0,0 +1,7 @@
+namespace CSharpIdentifiers.Access.Types
+{
+    internal class TypeParameter<TValue> where TValue : new()
+    {
+        private TValue Value => new TValue();
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/CSharpIdentifiers.csproj b/Tests/Identifiers/CSharpIdentifiers/CSharpIdentifiers.csproj
index e185c1a..74e37f6 100644
--- a/Tests/Identifiers/CSharpIdentifiers/CSharpIdentifiers.csproj
+++ b/Tests/Identifiers/CSharpIdentifiers/CSharpIdentifiers.csproj
@@ -48,6 +48,12 @@
     <Compile Include="Access\Methods\Method.cs" />
     <Compile Include="Access\Methods\StaticMethod.cs" />
     <Compile Include="Access\Namespaces\CustomNamespaces.cs" />
+    <Compile Include="Access\Types\ClassType.cs" />
+    <Compile Include="Access\Types\DelegateType.cs" />
+    <Compile Include="Access\Types\EnumType.cs" />
+    <Compile Include="Access\Types\InterfaceType.cs" />
+    <Compile Include="Access\Types\StructureType.cs" />
+    <Compile Include="Access\Types\TypeParameter.cs" />
     <Compile Include="AnalyzeOptions\AliasNamespace.cs" />
     <Compile Include="AnalyzeOptions\LocalVariable.cs" />
     <Compile Include="AnalyzeOptions\Member.cs" />
@@ -117,6 +123,12 @@
     <Compile Include="Declarations\Parameters\Variable.cs" />
     <Compile Include="Declarations\Parameters\Optional.cs" />
     <Compile Include="Declarations\Parameters\SimpleParameter.cs" />
+    <Compile Include="Declarations\Types\ClassType.cs" />
+    <Compile Include="Declarations\Types\DelegateType.cs" />
+    <Compile Include="Declarations\Types\EnumType.cs" />
+    <Compile Include="Declarations\Types\InterfaceType.cs" />
+    <Compile Include="Declarations\Types\StructureType.cs" />
+    <Compile Include="Declarations\Types\TypeParameter.cs" />
     <Compile Include="XmlDocComment\TypeParam.cs" />
     <Compile Include="XmlDocComment\TypeParamRef.cs" />
     <Compile Include="XmlDocComment\CrefAttribute.cs" />
diff --git a/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/ClassType.cs b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/ClassType.cs
new file mode 100644
index 0000000..7b1f1c2
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/ClassType.cs
@@ -0,0 +1,6 @@
+namespace CSharpIdentifiers.Declarations.Types
+{
+    internal class ClassType
+    {
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/DelegateType.cs b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/DelegateType.cs
new file mode 100644
index 0000000..76f1bec
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/DelegateType.cs
@@ -0,0 +1,4 @@
+namespace CSharpIdentifiers.Declarations.Types
+{
+    internal delegate void Handle();
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/EnumType.cs b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/EnumType.cs
new file mode 100644
index 0000000..9fe695d
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/EnumType.cs
@@ -0,0 +1,6 @@
+namespace CSharpIdentifiers.Declarations.Types
+{
+    internal enum EnumType
+    {
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/InterfaceType.cs b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/InterfaceType.cs
new file mode 100644
index 0000000..0246740
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/InterfaceType.cs
@@ -0,0 +1,6 @@
+namespace CSharpIdentifiers.Declarations.Types
+{
+    internal interface InterfaceType
+    {
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/StructureType.cs b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/StructureType.cs
new file mode 100644
index 0000000..4ac30da
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/StructureType.cs
@@ -0,0 +1,6 @@
+namespace CSharpIdentifiers.Declarations.Types
+{
+    internal struct StructureType
+    {
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/TypeParameter.cs b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/TypeParameter.cs
new file mode 100644
index 0000000..9d3fe12
--- /dev/null
+++ b/Tests/Identifiers/CSharpIdentifiers/Declarations/Types/TypeParameter.cs
@@ -0,0 +1,9 @@
+namespace CSharpIdentifiers.Declarations.Types
+{
+    internal class TypeParameter<TIn>
+    {
+        public void Method<TOther>()
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/ClassType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/ClassType.vb
new file mode 100644
index 0000000..4e11c96
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/ClassType.vb
@@ -0,0 +1,9 @@
+Namespace Access.Types
+
+  Public Class ClassType
+
+    Public field As ClassType
+
+  End Class
+
+End Namespace
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/DelegateType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/DelegateType.vb
new file mode 100644
index 0000000..105cecc
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/DelegateType.vb
@@ -0,0 +1,11 @@
+Namespace Access.Types
+
+  Public Class DelegateType
+
+    Public Delegate Sub Handle()
+
+    Public field As Handle
+
+  End Class
+
+End Namespace
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/EnumType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/EnumType.vb
new file mode 100644
index 0000000..85dd72f
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/EnumType.vb
@@ -0,0 +1,13 @@
+Namespace Access.Types
+
+  Public Class EnumType
+
+    Public Enum MyEnum
+      V
+    End Enum
+
+    Public field As MyEnum
+
+  End Class
+
+End Namespace
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/InterfaceType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/InterfaceType.vb
new file mode 100644
index 0000000..48e8f03
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/InterfaceType.vb
@@ -0,0 +1,12 @@
+Namespace Access.Types
+
+  Public Class InterfaceType
+
+    Public Interface IInterfaceType
+
+    End Interface
+
+    Public field As IInterfaceType
+  End Class
+
+End Namespace
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/ModuleType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/ModuleType.vb
new file mode 100644
index 0000000..d4e7e46
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/ModuleType.vb
@@ -0,0 +1,11 @@
+Namespace Access.Types
+  Public Module ModuleType
+
+    Public field As Integer
+
+    Sub Method()
+      Dim value = ModuleType.field
+    End Sub
+
+  End Module
+End Namespace
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/StructureType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/StructureType.vb
new file mode 100644
index 0000000..4e75895
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/StructureType.vb
@@ -0,0 +1,11 @@
+Namespace Access.Types
+
+  Public Structure StructureType
+
+    Sub Method()
+      Dim value = New StructureType()
+    End Sub
+
+  End Structure
+
+End Namespace
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/TypeParameter.vb b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/TypeParameter.vb
new file mode 100644
index 0000000..fc2bb5f
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Access/Types/TypeParameter.vb
@@ -0,0 +1,7 @@
+Namespace Access.Types
+
+  Public Class TypeParameter(Of TValue)
+    Public fiedl As TValue
+  End Class
+
+End Namespace
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/ClassType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/ClassType.vb
new file mode 100644
index 0000000..4885a72
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/ClassType.vb
@@ -0,0 +1,3 @@
+Public Class ClassType
+
+End Class
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/DelegateType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/DelegateType.vb
new file mode 100644
index 0000000..21746aa
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/DelegateType.vb
@@ -0,0 +1 @@
+Public Delegate Sub DelegateType()
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/EnumType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/EnumType.vb
new file mode 100644
index 0000000..48ef59b
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/EnumType.vb
@@ -0,0 +1,3 @@
+Public Enum EnumType
+  V
+End Enum
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/InterfaceType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/InterfaceType.vb
new file mode 100644
index 0000000..32369fb
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/InterfaceType.vb
@@ -0,0 +1,3 @@
+Public Interface InterfaceType
+
+End Interface
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/ModuleType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/ModuleType.vb
new file mode 100644
index 0000000..8842eff
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/ModuleType.vb
@@ -0,0 +1,3 @@
+Module ModuleType
+
+End Module
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/StructureType.vb b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/StructureType.vb
new file mode 100644
index 0000000..5c470d5
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/StructureType.vb
@@ -0,0 +1,3 @@
+Public Structure StructureType
+
+End Structure
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/TypeParameter.vb b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/TypeParameter.vb
new file mode 100644
index 0000000..47352d5
--- /dev/null
+++ b/Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/TypeParameter.vb
@@ -0,0 +1,3 @@
+Public Class TypeParameter(Of TValue)
+
+End Class
\ No newline at end of file
diff --git a/Tests/Identifiers/VisualBasicIdentifiers/VisualBasicIdentifiers.vbproj b/Tests/Identifiers/VisualBasicIdentifiers/VisualBasicIdentifiers.vbproj
index 9ea6c7c..11ccb1e 100644
--- a/Tests/Identifiers/VisualBasicIdentifiers/VisualBasicIdentifiers.vbproj
+++ b/Tests/Identifiers/VisualBasicIdentifiers/VisualBasicIdentifiers.vbproj
@@ -89,6 +89,13 @@
     <Compile Include="Access\Parameters\DelegateParameter.vb" />
     <Compile Include="Access\Parameters\OptionalParameter.vb" />
     <Compile Include="Access\Parameters\Variable.vb" />
+    <Compile Include="Access\Types\ClassType.vb" />
+    <Compile Include="Access\Types\DelegateType.vb" />
+    <Compile Include="Access\Types\EnumType.vb" />
+    <Compile Include="Access\Types\InterfaceType.vb" />
+    <Compile Include="Access\Types\ModuleType.vb" />
+    <Compile Include="Access\Types\StructureType.vb" />
+    <Compile Include="Access\Types\TypeParameter.vb" />
     <Compile Include="AnalyzeOptions\LocalVariable.vb" />
     <Compile Include="AnalyzeOptions\Member.vb" />
     <Compile Include="AnalyzeOptions\Method.vb" />
@@ -141,6 +148,13 @@
     <Compile Include="Declarations\Parameters\SimpleParameter.vb" />
     <Compile Include="Declarations\Parameters\TypeCharacter.vb" />
     <Compile Include="Declarations\Parameters\Variable.vb" />
+    <Compile Include="Declarations\Types\ClassType.vb" />
+    <Compile Include="Declarations\Types\DelegateType.vb" />
+    <Compile Include="Declarations\Types\EnumType.vb" />
+    <Compile Include="Declarations\Types\InterfaceType.vb" />
+    <Compile Include="Declarations\Types\ModuleType.vb" />
+    <Compile Include="Declarations\Types\StructureType.vb" />
+    <Compile Include="Declarations\Types\TypeParameter.vb" />
     <Compile Include="Example.vb" />
     <Compile Include="My Project\AssemblyInfo.vb" />
     <Compile Include="My Project\Application.Designer.vb">
diff --git a/src/common/CoCo.MsBuild/MsBuildEngine.cs b/src/common/CoCo.MsBuild/MsBuildEngine.cs
index 108facb..1d407c4 100644
--- a/src/common/CoCo.MsBuild/MsBuildEngine.cs
+++ b/src/common/CoCo.MsBuild/MsBuildEngine.cs
@@ -108,13 +108,14 @@ public MsBuildEngine(Logger logger)
             for (int i = 0; i < projectFileNames.Length; ++i)
             {
                 var projectGlobalProperties = globalProperties[i];
-                var properties = new Dictionary<string, string>(projectGlobalProperties.Count);
+                Dictionary<string, string> properties = null;
                 if (projectGlobalProperties != null)
                 {
+                    properties = new Dictionary<string, string>(projectGlobalProperties.Count);
                     var removeProjectProperties = removeGlobalProperties[i];
                     foreach (DictionaryEntry item in projectGlobalProperties)
                     {
-                        if (item.Key is string key && (removeGlobalProperties == null || !removeProjectProperties.Contains(key)))
+                        if (item.Key is string key && (removeProjectProperties is null || !removeProjectProperties.Contains(key)))
                         {
                             properties.Add(key, item.Value as string);
                         }
@@ -131,15 +132,15 @@ public MsBuildEngine(Logger logger)
                     }
                 }
 
-                var project = new Project(projectFileNames[i], properties, existingToolsVersion);
-                var result = project.CreateProjectInstance().Build(targetNames, new ILogger[0], out var targetOuputs);
+                var project = new Project(projectFileNames[i], properties ?? new Dictionary<string, string>(), existingToolsVersion);
+                var result = project.CreateProjectInstance().Build(targetNames, new ILogger[0], out var targetOutputs);
                 if (!result) _logger.Error("{0} project was failed to build", projectFileNames[i]);
                 allSuccess &= result;
 
                 if (returnTargetOutputs)
                 {
-                    var projectTargetOutputs = new Dictionary<string, ITaskItem[]>(targetOuputs.Count);
-                    foreach (var item in targetOuputs)
+                    var projectTargetOutputs = new Dictionary<string, ITaskItem[]>(targetOutputs.Count);
+                    foreach (var item in targetOutputs)
                     {
                         projectTargetOutputs.Add(item.Key, item.Value.Items);
                     }
diff --git a/src/common/CoCo.UI/UI/PresetsControl.xaml b/src/common/CoCo.UI/UI/PresetsControl.xaml
index 55de8d1..105017b 100644
--- a/src/common/CoCo.UI/UI/PresetsControl.xaml
+++ b/src/common/CoCo.UI/UI/PresetsControl.xaml
@@ -67,7 +67,6 @@
                      Margin="8,0,8,0"
                      Command="{Binding ApplyPreset}"
                      CommandParameter="{Binding}"
-                     Foreground="#5e5e5a"
                      Style="{StaticResource commonButtonStyle}"
                      Template="{StaticResource ApplyPresetButton}" />
                   <Button
diff --git a/src/common/CoCo.UI/ViewModels/ClassificationColorViewModel.cs b/src/common/CoCo.UI/ViewModels/ClassificationColorViewModel.cs
index bd172e7..d82a434 100644
--- a/src/common/CoCo.UI/ViewModels/ClassificationColorViewModel.cs
+++ b/src/common/CoCo.UI/ViewModels/ClassificationColorViewModel.cs
@@ -9,7 +9,8 @@ namespace CoCo.UI.ViewModels
     /// </summary>
     public class ClassificationColorViewModel : BaseViewModel
     {
-        public ClassificationColorViewModel(Color classificationColor, bool colorWasReset, IResetValuesProvider resetValuesProvider)
+        public ClassificationColorViewModel(
+            string classificationName, Color classificationColor, bool colorWasReset, IResetValuesProvider resetValuesProvider)
         {
             _color = classificationColor;
             _colorText = _color.ToString();
@@ -25,7 +26,7 @@ public ClassificationColorViewModel(Color classificationColor, bool colorWasRese
             });
             ResetColor = new DelegateCommand(() =>
             {
-                Color = resetValuesProvider.Foreground;
+                Color = resetValuesProvider.GetForeground(classificationName);
                 ColorWasReset = true;
             });
 
diff --git a/src/common/CoCo.UI/ViewModels/ClassificationViewModel.cs b/src/common/CoCo.UI/ViewModels/ClassificationViewModel.cs
index 84ace23..efdb5aa 100644
--- a/src/common/CoCo.UI/ViewModels/ClassificationViewModel.cs
+++ b/src/common/CoCo.UI/ViewModels/ClassificationViewModel.cs
@@ -22,9 +22,9 @@ public ClassificationViewModel(Classification classification, IResetValuesProvid
             _fontRenderingSize = classification.FontRenderingSize;
 
             Foreground = new ClassificationColorViewModel(
-                classification.Foreground, classification.ForegroundWasReset, resetValuesProvider);
+                _classificationName, classification.Foreground, classification.ForegroundWasReset, resetValuesProvider);
             Background = new ClassificationColorViewModel(
-                classification.Background, classification.BackgroundWasReset, resetValuesProvider);
+                _classificationName, classification.Background, classification.BackgroundWasReset, resetValuesProvider);
 
             _fontRenderingSizeWasReset = classification.FontRenderingSizeWasReset;
 
@@ -32,7 +32,7 @@ public ClassificationViewModel(Classification classification, IResetValuesProvid
 
             ResetFontRenderingSize = new DelegateCommand(() =>
             {
-                SetProperty(ref _fontRenderingSize, resetValuesProvider.FontRenderingSize, nameof(Size));
+                SetProperty(ref _fontRenderingSize, resetValuesProvider.GetFontRenderingSize(_classificationName), nameof(Size));
                 _fontRenderingSizeWasReset = true;
             });
         }
diff --git a/src/common/CoCo.UI/ViewModels/IResetValuesProvider.cs b/src/common/CoCo.UI/ViewModels/IResetValuesProvider.cs
index 3c9a83b..e83d7f1 100644
--- a/src/common/CoCo.UI/ViewModels/IResetValuesProvider.cs
+++ b/src/common/CoCo.UI/ViewModels/IResetValuesProvider.cs
@@ -10,10 +10,10 @@ namespace CoCo.UI.ViewModels
     /// </remarks>
     public interface IResetValuesProvider
     {
-        Color Foreground { get; }
+        Color GetForeground(string name);
 
-        Color Background { get; }
+        Color GetBackground(string name);
 
-        int FontRenderingSize { get; }
+        int GetFontRenderingSize(string name);
     }
 }
\ No newline at end of file
diff --git a/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs b/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs
index 172abdb..bc05377 100644
--- a/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs
+++ b/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs
@@ -31,6 +31,12 @@ internal class CSharpClassifier : RoslynEditorClassifier
         private IClassificationType _labelType;
         private IClassificationType _constantFieldType;
         private IClassificationType _destructorMethodType;
+        private IClassificationType _typeParameterType;
+        private IClassificationType _classType;
+        private IClassificationType _structureType;
+        private IClassificationType _interfaceType;
+        private IClassificationType _enumType;
+        private IClassificationType _delegateType;
 
         internal CSharpClassifier(
             IReadOnlyDictionary<string, ClassificationInfo> classifications,
@@ -61,10 +67,19 @@ internal CSharpClassifier(IReadOnlyDictionary<string, ClassificationInfo> classi
                 if (!semanticModel.TryGetSymbolInfo(node, out var symbol, out var reason))
                 {
                     // NOTE: handle alias in using directive
-                    if ((node.Parent as NameEqualsSyntax)?.Parent is UsingDirectiveSyntax)
+                    if ((node.Parent as NameEqualsSyntax)?.Parent is UsingDirectiveSyntax usingSyntax)
                     {
-                        AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, _aliasNamespaceType);
-                        continue;
+                        var aliasNameSymbol = semanticModel.GetSymbolInfo(usingSyntax.Name).Symbol;
+                        var aliasType =
+                            aliasNameSymbol.Kind == SymbolKind.Namespace ? _aliasNamespaceType :
+                            aliasNameSymbol.Kind == SymbolKind.NamedType ? GetTypeClassification(aliasNameSymbol as INamedTypeSymbol) :
+                            null;
+
+                        if (!(aliasType is null))
+                        {
+                            AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, aliasType);
+                            continue;
+                        }
                     }
 
                     Log.Debug("Nothing is found. Span start at {0} and end at {1}", item.TextSpan.Start, item.TextSpan.End);
@@ -124,6 +139,18 @@ internal CSharpClassifier(IReadOnlyDictionary<string, ClassificationInfo> classi
                         AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, methodType, node);
                         break;
 
+                    case SymbolKind.TypeParameter:
+                        AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, _typeParameterType, node);
+                        break;
+
+                    case SymbolKind.NamedType:
+                        var type = GetTypeClassification(symbol as INamedTypeSymbol);
+                        if (!(type is null))
+                        {
+                            AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, type, node);
+                        }
+                        break;
+
                     default:
                         Log.Debug("Symbol kind={0} was on position [{1}..{2}]", symbol.Kind, item.TextSpan.Start, item.TextSpan.End);
                         Log.Debug("Node is: {0}", node);
@@ -134,6 +161,14 @@ internal CSharpClassifier(IReadOnlyDictionary<string, ClassificationInfo> classi
             return spans;
         }
 
+        private IClassificationType GetTypeClassification(INamedTypeSymbol typeSymbol) =>
+            typeSymbol.TypeKind == TypeKind.Class ? _classType :
+            typeSymbol.TypeKind == TypeKind.Struct ? _structureType :
+            typeSymbol.TypeKind == TypeKind.Interface ? _interfaceType :
+            typeSymbol.TypeKind == TypeKind.Enum ? _enumType :
+            typeSymbol.TypeKind == TypeKind.Delegate ? _delegateType :
+            null;
+
         private void AppendClassificationSpan(
            List<ClassificationSpan> spans, ITextSnapshot snapshot, TextSpan span, IClassificationType type, SyntaxNode node = null)
         {
@@ -153,7 +188,7 @@ void InitializeClassification(string name, ref IClassificationType type)
             {
                 var info = classifications[name];
                 type = info.ClassificationType;
-                options[type] = info;
+                options[type] = info.Option;
                 builder.Add(type);
             }
 
@@ -173,6 +208,12 @@ void InitializeClassification(string name, ref IClassificationType type)
             InitializeClassification(CSharpNames.LabelName, ref _labelType);
             InitializeClassification(CSharpNames.ConstantFieldName, ref _constantFieldType);
             InitializeClassification(CSharpNames.DestructorName, ref _destructorMethodType);
+            InitializeClassification(CSharpNames.TypeParameterName, ref _typeParameterType);
+            InitializeClassification(CSharpNames.ClassName, ref _classType);
+            InitializeClassification(CSharpNames.StructureName, ref _structureType);
+            InitializeClassification(CSharpNames.InterfaceName, ref _interfaceType);
+            InitializeClassification(CSharpNames.EnumName, ref _enumType);
+            InitializeClassification(CSharpNames.DelegateName, ref _delegateType);
 
             base.classifications = builder.ToImmutable();
         }
diff --git a/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpNames.cs b/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpNames.cs
index 64fb36b..f402799 100644
--- a/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpNames.cs
+++ b/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpNames.cs
@@ -20,6 +20,12 @@ public static class CSharpNames
         public const string LabelName = "CoCo csharp label name";
         public const string ConstantFieldName = "CoCo csharp constant field name";
         public const string DestructorName = "CoCo csharp destructor method name";
+        public const string TypeParameterName = "CoCo csharp type parameter name";
+        public const string ClassName = "CoCo csharp class name";
+        public const string StructureName = "CoCo csharp structure name";
+        public const string EnumName = "CoCo csharp enum name";
+        public const string InterfaceName = "CoCo csharp interface name";
+        public const string DelegateName = "CoCo csharp delegate name";
 
         private static ImmutableArray<string> _all;
 
@@ -46,6 +52,12 @@ public static ImmutableArray<string> All
                 builder.Add(LabelName);
                 builder.Add(ConstantFieldName);
                 builder.Add(DestructorName);
+                builder.Add(TypeParameterName);
+                builder.Add(ClassName);
+                builder.Add(StructureName);
+                builder.Add(InterfaceName);
+                builder.Add(EnumName);
+                builder.Add(DelegateName);
                 return _all = builder.ToImmutable();
             }
         }
diff --git a/src/vs14/CoCo.Analyser_vs14/ClassificationHelper.cs b/src/vs14/CoCo.Analyser_vs14/ClassificationHelper.cs
index 4160b9c..d8ff18e 100644
--- a/src/vs14/CoCo.Analyser_vs14/ClassificationHelper.cs
+++ b/src/vs14/CoCo.Analyser_vs14/ClassificationHelper.cs
@@ -3,6 +3,8 @@
     public static class ClassificationHelper
     {
         public static bool IsSupportedClassification(string classification) =>
-            classification == "identifier";
+            classification == "identifier" || classification == "class name" || classification == "delegate name" ||
+            classification == "enum name" || classification == "interface name" || classification == "module name" ||
+            classification == "struct name" || classification == "type parameter name";
     }
 }
\ No newline at end of file
diff --git a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Access/Types.cs b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Access/Types.cs
new file mode 100644
index 0000000..5304dc5
--- /dev/null
+++ b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Access/Types.cs
@@ -0,0 +1,65 @@
+using CoCo.Analyser.CSharp;
+using CoCo.Test.Common;
+using NUnit.Framework;
+
+namespace CoCo.Test.CSharpIdentifiers.Access
+{
+    internal class Types : CSharpIdentifierTests
+    {
+        [Test]
+        public void ClassTest()
+        {
+            GetContext(@"Access\Types\ClassType.cs")
+                .AddInfo(CSharpNames.ClassName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.ClassName.ClassifyAt(152, 9));
+        }
+
+        [Test]
+        public void StructureTest()
+        {
+            GetContext(@"Access\Types\StructureType.cs")
+                .AddInfo(CSharpNames.StructureName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.StructureName.ClassifyAt(157, 13));
+        }
+
+        [Test]
+        public void InterfaceTest()
+        {
+            GetContext(@"Access\Types\InterfaceType.cs")
+                .AddInfo(CSharpNames.InterfaceName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.InterfaceName.ClassifyAt(166, 14));
+        }
+
+        [Test]
+        public void EnumTest()
+        {
+            GetContext(@"Access\Types\EnumType.cs")
+                .AddInfo(CSharpNames.EnumName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.EnumName.ClassifyAt(160, 6));
+        }
+
+        [Test]
+        public void DelegateTest()
+        {
+            GetContext(@"Access\Types\DelegateType.cs")
+                .AddInfo(CSharpNames.DelegateName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.DelegateName.ClassifyAt(144, 6));
+        }
+
+        [Test]
+        public void TypeParameterTest()
+        {
+            GetContext(@"Access\Types\TypeParameter.cs")
+                .AddInfo(CSharpNames.TypeParameterName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.TypeParameterName.ClassifyAt(92, 6),
+                    CSharpNames.TypeParameterName.ClassifyAt(131, 6),
+                    CSharpNames.TypeParameterName.ClassifyAt(151, 6));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Namespaces.cs b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Namespaces.cs
index ea515fc..ae9c1f6 100644
--- a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Namespaces.cs
+++ b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Namespaces.cs
@@ -29,7 +29,7 @@ public void NamespaceTest_DeclarationWithAlias()
         [Test]
         public void NamespaceTest_TypeAlias()
         {
-            GetContext(@"Declarations\Namespaces\TypeAlias.cs").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Namespaces\TypeAlias.cs").GetClassifications().AssertContains(
                 CSharpNames.NamespaceName.ClassifyAt(67, 6),
                 CSharpNames.NamespaceName.ClassifyAt(74, 11),
                 CSharpNames.NamespaceName.ClassifyAt(86, 7));
@@ -38,7 +38,7 @@ public void NamespaceTest_TypeAlias()
         [Test]
         public void NamespaceTest_StaticType()
         {
-            GetContext(@"Declarations\Namespaces\StaticType.cs").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Namespaces\StaticType.cs").GetClassifications().AssertContains(
                 CSharpNames.NamespaceName.ClassifyAt(13, 6),
                 CSharpNames.NamespaceName.ClassifyAt(20, 9));
         }
diff --git a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Types.cs b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Types.cs
new file mode 100644
index 0000000..ea39295
--- /dev/null
+++ b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Types.cs
@@ -0,0 +1,64 @@
+using CoCo.Analyser.CSharp;
+using CoCo.Test.Common;
+using NUnit.Framework;
+
+namespace CoCo.Test.CSharpIdentifiers.Declarations
+{
+    internal class Types : CSharpIdentifierTests
+    {
+        [Test]
+        public void TypeParameterTest()
+        {
+            GetContext(@"Declarations\Types\TypeParameter.cs")
+                .AddInfo(CSharpNames.TypeParameterName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.TypeParameterName.ClassifyAt(84, 3),
+                    CSharpNames.TypeParameterName.ClassifyAt(124, 6));
+        }
+
+        [Test]
+        public void ClassTest()
+        {
+            GetContext(@"Declarations\Types\ClassType.cs")
+                .AddInfo(CSharpNames.ClassName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.ClassName.ClassifyAt(70, 9));
+        }
+
+        [Test]
+        public void StructureTest()
+        {
+            GetContext(@"Declarations\Types\StructureType.cs")
+                .AddInfo(CSharpNames.StructureName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.StructureName.ClassifyAt(71, 13));
+        }
+
+        [Test]
+        public void InterfaceTest()
+        {
+            GetContext(@"Declarations\Types\InterfaceType.cs")
+                .AddInfo(CSharpNames.InterfaceName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.InterfaceName.ClassifyAt(74, 13));
+        }
+
+        [Test]
+        public void EnumTest()
+        {
+            GetContext(@"Declarations\Types\EnumType.cs")
+                .AddInfo(CSharpNames.EnumName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.EnumName.ClassifyAt(69, 8));
+        }
+
+        [Test]
+        public void DelegateTest()
+        {
+            GetContext(@"Declarations\Types\DelegateType.cs")
+                .AddInfo(CSharpNames.DelegateName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.DelegateName.ClassifyAt(78, 6));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/SimpleTest.cs b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/SimpleTest.cs
index 9248cc0..be81a6c 100644
--- a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/SimpleTest.cs
+++ b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/SimpleTest.cs
@@ -9,11 +9,14 @@ internal class SimpleTest : CSharpIdentifierTests
         [Test]
         public void CommonTest()
         {
-            GetContext(@"SimpleExample.cs").GetClassifications().AssertIsEquivalent(
-                CSharpNames.NamespaceName.ClassifyAt(10, 17),
-                CSharpNames.MethodName.ClassifyAt(94, 6),
-                CSharpNames.ParameterName.ClassifyAt(108, 6),
-                CSharpNames.LocalVariableName.ClassifyAt(144, 5));
+            GetContext(@"SimpleExample.cs")
+                .AddInfo(CSharpNames.ClassName.Enable())
+                .GetClassifications().AssertIsEquivalent(
+                    CSharpNames.NamespaceName.ClassifyAt(10, 17),
+                    CSharpNames.ClassName.ClassifyAt(51, 13),
+                    CSharpNames.MethodName.ClassifyAt(94, 6),
+                    CSharpNames.ParameterName.ClassifyAt(108, 6),
+                    CSharpNames.LocalVariableName.ClassifyAt(144, 5));
         }
     }
 }
\ No newline at end of file
diff --git a/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Access/Types.cs b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Access/Types.cs
new file mode 100644
index 0000000..1eed4ed
--- /dev/null
+++ b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Access/Types.cs
@@ -0,0 +1,72 @@
+using CoCo.Analyser.VisualBasic;
+using CoCo.Test.Common;
+using NUnit.Framework;
+
+namespace CoCo.Test.VisualBasicIdentifiers.Access
+{
+    internal class Types : VisualBasicIdentifierTests
+    {
+        [Test]
+        public void TypeParameterTest()
+        {
+            GetContext(@"Access\Types\TypeParameter.vb")
+                .AddInfo(VisualBasicNames.TypeParameterName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.TypeParameterName.ClassifyAt(87, 6));
+        }
+
+        [Test]
+        public void ClassTest()
+        {
+            GetContext(@"Access\Types\ClassType.vb")
+                .AddInfo(VisualBasicNames.ClassName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.ClassName.ClassifyAt(74, 9));
+        }
+
+        [Test]
+        public void StructureTest()
+        {
+            GetContext(@"Access\Types\StructureType.vb")
+                .AddInfo(VisualBasicNames.StructureName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.StructureName.ClassifyAt(102, 13));
+        }
+
+        [Test]
+        public void ModuleTest()
+        {
+            GetContext(@"Access\Types\ModuleType.vb")
+                .AddInfo(VisualBasicNames.ModuleName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.ModuleName.ClassifyAt(121, 10));
+        }
+
+        [Test]
+        public void InterfaceTest()
+        {
+            GetContext(@"Access\Types\InterfaceType.vb")
+                .AddInfo(VisualBasicNames.InterfaceName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.InterfaceName.ClassifyAt(138, 14));
+        }
+
+        [Test]
+        public void EnumTest()
+        {
+            GetContext(@"Access\Types\EnumType.vb")
+                .AddInfo(VisualBasicNames.EnumName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.EnumName.ClassifyAt(122, 6));
+        }
+
+        [Test]
+        public void DelegateTest()
+        {
+            GetContext(@"Access\Types\DelegateType.vb")
+                .AddInfo(VisualBasicNames.DelegateName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.DelegateName.ClassifyAt(113, 6));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Enum.cs b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Enum.cs
index 9a20386..9bd2157 100644
--- a/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Enum.cs
+++ b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Enum.cs
@@ -9,7 +9,7 @@ internal class Enum : VisualBasicIdentifierTests
         [Test]
         public void EnumTest()
         {
-            GetContext(@"Declarations\EnumDeclaration.vb").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\EnumDeclaration.vb").GetClassifications().AssertContains(
                 VisualBasicNames.EnumFieldName.ClassifyAt(22, 4),
                 VisualBasicNames.EnumFieldName.ClassifyAt(30, 5),
                 VisualBasicNames.EnumFieldName.ClassifyAt(39, 6),
diff --git a/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Methods.cs b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Methods.cs
index b50ad8b..daab9c0 100644
--- a/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Methods.cs
+++ b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Methods.cs
@@ -9,14 +9,14 @@ internal class Methods : VisualBasicIdentifierTests
         [Test]
         public void MethodTest_Sub()
         {
-            GetContext(@"Declarations\Methods\SubMethod.vb").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Methods\SubMethod.vb").GetClassifications().AssertContains(
                 VisualBasicNames.SubName.ClassifyAt(39, 6));
         }
 
         [Test]
         public void MethodTest_Function()
         {
-            GetContext(@"Declarations\Methods\FunctionMethod.vb").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Methods\FunctionMethod.vb").GetClassifications().AssertContains(
                 VisualBasicNames.FunctionName.ClassifyAt(49, 6));
         }
 
@@ -30,13 +30,17 @@ public void MethodTest_Extension()
         [Test]
         public void MethodTest_Constructor()
         {
-            GetContext(@"Declarations\Methods\Constructor.vb").GetClassifications().AssertIsEmpty();
+            GetContext(@"Declarations\Methods\Constructor.vb")
+                .AddInfo(VisualBasicNames.ClassName.Disable())
+                .GetClassifications().AssertIsEmpty();
         }
 
         [Test]
         public void MethodTest_SharedConstructor()
         {
-            GetContext(@"Declarations\Methods\StaticConstructor.vb").GetClassifications().AssertIsEmpty();
+            GetContext(@"Declarations\Methods\StaticConstructor.vb")
+                .AddInfo(VisualBasicNames.ClassName.Disable())
+                .GetClassifications().AssertIsEmpty();
         }
 
         [Test]
diff --git a/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Namespaces.cs b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Namespaces.cs
index a794e01..784fc2b 100644
--- a/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Namespaces.cs
+++ b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Namespaces.cs
@@ -26,7 +26,7 @@ public void NamespaceTest_Import()
         [Test]
         public void NamespaceTest_StaticType()
         {
-            GetContext(@"Declarations\Namespaces\StaticType.vb").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Namespaces\StaticType.vb").GetClassifications().AssertContains(
                 VisualBasicNames.NamespaceName.ClassifyAt(8, 6));
         }
 
@@ -42,7 +42,7 @@ public void NamespaceTest_Alias()
         [Test]
         public void NamespaceTest_TypeAlias()
         {
-            GetContext(@"Declarations\Namespaces\TypeAlias.vb").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Namespaces\TypeAlias.vb").GetClassifications().AssertContains(
                 VisualBasicNames.NamespaceName.ClassifyAt(13, 6));
         }
 
diff --git a/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Types.cs b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Types.cs
new file mode 100644
index 0000000..5bd2c8d
--- /dev/null
+++ b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Types.cs
@@ -0,0 +1,72 @@
+using CoCo.Analyser.VisualBasic;
+using CoCo.Test.Common;
+using NUnit.Framework;
+
+namespace CoCo.Test.VisualBasicIdentifiers.Declarations
+{
+    internal class Types : VisualBasicIdentifierTests
+    {
+        [Test]
+        public void TypeParameterTest()
+        {
+            GetContext(@"Declarations\Types\TypeParameter.vb")
+                .AddInfo(VisualBasicNames.TypeParameterName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.TypeParameterName.ClassifyAt(30, 6));
+        }
+
+        [Test]
+        public void ClassTest()
+        {
+            GetContext(@"Declarations\Types\ClassType.vb")
+                .AddInfo(VisualBasicNames.ClassName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.ClassName.ClassifyAt(13, 9));
+        }
+
+        [Test]
+        public void StructureTest()
+        {
+            GetContext(@"Declarations\Types\StructureType.vb")
+                .AddInfo(VisualBasicNames.StructureName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.StructureName.ClassifyAt(17, 13));
+        }
+
+        [Test]
+        public void ModuleTest()
+        {
+            GetContext(@"Declarations\Types\ModuleType.vb")
+                .AddInfo(VisualBasicNames.ModuleName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.ModuleName.ClassifyAt(7, 10));
+        }
+
+        [Test]
+        public void InterfaceTest()
+        {
+            GetContext(@"Declarations\Types\InterfaceType.vb")
+                .AddInfo(VisualBasicNames.InterfaceName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.InterfaceName.ClassifyAt(17, 13));
+        }
+
+        [Test]
+        public void EnumTest()
+        {
+            GetContext(@"Declarations\Types\EnumType.vb")
+                .AddInfo(VisualBasicNames.EnumName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.EnumName.ClassifyAt(12, 8));
+        }
+
+        [Test]
+        public void DelegateTest()
+        {
+            GetContext(@"Declarations\Types\DelegateType.vb")
+                .AddInfo(VisualBasicNames.DelegateName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.DelegateName.ClassifyAt(20, 12));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/vs14/CoCo_vs14/Services/PresetService.cs b/src/vs14/CoCo_vs14/Services/PresetService.cs
index 251c899..5f976c7 100644
--- a/src/vs14/CoCo_vs14/Services/PresetService.cs
+++ b/src/vs14/CoCo_vs14/Services/PresetService.cs
@@ -4,56 +4,59 @@
 using CoCo.Analyser.CSharp;
 using CoCo.Analyser.VisualBasic;
 using CoCo.Settings;
-using Microsoft.VisualStudio.Text.Formatting;
 
 namespace CoCo.Services
 {
     public static class PresetService
     {
-        private static Dictionary<string, List<PresetSettings>> _defaultPresets;
+        private static Dictionary<string, IReadOnlyDictionary<string, PresetSettings>> _defaultPresets;
 
         /// <summary>
         /// Returns the default CoCo settings that are grouped by languages
         /// </summary>
-        public static IReadOnlyDictionary<string, List<PresetSettings>> GetDefaultPresets(TextFormattingRunProperties defaultFormatting)
+        public static IReadOnlyDictionary<string, IReadOnlyDictionary<string, PresetSettings>> GetDefaultPresets()
         {
+            if (!(_defaultPresets is null)) return _defaultPresets;
+
+            _defaultPresets = new Dictionary<string, IReadOnlyDictionary<string, PresetSettings>>();
+
+            var defaulltIdentifierFormatting = FormattingService.GetDefaultIdentifierFormatting();
+
             ClassificationSettings CreateClassification(string name, byte r, byte g, byte b)
             {
+                var defaultFormatting = defaulltIdentifierFormatting;
+                if (ClassificationManager.TryGetDefaultNonIdentifierClassification(name, out var defaultClassification))
+                {
+                    defaultFormatting = FormattingService.GetDefaultFormatting(defaultClassification);
+                }
+
                 var classification = defaultFormatting.ToDefaultSettings(name);
                 classification.Foreground = Color.FromRgb(r, g, b);
                 return classification;
             }
 
-            if (!(_defaultPresets is null)) return _defaultPresets;
-
-            _defaultPresets = new Dictionary<string, List<PresetSettings>>();
-
-            var presets = new List<PresetSettings>
+            var presets = new Dictionary<string, PresetSettings>
             {
-                new PresetSettings
+                ["CoCo light|blue theme"] = new PresetSettings
                 {
                     Name = "CoCo light|blue theme",
                     Classifications = new List<ClassificationSettings>
                     {
-                        CreateClassification(CSharpNames.AliasNamespaceName, 220, 220, 220),
                         CreateClassification(CSharpNames.ConstantFieldName, 255, 157, 255),
-                        CreateClassification(CSharpNames.ConstructorName, 220, 220, 220),
-                        CreateClassification(CSharpNames.DestructorName, 220, 220, 220),
                         CreateClassification(CSharpNames.EnumFieldName, 0, 193, 193),
-                        CreateClassification(CSharpNames.EventName, 220, 220, 220),
                         CreateClassification(CSharpNames.ExtensionMethodName, 233, 122, 0),
                         CreateClassification(CSharpNames.FieldName, 255, 157, 255),
                         CreateClassification(CSharpNames.LabelName, 120, 20, 0),
                         CreateClassification(CSharpNames.LocalVariableName, 128, 128, 0),
                         CreateClassification(CSharpNames.MethodName, 187, 54, 4),
-                        CreateClassification(CSharpNames.NamespaceName, 220, 220, 220),
                         CreateClassification(CSharpNames.ParameterName, 128, 128, 128),
                         CreateClassification(CSharpNames.PropertyName, 255, 0, 255),
                         CreateClassification(CSharpNames.RangeVariableName, 128, 128, 0),
                         CreateClassification(CSharpNames.StaticMethodName, 154, 82, 0)
                     }
                 },
-                new PresetSettings
+
+                ["CoCo dark theme"] = new PresetSettings
                 {
                     Name = "CoCo dark theme",
                     Classifications = new List<ClassificationSettings>
@@ -79,23 +82,20 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b)
             };
             _defaultPresets[Languages.CSharp] = presets;
 
-            presets = new List<PresetSettings>
+            presets = new Dictionary<string, PresetSettings>
             {
-                new PresetSettings
+                ["CoCo light|blue theme"] = new PresetSettings
                 {
                     Name = "CoCo light|blue theme",
                     Classifications = new List<ClassificationSettings>
                     {
-                        CreateClassification(VisualBasicNames.AliasNamespaceName, 220, 220, 220),
                         CreateClassification(VisualBasicNames.ConstantFieldName, 255, 157, 255),
                         CreateClassification(VisualBasicNames.EnumFieldName, 0, 193, 193),
-                        CreateClassification(VisualBasicNames.EventName, 220, 220, 220),
                         CreateClassification(VisualBasicNames.ExtensionMethodName, 233, 122, 0),
                         CreateClassification(VisualBasicNames.FieldName, 255, 157, 255),
                         CreateClassification(VisualBasicNames.FunctionName, 187, 54, 4),
                         CreateClassification(VisualBasicNames.FunctionVariableName, 128, 64, 0),
                         CreateClassification(VisualBasicNames.LocalVariableName, 128, 128, 0),
-                        CreateClassification(VisualBasicNames.NamespaceName, 220, 220, 220),
                         CreateClassification(VisualBasicNames.ParameterName, 128, 128, 128),
                         CreateClassification(VisualBasicNames.PropertyName, 255, 0, 255),
                         CreateClassification(VisualBasicNames.RangeVariableName, 128, 128, 0),
@@ -105,7 +105,8 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b)
                         CreateClassification(VisualBasicNames.WithEventsPropertyName, 255, 0, 128)
                     }
                 },
-                new PresetSettings
+
+                ["CoCo dark theme"] = new PresetSettings
                 {
                     Name = "CoCo dark theme",
                     Classifications = new List<ClassificationSettings>
@@ -134,16 +135,5 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b)
 
             return _defaultPresets;
         }
-
-        public static IReadOnlyDictionary<string, ISet<string>> GetDefaultPresetsNames()
-        {
-            var presets = new HashSet<string> { "CoCo light|blue theme", "CoCo dark theme" };
-
-            return new Dictionary<string, ISet<string>>
-            {
-                [Languages.CSharp] = presets,
-                [Languages.VisualBasic] = presets,
-            };
-        }
     }
 }
\ No newline at end of file
diff --git a/src/vs15/CoCo.Analyser/CSharp/CSharpClassifier.cs b/src/vs15/CoCo.Analyser/CSharp/CSharpClassifier.cs
index c57ad07..9381318 100644
--- a/src/vs15/CoCo.Analyser/CSharp/CSharpClassifier.cs
+++ b/src/vs15/CoCo.Analyser/CSharp/CSharpClassifier.cs
@@ -32,6 +32,12 @@ internal class CSharpClassifier : RoslynEditorClassifier
         private IClassificationType _localMethodType;
         private IClassificationType _constantFieldType;
         private IClassificationType _destructorType;
+        private IClassificationType _typeParameterType;
+        private IClassificationType _classType;
+        private IClassificationType _structureType;
+        private IClassificationType _interfaceType;
+        private IClassificationType _enumType;
+        private IClassificationType _delegateType;
 
         internal CSharpClassifier(
             IReadOnlyDictionary<string, ClassificationInfo> classifications,
@@ -62,10 +68,19 @@ internal CSharpClassifier(IReadOnlyDictionary<string, ClassificationInfo> classi
                 if (!semanticModel.TryGetSymbolInfo(node, out var symbol, out var reason))
                 {
                     // NOTE: handle alias in using directive
-                    if ((node.Parent as NameEqualsSyntax)?.Parent is UsingDirectiveSyntax)
+                    if ((node.Parent as NameEqualsSyntax)?.Parent is UsingDirectiveSyntax usingSyntax)
                     {
-                        AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, _aliasNamespaceType);
-                        continue;
+                        var aliasNameSymbol = semanticModel.GetSymbolInfo(usingSyntax.Name).Symbol;
+                        var aliasType =
+                            aliasNameSymbol.Kind == SymbolKind.Namespace ? _aliasNamespaceType :
+                            aliasNameSymbol.Kind == SymbolKind.NamedType ? GetTypeClassification(aliasNameSymbol as INamedTypeSymbol) :
+                            null;
+
+                        if (!(aliasType is null))
+                        {
+                            AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, aliasType);
+                            continue;
+                        }
                     }
 
                     Log.Debug("Nothing is found. Span start at {0} and end at {1}", item.TextSpan.Start, item.TextSpan.End);
@@ -126,6 +141,19 @@ internal CSharpClassifier(IReadOnlyDictionary<string, ClassificationInfo> classi
                         AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, methodType, node);
                         break;
 
+                    case SymbolKind.TypeParameter:
+                        AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, _typeParameterType, node);
+                        break;
+
+                    case SymbolKind.NamedType:
+                        var typeSymbol = symbol as INamedTypeSymbol;
+                        var type = GetTypeClassification(typeSymbol);
+                        if (!(type is null))
+                        {
+                            AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, type, node);
+                        }
+                        break;
+
                     default:
                         Log.Debug("Symbol kind={0} was on position [{1}..{2}]", symbol.Kind, item.TextSpan.Start, item.TextSpan.End);
                         Log.Debug("Node is: {0}", node);
@@ -136,6 +164,14 @@ internal CSharpClassifier(IReadOnlyDictionary<string, ClassificationInfo> classi
             return spans;
         }
 
+        private IClassificationType GetTypeClassification(INamedTypeSymbol typeSymbol) =>
+            typeSymbol.TypeKind == TypeKind.Class ? _classType :
+            typeSymbol.TypeKind == TypeKind.Struct ? _structureType :
+            typeSymbol.TypeKind == TypeKind.Interface ? _interfaceType :
+            typeSymbol.TypeKind == TypeKind.Enum ? _enumType :
+            typeSymbol.TypeKind == TypeKind.Delegate ? _delegateType :
+            null;
+
         private void AppendClassificationSpan(
            List<ClassificationSpan> spans, ITextSnapshot snapshot,
             TextSpan span, IClassificationType type, SyntaxNode node = null)
@@ -156,7 +192,7 @@ void InitializeClassification(string name, ref IClassificationType type)
             {
                 var info = classifications[name];
                 type = info.ClassificationType;
-                options[type] = info;
+                options[type] = info.Option;
                 builder.Add(type);
             }
 
@@ -177,6 +213,12 @@ void InitializeClassification(string name, ref IClassificationType type)
             InitializeClassification(CSharpNames.LocalMethodName, ref _localMethodType);
             InitializeClassification(CSharpNames.ConstantFieldName, ref _constantFieldType);
             InitializeClassification(CSharpNames.DestructorName, ref _destructorType);
+            InitializeClassification(CSharpNames.TypeParameterName, ref _typeParameterType);
+            InitializeClassification(CSharpNames.ClassName, ref _classType);
+            InitializeClassification(CSharpNames.StructureName, ref _structureType);
+            InitializeClassification(CSharpNames.InterfaceName, ref _interfaceType);
+            InitializeClassification(CSharpNames.EnumName, ref _enumType);
+            InitializeClassification(CSharpNames.DelegateName, ref _delegateType);
 
             base.classifications = builder.ToImmutable();
         }
diff --git a/src/vs15/CoCo.Analyser/CSharp/CSharpNames.cs b/src/vs15/CoCo.Analyser/CSharp/CSharpNames.cs
index 6621f9d..f103d8d 100644
--- a/src/vs15/CoCo.Analyser/CSharp/CSharpNames.cs
+++ b/src/vs15/CoCo.Analyser/CSharp/CSharpNames.cs
@@ -21,6 +21,12 @@ public static class CSharpNames
         public const string LocalMethodName = "CoCo csharp local method name";
         public const string ConstantFieldName = "CoCo csharp constant field name";
         public const string DestructorName = "CoCo csharp destructor method name";
+        public const string TypeParameterName = "CoCo csharp type parameter name";
+        public const string ClassName = "CoCo csharp class name";
+        public const string StructureName = "CoCo csharp structure name";
+        public const string EnumName = "CoCo csharp enum name";
+        public const string InterfaceName = "CoCo csharp interface name";
+        public const string DelegateName = "CoCo csharp delegate name";
 
         private static ImmutableArray<string> _all;
 
@@ -48,6 +54,12 @@ public static ImmutableArray<string> All
                 builder.Add(LocalMethodName);
                 builder.Add(ConstantFieldName);
                 builder.Add(DestructorName);
+                builder.Add(TypeParameterName);
+                builder.Add(ClassName);
+                builder.Add(StructureName);
+                builder.Add(InterfaceName);
+                builder.Add(EnumName);
+                builder.Add(DelegateName);
                 return _all = builder.ToImmutable();
             }
         }
diff --git a/src/vs15/CoCo.Analyser/ClassificationHelper.cs b/src/vs15/CoCo.Analyser/ClassificationHelper.cs
index cb92889..6aef912 100644
--- a/src/vs15/CoCo.Analyser/ClassificationHelper.cs
+++ b/src/vs15/CoCo.Analyser/ClassificationHelper.cs
@@ -6,6 +6,8 @@ public static class ClassificationHelper
             classification == "identifier" || classification == "extension method name" || classification == "field name" ||
             classification == "property name" || classification == "method name" || classification == "local name" ||
             classification == "parameter name" || classification == "event name" || classification == "enum member name" ||
-            classification == "constant name";
+            classification == "constant name" || classification == "class name" || classification == "delegate name" ||
+            classification == "enum name" || classification == "interface name" || classification == "module name" ||
+            classification == "struct name" || classification == "type parameter name";
     }
 }
\ No newline at end of file
diff --git a/src/vs15/CoCo.Analyser/ClassificationInfo.cs b/src/vs15/CoCo.Analyser/ClassificationInfo.cs
index 471f667..85c7b32 100644
--- a/src/vs15/CoCo.Analyser/ClassificationInfo.cs
+++ b/src/vs15/CoCo.Analyser/ClassificationInfo.cs
@@ -4,15 +4,25 @@ namespace CoCo.Analyser
 {
     public struct ClassificationInfo
     {
-        public ClassificationInfo(IClassificationType classificationType, bool isDisabled, bool isDisabledInXml)
+        public ClassificationInfo(IClassificationType classificationType, ClassificationOption option)
         {
             ClassificationType = classificationType;
-            IsDisabled = isDisabled;
-            IsDisabledInXml = isDisabledInXml;
+            Option = option;
         }
 
         public IClassificationType ClassificationType { get; }
 
+        public ClassificationOption Option { get; }
+    }
+
+    public struct ClassificationOption
+    {
+        public ClassificationOption(bool isDisabled, bool isDisabledInXml)
+        {
+            IsDisabled = isDisabled;
+            IsDisabledInXml = isDisabledInXml;
+        }
+
         public bool IsDisabled { get; }
 
         public bool IsDisabledInXml { get; }
diff --git a/src/vs15/CoCo.Analyser/ClassificationService.cs b/src/vs15/CoCo.Analyser/ClassificationService.cs
index 83df851..b3c4181 100644
--- a/src/vs15/CoCo.Analyser/ClassificationService.cs
+++ b/src/vs15/CoCo.Analyser/ClassificationService.cs
@@ -1,9 +1,34 @@
-using Microsoft.VisualStudio.Text.Classification;
+using System.Collections.Generic;
+using CoCo.Analyser.CSharp;
+using CoCo.Analyser.VisualBasic;
+using Microsoft.VisualStudio.Text.Classification;
 
 namespace CoCo.Analyser
 {
     internal static class ClassificationService
     {
-        public static ClassificationInfo GetDefaultInfo(IClassificationType type) => new ClassificationInfo(type, false, false);
+        private static readonly HashSet<string> _disabledClassifications = new HashSet<string>
+        {
+            CSharpNames.ClassName,
+            CSharpNames.StructureName,
+            CSharpNames.InterfaceName,
+            CSharpNames.EnumName,
+            CSharpNames.DelegateName,
+            CSharpNames.TypeParameterName,
+
+            VisualBasicNames.ClassName,
+            VisualBasicNames.StructureName,
+            VisualBasicNames.ModuleName,
+            VisualBasicNames.InterfaceName,
+            VisualBasicNames.EnumName,
+            VisualBasicNames.DelegateName,
+            VisualBasicNames.TypeParameterName
+        };
+
+        public static ClassificationOption GetDefaultInfo(IClassificationType type) => GetDefaultOption(type.Classification);
+
+        public static ClassificationOption GetDefaultOption(string name) => _disabledClassifications.Contains(name)
+            ? new ClassificationOption(true, true)
+            : new ClassificationOption(false, false);
     }
 }
\ No newline at end of file
diff --git a/src/vs15/CoCo.Analyser/ClassificationsChangedEventArgs.cs b/src/vs15/CoCo.Analyser/ClassificationsChangedEventArgs.cs
index d62e7da..a9bf85d 100644
--- a/src/vs15/CoCo.Analyser/ClassificationsChangedEventArgs.cs
+++ b/src/vs15/CoCo.Analyser/ClassificationsChangedEventArgs.cs
@@ -9,11 +9,11 @@ namespace CoCo.Analyser
     public class ClassificationsChangedEventArgs : EventArgs
     {
         public ClassificationsChangedEventArgs(
-            IReadOnlyDictionary<IClassificationType, ClassificationInfo> changedClassifications)
+            IReadOnlyDictionary<IClassificationType, ClassificationOption> changedClassifications)
         {
             ChangedClassifications = changedClassifications;
         }
 
-        public IReadOnlyDictionary<IClassificationType, ClassificationInfo> ChangedClassifications;
+        public IReadOnlyDictionary<IClassificationType, ClassificationOption> ChangedClassifications;
     }
 }
\ No newline at end of file
diff --git a/src/vs15/CoCo.Analyser/RoslynEditorClassifier.cs b/src/vs15/CoCo.Analyser/RoslynEditorClassifier.cs
index 9f53b04..1d1fd7b 100644
--- a/src/vs15/CoCo.Analyser/RoslynEditorClassifier.cs
+++ b/src/vs15/CoCo.Analyser/RoslynEditorClassifier.cs
@@ -19,8 +19,8 @@ internal abstract class RoslynEditorClassifier : IClassifier
 
         private SemanticModel _semanticModel;
 
-        protected readonly Dictionary<IClassificationType, ClassificationInfo> options =
-            new Dictionary<IClassificationType, ClassificationInfo>();
+        protected readonly Dictionary<IClassificationType, ClassificationOption> options =
+            new Dictionary<IClassificationType, ClassificationOption>();
 
         protected ImmutableArray<IClassificationType> classifications;
 
diff --git a/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicClassifier.cs b/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicClassifier.cs
index 994bf63..829fd54 100644
--- a/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicClassifier.cs
+++ b/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicClassifier.cs
@@ -30,6 +30,13 @@ internal class VisualBasicClassifier : RoslynEditorClassifier
         private IClassificationType _aliasNamespaceType;
         private IClassificationType _staticLocalVariableType;
         private IClassificationType _eventType;
+        private IClassificationType _classType;
+        private IClassificationType _structureType;
+        private IClassificationType _moduleType;
+        private IClassificationType _interfaceType;
+        private IClassificationType _delegateType;
+        private IClassificationType _enumType;
+        private IClassificationType _typeParameterType;
 
         internal VisualBasicClassifier(
             IReadOnlyDictionary<string, ClassificationInfo> classifications,
@@ -60,10 +67,19 @@ internal VisualBasicClassifier(IReadOnlyDictionary<string, ClassificationInfo> c
                 if (!semanticModel.TryGetSymbolInfo(node, out var symbol, out var reason))
                 {
                     // NOTE: handle alias in imports directive
-                    if (node is ImportAliasClauseSyntax aliasSyntax)
+                    if (node is ImportAliasClauseSyntax && node.Parent is SimpleImportsClauseSyntax importSyntax)
                     {
-                        AppendClassificationSpan(spans, span.Snapshot, aliasSyntax.Identifier.Span, _aliasNamespaceType);
-                        continue;
+                        var aliasNameSymbol = semanticModel.GetSymbolInfo(importSyntax.Name).Symbol;
+                        var aliasType =
+                            aliasNameSymbol.Kind == SymbolKind.Namespace ? _aliasNamespaceType :
+                            aliasNameSymbol.Kind == SymbolKind.NamedType ? GetTypeClassification(aliasNameSymbol as INamedTypeSymbol) :
+                            null;
+
+                        if (!(aliasType is null))
+                        {
+                            AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, aliasType);
+                            continue;
+                        }
                     }
 
                     Log.Debug("Nothing is found. Span start at {0} and end at {1}", item.TextSpan.Start, item.TextSpan.End);
@@ -126,6 +142,18 @@ internal VisualBasicClassifier(IReadOnlyDictionary<string, ClassificationInfo> c
                         AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, _eventType, node);
                         break;
 
+                    case SymbolKind.TypeParameter:
+                        AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, _typeParameterType, node);
+                        break;
+
+                    case SymbolKind.NamedType:
+                        var type = GetTypeClassification(symbol as INamedTypeSymbol);
+                        if (!(type is null))
+                        {
+                            AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, type, node);
+                        }
+                        break;
+
                     default:
                         Log.Debug("Symbol kind={0} was on position [{1}..{2}]", symbol.Kind, item.TextSpan.Start, item.TextSpan.End);
                         Log.Debug("Node is: {0}", node);
@@ -136,6 +164,15 @@ internal VisualBasicClassifier(IReadOnlyDictionary<string, ClassificationInfo> c
             return spans;
         }
 
+        private IClassificationType GetTypeClassification(INamedTypeSymbol typeSymbol) =>
+           typeSymbol.TypeKind == TypeKind.Class ? _classType :
+           typeSymbol.TypeKind == TypeKind.Struct ? _structureType :
+           typeSymbol.TypeKind == TypeKind.Module ? _moduleType :
+           typeSymbol.TypeKind == TypeKind.Interface ? _interfaceType :
+           typeSymbol.TypeKind == TypeKind.Enum ? _enumType :
+           typeSymbol.TypeKind == TypeKind.Delegate ? _delegateType :
+           null;
+
         private void AppendClassificationSpan(
            List<ClassificationSpan> spans, ITextSnapshot snapshot, TextSpan span, IClassificationType type, SyntaxNode node = null)
         {
@@ -155,7 +192,7 @@ void InitializeClassification(string name, ref IClassificationType type)
             {
                 var info = classifications[name];
                 type = info.ClassificationType;
-                options[type] = info;
+                options[type] = info.Option;
                 builder.Add(type);
             }
 
@@ -176,6 +213,13 @@ void InitializeClassification(string name, ref IClassificationType type)
             InitializeClassification(VisualBasicNames.AliasNamespaceName, ref _aliasNamespaceType);
             InitializeClassification(VisualBasicNames.StaticLocalVariableName, ref _staticLocalVariableType);
             InitializeClassification(VisualBasicNames.EventName, ref _eventType);
+            InitializeClassification(VisualBasicNames.ClassName, ref _classType);
+            InitializeClassification(VisualBasicNames.StructureName, ref _structureType);
+            InitializeClassification(VisualBasicNames.ModuleName, ref _moduleType);
+            InitializeClassification(VisualBasicNames.InterfaceName, ref _interfaceType);
+            InitializeClassification(VisualBasicNames.DelegateName, ref _delegateType);
+            InitializeClassification(VisualBasicNames.EnumName, ref _enumType);
+            InitializeClassification(VisualBasicNames.TypeParameterName, ref _typeParameterType);
 
             base.classifications = builder.ToImmutable();
         }
diff --git a/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicNames.cs b/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicNames.cs
index 2893f8f..5c9da1a 100644
--- a/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicNames.cs
+++ b/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicNames.cs
@@ -21,6 +21,13 @@ public static class VisualBasicNames
         public const string AliasNamespaceName = "CoCo visual basic alias namespace name";
         public const string StaticLocalVariableName = "CoCo visual basic static local variable name";
         public const string EventName = "CoCo visual basic event name";
+        public const string ClassName = "CoCo visual basic class name";
+        public const string StructureName = "CoCo visual basic structure name";
+        public const string ModuleName = "CoCo visual basic module name";
+        public const string InterfaceName = "CoCo visual basic interface name";
+        public const string DelegateName = "CoCo visual basic delegate name";
+        public const string EnumName = "CoCo visual basic enum name";
+        public const string TypeParameterName = "CoCo visual basic type parameter name";
 
         private static ImmutableArray<string> _all;
 
@@ -48,6 +55,13 @@ public static ImmutableArray<string> All
                 builder.Add(AliasNamespaceName);
                 builder.Add(StaticLocalVariableName);
                 builder.Add(EventName);
+                builder.Add(ClassName);
+                builder.Add(StructureName);
+                builder.Add(ModuleName);
+                builder.Add(InterfaceName);
+                builder.Add(DelegateName);
+                builder.Add(EnumName);
+                builder.Add(TypeParameterName);
 
                 return _all = builder.ToImmutable();
             }
diff --git a/src/vs15/CoCo.Test.CSharpIdentifiers/Access/Types.cs b/src/vs15/CoCo.Test.CSharpIdentifiers/Access/Types.cs
new file mode 100644
index 0000000..bc22a76
--- /dev/null
+++ b/src/vs15/CoCo.Test.CSharpIdentifiers/Access/Types.cs
@@ -0,0 +1,65 @@
+using CoCo.Analyser.CSharp;
+using CoCo.Test.Common;
+using NUnit.Framework;
+
+namespace CoCo.Test.CSharpIdentifiers.Access
+{
+    class Types : CSharpIdentifierTests
+    {
+        [Test]
+        public void ClassTest()
+        {
+            GetContext(@"Access\Types\ClassType.cs")
+                .AddInfo(CSharpNames.ClassName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.ClassName.ClassifyAt(152, 9));
+        }
+
+        [Test]
+        public void StructureTest()
+        {
+            GetContext(@"Access\Types\StructureType.cs")
+                .AddInfo(CSharpNames.StructureName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.StructureName.ClassifyAt(157, 13));
+        }
+
+        [Test]
+        public void InterfaceTest()
+        {
+            GetContext(@"Access\Types\InterfaceType.cs")
+                .AddInfo(CSharpNames.InterfaceName.Enable())
+                .GetClassifications().AssertContains(
+                CSharpNames.InterfaceName.ClassifyAt(166, 14));
+        }
+
+        [Test]
+        public void EnumTest()
+        {
+            GetContext(@"Access\Types\EnumType.cs")
+                .AddInfo(CSharpNames.EnumName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.EnumName.ClassifyAt(160, 6));
+        }
+
+        [Test]
+        public void DelegateTest()
+        {
+            GetContext(@"Access\Types\DelegateType.cs")
+                .AddInfo(CSharpNames.DelegateName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.DelegateName.ClassifyAt(144, 6));
+        }
+
+        [Test]
+        public void TypeParameterTest()
+        {
+            GetContext(@"Access\Types\TypeParameter.cs")
+                .AddInfo(CSharpNames.TypeParameterName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.TypeParameterName.ClassifyAt(92, 6),
+                    CSharpNames.TypeParameterName.ClassifyAt(131, 6),
+                    CSharpNames.TypeParameterName.ClassifyAt(151, 6));
+        }
+    }
+}
diff --git a/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Namespaces.cs b/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Namespaces.cs
index ea515fc..ae9c1f6 100644
--- a/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Namespaces.cs
+++ b/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Namespaces.cs
@@ -29,7 +29,7 @@ public void NamespaceTest_DeclarationWithAlias()
         [Test]
         public void NamespaceTest_TypeAlias()
         {
-            GetContext(@"Declarations\Namespaces\TypeAlias.cs").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Namespaces\TypeAlias.cs").GetClassifications().AssertContains(
                 CSharpNames.NamespaceName.ClassifyAt(67, 6),
                 CSharpNames.NamespaceName.ClassifyAt(74, 11),
                 CSharpNames.NamespaceName.ClassifyAt(86, 7));
@@ -38,7 +38,7 @@ public void NamespaceTest_TypeAlias()
         [Test]
         public void NamespaceTest_StaticType()
         {
-            GetContext(@"Declarations\Namespaces\StaticType.cs").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Namespaces\StaticType.cs").GetClassifications().AssertContains(
                 CSharpNames.NamespaceName.ClassifyAt(13, 6),
                 CSharpNames.NamespaceName.ClassifyAt(20, 9));
         }
diff --git a/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Types.cs b/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Types.cs
new file mode 100644
index 0000000..ea39295
--- /dev/null
+++ b/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Types.cs
@@ -0,0 +1,64 @@
+using CoCo.Analyser.CSharp;
+using CoCo.Test.Common;
+using NUnit.Framework;
+
+namespace CoCo.Test.CSharpIdentifiers.Declarations
+{
+    internal class Types : CSharpIdentifierTests
+    {
+        [Test]
+        public void TypeParameterTest()
+        {
+            GetContext(@"Declarations\Types\TypeParameter.cs")
+                .AddInfo(CSharpNames.TypeParameterName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.TypeParameterName.ClassifyAt(84, 3),
+                    CSharpNames.TypeParameterName.ClassifyAt(124, 6));
+        }
+
+        [Test]
+        public void ClassTest()
+        {
+            GetContext(@"Declarations\Types\ClassType.cs")
+                .AddInfo(CSharpNames.ClassName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.ClassName.ClassifyAt(70, 9));
+        }
+
+        [Test]
+        public void StructureTest()
+        {
+            GetContext(@"Declarations\Types\StructureType.cs")
+                .AddInfo(CSharpNames.StructureName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.StructureName.ClassifyAt(71, 13));
+        }
+
+        [Test]
+        public void InterfaceTest()
+        {
+            GetContext(@"Declarations\Types\InterfaceType.cs")
+                .AddInfo(CSharpNames.InterfaceName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.InterfaceName.ClassifyAt(74, 13));
+        }
+
+        [Test]
+        public void EnumTest()
+        {
+            GetContext(@"Declarations\Types\EnumType.cs")
+                .AddInfo(CSharpNames.EnumName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.EnumName.ClassifyAt(69, 8));
+        }
+
+        [Test]
+        public void DelegateTest()
+        {
+            GetContext(@"Declarations\Types\DelegateType.cs")
+                .AddInfo(CSharpNames.DelegateName.Enable())
+                .GetClassifications().AssertContains(
+                    CSharpNames.DelegateName.ClassifyAt(78, 6));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/vs15/CoCo.Test.CSharpIdentifiers/SimpleTest.cs b/src/vs15/CoCo.Test.CSharpIdentifiers/SimpleTest.cs
index f2ba8ec..f8d3334 100644
--- a/src/vs15/CoCo.Test.CSharpIdentifiers/SimpleTest.cs
+++ b/src/vs15/CoCo.Test.CSharpIdentifiers/SimpleTest.cs
@@ -10,11 +10,14 @@ internal class SimpleTest : CSharpIdentifierTests
         [Test]
         public void CommonTest()
         {
-            GetContext(@"SimpleExample.cs").GetClassifications().AssertIsEquivalent(
-                CSharpNames.NamespaceName.ClassifyAt(10, 17),
-                CSharpNames.MethodName.ClassifyAt(94, 6),
-                CSharpNames.ParameterName.ClassifyAt(108, 6),
-                CSharpNames.LocalVariableName.ClassifyAt(144, 5));
+            GetContext(@"SimpleExample.cs")
+                .AddInfo(CSharpNames.ClassName.Enable())
+                .GetClassifications().AssertIsEquivalent(
+                    CSharpNames.NamespaceName.ClassifyAt(10, 17),
+                    CSharpNames.ClassName.ClassifyAt(51, 13),
+                    CSharpNames.MethodName.ClassifyAt(94, 6),
+                    CSharpNames.ParameterName.ClassifyAt(108, 6),
+                    CSharpNames.LocalVariableName.ClassifyAt(144, 5));
         }
     }
 }
\ No newline at end of file
diff --git a/src/vs15/CoCo.Test.Common/ClassificationHelper.cs b/src/vs15/CoCo.Test.Common/ClassificationHelper.cs
index 4e6b5ac..a012bbd 100644
--- a/src/vs15/CoCo.Test.Common/ClassificationHelper.cs
+++ b/src/vs15/CoCo.Test.Common/ClassificationHelper.cs
@@ -25,13 +25,26 @@ public static SimplifiedClassificationSpan ClassifyAt(this string name, int star
             ? throw new ArgumentOutOfRangeException(nameof(name), "Argument must be one of constant names")
             : new SimplifiedClassificationSpan(new Span(start, length), new ClassificationType(name));
 
-        public static SimplifiedClassificationInfo Disable(this string name) => IsUnknownClassification(name)
-            ? throw new ArgumentOutOfRangeException(nameof(name), "Argument must be one of constant names")
-            : new SimplifiedClassificationInfo { Name = name, IsDisabled = true };
+        public static SimplifiedClassificationInfo Enable(this string name)
+        {
+            if (IsUnknownClassification(name)) throw new ArgumentOutOfRangeException(nameof(name), "Argument must be one of constant names");
+            SimplifiedClassificationInfo info = name;
+            return info.Enable();
+        }
 
-        public static SimplifiedClassificationInfo DisableInXml(this string name) => IsUnknownClassification(name)
-            ? throw new ArgumentOutOfRangeException(nameof(name), "Argument must be one of constant names")
-            : new SimplifiedClassificationInfo { Name = name, IsDisabledInXml = true };
+        public static SimplifiedClassificationInfo Disable(this string name)
+        {
+            if (IsUnknownClassification(name)) throw new ArgumentOutOfRangeException(nameof(name), "Argument must be one of constant names");
+            SimplifiedClassificationInfo info = name;
+            return info.Disable();
+        }
+
+        public static SimplifiedClassificationInfo DisableInXml(this string name)
+        {
+            if (IsUnknownClassification(name)) throw new ArgumentOutOfRangeException(nameof(name), "Argument must be one of constant names");
+            SimplifiedClassificationInfo info = name;
+            return info.DisableInXml();
+        }
 
         public static List<SimplifiedClassificationSpan> GetClassifications(
             string path, Project project, IReadOnlyList<SimplifiedClassificationInfo> infos = null)
@@ -87,20 +100,15 @@ public static SimplifiedClassificationInfo DisableInXml(this string name) => IsU
         private static RoslynEditorClassifier GetClassifier(
             ProgrammingLanguage language, IReadOnlyList<SimplifiedClassificationInfo> infos)
         {
-            var dictionary = infos is null ? null : infos.ToDictionary(x => x.Name);
+            var dictionary = infos?.ToDictionary(x => x.Name);
             var classificationTypes = new Dictionary<string, ClassificationInfo>(32);
             var names = language == ProgrammingLanguage.VisualBasic ? VisualBasicNames.All : CSharpNames.All;
             foreach (var name in names)
             {
-                if (dictionary is null || !dictionary.TryGetValue(name, out var info))
-                {
-                    classificationTypes.Add(name, ClassificationService.GetDefaultInfo(new ClassificationType(name)));
-                }
-                else
-                {
-                    classificationTypes.Add(
-                        name, new ClassificationInfo(new ClassificationType(name), !info.IsDisabled, !info.IsDisabledInXml));
-                }
+                var option = dictionary is null || !dictionary.TryGetValue(name, out var simplifiedInfo)
+                    ? ClassificationService.GetDefaultOption(name)
+                    : simplifiedInfo;
+                classificationTypes.Add(name, new ClassificationInfo(new ClassificationType(name), option));
             }
 
             return language == ProgrammingLanguage.VisualBasic
@@ -159,7 +167,7 @@ private static CompilationUnit[] ExtractCompilationUnits(Project project)
                     optionExplicit: project.OptionExplicit,
                     optionInfer: project.OptionInfer,
                     optionStrict: project.OptionStrict ? OptionStrict.On : OptionStrict.Off);
-                return new CompilationUnit[2]
+                return new CompilationUnit[]
                 {
                     CSharpCompilation.Create($"{project.ProjectName}_{LanguageNames.CSharp}")
                         .AddSyntaxTrees(csharpTrees)
diff --git a/src/vs15/CoCo.Test.Common/ClassificationInfo.cs b/src/vs15/CoCo.Test.Common/ClassificationInfo.cs
index bad06f3..714a3b3 100644
--- a/src/vs15/CoCo.Test.Common/ClassificationInfo.cs
+++ b/src/vs15/CoCo.Test.Common/ClassificationInfo.cs
@@ -2,7 +2,7 @@
 
 namespace CoCo.Test.Common
 {
-    public struct SimplifiedClassificationInfo
+    public class SimplifiedClassificationInfo
     {
         public string Name;
         public bool IsDisabled;
@@ -11,29 +11,38 @@ public struct SimplifiedClassificationInfo
         private SimplifiedClassificationInfo(string name)
         {
             Name = name;
-            var info = ClassificationService.GetDefaultInfo(new ClassificationType(name));
-            IsDisabled = !info.IsDisabled;
-            IsDisabledInXml = !info.IsDisabledInXml;
+            var info = ClassificationService.GetDefaultOption(name);
+            IsDisabled = info.IsDisabled;
+            IsDisabledInXml = info.IsDisabledInXml;
         }
 
-        public SimplifiedClassificationInfo Disable() => new SimplifiedClassificationInfo
+        public SimplifiedClassificationInfo Disable() => new SimplifiedClassificationInfo(Name)
         {
-            IsDisabled = false,
+            IsDisabled = true,
             IsDisabledInXml = IsDisabledInXml
         };
 
-        public SimplifiedClassificationInfo Enable() => new SimplifiedClassificationInfo
+        public SimplifiedClassificationInfo DisableInXml() => new SimplifiedClassificationInfo(Name)
         {
-            IsDisabled = true,
+            IsDisabled = IsDisabled,
+            IsDisabledInXml = true
+        };
+
+        public SimplifiedClassificationInfo Enable() => new SimplifiedClassificationInfo(Name)
+        {
+            IsDisabled = false,
             IsDisabledInXml = IsDisabledInXml
         };
 
-        public SimplifiedClassificationInfo EnableInXml() => new SimplifiedClassificationInfo
+        public SimplifiedClassificationInfo EnableInXml() => new SimplifiedClassificationInfo(Name)
         {
             IsDisabled = IsDisabled,
-            IsDisabledInXml = true
+            IsDisabledInXml = false
         };
 
         public static implicit operator SimplifiedClassificationInfo(string name) => new SimplifiedClassificationInfo(name);
+
+        public static implicit operator ClassificationOption(SimplifiedClassificationInfo info) =>
+            new ClassificationOption(info.IsDisabled, info.IsDisabledInXml);
     }
 }
\ No newline at end of file
diff --git a/src/vs15/CoCo.Test.VisualBasicIdentifiers/Access/Types.cs b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Access/Types.cs
new file mode 100644
index 0000000..1eed4ed
--- /dev/null
+++ b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Access/Types.cs
@@ -0,0 +1,72 @@
+using CoCo.Analyser.VisualBasic;
+using CoCo.Test.Common;
+using NUnit.Framework;
+
+namespace CoCo.Test.VisualBasicIdentifiers.Access
+{
+    internal class Types : VisualBasicIdentifierTests
+    {
+        [Test]
+        public void TypeParameterTest()
+        {
+            GetContext(@"Access\Types\TypeParameter.vb")
+                .AddInfo(VisualBasicNames.TypeParameterName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.TypeParameterName.ClassifyAt(87, 6));
+        }
+
+        [Test]
+        public void ClassTest()
+        {
+            GetContext(@"Access\Types\ClassType.vb")
+                .AddInfo(VisualBasicNames.ClassName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.ClassName.ClassifyAt(74, 9));
+        }
+
+        [Test]
+        public void StructureTest()
+        {
+            GetContext(@"Access\Types\StructureType.vb")
+                .AddInfo(VisualBasicNames.StructureName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.StructureName.ClassifyAt(102, 13));
+        }
+
+        [Test]
+        public void ModuleTest()
+        {
+            GetContext(@"Access\Types\ModuleType.vb")
+                .AddInfo(VisualBasicNames.ModuleName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.ModuleName.ClassifyAt(121, 10));
+        }
+
+        [Test]
+        public void InterfaceTest()
+        {
+            GetContext(@"Access\Types\InterfaceType.vb")
+                .AddInfo(VisualBasicNames.InterfaceName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.InterfaceName.ClassifyAt(138, 14));
+        }
+
+        [Test]
+        public void EnumTest()
+        {
+            GetContext(@"Access\Types\EnumType.vb")
+                .AddInfo(VisualBasicNames.EnumName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.EnumName.ClassifyAt(122, 6));
+        }
+
+        [Test]
+        public void DelegateTest()
+        {
+            GetContext(@"Access\Types\DelegateType.vb")
+                .AddInfo(VisualBasicNames.DelegateName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.DelegateName.ClassifyAt(113, 6));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Enum.cs b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Enum.cs
index 9a20386..9bd2157 100644
--- a/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Enum.cs
+++ b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Enum.cs
@@ -9,7 +9,7 @@ internal class Enum : VisualBasicIdentifierTests
         [Test]
         public void EnumTest()
         {
-            GetContext(@"Declarations\EnumDeclaration.vb").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\EnumDeclaration.vb").GetClassifications().AssertContains(
                 VisualBasicNames.EnumFieldName.ClassifyAt(22, 4),
                 VisualBasicNames.EnumFieldName.ClassifyAt(30, 5),
                 VisualBasicNames.EnumFieldName.ClassifyAt(39, 6),
diff --git a/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Methods.cs b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Methods.cs
index b50ad8b..daab9c0 100644
--- a/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Methods.cs
+++ b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Methods.cs
@@ -9,14 +9,14 @@ internal class Methods : VisualBasicIdentifierTests
         [Test]
         public void MethodTest_Sub()
         {
-            GetContext(@"Declarations\Methods\SubMethod.vb").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Methods\SubMethod.vb").GetClassifications().AssertContains(
                 VisualBasicNames.SubName.ClassifyAt(39, 6));
         }
 
         [Test]
         public void MethodTest_Function()
         {
-            GetContext(@"Declarations\Methods\FunctionMethod.vb").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Methods\FunctionMethod.vb").GetClassifications().AssertContains(
                 VisualBasicNames.FunctionName.ClassifyAt(49, 6));
         }
 
@@ -30,13 +30,17 @@ public void MethodTest_Extension()
         [Test]
         public void MethodTest_Constructor()
         {
-            GetContext(@"Declarations\Methods\Constructor.vb").GetClassifications().AssertIsEmpty();
+            GetContext(@"Declarations\Methods\Constructor.vb")
+                .AddInfo(VisualBasicNames.ClassName.Disable())
+                .GetClassifications().AssertIsEmpty();
         }
 
         [Test]
         public void MethodTest_SharedConstructor()
         {
-            GetContext(@"Declarations\Methods\StaticConstructor.vb").GetClassifications().AssertIsEmpty();
+            GetContext(@"Declarations\Methods\StaticConstructor.vb")
+                .AddInfo(VisualBasicNames.ClassName.Disable())
+                .GetClassifications().AssertIsEmpty();
         }
 
         [Test]
diff --git a/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Namespaces.cs b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Namespaces.cs
index a794e01..784fc2b 100644
--- a/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Namespaces.cs
+++ b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Namespaces.cs
@@ -26,7 +26,7 @@ public void NamespaceTest_Import()
         [Test]
         public void NamespaceTest_StaticType()
         {
-            GetContext(@"Declarations\Namespaces\StaticType.vb").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Namespaces\StaticType.vb").GetClassifications().AssertContains(
                 VisualBasicNames.NamespaceName.ClassifyAt(8, 6));
         }
 
@@ -42,7 +42,7 @@ public void NamespaceTest_Alias()
         [Test]
         public void NamespaceTest_TypeAlias()
         {
-            GetContext(@"Declarations\Namespaces\TypeAlias.vb").GetClassifications().AssertIsEquivalent(
+            GetContext(@"Declarations\Namespaces\TypeAlias.vb").GetClassifications().AssertContains(
                 VisualBasicNames.NamespaceName.ClassifyAt(13, 6));
         }
 
diff --git a/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Types.cs b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Types.cs
new file mode 100644
index 0000000..5bd2c8d
--- /dev/null
+++ b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Types.cs
@@ -0,0 +1,72 @@
+using CoCo.Analyser.VisualBasic;
+using CoCo.Test.Common;
+using NUnit.Framework;
+
+namespace CoCo.Test.VisualBasicIdentifiers.Declarations
+{
+    internal class Types : VisualBasicIdentifierTests
+    {
+        [Test]
+        public void TypeParameterTest()
+        {
+            GetContext(@"Declarations\Types\TypeParameter.vb")
+                .AddInfo(VisualBasicNames.TypeParameterName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.TypeParameterName.ClassifyAt(30, 6));
+        }
+
+        [Test]
+        public void ClassTest()
+        {
+            GetContext(@"Declarations\Types\ClassType.vb")
+                .AddInfo(VisualBasicNames.ClassName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.ClassName.ClassifyAt(13, 9));
+        }
+
+        [Test]
+        public void StructureTest()
+        {
+            GetContext(@"Declarations\Types\StructureType.vb")
+                .AddInfo(VisualBasicNames.StructureName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.StructureName.ClassifyAt(17, 13));
+        }
+
+        [Test]
+        public void ModuleTest()
+        {
+            GetContext(@"Declarations\Types\ModuleType.vb")
+                .AddInfo(VisualBasicNames.ModuleName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.ModuleName.ClassifyAt(7, 10));
+        }
+
+        [Test]
+        public void InterfaceTest()
+        {
+            GetContext(@"Declarations\Types\InterfaceType.vb")
+                .AddInfo(VisualBasicNames.InterfaceName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.InterfaceName.ClassifyAt(17, 13));
+        }
+
+        [Test]
+        public void EnumTest()
+        {
+            GetContext(@"Declarations\Types\EnumType.vb")
+                .AddInfo(VisualBasicNames.EnumName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.EnumName.ClassifyAt(12, 8));
+        }
+
+        [Test]
+        public void DelegateTest()
+        {
+            GetContext(@"Declarations\Types\DelegateType.vb")
+                .AddInfo(VisualBasicNames.DelegateName.Enable())
+                .GetClassifications().AssertContains(
+                    VisualBasicNames.DelegateName.ClassifyAt(20, 12));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/vs15/CoCo/ClassificationManager.cs b/src/vs15/CoCo/ClassificationManager.cs
index 9ece1e8..04e2439 100644
--- a/src/vs15/CoCo/ClassificationManager.cs
+++ b/src/vs15/CoCo/ClassificationManager.cs
@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using CoCo.Analyser;
+using CoCo.Analyser.CSharp;
+using CoCo.Analyser.VisualBasic;
 using CoCo.Providers;
 using CoCo.Utils;
 using Microsoft.VisualStudio.Language.StandardClassification;
@@ -10,23 +12,48 @@ namespace CoCo
 {
     public sealed class ClassificationManager
     {
-        private static Dictionary<string, ICollection<IClassificationType>> _classifications;
-
-        private ClassificationManager()
+        private static readonly IReadOnlyDictionary<string, string> _nonIdentifierClassifications = new Dictionary<string, string>
         {
-        }
+            [CSharpNames.ClassName] = "class name",
+            [CSharpNames.StructureName] = "struct name",
+            [CSharpNames.InterfaceName] = "interface name",
+            [CSharpNames.EnumName] = "enum name",
+            [CSharpNames.DelegateName] = "delegate name",
+            [CSharpNames.TypeParameterName] = "type parameter name",
 
-        private static ClassificationManager _instance;
+            [VisualBasicNames.ClassName] = "class name",
+            [VisualBasicNames.StructureName] = "struct name",
+            [VisualBasicNames.InterfaceName] = "interface name",
+            [VisualBasicNames.EnumName] = "enum name",
+            [VisualBasicNames.DelegateName] = "delegate name",
+            [VisualBasicNames.TypeParameterName] = "type parameter name",
+            [VisualBasicNames.ModuleName] = "module name",
+        };
 
-        public static ClassificationManager Instance => _instance ?? (_instance = new ClassificationManager());
+        private static Dictionary<string, ICollection<IClassificationType>> _classifications;
 
-        public IClassificationType DefaultClassification =>
+        public static IClassificationType DefaultIdentifierClassification =>
             ServicesProvider.Instance.RegistryService.GetClassificationType(PredefinedClassificationTypeNames.Identifier);
 
+        /// <summary>
+        /// Try to retreive a default classification for <paramref name="name"/> if it isn't <see cref="PredefinedClassificationTypeNames.Identifier"/>
+        /// </summary>
+        public static bool TryGetDefaultNonIdentifierClassification(string name, out IClassificationType classification)
+        {
+            if (_nonIdentifierClassifications.TryGetValue(name, out var classificationName))
+            {
+                classification = ServicesProvider.Instance.RegistryService.GetClassificationType(classificationName);
+                return !(classification is null);
+            }
+
+            classification = null;
+            return false;
+        }
+
         /// <returns>
         /// Classifications are grouped by language
         /// </returns>
-        public IReadOnlyDictionary<string, ICollection<IClassificationType>> GetClassifications()
+        public static IReadOnlyDictionary<string, ICollection<IClassificationType>> GetClassifications()
         {
             if (_classifications != null) return _classifications;
 
@@ -36,32 +63,38 @@ private ClassificationManager()
             var formatMapService = ServicesProvider.Instance.FormatMapService;
 
             var formatMap = formatMapService.GetClassificationFormatMap(category: "text");
-            var identifierPosition = GetIdentifierPosition(registryService, formatMap);
+            var identifierPosition = GetClassificationPosition(registryService, formatMap, PredefinedClassificationTypeNames.Identifier);
 
             foreach (var (language, names) in Names.All)
             {
                 var languageClassifications = new List<IClassificationType>();
                 foreach (var name in names)
                 {
+                    var classificationPosition = identifierPosition;
+                    if (_nonIdentifierClassifications.TryGetValue(name, out var relevantClassification))
+                    {
+                        classificationPosition = GetClassificationPosition(registryService, formatMap, relevantClassification);
+                    }
+
                     var classificationType = registryService.GetClassificationType(name);
                     if (classificationType != null)
                     {
                         // TODO: need to carefully test this case
-                        if (identifierPosition > 0)
+                        if (classificationPosition > 0)
                         {
-                            // NOTE: Set priority of classification next to identifier
-                            SetPriority(formatMap, classificationType, identifierPosition);
+                            // NOTE: Set priority of classification next to the relevant classification
+                            SetPriority(formatMap, classificationType, classificationPosition);
                         }
                     }
                     else
                     {
                         classificationType = registryService.CreateClassificationType(name, new IClassificationType[0]);
                         var formatting = TextFormattingRunProperties.CreateTextFormattingRunProperties();
-                        if (identifierPosition > 0)
+                        if (classificationPosition > 0)
                         {
-                            // NOTE: Set priority of classification next to identifier
-                            var afterIdentifierClassification = formatMap.CurrentPriorityOrder[identifierPosition + 1];
-                            formatMap.AddExplicitTextProperties(classificationType, formatting, afterIdentifierClassification);
+                            // NOTE: Set priority of classification next to the relevant classification
+                            var afterClassification = formatMap.CurrentPriorityOrder[classificationPosition + 1];
+                            formatMap.AddExplicitTextProperties(classificationType, formatting, afterClassification);
                         }
                         else
                         {
@@ -79,41 +112,45 @@ private ClassificationManager()
         }
 
         /// <returns>
-        /// if <see cref="PredefinedClassificationTypeNames.Identifier"/> classification doesn't exist or
+        /// if <paramref name="classificationName"/> classification doesn't exist or
         /// it is the last element returns -1, otherwise returns it position
         /// </returns>
-        private static int GetIdentifierPosition(IClassificationTypeRegistryService registryService, IClassificationFormatMap formatMap)
+        private static int GetClassificationPosition(
+            IClassificationTypeRegistryService registryService, IClassificationFormatMap formatMap, string classificationName)
         {
-            var identifierClassification = registryService.GetClassificationType(PredefinedClassificationTypeNames.Identifier);
-            if (identifierClassification != null)
+            var classification = registryService.GetClassificationType(classificationName);
+            if (classification != null)
             {
-                var identifierPosition = formatMap.CurrentPriorityOrder.IndexOf(identifierClassification);
-                if (identifierPosition >= 0 && identifierPosition < formatMap.CurrentPriorityOrder.Count - 1) return identifierPosition;
+                var classificationPosition = formatMap.CurrentPriorityOrder.IndexOf(classification);
+                if (classificationPosition >= 0 && classificationPosition < formatMap.CurrentPriorityOrder.Count - 1)
+                {
+                    return classificationPosition;
+                }
             }
             return -1;
         }
 
         /// <summary>
-        /// Swap priority of items from <paramref name="classificationType"/> to identifier classification: <para/>
-        /// * [...,cur,a1,a2,id,...] -> [...,a1,a2,id,cur,...]<para/>
-        /// * [...,id,a1,a2,cur,...] -> [...,id,cur,a1,a2,...]
+        /// Swap priority of items from <paramref name="classificationType"/> to classification: <para/>
+        /// * [...,cur,a1,a2,tar,...] -> [...,a1,a2,tar,cur,...]<para/>
+        /// * [...,tar,a1,a2,cur,...] -> [...,tar,cur,a1,a2,...]
         /// </summary>
         private static void SetPriority(
             IClassificationFormatMap formatMap,
             IClassificationType classificationType,
-            int identifierPosition)
+            int classificationPosition)
         {
             var index = formatMap.CurrentPriorityOrder.IndexOf(classificationType);
-            if (index < identifierPosition)
+            if (index < classificationPosition)
             {
-                while (index < identifierPosition)
+                while (index < classificationPosition)
                 {
                     formatMap.SwapPriorities(classificationType, formatMap.CurrentPriorityOrder[++index]);
                 }
             }
             else
             {
-                while (identifierPosition < --index)
+                while (classificationPosition < --index)
                 {
                     formatMap.SwapPriorities(formatMap.CurrentPriorityOrder[index], classificationType);
                 }
diff --git a/src/vs15/CoCo/Extensions.cs b/src/vs15/CoCo/Extensions.cs
index cad2bfc..d774bcf 100644
--- a/src/vs15/CoCo/Extensions.cs
+++ b/src/vs15/CoCo/Extensions.cs
@@ -1,5 +1,6 @@
 using System.Windows;
 using System.Windows.Media;
+using CoCo.Analyser;
 using CoCo.Settings;
 using Microsoft.VisualStudio.Text.Formatting;
 
@@ -12,18 +13,22 @@ public static class Extensions
         /// which doesn't set the default values for properties that can be reset
         /// </summary>
         public static ClassificationSettings ToDefaultSettings(
-           this TextFormattingRunProperties formatting, string classificationName) => new ClassificationSettings
-           {
-               Name = classificationName,
-               IsBold = formatting.Bold,
-               IsItalic = formatting.Italic,
-               IsOverline = formatting.TextDecorations.Contains(TextDecorations.OverLine[0]),
-               IsUnderline = formatting.TextDecorations.Contains(TextDecorations.Underline[0]),
-               IsStrikethrough = formatting.TextDecorations.Contains(TextDecorations.Strikethrough[0]),
-               IsBaseline = formatting.TextDecorations.Contains(TextDecorations.Baseline[0]),
-               IsDisabled = false,
-               IsDisabledInXml = false,
-           };
+           this TextFormattingRunProperties formatting, string classificationName)
+        {
+            var defaultOption = ClassificationService.GetDefaultOption(classificationName);
+            return new ClassificationSettings
+            {
+                Name = classificationName,
+                IsBold = formatting.Bold,
+                IsItalic = formatting.Italic,
+                IsOverline = formatting.TextDecorations.Contains(TextDecorations.OverLine[0]),
+                IsUnderline = formatting.TextDecorations.Contains(TextDecorations.Underline[0]),
+                IsStrikethrough = formatting.TextDecorations.Contains(TextDecorations.Strikethrough[0]),
+                IsBaseline = formatting.TextDecorations.Contains(TextDecorations.Baseline[0]),
+                IsDisabled = defaultOption.IsDisabled,
+                IsDisabledInXml = defaultOption.IsDisabledInXml,
+            };
+        }
 
         /// <summary>
         /// Gets <see cref="SolidColorBrush.Color"/> if <paramref name="brush"/> is <see cref="SolidColorBrush"/>
diff --git a/src/vs15/CoCo/Providers/CSharpClassifierProvider.cs b/src/vs15/CoCo/Providers/CSharpClassifierProvider.cs
index e3e81af..eca2ae9 100644
--- a/src/vs15/CoCo/Providers/CSharpClassifierProvider.cs
+++ b/src/vs15/CoCo/Providers/CSharpClassifierProvider.cs
@@ -71,7 +71,7 @@ private void OnAnalyzeOptionChanged(ClassificationsChangedEventArgs args)
             {
                 if (_classificationsInfo.ContainsKey(classificationType.Classification))
                 {
-                    _classificationsInfo[classificationType.Classification] = info;
+                    _classificationsInfo[classificationType.Classification] = new ClassificationInfo(classificationType, info);
                 }
             }
         }
diff --git a/src/vs15/CoCo/Providers/ResetValuesProvider.cs b/src/vs15/CoCo/Providers/ResetValuesProvider.cs
index ca4ac88..53fe1e2 100644
--- a/src/vs15/CoCo/Providers/ResetValuesProvider.cs
+++ b/src/vs15/CoCo/Providers/ResetValuesProvider.cs
@@ -14,10 +14,10 @@ private ResetValuesProvider()
 
         public static ResetValuesProvider Instance => _instance ?? (_instance = new ResetValuesProvider());
 
-        public Color Foreground => FormattingService.GetDefaultFormatting().ForegroundBrush.GetColor();
+        public Color GetForeground(string name) => FormattingService.GetDefaultFormatting(name).ForegroundBrush.GetColor();
 
-        public Color Background => FormattingService.GetDefaultFormatting().BackgroundBrush.GetColor();
+        public Color GetBackground(string name) => FormattingService.GetDefaultFormatting(name).BackgroundBrush.GetColor();
 
-        public int FontRenderingSize => (int)FormattingService.GetDefaultFormatting().FontRenderingEmSize;
+        public int GetFontRenderingSize(string name) => (int)FormattingService.GetDefaultFormatting(name).FontRenderingEmSize;
     }
 }
\ No newline at end of file
diff --git a/src/vs15/CoCo/Providers/VisualBasicClassifierProvider.cs b/src/vs15/CoCo/Providers/VisualBasicClassifierProvider.cs
index 58c0215..2d4432f 100644
--- a/src/vs15/CoCo/Providers/VisualBasicClassifierProvider.cs
+++ b/src/vs15/CoCo/Providers/VisualBasicClassifierProvider.cs
@@ -67,7 +67,7 @@ private void OnAnalyzeOptionChanged(ClassificationsChangedEventArgs args)
             {
                 if (_classificationsInfo.ContainsKey(classificationType.Classification))
                 {
-                    _classificationsInfo[classificationType.Classification] = info;
+                    _classificationsInfo[classificationType.Classification] = new ClassificationInfo(classificationType, info);
                 }
             }
         }
diff --git a/src/vs15/CoCo/Services/AnalyzingService.cs b/src/vs15/CoCo/Services/AnalyzingService.cs
index f3798da..dcdd3f3 100644
--- a/src/vs15/CoCo/Services/AnalyzingService.cs
+++ b/src/vs15/CoCo/Services/AnalyzingService.cs
@@ -18,7 +18,7 @@ private AnalyzingService()
         public static void SetAnalyzingOptions(Option option)
         {
             var classificationTypes = new Dictionary<string, IClassificationType>(Names.All.Count);
-            foreach (var languageClassifications in ClassificationManager.Instance.GetClassifications().Values)
+            foreach (var languageClassifications in ClassificationManager.GetClassifications().Values)
             {
                 foreach (var classification in languageClassifications)
                 {
@@ -26,14 +26,14 @@ public static void SetAnalyzingOptions(Option option)
                 }
             }
 
-            var classifications = new Dictionary<IClassificationType, ClassificationInfo>(classificationTypes.Count);
+            var classifications = new Dictionary<IClassificationType, ClassificationOption>(classificationTypes.Count);
             foreach (var language in option.Languages)
             {
                 foreach (var classification in language.Classifications)
                 {
                     if (classificationTypes.TryGetValue(classification.Name, out var type))
                     {
-                        classifications.Add(type, new ClassificationInfo(type, classification.IsDisabled, classification.IsDisabledInXml));
+                        classifications.Add(type, new ClassificationOption(classification.IsDisabled, classification.IsDisabledInXml));
                     }
                 }
             }
diff --git a/src/vs15/CoCo/Services/FormattingService.cs b/src/vs15/CoCo/Services/FormattingService.cs
index 73047b6..a564292 100644
--- a/src/vs15/CoCo/Services/FormattingService.cs
+++ b/src/vs15/CoCo/Services/FormattingService.cs
@@ -11,17 +11,32 @@ namespace CoCo.Services
 {
     public static class FormattingService
     {
-        public static TextFormattingRunProperties GetDefaultFormatting()
+        public static TextFormattingRunProperties GetDefaultFormatting(string classificationName)
         {
             var classificationFormatMap = ServicesProvider.Instance.FormatMapService.GetClassificationFormatMap(category: "text");
-            return GetDefaultFormatting(classificationFormatMap, ClassificationManager.Instance.DefaultClassification);
+            if (ClassificationManager.TryGetDefaultNonIdentifierClassification(classificationName, out var defaultClassification))
+            {
+                return GetDefaultFormatting(classificationFormatMap, defaultClassification);
+            }
+            return GetDefaultFormatting(classificationFormatMap, ClassificationManager.DefaultIdentifierClassification);
+        }
+
+        public static TextFormattingRunProperties GetDefaultIdentifierFormatting()
+        {
+            var classificationFormatMap = ServicesProvider.Instance.FormatMapService.GetClassificationFormatMap(category: "text");
+            return GetDefaultFormatting(classificationFormatMap, ClassificationManager.DefaultIdentifierClassification);
+        }
+
+        public static TextFormattingRunProperties GetDefaultFormatting(IClassificationType classification)
+        {
+            var classificationFormatMap = ServicesProvider.Instance.FormatMapService.GetClassificationFormatMap(category: "text");
+            return GetDefaultFormatting(classificationFormatMap, classification);
         }
 
         public static void SetFormattingOptions(Option option)
         {
-            var classificationTypes = ClassificationManager.Instance.GetClassifications();
+            var classificationTypes = ClassificationManager.GetClassifications();
             var classificationFormatMap = ServicesProvider.Instance.FormatMapService.GetClassificationFormatMap(category: "text");
-            var defaultFormatting = GetDefaultFormatting(classificationFormatMap, ClassificationManager.Instance.DefaultClassification);
 
             var classificationsMap = new Dictionary<string, IClassificationType>(23);
             foreach (var classifications in classificationTypes.Values)
@@ -32,6 +47,9 @@ public static void SetFormattingOptions(Option option)
                 }
             }
 
+            var defaultIdentifierFormatting =
+                GetDefaultFormatting(classificationFormatMap, ClassificationManager.DefaultIdentifierClassification);
+
             foreach (var language in option.Languages)
             {
                 // TODO: do need to write in a log if the classification after preparing still not exists?
@@ -40,6 +58,13 @@ public static void SetFormattingOptions(Option option)
                 {
                     if (classificationsMap.TryGetValue(classification.Name, out var classificationType))
                     {
+                        var defaultFormatting = defaultIdentifierFormatting;
+                        if (ClassificationManager.TryGetDefaultNonIdentifierClassification(
+                            classification.Name, out var defaultClassification))
+                        {
+                            defaultFormatting = GetDefaultFormatting(classificationFormatMap, defaultClassification);
+                        }
+
                         var formatting = classificationFormatMap.GetExplicitTextProperties(classificationType);
                         formatting = Apply(formatting, classification, defaultFormatting);
                         classificationFormatMap.SetExplicitTextProperties(classificationType, formatting);
diff --git a/src/vs15/CoCo/Services/OptionService.cs b/src/vs15/CoCo/Services/OptionService.cs
index 73e48cf..518c8f4 100644
--- a/src/vs15/CoCo/Services/OptionService.cs
+++ b/src/vs15/CoCo/Services/OptionService.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Windows;
 using CoCo.Analyser;
 using CoCo.Settings;
@@ -32,15 +31,15 @@ List<ClassificationSettings> ToSettings(ICollection<Classification> classificati
             {
                 var classificationsSettings = ToSettings(language.Classifications);
 
-                if (!PresetService.GetDefaultPresetsNames().TryGetValue(language.Name, out var defaultPresets))
+                if (!PresetService.GetDefaultPresets().TryGetValue(language.Name, out var defaultPresets))
                 {
-                    defaultPresets = new HashSet<string>();
+                    defaultPresets = null;
                 }
 
                 var presetsSettings = new List<PresetSettings>(language.Presets.Count);
                 foreach (var preset in language.Presets)
                 {
-                    if (defaultPresets.Contains(preset.Name)) continue;
+                    if (!(defaultPresets is null) && defaultPresets.ContainsKey(preset.Name)) continue;
 
                     presetsSettings.Add(new PresetSettings
                     {
@@ -64,13 +63,10 @@ List<ClassificationSettings> ToSettings(ICollection<Classification> classificati
         /// </summary>
         public static Option ToOption(Settings.Settings settings)
         {
-            var classificationTypes = ClassificationManager.Instance.GetClassifications();
-            var defaultFormatting = FormattingService.GetDefaultFormatting();
-
-            var defaultPresets = PresetService.GetDefaultPresets(defaultFormatting);
+            var defaultPresets = PresetService.GetDefaultPresets();
 
             var option = new Option();
-            foreach (var (languageName, classifications) in classificationTypes)
+            foreach (var (languageName, classifications) in ClassificationManager.GetClassifications())
             {
                 var language = new Language(languageName);
                 var languageClassifications = new List<(string, string)>(17);
@@ -81,9 +77,8 @@ public static Option ToOption(Settings.Settings settings)
 
                 if (!defaultPresets.TryGetValue(language.Name, out var defaultLanguagePresets))
                 {
-                    defaultLanguagePresets = new List<PresetSettings>();
+                    defaultLanguagePresets = null;
                 }
-                var presetNames = defaultLanguagePresets.ToHashSet(x => x.Name);
 
                 var isLanguageExists = false;
                 foreach (var languageSettings in settings.Languages)
@@ -92,17 +87,15 @@ public static Option ToOption(Settings.Settings settings)
                     if (languageSettings.Name.Equals(language.Name))
                     {
                         isLanguageExists = true;
-                        FillClassifications(
-                            languageClassifications, languageSettings.CurrentClassifications, language.Classifications, defaultFormatting);
+                        FillClassifications(languageClassifications, languageSettings.CurrentClassifications, language.Classifications);
 
                         foreach (var presetSettings in languageSettings.Presets)
                         {
                             // NOTE: skip CoCo default presets, they will be added below
-                            if (presetNames.Contains(presetSettings.Name)) continue;
+                            if (!(defaultLanguagePresets is null) && defaultLanguagePresets.ContainsKey(presetSettings.Name)) continue;
 
                             var preset = new Preset(presetSettings.Name);
-                            FillClassifications(
-                                languageClassifications, presetSettings.Classifications, preset.Classifications, defaultFormatting);
+                            FillClassifications(languageClassifications, presetSettings.Classifications, preset.Classifications);
                             language.Presets.Add(preset);
                         }
                         break;
@@ -110,18 +103,16 @@ public static Option ToOption(Settings.Settings settings)
                 }
 
                 // NOTE: add CoCo default presets
-                foreach (var defaultPreset in defaultLanguagePresets)
+                foreach (var defaultPreset in defaultLanguagePresets.Values)
                 {
                     var preset = new Preset(defaultPreset.Name);
-                    FillClassifications(
-                        languageClassifications, defaultPreset.Classifications, preset.Classifications, defaultFormatting);
+                    FillClassifications(languageClassifications, defaultPreset.Classifications, preset.Classifications);
                     language.Presets.Add(preset);
                 }
                 // NOTE: add default classifications
                 if (!isLanguageExists)
                 {
-                    FillClassifications(
-                        languageClassifications, Array.Empty<ClassificationSettings>(), language.Classifications, defaultFormatting);
+                    FillClassifications(languageClassifications, Array.Empty<ClassificationSettings>(), language.Classifications);
                 }
                 option.Languages.Add(language);
             }
@@ -132,17 +123,23 @@ public static Option ToOption(Settings.Settings settings)
         /// <summary>
         /// Converts an existing <paramref name="classificationsSettings"/> to <see cref="Classification"/> and appends them to
         /// <paramref name="classifications"/>, also create <see cref="Classification"/> from non existing classifications in
-        /// <paramref name="classificationsSettings"/> set the default values of fields using <paramref name="defaultFormatting"/>
+        /// <paramref name="classificationsSettings"/> set the default values of fields
         /// </summary>
         /// <param name="classificationNames">string * string -> name * display name</param>
         private static void FillClassifications(
             IEnumerable<(string, string)> classificationNames,
             ICollection<ClassificationSettings> classificationsSettings,
-            ICollection<Classification> classifications,
-            TextFormattingRunProperties defaultFormatting)
+            ICollection<Classification> classifications)
         {
+            var defaultIdentifierFormatting = FormattingService.GetDefaultIdentifierFormatting();
             foreach (var (name, displayName) in classificationNames)
             {
+                var defaultFormatting = defaultIdentifierFormatting;
+                if (ClassificationManager.TryGetDefaultNonIdentifierClassification(name, out var classification))
+                {
+                    defaultFormatting = FormattingService.GetDefaultFormatting(classification);
+                }
+
                 var isClassificationExists = false;
                 foreach (var classificationSettings in classificationsSettings)
                 {
@@ -213,8 +210,10 @@ public static Option ToOption(Settings.Settings settings)
             classification.IsBaseline = classificationSettings.IsBaseline ??
                 defaultFormatting.TextDecorations.Contains(TextDecorations.Baseline[0]);
 
-            classification.IsDisabled = classificationSettings.IsDisabled ?? false;
-            classification.IsDisabledInXml = classificationSettings.IsDisabledInXml ?? false;
+            var defaultOption = ClassificationService.GetDefaultOption(classification.Name);
+
+            classification.IsDisabled = classificationSettings.IsDisabled ?? defaultOption.IsDisabled;
+            classification.IsDisabledInXml = classificationSettings.IsDisabledInXml ?? defaultOption.IsDisabledInXml;
 
             return classification;
         }
diff --git a/src/vs15/CoCo/Services/PresetService.cs b/src/vs15/CoCo/Services/PresetService.cs
index 0256d31..69c5aa0 100644
--- a/src/vs15/CoCo/Services/PresetService.cs
+++ b/src/vs15/CoCo/Services/PresetService.cs
@@ -4,57 +4,60 @@
 using CoCo.Analyser.CSharp;
 using CoCo.Analyser.VisualBasic;
 using CoCo.Settings;
-using Microsoft.VisualStudio.Text.Formatting;
 
 namespace CoCo.Services
 {
     public static class PresetService
     {
-        private static Dictionary<string, List<PresetSettings>> _defaultPresets;
+        private static Dictionary<string, IReadOnlyDictionary<string, PresetSettings>> _defaultPresets;
 
         /// <summary>
         /// Returns the default CoCo settings that are grouped by languages
         /// </summary>
-        public static IReadOnlyDictionary<string, List<PresetSettings>> GetDefaultPresets(TextFormattingRunProperties defaultFormatting)
+        public static IReadOnlyDictionary<string, IReadOnlyDictionary<string, PresetSettings>> GetDefaultPresets()
         {
+            if (!(_defaultPresets is null)) return _defaultPresets;
+
+            _defaultPresets = new Dictionary<string, IReadOnlyDictionary<string, PresetSettings>>();
+
+            var defaulltIdentifierFormatting = FormattingService.GetDefaultIdentifierFormatting();
+
             ClassificationSettings CreateClassification(string name, byte r, byte g, byte b)
             {
+                var defaultFormatting = defaulltIdentifierFormatting;
+                if (ClassificationManager.TryGetDefaultNonIdentifierClassification(name, out var defaultClassification))
+                {
+                    defaultFormatting = FormattingService.GetDefaultFormatting(defaultClassification);
+                }
+
                 var classification = defaultFormatting.ToDefaultSettings(name);
                 classification.Foreground = Color.FromRgb(r, g, b);
                 return classification;
             }
 
-            if (!(_defaultPresets is null)) return _defaultPresets;
-
-            _defaultPresets = new Dictionary<string, List<PresetSettings>>();
-
-            var presets = new List<PresetSettings>
+            var presets = new Dictionary<string, PresetSettings>
             {
-                new PresetSettings
+                ["CoCo light|blue theme"] = new PresetSettings
                 {
                     Name = "CoCo light|blue theme",
                     Classifications = new List<ClassificationSettings>
                     {
-                        CreateClassification(CSharpNames.AliasNamespaceName, 220, 220, 220),
                         CreateClassification(CSharpNames.ConstantFieldName, 255, 157, 255),
-                        CreateClassification(CSharpNames.ConstructorName, 220, 220, 220),
-                        CreateClassification(CSharpNames.DestructorName, 220, 220, 220),
                         CreateClassification(CSharpNames.EnumFieldName, 0, 193, 193),
-                        CreateClassification(CSharpNames.EventName, 220, 220, 220),
                         CreateClassification(CSharpNames.ExtensionMethodName, 233, 122, 0),
                         CreateClassification(CSharpNames.FieldName, 255, 157, 255),
                         CreateClassification(CSharpNames.LabelName, 120, 20, 0),
                         CreateClassification(CSharpNames.LocalMethodName, 187, 20, 0),
                         CreateClassification(CSharpNames.LocalVariableName, 128, 128, 0),
                         CreateClassification(CSharpNames.MethodName, 187, 54, 4),
-                        CreateClassification(CSharpNames.NamespaceName, 220, 220, 220),
                         CreateClassification(CSharpNames.ParameterName, 128, 128, 128),
                         CreateClassification(CSharpNames.PropertyName, 255, 0, 255),
                         CreateClassification(CSharpNames.RangeVariableName, 128, 128, 0),
                         CreateClassification(CSharpNames.StaticMethodName, 154, 82, 0)
                     }
                 },
-                new PresetSettings
+
+                ["CoCo dark theme"] = new PresetSettings
                 {
                     Name = "CoCo dark theme",
                     Classifications = new List<ClassificationSettings>
@@ -81,23 +84,20 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b)
             };
             _defaultPresets[Languages.CSharp] = presets;
 
-            presets = new List<PresetSettings>
+            presets = new Dictionary<string, PresetSettings>
             {
-                new PresetSettings
+                ["CoCo light|blue theme"] = new PresetSettings
                 {
                     Name = "CoCo light|blue theme",
                     Classifications = new List<ClassificationSettings>
                     {
-                        CreateClassification(VisualBasicNames.AliasNamespaceName, 220, 220, 220),
                         CreateClassification(VisualBasicNames.ConstantFieldName, 255, 157, 255),
                         CreateClassification(VisualBasicNames.EnumFieldName, 0, 193, 193),
-                        CreateClassification(VisualBasicNames.EventName, 220, 220, 220),
                         CreateClassification(VisualBasicNames.ExtensionMethodName, 233, 122, 0),
                         CreateClassification(VisualBasicNames.FieldName, 255, 157, 255),
                         CreateClassification(VisualBasicNames.FunctionName, 187, 54, 4),
                         CreateClassification(VisualBasicNames.FunctionVariableName, 128, 64, 0),
                         CreateClassification(VisualBasicNames.LocalVariableName, 128, 128, 0),
-                        CreateClassification(VisualBasicNames.NamespaceName, 220, 220, 220),
                         CreateClassification(VisualBasicNames.ParameterName, 128, 128, 128),
                         CreateClassification(VisualBasicNames.PropertyName, 255, 0, 255),
                         CreateClassification(VisualBasicNames.RangeVariableName, 128, 128, 0),
@@ -107,7 +107,8 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b)
                         CreateClassification(VisualBasicNames.WithEventsPropertyName, 255, 0, 128)
                     }
                 },
-                new PresetSettings
+
+                ["CoCo dark theme"] = new PresetSettings
                 {
                     Name = "CoCo dark theme",
                     Classifications = new List<ClassificationSettings>
@@ -136,16 +137,5 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b)
 
             return _defaultPresets;
         }
-
-        public static IReadOnlyDictionary<string, ISet<string>> GetDefaultPresetsNames()
-        {
-            var presets = new HashSet<string> { "CoCo light|blue theme", "CoCo dark theme" };
-
-            return new Dictionary<string, ISet<string>>
-            {
-                [Languages.CSharp] = presets,
-                [Languages.VisualBasic] = presets,
-            };
-        }
     }
 }
\ No newline at end of file
diff --git a/src/vs15/CoCo/VsPackage.cs b/src/vs15/CoCo/VsPackage.cs
index a4d6ccf..6e74d34 100644
--- a/src/vs15/CoCo/VsPackage.cs
+++ b/src/vs15/CoCo/VsPackage.cs
@@ -12,11 +12,11 @@
 
 namespace CoCo
 {
-    [PackageRegistration(UseManagedResourcesOnly = true)]
+    [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
     [ProvideOptionPage(typeof(ClassificationsOption), "CoCo", "Classifications", 0, 0, true)]
     [ProvideOptionPage(typeof(PresetsOption), "CoCo", "Presets", 0, 0, true)]
     [Guid(Guids.Package)]
-    public sealed class VsPackage : Package
+    public sealed class VsPackage : AsyncPackage
     {
         private static OptionViewModel _optionViewModel;