From 3a5ebef990aab8b3a0c7167dc31e1360beca8f6b Mon Sep 17 00:00:00 2001 From: George Alexandria Date: Sat, 20 Oct 2018 18:12:42 +0300 Subject: [PATCH 1/7] Classify csharp types. --- .../Access/Types/ClassType.cs | 10 ++++ .../Access/Types/DelegateType.cs | 9 ++++ .../Access/Types/EnumType.cs | 11 ++++ .../Access/Types/InterfaceType.cs | 11 ++++ .../Access/Types/StructureType.cs | 10 ++++ .../Access/Types/TypeParameter.cs | 7 +++ .../CSharpIdentifiers.csproj | 12 +++++ .../Declarations/Types/ClassType.cs | 6 +++ .../Declarations/Types/DelegateType.cs | 4 ++ .../Declarations/Types/EnumType.cs | 6 +++ .../Declarations/Types/InterfaceType.cs | 6 +++ .../Declarations/Types/StructureType.cs | 6 +++ .../Declarations/Types/TypeParameter.cs | 9 ++++ .../CSharp/CSharpClassifier.cs | 48 +++++++++++++++-- .../CoCo.Analyser_vs14/CSharp/CSharpNames.cs | 12 +++++ .../ClassificationHelper.cs | 4 +- .../Access/Types.cs | 53 +++++++++++++++++++ .../Declarations/Namespaces.cs | 4 +- .../Declarations/Types.cs | 52 ++++++++++++++++++ .../SimpleTest.cs | 1 + .../CoCo.Analyser/CSharp/CSharpClassifier.cs | 48 +++++++++++++++-- src/vs15/CoCo.Analyser/CSharp/CSharpNames.cs | 12 +++++ .../CoCo.Analyser/ClassificationHelper.cs | 4 +- .../Access/Types.cs | 53 +++++++++++++++++++ .../Declarations/Namespaces.cs | 4 +- .../Declarations/Types.cs | 52 ++++++++++++++++++ .../CoCo.Test.CSharpIdentifiers/SimpleTest.cs | 1 + 27 files changed, 443 insertions(+), 12 deletions(-) create mode 100644 Tests/Identifiers/CSharpIdentifiers/Access/Types/ClassType.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Access/Types/DelegateType.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Access/Types/EnumType.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Access/Types/InterfaceType.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Access/Types/StructureType.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Access/Types/TypeParameter.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Declarations/Types/ClassType.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Declarations/Types/DelegateType.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Declarations/Types/EnumType.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Declarations/Types/InterfaceType.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Declarations/Types/StructureType.cs create mode 100644 Tests/Identifiers/CSharpIdentifiers/Declarations/Types/TypeParameter.cs create mode 100644 src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Access/Types.cs create mode 100644 src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Types.cs create mode 100644 src/vs15/CoCo.Test.CSharpIdentifiers/Access/Types.cs create mode 100644 src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Types.cs 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 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 @@ + + + + + + @@ -117,6 +123,12 @@ + + + + + + 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 + { + public void Method() + { + } + } +} \ 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..9898f52 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 classifications, @@ -61,10 +67,19 @@ internal CSharpClassifier(IReadOnlyDictionary 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,19 @@ internal CSharpClassifier(IReadOnlyDictionary 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); @@ -134,6 +162,14 @@ internal CSharpClassifier(IReadOnlyDictionary 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 spans, ITextSnapshot snapshot, TextSpan span, IClassificationType type, SyntaxNode node = null) { @@ -173,6 +209,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 _all; @@ -46,6 +52,12 @@ public static ImmutableArray 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..9515014 --- /dev/null +++ b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Access/Types.cs @@ -0,0 +1,53 @@ +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").GetClassifications().AssertContains( + CSharpNames.ClassName.ClassifyAt(152, 9)); + } + + [Test] + public void StructureTest() + { + GetContext(@"Access\Types\StructureType.cs").GetClassifications().AssertContains( + CSharpNames.StructureName.ClassifyAt(157, 13)); + } + + [Test] + public void InterfaceTest() + { + GetContext(@"Access\Types\InterfaceType.cs").GetClassifications().AssertContains( + CSharpNames.InterfaceName.ClassifyAt(166, 14)); + } + + [Test] + public void EnumTest() + { + GetContext(@"Access\Types\EnumType.cs").GetClassifications().AssertContains( + CSharpNames.EnumName.ClassifyAt(160, 6)); + } + + [Test] + public void DelegateTest() + { + GetContext(@"Access\Types\DelegateType.cs").GetClassifications().AssertContains( + CSharpNames.DelegateName.ClassifyAt(144, 6)); + } + + [Test] + public void TypeParameterTest() + { + GetContext(@"Access\Types\TypeParameter.cs").GetClassifications().AssertContains( + CSharpNames.TypeParameterName.ClassifyAt(92, 6), + CSharpNames.TypeParameterName.ClassifyAt(131, 6), + CSharpNames.TypeParameterName.ClassifyAt(151, 6)); + } + } +} 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..3ad5b2a --- /dev/null +++ b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Types.cs @@ -0,0 +1,52 @@ +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").GetClassifications().AssertContains( + CSharpNames.TypeParameterName.ClassifyAt(84, 3), + CSharpNames.TypeParameterName.ClassifyAt(124, 6)); + } + + [Test] + public void ClassTest() + { + GetContext(@"Declarations\Types\ClassType.cs").GetClassifications().AssertContains( + CSharpNames.ClassName.ClassifyAt(70, 9)); + } + + [Test] + public void StructureTest() + { + GetContext(@"Declarations\Types\StructureType.cs").GetClassifications().AssertContains( + CSharpNames.StructureName.ClassifyAt(71, 13)); + } + + [Test] + public void InterfaceTest() + { + GetContext(@"Declarations\Types\InterfaceType.cs").GetClassifications().AssertContains( + CSharpNames.InterfaceName.ClassifyAt(74, 13)); + } + + [Test] + public void EnumTest() + { + GetContext(@"Declarations\Types\EnumType.cs").GetClassifications().AssertContains( + CSharpNames.EnumName.ClassifyAt(69, 8)); + } + + [Test] + public void DelegateTest() + { + GetContext(@"Declarations\Types\DelegateType.cs").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..16cd3a0 100644 --- a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/SimpleTest.cs +++ b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/SimpleTest.cs @@ -11,6 +11,7 @@ public void CommonTest() { GetContext(@"SimpleExample.cs").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)); diff --git a/src/vs15/CoCo.Analyser/CSharp/CSharpClassifier.cs b/src/vs15/CoCo.Analyser/CSharp/CSharpClassifier.cs index c57ad07..cd82be3 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 classifications, @@ -62,10 +68,19 @@ internal CSharpClassifier(IReadOnlyDictionary 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 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 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 spans, ITextSnapshot snapshot, TextSpan span, IClassificationType type, SyntaxNode node = null) @@ -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 _all; @@ -48,6 +54,12 @@ public static ImmutableArray 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.Test.CSharpIdentifiers/Access/Types.cs b/src/vs15/CoCo.Test.CSharpIdentifiers/Access/Types.cs new file mode 100644 index 0000000..9515014 --- /dev/null +++ b/src/vs15/CoCo.Test.CSharpIdentifiers/Access/Types.cs @@ -0,0 +1,53 @@ +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").GetClassifications().AssertContains( + CSharpNames.ClassName.ClassifyAt(152, 9)); + } + + [Test] + public void StructureTest() + { + GetContext(@"Access\Types\StructureType.cs").GetClassifications().AssertContains( + CSharpNames.StructureName.ClassifyAt(157, 13)); + } + + [Test] + public void InterfaceTest() + { + GetContext(@"Access\Types\InterfaceType.cs").GetClassifications().AssertContains( + CSharpNames.InterfaceName.ClassifyAt(166, 14)); + } + + [Test] + public void EnumTest() + { + GetContext(@"Access\Types\EnumType.cs").GetClassifications().AssertContains( + CSharpNames.EnumName.ClassifyAt(160, 6)); + } + + [Test] + public void DelegateTest() + { + GetContext(@"Access\Types\DelegateType.cs").GetClassifications().AssertContains( + CSharpNames.DelegateName.ClassifyAt(144, 6)); + } + + [Test] + public void TypeParameterTest() + { + GetContext(@"Access\Types\TypeParameter.cs").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..3ad5b2a --- /dev/null +++ b/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Types.cs @@ -0,0 +1,52 @@ +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").GetClassifications().AssertContains( + CSharpNames.TypeParameterName.ClassifyAt(84, 3), + CSharpNames.TypeParameterName.ClassifyAt(124, 6)); + } + + [Test] + public void ClassTest() + { + GetContext(@"Declarations\Types\ClassType.cs").GetClassifications().AssertContains( + CSharpNames.ClassName.ClassifyAt(70, 9)); + } + + [Test] + public void StructureTest() + { + GetContext(@"Declarations\Types\StructureType.cs").GetClassifications().AssertContains( + CSharpNames.StructureName.ClassifyAt(71, 13)); + } + + [Test] + public void InterfaceTest() + { + GetContext(@"Declarations\Types\InterfaceType.cs").GetClassifications().AssertContains( + CSharpNames.InterfaceName.ClassifyAt(74, 13)); + } + + [Test] + public void EnumTest() + { + GetContext(@"Declarations\Types\EnumType.cs").GetClassifications().AssertContains( + CSharpNames.EnumName.ClassifyAt(69, 8)); + } + + [Test] + public void DelegateTest() + { + GetContext(@"Declarations\Types\DelegateType.cs").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..810dcd3 100644 --- a/src/vs15/CoCo.Test.CSharpIdentifiers/SimpleTest.cs +++ b/src/vs15/CoCo.Test.CSharpIdentifiers/SimpleTest.cs @@ -12,6 +12,7 @@ public void CommonTest() { GetContext(@"SimpleExample.cs").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)); From f1c2fe653bb8b17be7f0b9cebae80dd8c9f3bae8 Mon Sep 17 00:00:00 2001 From: George Alexandria Date: Sat, 20 Oct 2018 20:31:40 +0300 Subject: [PATCH 2/7] Classify visual basic types --- .../Access/Types/ClassType.vb | 9 +++ .../Access/Types/DelegateType.vb | 11 ++++ .../Access/Types/EnumType.vb | 13 +++++ .../Access/Types/InterfaceType.vb | 12 ++++ .../Access/Types/ModuleType.vb | 11 ++++ .../Access/Types/StructureType.vb | 11 ++++ .../Access/Types/TypeParameter.vb | 7 +++ .../Declarations/Types/ClassType.vb | 3 + .../Declarations/Types/DelegateType.vb | 1 + .../Declarations/Types/EnumType.vb | 3 + .../Declarations/Types/InterfaceType.vb | 3 + .../Declarations/Types/ModuleType.vb | 3 + .../Declarations/Types/StructureType.vb | 3 + .../Declarations/Types/TypeParameter.vb | 3 + .../VisualBasicIdentifiers.vbproj | 14 +++++ .../CSharp/CSharpClassifier.cs | 3 +- .../Access/Types.cs | 58 +++++++++++++++++++ .../Declarations/Enum.cs | 2 +- .../Declarations/Methods.cs | 12 ++-- .../Declarations/Namespaces.cs | 4 +- .../Declarations/Types.cs | 58 +++++++++++++++++++ .../VisualBasic/VisualBasicClassifier.cs | 50 +++++++++++++++- .../VisualBasic/VisualBasicNames.cs | 14 +++++ .../CoCo.Test.Common/ClassificationHelper.cs | 2 +- .../Access/Types.cs | 58 +++++++++++++++++++ .../Declarations/Enum.cs | 2 +- .../Declarations/Methods.cs | 12 ++-- .../Declarations/Namespaces.cs | 4 +- .../Declarations/Types.cs | 58 +++++++++++++++++++ 29 files changed, 424 insertions(+), 20 deletions(-) create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Access/Types/ClassType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Access/Types/DelegateType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Access/Types/EnumType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Access/Types/InterfaceType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Access/Types/ModuleType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Access/Types/StructureType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Access/Types/TypeParameter.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/ClassType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/DelegateType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/EnumType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/InterfaceType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/ModuleType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/StructureType.vb create mode 100644 Tests/Identifiers/VisualBasicIdentifiers/Declarations/Types/TypeParameter.vb create mode 100644 src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Access/Types.cs create mode 100644 src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Types.cs create mode 100644 src/vs15/CoCo.Test.VisualBasicIdentifiers/Access/Types.cs create mode 100644 src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Types.cs 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 @@ + + + + + + + @@ -141,6 +148,13 @@ + + + + + + + diff --git a/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs b/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs index 9898f52..9efc11c 100644 --- a/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs +++ b/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs @@ -144,8 +144,7 @@ internal CSharpClassifier(IReadOnlyDictionary classi break; case SymbolKind.NamedType: - var typeSymbol = symbol as INamedTypeSymbol; - var type = GetTypeClassification(typeSymbol); + var type = GetTypeClassification(symbol as INamedTypeSymbol); if (!(type is null)) { AppendClassificationSpan(spans, span.Snapshot, item.TextSpan, type, node); 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..cf3f87b --- /dev/null +++ b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Access/Types.cs @@ -0,0 +1,58 @@ +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").GetClassifications().AssertContains( + VisualBasicNames.TypeParameterName.ClassifyAt(87, 6)); + } + + [Test] + public void ClassTest() + { + GetContext(@"Access\Types\ClassType.vb").GetClassifications().AssertContains( + VisualBasicNames.ClassName.ClassifyAt(74, 9)); + } + + [Test] + public void StructureTest() + { + GetContext(@"Access\Types\StructureType.vb").GetClassifications().AssertContains( + VisualBasicNames.StructureName.ClassifyAt(102, 13)); + } + + [Test] + public void ModuleTest() + { + GetContext(@"Access\Types\ModuleType.vb").GetClassifications().AssertContains( + VisualBasicNames.ModuleName.ClassifyAt(121, 10)); + } + + [Test] + public void InterfaceTest() + { + GetContext(@"Access\Types\InterfaceType.vb").GetClassifications().AssertContains( + VisualBasicNames.InterfaceName.ClassifyAt(138, 14)); + } + + [Test] + public void EnumTest() + { + GetContext(@"Access\Types\EnumType.vb").GetClassifications().AssertContains( + VisualBasicNames.EnumName.ClassifyAt(122, 6)); + } + + [Test] + public void DelegateTest() + { + GetContext(@"Access\Types\DelegateType.vb").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..ae06432 --- /dev/null +++ b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Types.cs @@ -0,0 +1,58 @@ +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").GetClassifications().AssertContains( + VisualBasicNames.TypeParameterName.ClassifyAt(30, 6)); + } + + [Test] + public void ClassTest() + { + GetContext(@"Declarations\Types\ClassType.vb").GetClassifications().AssertContains( + VisualBasicNames.ClassName.ClassifyAt(13, 9)); + } + + [Test] + public void StructureTest() + { + GetContext(@"Declarations\Types\StructureType.vb").GetClassifications().AssertContains( + VisualBasicNames.StructureName.ClassifyAt(17, 13)); + } + + [Test] + public void ModuleTest() + { + GetContext(@"Declarations\Types\ModuleType.vb").GetClassifications().AssertContains( + VisualBasicNames.ModuleName.ClassifyAt(7, 10)); + } + + [Test] + public void InterfaceTest() + { + GetContext(@"Declarations\Types\InterfaceType.vb").GetClassifications().AssertContains( + VisualBasicNames.InterfaceName.ClassifyAt(17, 13)); + } + + [Test] + public void EnumTest() + { + GetContext(@"Declarations\Types\EnumType.vb").GetClassifications().AssertContains( + VisualBasicNames.EnumName.ClassifyAt(12, 8)); + } + + [Test] + public void DelegateTest() + { + GetContext(@"Declarations\Types\DelegateType.vb").GetClassifications().AssertContains( + VisualBasicNames.DelegateName.ClassifyAt(20, 12)); + } + } +} \ No newline at end of file diff --git a/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicClassifier.cs b/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicClassifier.cs index 994bf63..bf91eec 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 classifications, @@ -60,10 +67,19 @@ internal VisualBasicClassifier(IReadOnlyDictionary 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 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 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 spans, ITextSnapshot snapshot, TextSpan span, IClassificationType type, SyntaxNode node = null) { @@ -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 _all; @@ -48,6 +55,13 @@ public static ImmutableArray 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.Common/ClassificationHelper.cs b/src/vs15/CoCo.Test.Common/ClassificationHelper.cs index 4e6b5ac..9412417 100644 --- a/src/vs15/CoCo.Test.Common/ClassificationHelper.cs +++ b/src/vs15/CoCo.Test.Common/ClassificationHelper.cs @@ -99,7 +99,7 @@ public static SimplifiedClassificationInfo DisableInXml(this string name) => IsU else { classificationTypes.Add( - name, new ClassificationInfo(new ClassificationType(name), !info.IsDisabled, !info.IsDisabledInXml)); + name, new ClassificationInfo(new ClassificationType(name), info.IsDisabled, info.IsDisabledInXml)); } } 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..cf3f87b --- /dev/null +++ b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Access/Types.cs @@ -0,0 +1,58 @@ +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").GetClassifications().AssertContains( + VisualBasicNames.TypeParameterName.ClassifyAt(87, 6)); + } + + [Test] + public void ClassTest() + { + GetContext(@"Access\Types\ClassType.vb").GetClassifications().AssertContains( + VisualBasicNames.ClassName.ClassifyAt(74, 9)); + } + + [Test] + public void StructureTest() + { + GetContext(@"Access\Types\StructureType.vb").GetClassifications().AssertContains( + VisualBasicNames.StructureName.ClassifyAt(102, 13)); + } + + [Test] + public void ModuleTest() + { + GetContext(@"Access\Types\ModuleType.vb").GetClassifications().AssertContains( + VisualBasicNames.ModuleName.ClassifyAt(121, 10)); + } + + [Test] + public void InterfaceTest() + { + GetContext(@"Access\Types\InterfaceType.vb").GetClassifications().AssertContains( + VisualBasicNames.InterfaceName.ClassifyAt(138, 14)); + } + + [Test] + public void EnumTest() + { + GetContext(@"Access\Types\EnumType.vb").GetClassifications().AssertContains( + VisualBasicNames.EnumName.ClassifyAt(122, 6)); + } + + [Test] + public void DelegateTest() + { + GetContext(@"Access\Types\DelegateType.vb").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..ae06432 --- /dev/null +++ b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Types.cs @@ -0,0 +1,58 @@ +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").GetClassifications().AssertContains( + VisualBasicNames.TypeParameterName.ClassifyAt(30, 6)); + } + + [Test] + public void ClassTest() + { + GetContext(@"Declarations\Types\ClassType.vb").GetClassifications().AssertContains( + VisualBasicNames.ClassName.ClassifyAt(13, 9)); + } + + [Test] + public void StructureTest() + { + GetContext(@"Declarations\Types\StructureType.vb").GetClassifications().AssertContains( + VisualBasicNames.StructureName.ClassifyAt(17, 13)); + } + + [Test] + public void ModuleTest() + { + GetContext(@"Declarations\Types\ModuleType.vb").GetClassifications().AssertContains( + VisualBasicNames.ModuleName.ClassifyAt(7, 10)); + } + + [Test] + public void InterfaceTest() + { + GetContext(@"Declarations\Types\InterfaceType.vb").GetClassifications().AssertContains( + VisualBasicNames.InterfaceName.ClassifyAt(17, 13)); + } + + [Test] + public void EnumTest() + { + GetContext(@"Declarations\Types\EnumType.vb").GetClassifications().AssertContains( + VisualBasicNames.EnumName.ClassifyAt(12, 8)); + } + + [Test] + public void DelegateTest() + { + GetContext(@"Declarations\Types\DelegateType.vb").GetClassifications().AssertContains( + VisualBasicNames.DelegateName.ClassifyAt(20, 12)); + } + } +} \ No newline at end of file From 560fe7ff7bc9fcb28f9d35d7cb4b151a951425d4 Mon Sep 17 00:00:00 2001 From: George Alexandria Date: Sun, 21 Oct 2018 15:06:06 +0300 Subject: [PATCH 3/7] Disable by default analyzing of csharp and visual basic types. --- .../CSharp/CSharpClassifier.cs | 2 +- .../Access/Types.cs | 44 ++++++++++++------- .../Declarations/Types.cs | 38 ++++++++++------ .../SimpleTest.cs | 14 +++--- .../Access/Types.cs | 42 ++++++++++++------ .../Declarations/Types.cs | 42 ++++++++++++------ .../CoCo.Analyser/CSharp/CSharpClassifier.cs | 2 +- src/vs15/CoCo.Analyser/ClassificationInfo.cs | 16 +++++-- .../CoCo.Analyser/ClassificationService.cs | 29 +++++++++++- .../ClassificationsChangedEventArgs.cs | 4 +- .../CoCo.Analyser/RoslynEditorClassifier.cs | 4 +- .../VisualBasic/VisualBasicClassifier.cs | 2 +- .../Access/Types.cs | 38 ++++++++++------ .../Declarations/Types.cs | 38 ++++++++++------ .../CoCo.Test.CSharpIdentifiers/SimpleTest.cs | 14 +++--- .../CoCo.Test.Common/ClassificationHelper.cs | 38 +++++++++------- .../CoCo.Test.Common/ClassificationInfo.cs | 29 +++++++----- .../Access/Types.cs | 42 ++++++++++++------ .../Declarations/Types.cs | 42 ++++++++++++------ .../Providers/CSharpClassifierProvider.cs | 2 +- .../VisualBasicClassifierProvider.cs | 2 +- src/vs15/CoCo/Services/AnalyzingService.cs | 4 +- 22 files changed, 324 insertions(+), 164 deletions(-) diff --git a/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs b/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs index 9efc11c..bc05377 100644 --- a/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs +++ b/src/vs14/CoCo.Analyser_vs14/CSharp/CSharpClassifier.cs @@ -188,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); } diff --git a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Access/Types.cs b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Access/Types.cs index 9515014..5304dc5 100644 --- a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Access/Types.cs +++ b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Access/Types.cs @@ -4,50 +4,62 @@ namespace CoCo.Test.CSharpIdentifiers.Access { - class Types : CSharpIdentifierTests + internal class Types : CSharpIdentifierTests { [Test] public void ClassTest() { - GetContext(@"Access\Types\ClassType.cs").GetClassifications().AssertContains( - CSharpNames.ClassName.ClassifyAt(152, 9)); + 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").GetClassifications().AssertContains( - CSharpNames.StructureName.ClassifyAt(157, 13)); + 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").GetClassifications().AssertContains( - CSharpNames.InterfaceName.ClassifyAt(166, 14)); + 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").GetClassifications().AssertContains( - CSharpNames.EnumName.ClassifyAt(160, 6)); + 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").GetClassifications().AssertContains( - CSharpNames.DelegateName.ClassifyAt(144, 6)); + 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").GetClassifications().AssertContains( - CSharpNames.TypeParameterName.ClassifyAt(92, 6), - CSharpNames.TypeParameterName.ClassifyAt(131, 6), - CSharpNames.TypeParameterName.ClassifyAt(151, 6)); + 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/Types.cs b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Types.cs index 3ad5b2a..ea39295 100644 --- a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Types.cs +++ b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/Declarations/Types.cs @@ -9,44 +9,56 @@ internal class Types : CSharpIdentifierTests [Test] public void TypeParameterTest() { - GetContext(@"Declarations\Types\TypeParameter.cs").GetClassifications().AssertContains( - CSharpNames.TypeParameterName.ClassifyAt(84, 3), - CSharpNames.TypeParameterName.ClassifyAt(124, 6)); + 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").GetClassifications().AssertContains( - CSharpNames.ClassName.ClassifyAt(70, 9)); + 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").GetClassifications().AssertContains( - CSharpNames.StructureName.ClassifyAt(71, 13)); + 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").GetClassifications().AssertContains( - CSharpNames.InterfaceName.ClassifyAt(74, 13)); + 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").GetClassifications().AssertContains( - CSharpNames.EnumName.ClassifyAt(69, 8)); + 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").GetClassifications().AssertContains( - CSharpNames.DelegateName.ClassifyAt(78, 6)); + 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 16cd3a0..be81a6c 100644 --- a/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/SimpleTest.cs +++ b/src/vs14/CoCo.Test.CSharpIdentifiers_vs14/SimpleTest.cs @@ -9,12 +9,14 @@ internal class SimpleTest : CSharpIdentifierTests [Test] public void CommonTest() { - GetContext(@"SimpleExample.cs").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)); + 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 index cf3f87b..1eed4ed 100644 --- a/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Access/Types.cs +++ b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Access/Types.cs @@ -9,50 +9,64 @@ internal class Types : VisualBasicIdentifierTests [Test] public void TypeParameterTest() { - GetContext(@"Access\Types\TypeParameter.vb").GetClassifications().AssertContains( - VisualBasicNames.TypeParameterName.ClassifyAt(87, 6)); + 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").GetClassifications().AssertContains( - VisualBasicNames.ClassName.ClassifyAt(74, 9)); + 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").GetClassifications().AssertContains( - VisualBasicNames.StructureName.ClassifyAt(102, 13)); + 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").GetClassifications().AssertContains( - VisualBasicNames.ModuleName.ClassifyAt(121, 10)); + 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").GetClassifications().AssertContains( - VisualBasicNames.InterfaceName.ClassifyAt(138, 14)); + 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").GetClassifications().AssertContains( - VisualBasicNames.EnumName.ClassifyAt(122, 6)); + 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").GetClassifications().AssertContains( - VisualBasicNames.DelegateName.ClassifyAt(113, 6)); + 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/Types.cs b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Types.cs index ae06432..5bd2c8d 100644 --- a/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Types.cs +++ b/src/vs14/CoCo.Test.VisualBasicIdentifiers_vs14/Declarations/Types.cs @@ -9,50 +9,64 @@ internal class Types : VisualBasicIdentifierTests [Test] public void TypeParameterTest() { - GetContext(@"Declarations\Types\TypeParameter.vb").GetClassifications().AssertContains( - VisualBasicNames.TypeParameterName.ClassifyAt(30, 6)); + 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").GetClassifications().AssertContains( - VisualBasicNames.ClassName.ClassifyAt(13, 9)); + 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").GetClassifications().AssertContains( - VisualBasicNames.StructureName.ClassifyAt(17, 13)); + 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").GetClassifications().AssertContains( - VisualBasicNames.ModuleName.ClassifyAt(7, 10)); + 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").GetClassifications().AssertContains( - VisualBasicNames.InterfaceName.ClassifyAt(17, 13)); + 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").GetClassifications().AssertContains( - VisualBasicNames.EnumName.ClassifyAt(12, 8)); + 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").GetClassifications().AssertContains( - VisualBasicNames.DelegateName.ClassifyAt(20, 12)); + 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.Analyser/CSharp/CSharpClassifier.cs b/src/vs15/CoCo.Analyser/CSharp/CSharpClassifier.cs index cd82be3..9381318 100644 --- a/src/vs15/CoCo.Analyser/CSharp/CSharpClassifier.cs +++ b/src/vs15/CoCo.Analyser/CSharp/CSharpClassifier.cs @@ -192,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); } 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..dadf70b 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 _disabledClassifications = new HashSet + { + 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) => GetDefaultInfo(type.Classification); + + public static ClassificationOption GetDefaultInfo(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 changedClassifications) + IReadOnlyDictionary changedClassifications) { ChangedClassifications = changedClassifications; } - public IReadOnlyDictionary ChangedClassifications; + public IReadOnlyDictionary 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 options = - new Dictionary(); + protected readonly Dictionary options = + new Dictionary(); protected ImmutableArray classifications; diff --git a/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicClassifier.cs b/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicClassifier.cs index bf91eec..829fd54 100644 --- a/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicClassifier.cs +++ b/src/vs15/CoCo.Analyser/VisualBasic/VisualBasicClassifier.cs @@ -192,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); } diff --git a/src/vs15/CoCo.Test.CSharpIdentifiers/Access/Types.cs b/src/vs15/CoCo.Test.CSharpIdentifiers/Access/Types.cs index 9515014..bc22a76 100644 --- a/src/vs15/CoCo.Test.CSharpIdentifiers/Access/Types.cs +++ b/src/vs15/CoCo.Test.CSharpIdentifiers/Access/Types.cs @@ -9,45 +9,57 @@ class Types : CSharpIdentifierTests [Test] public void ClassTest() { - GetContext(@"Access\Types\ClassType.cs").GetClassifications().AssertContains( - CSharpNames.ClassName.ClassifyAt(152, 9)); + 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").GetClassifications().AssertContains( - CSharpNames.StructureName.ClassifyAt(157, 13)); + 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").GetClassifications().AssertContains( + 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").GetClassifications().AssertContains( - CSharpNames.EnumName.ClassifyAt(160, 6)); + 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").GetClassifications().AssertContains( - CSharpNames.DelegateName.ClassifyAt(144, 6)); + 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").GetClassifications().AssertContains( - CSharpNames.TypeParameterName.ClassifyAt(92, 6), - CSharpNames.TypeParameterName.ClassifyAt(131, 6), - CSharpNames.TypeParameterName.ClassifyAt(151, 6)); + 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/Types.cs b/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Types.cs index 3ad5b2a..ea39295 100644 --- a/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Types.cs +++ b/src/vs15/CoCo.Test.CSharpIdentifiers/Declarations/Types.cs @@ -9,44 +9,56 @@ internal class Types : CSharpIdentifierTests [Test] public void TypeParameterTest() { - GetContext(@"Declarations\Types\TypeParameter.cs").GetClassifications().AssertContains( - CSharpNames.TypeParameterName.ClassifyAt(84, 3), - CSharpNames.TypeParameterName.ClassifyAt(124, 6)); + 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").GetClassifications().AssertContains( - CSharpNames.ClassName.ClassifyAt(70, 9)); + 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").GetClassifications().AssertContains( - CSharpNames.StructureName.ClassifyAt(71, 13)); + 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").GetClassifications().AssertContains( - CSharpNames.InterfaceName.ClassifyAt(74, 13)); + 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").GetClassifications().AssertContains( - CSharpNames.EnumName.ClassifyAt(69, 8)); + 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").GetClassifications().AssertContains( - CSharpNames.DelegateName.ClassifyAt(78, 6)); + 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 810dcd3..f8d3334 100644 --- a/src/vs15/CoCo.Test.CSharpIdentifiers/SimpleTest.cs +++ b/src/vs15/CoCo.Test.CSharpIdentifiers/SimpleTest.cs @@ -10,12 +10,14 @@ internal class SimpleTest : CSharpIdentifierTests [Test] public void CommonTest() { - GetContext(@"SimpleExample.cs").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)); + 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 9412417..b4c16a4 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 GetClassifications( string path, Project project, IReadOnlyList infos = null) @@ -92,15 +105,10 @@ public static SimplifiedClassificationInfo DisableInXml(this string name) => IsU 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.GetDefaultInfo(name) + : simplifiedInfo; + classificationTypes.Add(name, new ClassificationInfo(new ClassificationType(name), option)); } return language == ProgrammingLanguage.VisualBasic diff --git a/src/vs15/CoCo.Test.Common/ClassificationInfo.cs b/src/vs15/CoCo.Test.Common/ClassificationInfo.cs index bad06f3..963a8c9 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.GetDefaultInfo(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 index cf3f87b..1eed4ed 100644 --- a/src/vs15/CoCo.Test.VisualBasicIdentifiers/Access/Types.cs +++ b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Access/Types.cs @@ -9,50 +9,64 @@ internal class Types : VisualBasicIdentifierTests [Test] public void TypeParameterTest() { - GetContext(@"Access\Types\TypeParameter.vb").GetClassifications().AssertContains( - VisualBasicNames.TypeParameterName.ClassifyAt(87, 6)); + 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").GetClassifications().AssertContains( - VisualBasicNames.ClassName.ClassifyAt(74, 9)); + 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").GetClassifications().AssertContains( - VisualBasicNames.StructureName.ClassifyAt(102, 13)); + 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").GetClassifications().AssertContains( - VisualBasicNames.ModuleName.ClassifyAt(121, 10)); + 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").GetClassifications().AssertContains( - VisualBasicNames.InterfaceName.ClassifyAt(138, 14)); + 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").GetClassifications().AssertContains( - VisualBasicNames.EnumName.ClassifyAt(122, 6)); + 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").GetClassifications().AssertContains( - VisualBasicNames.DelegateName.ClassifyAt(113, 6)); + 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/Types.cs b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Types.cs index ae06432..5bd2c8d 100644 --- a/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Types.cs +++ b/src/vs15/CoCo.Test.VisualBasicIdentifiers/Declarations/Types.cs @@ -9,50 +9,64 @@ internal class Types : VisualBasicIdentifierTests [Test] public void TypeParameterTest() { - GetContext(@"Declarations\Types\TypeParameter.vb").GetClassifications().AssertContains( - VisualBasicNames.TypeParameterName.ClassifyAt(30, 6)); + 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").GetClassifications().AssertContains( - VisualBasicNames.ClassName.ClassifyAt(13, 9)); + 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").GetClassifications().AssertContains( - VisualBasicNames.StructureName.ClassifyAt(17, 13)); + 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").GetClassifications().AssertContains( - VisualBasicNames.ModuleName.ClassifyAt(7, 10)); + 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").GetClassifications().AssertContains( - VisualBasicNames.InterfaceName.ClassifyAt(17, 13)); + 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").GetClassifications().AssertContains( - VisualBasicNames.EnumName.ClassifyAt(12, 8)); + 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").GetClassifications().AssertContains( - VisualBasicNames.DelegateName.ClassifyAt(20, 12)); + 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/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/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..b529fd4 100644 --- a/src/vs15/CoCo/Services/AnalyzingService.cs +++ b/src/vs15/CoCo/Services/AnalyzingService.cs @@ -26,14 +26,14 @@ public static void SetAnalyzingOptions(Option option) } } - var classifications = new Dictionary(classificationTypes.Count); + var classifications = new Dictionary(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)); } } } From cdaa6a7dc80411601d0b750d9759358d74b5eaf5 Mon Sep 17 00:00:00 2001 From: George Alexandria Date: Sun, 21 Oct 2018 20:41:02 +0300 Subject: [PATCH 4/7] Use the default formatting and options by per classification. --- .../ClassificationColorViewModel.cs | 5 ++- .../ViewModels/ClassificationViewModel.cs | 6 +-- .../ViewModels/IResetValuesProvider.cs | 6 +-- src/vs14/CoCo_vs14/Services/PresetService.cs | 19 ++++++--- .../CoCo.Analyser/ClassificationService.cs | 4 +- .../CoCo.Test.Common/ClassificationHelper.cs | 2 +- .../CoCo.Test.Common/ClassificationInfo.cs | 2 +- src/vs15/CoCo/ClassificationManager.cs | 41 +++++++++++++++++-- src/vs15/CoCo/Extensions.cs | 29 +++++++------ .../CoCo/Providers/ResetValuesProvider.cs | 6 +-- src/vs15/CoCo/Services/FormattingService.cs | 32 +++++++++++++-- src/vs15/CoCo/Services/OptionService.cs | 34 +++++++-------- src/vs15/CoCo/Services/PresetService.cs | 19 ++++++--- 13 files changed, 143 insertions(+), 62 deletions(-) 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 /// 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 /// 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_vs14/Services/PresetService.cs b/src/vs14/CoCo_vs14/Services/PresetService.cs index 251c899..df568ff 100644 --- a/src/vs14/CoCo_vs14/Services/PresetService.cs +++ b/src/vs14/CoCo_vs14/Services/PresetService.cs @@ -4,7 +4,6 @@ using CoCo.Analyser.CSharp; using CoCo.Analyser.VisualBasic; using CoCo.Settings; -using Microsoft.VisualStudio.Text.Formatting; namespace CoCo.Services { @@ -15,19 +14,27 @@ public static class PresetService /// /// Returns the default CoCo settings that are grouped by languages /// - public static IReadOnlyDictionary> GetDefaultPresets(TextFormattingRunProperties defaultFormatting) + public static IReadOnlyDictionary> GetDefaultPresets() { + if (!(_defaultPresets is null)) return _defaultPresets; + + _defaultPresets = new Dictionary>(); + + var defaulltIdentifierFormatting = FormattingService.GetDefaultIdentifierFormatting(); + ClassificationSettings CreateClassification(string name, byte r, byte g, byte b) { + var defaultFormatting = defaulltIdentifierFormatting; + if (ClassificationManager.Instance.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>(); - var presets = new List { new PresetSettings diff --git a/src/vs15/CoCo.Analyser/ClassificationService.cs b/src/vs15/CoCo.Analyser/ClassificationService.cs index dadf70b..b3c4181 100644 --- a/src/vs15/CoCo.Analyser/ClassificationService.cs +++ b/src/vs15/CoCo.Analyser/ClassificationService.cs @@ -25,9 +25,9 @@ internal static class ClassificationService VisualBasicNames.TypeParameterName }; - public static ClassificationOption GetDefaultInfo(IClassificationType type) => GetDefaultInfo(type.Classification); + public static ClassificationOption GetDefaultInfo(IClassificationType type) => GetDefaultOption(type.Classification); - public static ClassificationOption GetDefaultInfo(string name) => _disabledClassifications.Contains(name) + public static ClassificationOption GetDefaultOption(string name) => _disabledClassifications.Contains(name) ? new ClassificationOption(true, true) : new ClassificationOption(false, false); } diff --git a/src/vs15/CoCo.Test.Common/ClassificationHelper.cs b/src/vs15/CoCo.Test.Common/ClassificationHelper.cs index b4c16a4..9d6a982 100644 --- a/src/vs15/CoCo.Test.Common/ClassificationHelper.cs +++ b/src/vs15/CoCo.Test.Common/ClassificationHelper.cs @@ -106,7 +106,7 @@ public static SimplifiedClassificationInfo DisableInXml(this string name) foreach (var name in names) { var option = dictionary is null || !dictionary.TryGetValue(name, out var simplifiedInfo) - ? ClassificationService.GetDefaultInfo(name) + ? ClassificationService.GetDefaultOption(name) : simplifiedInfo; classificationTypes.Add(name, new ClassificationInfo(new ClassificationType(name), option)); } diff --git a/src/vs15/CoCo.Test.Common/ClassificationInfo.cs b/src/vs15/CoCo.Test.Common/ClassificationInfo.cs index 963a8c9..714a3b3 100644 --- a/src/vs15/CoCo.Test.Common/ClassificationInfo.cs +++ b/src/vs15/CoCo.Test.Common/ClassificationInfo.cs @@ -11,7 +11,7 @@ public class SimplifiedClassificationInfo private SimplifiedClassificationInfo(string name) { Name = name; - var info = ClassificationService.GetDefaultInfo(name); + var info = ClassificationService.GetDefaultOption(name); IsDisabled = info.IsDisabled; IsDisabledInXml = info.IsDisabledInXml; } diff --git a/src/vs15/CoCo/ClassificationManager.cs b/src/vs15/CoCo/ClassificationManager.cs index 9ece1e8..0f222dd 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,19 +12,50 @@ namespace CoCo { public sealed class ClassificationManager { + private static readonly IReadOnlyDictionary _nonIdentifierClassifications = new Dictionary + { + [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", + + [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", + }; + private static Dictionary> _classifications; private ClassificationManager() { } - private static ClassificationManager _instance; + public static ClassificationManager Instance { get; } = new ClassificationManager(); - public static ClassificationManager Instance => _instance ?? (_instance = new ClassificationManager()); - - public IClassificationType DefaultClassification => + public IClassificationType DefaultIdentifierClassification => ServicesProvider.Instance.RegistryService.GetClassificationType(PredefinedClassificationTypeNames.Identifier); + /// + /// Try to retreive a default classification for if it isn't + /// + public 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; + } + /// /// Classifications are grouped by language /// 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 /// 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, + }; + } /// /// Gets if is 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/Services/FormattingService.cs b/src/vs15/CoCo/Services/FormattingService.cs index 73047b6..354b34a 100644 --- a/src/vs15/CoCo/Services/FormattingService.cs +++ b/src/vs15/CoCo/Services/FormattingService.cs @@ -11,17 +11,33 @@ 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.Instance.TryGetDefaultNonIdentifierClassification( + classificationName, out var defaultClassification)) + { + return GetDefaultFormatting(classificationFormatMap, defaultClassification); + } + return GetDefaultFormatting(classificationFormatMap, ClassificationManager.Instance.DefaultIdentifierClassification); + } + + public static TextFormattingRunProperties GetDefaultIdentifierFormatting() + { + var classificationFormatMap = ServicesProvider.Instance.FormatMapService.GetClassificationFormatMap(category: "text"); + return GetDefaultFormatting(classificationFormatMap, ClassificationManager.Instance.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 classificationFormatMap = ServicesProvider.Instance.FormatMapService.GetClassificationFormatMap(category: "text"); - var defaultFormatting = GetDefaultFormatting(classificationFormatMap, ClassificationManager.Instance.DefaultClassification); var classificationsMap = new Dictionary(23); foreach (var classifications in classificationTypes.Values) @@ -32,6 +48,9 @@ public static void SetFormattingOptions(Option option) } } + var defaultIdentifierFormatting = + GetDefaultFormatting(classificationFormatMap, ClassificationManager.Instance.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 +59,13 @@ public static void SetFormattingOptions(Option option) { if (classificationsMap.TryGetValue(classification.Name, out var classificationType)) { + var defaultFormatting = defaultIdentifierFormatting; + if (ClassificationManager.Instance.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..9db1ac2 100644 --- a/src/vs15/CoCo/Services/OptionService.cs +++ b/src/vs15/CoCo/Services/OptionService.cs @@ -65,9 +65,7 @@ List ToSettings(ICollection classificati 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) @@ -92,8 +90,7 @@ 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) { @@ -101,8 +98,7 @@ public static Option ToOption(Settings.Settings settings) if (presetNames.Contains(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; @@ -113,15 +109,13 @@ public static Option ToOption(Settings.Settings settings) foreach (var defaultPreset in defaultLanguagePresets) { 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(), language.Classifications, defaultFormatting); + FillClassifications(languageClassifications, Array.Empty(), language.Classifications); } option.Languages.Add(language); } @@ -132,17 +126,23 @@ public static Option ToOption(Settings.Settings settings) /// /// Converts an existing to and appends them to /// , also create from non existing classifications in - /// set the default values of fields using + /// set the default values of fields /// /// string * string -> name * display name private static void FillClassifications( IEnumerable<(string, string)> classificationNames, ICollection classificationsSettings, - ICollection classifications, - TextFormattingRunProperties defaultFormatting) + ICollection classifications) { + var defaultIdentifierFormatting = FormattingService.GetDefaultIdentifierFormatting(); foreach (var (name, displayName) in classificationNames) { + var defaultFormatting = defaultIdentifierFormatting; + if (ClassificationManager.Instance.TryGetDefaultNonIdentifierClassification(name, out var classification)) + { + defaultFormatting = FormattingService.GetDefaultFormatting(classification); + } + var isClassificationExists = false; foreach (var classificationSettings in classificationsSettings) { @@ -213,8 +213,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..29b065d 100644 --- a/src/vs15/CoCo/Services/PresetService.cs +++ b/src/vs15/CoCo/Services/PresetService.cs @@ -4,7 +4,6 @@ using CoCo.Analyser.CSharp; using CoCo.Analyser.VisualBasic; using CoCo.Settings; -using Microsoft.VisualStudio.Text.Formatting; namespace CoCo.Services { @@ -15,19 +14,27 @@ public static class PresetService /// /// Returns the default CoCo settings that are grouped by languages /// - public static IReadOnlyDictionary> GetDefaultPresets(TextFormattingRunProperties defaultFormatting) + public static IReadOnlyDictionary> GetDefaultPresets() { + if (!(_defaultPresets is null)) return _defaultPresets; + + _defaultPresets = new Dictionary>(); + + var defaulltIdentifierFormatting = FormattingService.GetDefaultIdentifierFormatting(); + ClassificationSettings CreateClassification(string name, byte r, byte g, byte b) { + var defaultFormatting = defaulltIdentifierFormatting; + if (ClassificationManager.Instance.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>(); - var presets = new List { new PresetSettings From 579704ba0df7f11796ddbf4ab6b1b1a06904d593 Mon Sep 17 00:00:00 2001 From: George Alexandria Date: Sun, 21 Oct 2018 22:09:36 +0300 Subject: [PATCH 5/7] Fixed priority order. --- src/vs15/CoCo/ClassificationManager.cs | 52 +++++++++++++++----------- 1 file changed, 31 insertions(+), 21 deletions(-) diff --git a/src/vs15/CoCo/ClassificationManager.cs b/src/vs15/CoCo/ClassificationManager.cs index 0f222dd..05c4f8e 100644 --- a/src/vs15/CoCo/ClassificationManager.cs +++ b/src/vs15/CoCo/ClassificationManager.cs @@ -69,32 +69,38 @@ public bool TryGetDefaultNonIdentifierClassification(string name, out IClassific 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(); 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 { @@ -112,41 +118,45 @@ public bool TryGetDefaultNonIdentifierClassification(string name, out IClassific } /// - /// if classification doesn't exist or + /// if classification doesn't exist or /// it is the last element returns -1, otherwise returns it position /// - 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; } /// - /// Swap priority of items from to identifier classification: - /// * [...,cur,a1,a2,id,...] -> [...,a1,a2,id,cur,...] - /// * [...,id,a1,a2,cur,...] -> [...,id,cur,a1,a2,...] + /// Swap priority of items from to classification: + /// * [...,cur,a1,a2,tar,...] -> [...,a1,a2,tar,cur,...] + /// * [...,tar,a1,a2,cur,...] -> [...,tar,cur,a1,a2,...] /// 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); } From 2e37af52d79cce2e5ad9e791148437a69a103dbf Mon Sep 17 00:00:00 2001 From: George Alexandria Date: Thu, 25 Oct 2018 00:26:19 +0300 Subject: [PATCH 6/7] Small cleanup code. --- src/common/CoCo.MsBuild/MsBuildEngine.cs | 13 +++++++------ src/common/CoCo.UI/UI/PresetsControl.xaml | 1 - src/vs14/CoCo_vs14/Services/PresetService.cs | 2 +- src/vs15/CoCo.Test.Common/ClassificationHelper.cs | 4 ++-- src/vs15/CoCo/ClassificationManager.cs | 12 +++--------- src/vs15/CoCo/Services/AnalyzingService.cs | 2 +- src/vs15/CoCo/Services/FormattingService.cs | 13 ++++++------- src/vs15/CoCo/Services/OptionService.cs | 4 ++-- src/vs15/CoCo/Services/PresetService.cs | 2 +- src/vs15/CoCo/VsPackage.cs | 4 ++-- 10 files changed, 25 insertions(+), 32 deletions(-) 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(projectGlobalProperties.Count); + Dictionary properties = null; if (projectGlobalProperties != null) { + properties = new Dictionary(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(), 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(targetOuputs.Count); - foreach (var item in targetOuputs) + var projectTargetOutputs = new Dictionary(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}" /> public static Option ToOption(Settings.Settings settings) { - var classificationTypes = ClassificationManager.Instance.GetClassifications(); + var classificationTypes = ClassificationManager.GetClassifications(); var defaultPresets = PresetService.GetDefaultPresets(); var option = new Option(); @@ -138,7 +138,7 @@ public static Option ToOption(Settings.Settings settings) foreach (var (name, displayName) in classificationNames) { var defaultFormatting = defaultIdentifierFormatting; - if (ClassificationManager.Instance.TryGetDefaultNonIdentifierClassification(name, out var classification)) + if (ClassificationManager.TryGetDefaultNonIdentifierClassification(name, out var classification)) { defaultFormatting = FormattingService.GetDefaultFormatting(classification); } diff --git a/src/vs15/CoCo/Services/PresetService.cs b/src/vs15/CoCo/Services/PresetService.cs index 29b065d..ee69333 100644 --- a/src/vs15/CoCo/Services/PresetService.cs +++ b/src/vs15/CoCo/Services/PresetService.cs @@ -25,7 +25,7 @@ public static class PresetService ClassificationSettings CreateClassification(string name, byte r, byte g, byte b) { var defaultFormatting = defaulltIdentifierFormatting; - if (ClassificationManager.Instance.TryGetDefaultNonIdentifierClassification(name, out var defaultClassification)) + if (ClassificationManager.TryGetDefaultNonIdentifierClassification(name, out var defaultClassification)) { defaultFormatting = FormattingService.GetDefaultFormatting(defaultClassification); } 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; From b451911f1532c95c60b2e4366be52d1c92520754 Mon Sep 17 00:00:00 2001 From: George Alexandria Date: Thu, 25 Oct 2018 22:43:45 +0300 Subject: [PATCH 7/7] Simplified presets. --- src/vs14/CoCo_vs14/Services/PresetService.cs | 39 ++++++-------------- src/vs15/CoCo/Services/OptionService.cs | 17 ++++----- src/vs15/CoCo/Services/PresetService.cs | 39 ++++++-------------- 3 files changed, 29 insertions(+), 66 deletions(-) diff --git a/src/vs14/CoCo_vs14/Services/PresetService.cs b/src/vs14/CoCo_vs14/Services/PresetService.cs index cf81342..5f976c7 100644 --- a/src/vs14/CoCo_vs14/Services/PresetService.cs +++ b/src/vs14/CoCo_vs14/Services/PresetService.cs @@ -9,16 +9,16 @@ namespace CoCo.Services { public static class PresetService { - private static Dictionary> _defaultPresets; + private static Dictionary> _defaultPresets; /// /// Returns the default CoCo settings that are grouped by languages /// - public static IReadOnlyDictionary> GetDefaultPresets() + public static IReadOnlyDictionary> GetDefaultPresets() { if (!(_defaultPresets is null)) return _defaultPresets; - _defaultPresets = new Dictionary>(); + _defaultPresets = new Dictionary>(); var defaulltIdentifierFormatting = FormattingService.GetDefaultIdentifierFormatting(); @@ -35,32 +35,28 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b) return classification; } - var presets = new List + var presets = new Dictionary { - new PresetSettings + ["CoCo light|blue theme"] = new PresetSettings { Name = "CoCo light|blue theme", Classifications = new List { - 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 @@ -86,23 +82,20 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b) }; _defaultPresets[Languages.CSharp] = presets; - presets = new List + presets = new Dictionary { - new PresetSettings + ["CoCo light|blue theme"] = new PresetSettings { Name = "CoCo light|blue theme", Classifications = new List { - 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), @@ -112,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 @@ -141,16 +135,5 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b) return _defaultPresets; } - - public static IReadOnlyDictionary> GetDefaultPresetsNames() - { - var presets = new HashSet { "CoCo light|blue theme", "CoCo dark theme" }; - - return new Dictionary> - { - [Languages.CSharp] = presets, - [Languages.VisualBasic] = presets, - }; - } } } \ No newline at end of file diff --git a/src/vs15/CoCo/Services/OptionService.cs b/src/vs15/CoCo/Services/OptionService.cs index b59316f..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 ToSettings(ICollection 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(); + defaultPresets = null; } var presetsSettings = new List(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,11 +63,10 @@ List ToSettings(ICollection classificati /// public static Option ToOption(Settings.Settings settings) { - var classificationTypes = ClassificationManager.GetClassifications(); 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); @@ -79,9 +77,8 @@ public static Option ToOption(Settings.Settings settings) if (!defaultPresets.TryGetValue(language.Name, out var defaultLanguagePresets)) { - defaultLanguagePresets = new List(); + defaultLanguagePresets = null; } - var presetNames = defaultLanguagePresets.ToHashSet(x => x.Name); var isLanguageExists = false; foreach (var languageSettings in settings.Languages) @@ -95,7 +92,7 @@ public static Option ToOption(Settings.Settings settings) 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); @@ -106,7 +103,7 @@ 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); diff --git a/src/vs15/CoCo/Services/PresetService.cs b/src/vs15/CoCo/Services/PresetService.cs index ee69333..69c5aa0 100644 --- a/src/vs15/CoCo/Services/PresetService.cs +++ b/src/vs15/CoCo/Services/PresetService.cs @@ -9,16 +9,16 @@ namespace CoCo.Services { public static class PresetService { - private static Dictionary> _defaultPresets; + private static Dictionary> _defaultPresets; /// /// Returns the default CoCo settings that are grouped by languages /// - public static IReadOnlyDictionary> GetDefaultPresets() + public static IReadOnlyDictionary> GetDefaultPresets() { if (!(_defaultPresets is null)) return _defaultPresets; - _defaultPresets = new Dictionary>(); + _defaultPresets = new Dictionary>(); var defaulltIdentifierFormatting = FormattingService.GetDefaultIdentifierFormatting(); @@ -35,33 +35,29 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b) return classification; } - var presets = new List + var presets = new Dictionary { - new PresetSettings + ["CoCo light|blue theme"] = new PresetSettings { Name = "CoCo light|blue theme", Classifications = new List { - 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 @@ -88,23 +84,20 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b) }; _defaultPresets[Languages.CSharp] = presets; - presets = new List + presets = new Dictionary { - new PresetSettings + ["CoCo light|blue theme"] = new PresetSettings { Name = "CoCo light|blue theme", Classifications = new List { - 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), @@ -114,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 @@ -143,16 +137,5 @@ ClassificationSettings CreateClassification(string name, byte r, byte g, byte b) return _defaultPresets; } - - public static IReadOnlyDictionary> GetDefaultPresetsNames() - { - var presets = new HashSet { "CoCo light|blue theme", "CoCo dark theme" }; - - return new Dictionary> - { - [Languages.CSharp] = presets, - [Languages.VisualBasic] = presets, - }; - } } } \ No newline at end of file