Improved highlighting of generics in class identifier, inheritance and generic constraints.

Author: ivanz

syntaxes/csharp.json

@@ -160,9 +160,31 @@
         }
       ]
     },
+    "type": {
+      "patterns": [
+        {
+          "match": "(\\w+\\s*<(?:[\\w\\s,\\.`\\[\\]\\*]+|\\g<1>)+>(?:\\s*\\[\\s*\\])?)",
+          "comment": "generic type",
+          "captures": {
+            "1": {
+              "name": "storage.type.cs"
+            }
+          }
+        },
+        {
+          "match": "\\b([a-zA-Z]+[\\w]*\\b(?:\\s*\\[\\s*\\])?\\*?)",
+          "comment": "non-generic type",
+          "captures": {
+            "1": {
+              "name": "storage.type.cs"
+            }
+          }
+        }
+      ]
+    },
     "generic-constraints": {
       "begin": "(where)\\s+(\\w+)\\s*:",
-      "end": "(?={)",
+      "end": "(?=where|{|$)",
       "beginCaptures": {
         "1": {
           "name": "keyword.other.cs"
@@ -185,12 +207,7 @@
           }
         },
         {
-          "match": "([\\w<>,\\[\\]]+)\\s*(?=,|where|{)",
-          "captures": {
-            "1": {
-              "name": "storage.type.cs"
-            }
-          }
+          "include": "#type"
         },
         {
           "include": "#generic-constraints"
@@ -214,21 +231,27 @@
           "include": "#comments"
         },
         {
-          "captures": {
+          "begin": "(class|struct|interface|enum)\\s+",
+          "end": "(?={|:|$|where)",
+          "name": "meta.class.identifier.cs",
+          "beginCaptures": {
             "1": {
               "name": "storage.modifier.cs"
-            },
-            "2": {
-              "name": "entity.name.type.class.cs"
             }
           },
-          "match": "(class|struct|interface|enum)\\s+(\\w+)",
-          "name": "meta.class.identifier.cs"
+          "patterns": [
+            {
+              "include": "#type"
+            }
+          ]
         },
         {
           "begin": ":",
           "end": "(?={|where)",
           "patterns": [
+            {
+              "include": "#type"
+            },
             {
               "match": "([\\w<>]+)\\s*",
               "captures": {

test/syntaxes/class.tests.ts

@@ -73,13 +73,27 @@ namespace TestNamespace
 
         });
 
+        it("generics in identifier", function () {
+
+            const input = `
+namespace TestNamespace
+{
+    class Dictionary<T, Dictionary<string, string>> { }
+}`;
+            let tokens: Token[] = TokenizerUtil.tokenize(input);
+
+            tokens.should.contain(Tokens.ClassKeyword("class", 4, 5));
+            tokens.should.contain(Tokens.ClassIdentifier("Dictionary<T, Dictionary<string, string>>", 4, 11));
+        });
+
         it("inheritance", function() {
 
 const input = `
 namespace TestNamespace
 {
     class PublicClass    : IInterface,    IInterfaceTwo { }
     class PublicClass<T> : IInterface<T>, IInterfaceTwo { }
+    class PublicClass<T> : Dictionary<T, Dictionary<string, string>>, IMap<T, Dictionary<string, string>> { }
 }`;
             let tokens: Token[] = TokenizerUtil.tokenize(input);
 
@@ -89,9 +103,12 @@ namespace TestNamespace
             tokens.should.contain(Tokens.Type("IInterfaceTwo", 4, 43));
 
             tokens.should.contain(Tokens.ClassKeyword("class", 5, 5));
-            tokens.should.contain(Tokens.ClassIdentifier("PublicClass", 5, 11));
+            tokens.should.contain(Tokens.ClassIdentifier("PublicClass<T>", 5, 11));
             tokens.should.contain(Tokens.Type("IInterface<T>", 5, 28));
             tokens.should.contain(Tokens.Type("IInterfaceTwo", 5, 43));
+
+            tokens.should.contain(Tokens.Type("Dictionary<T, Dictionary<string, string>>", 6, 28));
+            tokens.should.contain(Tokens.Type("IMap<T, Dictionary<string, string>>", 6, 71));
         });
 
         it("generic constraints", function() {
@@ -105,13 +122,13 @@ namespace TestNamespace
             let tokens: Token[] = TokenizerUtil.tokenize(input);
 
             tokens.should.contain(Tokens.ClassKeyword("class", 4, 5));
-            tokens.should.contain(Tokens.ClassIdentifier("PublicClass", 4, 11));
+            tokens.should.contain(Tokens.ClassIdentifier("PublicClass<T>", 4, 11));
             tokens.should.contain(Tokens.Keyword("where", 4, 26));
             tokens.should.contain(Tokens.Type("T", 4, 32));
             tokens.should.contain(Tokens.Type("ISomething", 4, 36));
 
             tokens.should.contain(Tokens.ClassKeyword("class", 5, 5));
-            tokens.should.contain(Tokens.ClassIdentifier("PublicClass", 5, 11));
+            tokens.should.contain(Tokens.ClassIdentifier("PublicClass<T, X>", 5, 11));
             tokens.should.contain(Tokens.Type("Dictionary<T, List<string>[]>", 5, 31));
             tokens.should.contain(Tokens.Type("ISomething", 5, 62));
             tokens.should.contain(Tokens.Keyword("where", 5, 73));

test/syntaxes/utils/tokenizer.ts

@@ -68,7 +68,7 @@ export namespace Tokens {
         createToken(text, "storage.modifier.cs", line, column);
 
     export const ClassIdentifier = (text: string, line?: number, column?: number) =>
-        createToken(text, "entity.name.type.class.cs", line, column);
+        createToken(text, "storage.type.cs", line, column);
 
     export const StorageModifierKeyword = (text: string, line?: number, column?: number) =>
         createToken(text, "storage.modifier.cs", line, column);