github-linguist 5.0.0 → 5.0.2

data/grammars/source.reason.json

@@ -0,0 +1,296 @@
+{
+  "fileTypes": [
+    "re",
+    "rei"
+  ],
+  "foldingStartMarker": "^.*\\bfun\\s*(\\w+\\s*)?\\([^\\)]*\\)(\\s*\\{[^\\}]*)?\\s*$",
+  "foldingStopMarker": "^\\s*\\}",
+  "name": "Reason",
+  "patterns": [
+    {
+      "include": "#reason_comment_doc_block"
+    },
+    {
+      "include": "#reason_comment_block"
+    },
+    {
+      "include": "#reason_named_arg"
+    },
+    {
+      "include": "#reason_module"
+    },
+    {
+      "include": "#reason_lifetime"
+    },
+    {
+      "include": "#reason_self"
+    },
+    {
+      "include": "#reason_string"
+    },
+    {
+      "include": "#reason_raw_string"
+    },
+    {
+      "match": "\\'([^\\'\\\\]|\\\\(x\\h{2}|u\\{\\h{1,6}\\}|.))\\'",
+      "name": "string.quoted.single.source.reason"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.source.reason"
+        },
+        "2": {
+          "name": "entity.name.function.source.reason"
+        }
+      },
+      "match": "\\b(fun)\\s+([a-zA-Z_][a-zA-Z0-9_]?[\\w\\:,+ \\'<>?]*)\\s*(?:\\()",
+      "name": "meta.function.source.reason"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.source.reason"
+        },
+        "2": {
+          "name": "keyword.source.reason"
+        },
+        "3": {
+          "name": "keyword.source.reason"
+        },
+        "4": {
+          "name": "variable.other.reason"
+        },
+        "5": {
+          "name": "storage.type.source.reason"
+        },
+        "6": {
+          "name": "keyword.operator.reason"
+        }
+      },
+      "comment": "This matches the 'let x = val' style of variable intitialization.",
+      "match": "(let|and)\\s+(module\\s+)(rec\\s+)?([[:alpha:]_][[:alnum:]_]*)\\s*(:[^=]*)?(=?)",
+      "name": "meta.initialization.reason"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.source.reason"
+        },
+        "2": {
+          "name": "keyword.source.reason"
+        },
+        "4": {
+          "name": "storage.type.source.reason"
+        },
+        "5": {
+          "name": "keyword.operator.reason"
+        }
+      },
+      "comment": "This matches the 'let x = val' style of variable intitialization.",
+      "match": "(let)\\s+(rec\\s+)?([[:alpha:]_][[:alnum:]_]*)\\s*(:[^=]*)?(=?)",
+      "name": "meta.initialization.reason"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.source.reason"
+        },
+        "2": {
+          "name": "support"
+        }
+      },
+      "match": "(extern\\s+crate)\\s+(\\w+)",
+      "name": "meta.import.reason"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.source.reason"
+        },
+        "2": {
+          "name": "entity.name.macro.source.reason"
+        }
+      },
+      "match": "\\b(macro_rules!)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?:\\{)",
+      "name": "meta.macro.source.reason"
+    },
+    {
+      "match": "\\b(as|box|break|claim|const|continue|copy|Copy|crate|do|drop|then|else|extern|for|if|impl|in|let|and|loop|switch|fun|open|include|mod|move|mutable|Owned|priv|pub|pure|ref|return|unsafe|use|while|mod|Send|static|trait|struct|enum|exception|type|module|rec|where)\\b",
+      "name": "keyword.source.reason"
+    },
+    {
+      "match": "\\b(Self|m32|m64|m128|f80|f16|f128|int|uint|isize|usize|float|char|bool|u8|u16|u32|u64|f32|f64|i8|i16|i32|i64|str|Option|Either|c_float|c_double|c_void|FILE|fpos_t|DIR|dirent|c_char|c_schar|c_uchar|c_short|c_ushort|c_int|c_uint|c_long|c_ulong|size_t|ptrdiff_t|clock_t|time_t|c_longlong|c_ulonglong|intptr_t|uintptr_t|off_t|dev_t|ino_t|pid_t|mode_t|ssize_t)\\b",
+      "name": "storage.type.source.reason"
+    },
+    {
+      "match": "\\bself\\b",
+      "name": "variable.language.source.reason"
+    },
+    {
+      "match": "\\b(true|false|Some|None|Ok|Err)\\b",
+      "name": "constant.language.source.reason"
+    },
+    {
+      "match": "\\b(EXIT_FAILURE|EXIT_SUCCESS|RAND_MAX|EOF|SEEK_SET|SEEK_CUR|SEEK_END|_IOFBF|_IONBF|_IOLBF|BUFSIZ|FOPEN_MAX|FILENAME_MAX|L_tmpnam|TMP_MAX|O_RDONLY|O_WRONLY|O_RDWR|O_APPEND|O_CREAT|O_EXCL|O_TRUNC|S_IFIFO|S_IFCHR|S_IFBLK|S_IFDIR|S_IFREG|S_IFMT|S_IEXEC|S_IWRITE|S_IREAD|S_IRWXU|S_IXUSR|S_IWUSR|S_IRUSR|F_OK|R_OK|W_OK|X_OK|STDIN_FILENO|STDOUT_FILENO|STDERR_FILENO)\\b",
+      "name": "support.constant.source.reason"
+    },
+    {
+      "begin": "#!?\\[",
+      "end": "\\]",
+      "name": "comment.block.attribute.reason",
+      "patterns": [
+        {
+          "include": "#reason_string"
+        },
+        {
+          "include": "#reason_raw_string"
+        }
+      ]
+    },
+    {
+      "match": "\\b(([0-9][0-9_]*)|([0-9][0-9_]*(usize|u8|u16|u32|u64))|([0-9][0-9_]*(isize|i8|i16|i32|i64)))\\b",
+      "name": "constant.numeric.integer.source.reason"
+    },
+    {
+      "match": "\\b((0x[a-fA-F0-9_]+)|(0x[a-fA-F0-9_]+(usize|u8|u16|u32|u64))|(0x[a-fA-F0-9_]+(isize|i8|i16|i32|i64)))\\b",
+      "name": "constant.numeric.hex.source.reason"
+    },
+    {
+      "match": "\\b((0b[01_]+)|(0b[01_]+(usize|u8|u16|u32|u64))|(0b[01_]+(isize|i8|i16|i32|i64)))\\b",
+      "name": "constant.numeric.binary.source.reason"
+    },
+    {
+      "match": "\\b(([0-9][0-9_]*(f32|f64|f))|([0-9][0-9_]*([eE][+-]=[0-9_]+))|([0-9][0-9_]*([eE][+-]=[0-9_]+)(f32|f64|f))|([0-9][0-9_]*\\.[0-9_]+)|([0-9][0-9_]*\\.[0-9_]+(f32|f64|f))|([0-9][0-9_]*\\.[0-9_]+%([eE][+-]=[0-9_]+))|([0-9][0-9_]*\\.[0-9_]+%([eE][+-]=[0-9_]+)(f32|f64|f)))\\b",
+      "name": "constant.numeric.float.source.reason"
+    },
+    {
+      "match": "(=>)|(->)|[-:=*,!.+|%/&~@<>;]",
+      "name": "keyword.operator.reason"
+    },
+    {
+      "match": "\\b_\\b",
+      "name": "support.function.reason"
+    },
+    {
+      "match": "\\b(\\w+)\\b(?=\\()",
+      "name": "support.function.reason"
+    },
+    {
+      "match": "\\b(\\w+!)(?=\\()",
+      "name": "support.macro.reason"
+    },
+    {
+      "match": "\\b(\\w+)::",
+      "name": "meta.namespace-block.reason"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "meta.preprocessor.reason"
+        }
+      },
+      "match": "\\b(\\w+!)\\s*[({\\[]",
+      "name": "meta.macro.source.reason"
+    },
+    {
+      "match": "(\\[|\\]|{|}|\\(|\\))",
+      "name": "punctuation.definition.bracket.reason"
+    },
+    {
+      "match": "\\b(Box|Vec|StrBuf|Path|Option|Result|Reader|Writer|Stream|Seek|Buffer|IoError|IoResult|Sender|SyncSender|Receiver|Cell|RefCell|Any)\\b",
+      "name": "support.class.std.source.reason"
+    },
+    {
+      "match": "\\b(Send|Sized|Copy|Share)\\b",
+      "name": "support.type.kind.source.reason"
+    },
+    {
+      "match": "\\bbox\\b",
+      "name": "storage.modifier.box.source.reason"
+    },
+    {
+      "match": "\\brec\\b",
+      "name": "storage.modifier.rec.source.reason"
+    },
+    {
+      "match": "\\bmodule\\b",
+      "name": "storage.modifier.module.source.reason"
+    }
+  ],
+  "repository": {
+    "reason_comment_block": {
+      "begin": "/\\*",
+      "end": "\\*/",
+      "name": "comment.block.source.reason",
+      "patterns": [
+        {
+          "include": "#reason_comment_block"
+        }
+      ]
+    },
+    "reason_comment_doc_block": {
+      "begin": "/\\*[!\\*][^\\*]",
+      "end": "\\*/",
+      "name": "comment.block.documentation.source.reason",
+      "patterns": [
+        {
+          "include": "#reason_comment_doc_block"
+        }
+      ]
+    },
+    "reason_escaped_character": {
+      "match": "\\\\(x\\h{2}|u\\{\\h{1,6}\\}|.)",
+      "name": "constant.character.escape.source.reason"
+    },
+    "reason_lifetime": {
+      "captures": {
+        "1": {
+          "name": "entity.name.lifetime.source.reason"
+        }
+      },
+      "match": "\\'([a-zA-Z_][a-zA-Z0-9_]*)(?!\\')\\b",
+      "name": "storage.modifier.lifetime.source.reason"
+    },
+    "reason_module": {
+      "captures": {
+        "1": {
+          "name": "variable.other.reason"
+        }
+      },
+      "match": "\\b([A-Z][a-zA-Z0-9_]*)\\b"
+    },
+    "reason_named_arg": {
+      "captures": {
+        "1": {
+          "name": "storage.modifier.lifetime.source.reason"
+        },
+        "2": {
+          "name": "entity.name.lifetime.source.reason"
+        }
+      },
+      "match": "(@([a-zA-Z_][a-zA-Z0-9_]*))\\b"
+    },
+    "reason_raw_string": {
+      "begin": "r(#*)\"",
+      "end": "\"(\\1)",
+      "name": "string.quoted.double.raw.source.reason"
+    },
+    "reason_self": {
+      "match": "\\bself\\b",
+      "name": "variable.language.source.reason"
+    },
+    "reason_string": {
+      "begin": "\"",
+      "end": "\"",
+      "name": "string.quoted.double.source.reason",
+      "patterns": [
+        {
+          "include": "#reason_escaped_character"
+        }
+      ]
+    }
+  },
+  "scopeName": "source.reason",
+  "uuid": "4339386b-4d67-4f0e-9e78-09ecbcddf71d"
+}

data/grammars/source.regexp.perl6fe.json

@@ -93,6 +93,10 @@
           ],
           "name": "meta.interpolation.perl6fe"
         },
+        {
+          "match": "<\\(|\\)>",
+          "name": "keyword.operator.capture.marker.regexp.perl6fe"
+        },
         {
           "begin": "(?!\\\\)<",
           "beginCaptures": {
@@ -159,9 +163,22 @@
             },
             {
               "begin": "\\[",
+              "beginCaptures": {
+                "0": {
+                  "name": "keyword.operator.charclass.open.regexp.perl6fe"
+                }
+              },
               "end": "\\]",
+              "endCaptures": {
+                "0": {
+                  "name": "keyword.operator.charclass.close.regexp.perl6fe"
+                }
+              },
               "contentName": "constant.character.custom.property.regexp.perl6fe",
               "patterns": [
+                {
+                  "include": "source.perl6fe#hex_escapes"
+                },
                 {
                   "match": "(?<!\\\\)\\\\\\]",
                   "name": "constant.character.custom.property.regexp.perl6fe"
@@ -209,6 +226,16 @@
           "end": "(?<=\\\\\\\\)\\'|(?<!\\\\)\\'",
           "name": "string.literal.perl6fe"
         },
+        {
+          "begin": "(?<!\\\\)‘",
+          "end": "(?<=\\\\\\\\)\\’|(?<!\\\\)’",
+          "name": "string.literal.perl6fe",
+          "patterns": [
+            {
+              "include": "source.perl6fe#q_left_single_right_single_string_content"
+            }
+          ]
+        },
         {
           "begin": "(?<!\\\\)\\\"",
           "end": "(?<=\\\\\\\\)\\\"|(?<!\\\\)\\\"",

data/grammars/source.rust.json

@@ -1,212 +1,609 @@
 {
+  "name": "Rust",
+  "scopeName": "source.rust",
   "fileTypes": [
     "rs"
   ],
-  "foldingStartMarker": "^.*\\bfn\\s*(\\w+\\s*)?\\([^\\)]*\\)(\\s*\\{[^\\}]*)?\\s*$",
-  "foldingStopMarker": "^\\s*\\}",
-  "name": "Rust",
+  "repository": {
+    "block_doc_comment": {
+      "comment": "Block documentation comment",
+      "name": "comment.block.documentation.rust",
+      "begin": "/\\*[\\*!](?![\\*/])",
+      "end": "\\*/",
+      "patterns": [
+        {
+          "include": "#block_doc_comment"
+        },
+        {
+          "include": "#block_comment"
+        }
+      ]
+    },
+    "block_comment": {
+      "comment": "Block comment",
+      "name": "comment.block.rust",
+      "begin": "/\\*",
+      "end": "\\*/",
+      "patterns": [
+        {
+          "include": "#block_doc_comment"
+        },
+        {
+          "include": "#block_comment"
+        }
+      ]
+    },
+    "line_doc_comment": {
+      "comment": "Single-line documentation comment",
+      "name": "comment.line.documentation.rust",
+      "begin": "//[!/](?=[^/])",
+      "end": "$"
+    },
+    "line_comment": {
+      "comment": "Single-line comment",
+      "name": "comment.line.double-slash.rust",
+      "begin": "//",
+      "end": "$"
+    },
+    "escaped_character": {
+      "name": "constant.character.escape.rust",
+      "match": "\\\\(x\\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.)"
+    },
+    "string_literal": {
+      "comment": "Double-quote string literal",
+      "name": "string.quoted.double.rust",
+      "begin": "b?\"",
+      "end": "\"",
+      "patterns": [
+        {
+          "include": "#escaped_character"
+        }
+      ]
+    },
+    "raw_string_literal": {
+      "comment": "Raw double-quote string literal",
+      "name": "string.quoted.double.raw.rust",
+      "begin": "b?r(#*)\"",
+      "end": "\"\\1"
+    },
+    "sigils": {
+      "comment": "Sigil",
+      "name": "keyword.operator.sigil.rust",
+      "match": "[&*](?=[a-zA-Z0-9_\\(\\[\\|\\\"]+)"
+    },
+    "self": {
+      "comment": "Self variable",
+      "name": "variable.language.rust",
+      "match": "\\bself\\b"
+    },
+    "mut": {
+      "comment": "Mutable storage modifier",
+      "name": "storage.modifier.mut.rust",
+      "match": "\\bmut\\b"
+    },
+    "box": {
+      "comment": "Box storage modifier",
+      "name": "storage.modifier.box.rust",
+      "match": "\\bbox\\b"
+    },
+    "const": {
+      "comment": "Const storage modifier",
+      "name": "storage.modifier.const.rust",
+      "match": "\\bconst\\b"
+    },
+    "pub": {
+      "comment": "Visibility modifier",
+      "name": "storage.modifier.visibility.rust",
+      "match": "\\bpub\\b"
+    },
+    "unsafe": {
+      "comment": "Unsafe code keyword",
+      "name": "keyword.other.unsafe.rust",
+      "match": "\\bunsafe\\b"
+    },
+    "where": {
+      "comment": "Generic where clause",
+      "name": "keyword.other.where.rust",
+      "match": "\\bwhere\\b"
+    },
+    "lifetime": {
+      "comment": "Named lifetime",
+      "name": "storage.modifier.lifetime.rust",
+      "match": "'([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+      "captures": {
+        "1": {
+          "name": "entity.name.lifetime.rust"
+        }
+      }
+    },
+    "ref_lifetime": {
+      "comment": "Reference with named lifetime",
+      "match": "&('([a-zA-Z_][a-zA-Z0-9_]*))\\b",
+      "captures": {
+        "1": {
+          "name": "storage.modifier.lifetime.rust"
+        },
+        "2": {
+          "name": "entity.name.lifetime.rust"
+        }
+      }
+    },
+    "core_types": {
+      "comment": "Built-in/core type",
+      "name": "storage.type.core.rust",
+      "match": "\\b(bool|char|usize|isize|u8|u16|u32|u64|u128|i8|i16|i32|i64|i128|f32|f64|str|Self|Option|Result)\\b"
+    },
+    "core_vars": {
+      "comment": "Core type variant",
+      "name": "support.constant.core.rust",
+      "match": "\\b(Some|None|Ok|Err)\\b"
+    },
+    "core_marker": {
+      "comment": "Core trait (marker)",
+      "name": "support.type.marker.rust",
+      "match": "\\b(Copy|Send|Sized|Sync)\\b"
+    },
+    "core_traits": {
+      "comment": "Core trait",
+      "name": "support.type.core.rust",
+      "match": "\\b(Drop|Fn|FnMut|FnOnce|Clone|PartialEq|PartialOrd|Eq|Ord|AsRef|AsMut|Into|From|Default|Iterator|Extend|IntoIterator|DoubleEndedIterator|ExactSizeIterator)\\b"
+    },
+    "std_types": {
+      "comment": "Standard library type",
+      "name": "storage.class.std.rust",
+      "match": "\\b(Box|String|Vec|Path|PathBuf)\\b"
+    },
+    "std_traits": {
+      "comment": "Standard library trait",
+      "name": "support.type.std.rust",
+      "match": "\\b(ToOwned|ToString)\\b"
+    },
+    "type_params": {
+      "comment": "Type parameters",
+      "name": "meta.type_params.rust",
+      "begin": "<(?![=<])",
+      "end": ">",
+      "patterns": [
+        {
+          "include": "#block_comment"
+        },
+        {
+          "include": "#line_comment"
+        },
+        {
+          "include": "#sigils"
+        },
+        {
+          "include": "#mut"
+        },
+        {
+          "include": "#lifetime"
+        },
+        {
+          "include": "#core_types"
+        },
+        {
+          "include": "#core_marker"
+        },
+        {
+          "include": "#core_traits"
+        },
+        {
+          "include": "#std_types"
+        },
+        {
+          "include": "#std_traits"
+        },
+        {
+          "include": "#type_params"
+        }
+      ]
+    }
+  },
   "patterns": [
     {
-      "include": "#rust_comment_doc_block"
+      "include": "#block_doc_comment"
     },
     {
-      "include": "#rust_comment_block"
+      "include": "#block_comment"
     },
     {
-      "include": "#rust_string"
+      "include": "#line_doc_comment"
     },
     {
-      "include": "#rust_raw_string"
+      "include": "#line_comment"
     },
     {
-      "match": "\\b[A-Z]\\b",
-      "name": "storage.type.source.rust"
+      "comment": "Attribute",
+      "name": "meta.attribute.rust",
+      "begin": "#\\!?\\[",
+      "end": "\\]",
+      "patterns": [
+        {
+          "include": "#string_literal"
+        }
+      ]
     },
     {
-      "match": "\\b_*[A-Z][a-zA-Z0-9_]*[a-z][a-zA-Z0-9_]*\\b",
-      "name": "storage.type.source.rust"
+      "comment": "Single-quote string literal (character)",
+      "name": "string.quoted.single.rust",
+      "match": "b?'([^'\\\\]|\\\\(x\\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.))'"
     },
     {
-      "match": "\\b(c_[a-z0-9_]+|[a-z_][a-z0-9_]*_t)\\b",
-      "name": "storage.type.source.rust"
+      "include": "#string_literal"
     },
     {
-      "match": "\\b([A-Z_][A-Z0-9_]+)\\b",
-      "name": "constant.other.source.rust"
+      "include": "#raw_string_literal"
     },
     {
-      "match": "\\'[a-zA-Z_][a-zA-Z0-9_]*(?!\\')\\b",
-      "name": "storage.modifier.lifetime.source.rust"
+      "comment": "Floating point literal (fraction)",
+      "name": "constant.numeric.float.rust",
+      "match": "\\b[0-9][0-9_]*\\.[0-9][0-9_]*([eE][+-]?[0-9_]+)?(f32|f64)?\\b"
     },
     {
-      "begin": "\\'(?=([^\\'\\\\]|\\\\(x\\h{2}|u\\{\\h{1,6}\\}|n|r|t|0|\"|'|\\\\))\\')",
-      "end": "\\'",
-      "name": "string.quoted.single.source.rust",
-      "patterns": [
-        {
-          "include": "#rust_escaped_character"
-        }
-      ]
+      "comment": "Floating point literal (exponent)",
+      "name": "constant.numeric.float.rust",
+      "match": "\\b[0-9][0-9_]*(\\.[0-9][0-9_]*)?[eE][+-]?[0-9_]+(f32|f64)?\\b"
     },
     {
-      "captures": {
-        "1": {
-          "name": "keyword.other.source.rust"
-        },
-        "2": {
-          "name": "entity.name.function.source.rust"
-        }
-      },
-      "match": "\\b(fn)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\b",
-      "name": "meta.function.source.rust"
+      "comment": "Floating point literal (typed)",
+      "name": "constant.numeric.float.rust",
+      "match": "\\b[0-9][0-9_]*(\\.[0-9][0-9_]*)?([eE][+-]?[0-9_]+)?(f32|f64)\\b"
     },
     {
-      "captures": {
-        "1": {
-          "name": "keyword.other.source.rust"
-        },
-        "2": {
-          "name": "entity.name.macro.source.rust"
-        }
-      },
-      "match": "\\b(macro_rules!)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\b",
-      "name": "meta.macro.source.rust"
+      "comment": "Integer literal (decimal)",
+      "name": "constant.numeric.integer.decimal.rust",
+      "match": "\\b[0-9][0-9_]*([ui](8|16|32|64|128|s|size))?\\b"
     },
     {
-      "match": "\\b(crate|enum|extern|fn|impl|let|mod|move|mut|pub|ref|static|struct|super|trait|type|unsafe|use|const|where)\\b",
-      "name": "keyword.other.source.rust"
+      "comment": "Integer literal (hexadecimal)",
+      "name": "constant.numeric.integer.hexadecimal.rust",
+      "match": "\\b0x[a-fA-F0-9_]+([ui](8|16|32|64|128|s|size))?\\b"
     },
     {
-      "match": "\\b(break|else|for|if|loop|match|return|while|continue)\\b",
-      "name": "keyword.control.source.rust"
+      "comment": "Integer literal (octal)",
+      "name": "constant.numeric.integer.octal.rust",
+      "match": "\\b0o[0-7_]+([ui](8|16|32|64|128|s|size))?\\b"
     },
     {
-      "match": "\\b(as|in|box)\\b",
-      "name": "keyword.operator.source.rust"
+      "comment": "Integer literal (binary)",
+      "name": "constant.numeric.integer.binary.rust",
+      "match": "\\b0b[01_]+([ui](8|16|32|64|128|s|size))?\\b"
     },
     {
-      "match": "\\b(virtual|proc|alignof|become|offsetof|priv|pure|sizeof|typeof|unsized|yield|do|abstract|final|override|macro)\\b",
-      "name": "invalid.illegal.source.rust"
+      "comment": "Static storage modifier",
+      "name": "storage.modifier.static.rust",
+      "match": "\\bstatic\\b"
     },
     {
-      "match": "\\b(true|false)\\b",
-      "name": "constant.language.source.rust"
+      "comment": "Boolean constant",
+      "name": "constant.language.boolean.rust",
+      "match": "\\b(true|false)\\b"
     },
     {
-      "match": "\\b(self)\\b",
-      "name": "variable.language.source.rust"
+      "comment": "Control keyword",
+      "name": "keyword.control.rust",
+      "match": "\\b(break|continue|else|if|in|for|loop|match|return|while)\\b"
     },
     {
-      "match": "(?<!::)\\b(Self|i8|i16|i32|i64|isize|u8|u16|u32|u64|usize|f32|f64|bool|char|str)\\b",
-      "name": "storage.type.source.rust"
+      "comment": "Keyword",
+      "name": "keyword.other.rust",
+      "match": "\\b(crate|extern|mod|let|proc|ref|use|super|as|move)\\b"
     },
     {
-      "begin": "#!?\\[",
-      "end": "\\]",
-      "name": "comment.block.attribute.source.rust",
-      "patterns": [
-        {
-          "include": "#rust_string"
-        },
-        {
-          "include": "#rust_raw_string"
-        }
-      ]
+      "include": "#unsafe"
     },
     {
-      "match": "\\b[0-9][0-9_]*(i8|i16|i32|i64|isize|u8|u16|u32|u64|usize)?\\b",
-      "name": "constant.numeric.integer.decimal.source.rust"
+      "include": "#sigils"
     },
     {
-      "match": "\\b0x[0-9a-fA-F_]*[0-9a-fA-F][0-9a-fA-F_]*(i8|i16|i32|i64|isize|u8|u16|u32|u64|usize)?\\b",
-      "name": "constant.numeric.integer.hexadecimal.source.rust"
+      "include": "#self"
     },
     {
-      "match": "\\b0o[0-7_]*[0-7][0-7_]*(i8|i16|i32|i64|isize|u8|u16|u32|u64|usize)?\\b",
-      "name": "constant.numeric.integer.octal.source.rust"
+      "include": "#mut"
     },
     {
-      "match": "\\b0b[0-1_]*[0-1][0-1_]*(i8|i16|i32|i64|isize|u8|u16|u32|u64|usize)?\\b",
-      "name": "constant.numeric.integer.binary.source.rust"
+      "include": "#box"
     },
     {
-      "match": "\\b[0-9][0-9_]*((f32|f64)|([eE][+-]?[0-9_]*[0-9][0-9_]*(f32|f64)?)|(\\.([0-9][0-9_]*([eE][+-]?[0-9_]*[0-9][0-9_]*)?(f32|f64)?)?))\\b",
-      "name": "constant.numeric.float.source.rust"
+      "include": "#lifetime"
     },
     {
-      "begin": "//[!/][^/].*",
-      "end": "$",
-      "name": "comment.line.documentation.source.rust"
+      "include": "#ref_lifetime"
     },
     {
-      "begin": "//",
-      "end": "$",
-      "name": "comment.line.double-slash.source.rust"
+      "include": "#const"
     },
     {
-      "match": "[-=<>&|!~@.,;:?+*/%^'#$]|\\b_\\b",
-      "name": "keyword.operator.source.rust"
+      "include": "#pub"
     },
     {
-      "match": "[(){}\\[\\]]|::",
-      "name": "meta.default.source.rust"
+      "comment": "Miscellaneous operator",
+      "name": "keyword.operator.misc.rust",
+      "match": "(=>|::|\\bas\\b)"
     },
     {
-      "match": "\\b[a-z_][a-z0-9_]*(?=\\()",
-      "name": "support.function.source.rust"
+      "comment": "Comparison operator",
+      "name": "keyword.operator.comparison.rust",
+      "match": "(&&|\\|\\||==|!=)"
     },
     {
-      "match": "\\b(Copy|Send|Sized|Sync|Drop|Fn|FnMut|FnOnce|Box|ToOwned|Clone|PartialEq|PartialOrd|Eq|Ord|AsRef|AsMut|Into|From|Default|Iterator|Extend|IntoIterator|DoubleEndedIterator|ExactSizeIterator|Option|Some|None|Result|Ok|Err|SliceConcatExt|String|ToString|Vec)\\b",
-      "name": "support.type.source.rust"
-    }
-  ],
-  "repository": {
-    "rust_comment_block": {
-      "begin": "/\\*",
-      "end": "\\*/",
-      "name": "comment.block.source.rust",
+      "comment": "Assignment operator",
+      "name": "keyword.operator.assignment.rust",
+      "match": "(\\+=|-=|/=|\\*=|%=|\\^=|&=|\\|=|<<=|>>=|=)"
+    },
+    {
+      "comment": "Arithmetic operator",
+      "name": "keyword.operator.arithmetic.rust",
+      "match": "(!|\\+|-|/|\\*|%|\\^|&|\\||<<|>>)"
+    },
+    {
+      "comment": "Comparison operator (second group because of regex precedence)",
+      "name": "keyword.operator.comparison.rust",
+      "match": "(<=|>=|<|>)"
+    },
+    {
+      "include": "#core_types"
+    },
+    {
+      "include": "#core_vars"
+    },
+    {
+      "include": "#core_marker"
+    },
+    {
+      "include": "#core_traits"
+    },
+    {
+      "include": "#std_types"
+    },
+    {
+      "include": "#std_traits"
+    },
+    {
+      "comment": "Built-in macro",
+      "name": "support.function.builtin.rust",
+      "match": "\\b(macro_rules|format_args|env|option_env|concat_idents|concat|log_syntax|line|column|file|stringify|include|include_str|include_bytes|module_path|asm|cfg|trace_macros)!"
+    },
+    {
+      "comment": "Core macro",
+      "name": "support.function.core.rust",
+      "match": "\\b(panic|assert|assert_eq|debug_assert|debug_assert_eq|try|write|writeln|unreachable|unimplemented)!"
+    },
+    {
+      "comment": "Standard library macro",
+      "name": "support.function.std.rust",
+      "match": "\\b(format|print|println|select|vec)!"
+    },
+    {
+      "comment": "Logging macro",
+      "name": "support.function.log.rust",
+      "match": "\\b(log|error|warn|info|debug|trace|log_enabled)!"
+    },
+    {
+      "comment": "Invokation of a macro",
+      "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*\\!)\\s*[({\\[]",
+      "captures": {
+        "1": {
+          "name": "entity.name.function.macro.rust"
+        }
+      }
+    },
+    {
+      "comment": "Function call",
+      "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(",
+      "captures": {
+        "1": {
+          "name": "entity.name.function.rust"
+        }
+      }
+    },
+    {
+      "comment": "Function definition",
+      "begin": "\\b(fn)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+      "end": "[\\{;]",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.fn.rust"
+        },
+        "2": {
+          "name": "entity.name.function.rust"
+        }
+      },
       "patterns": [
         {
-          "include": "#rust_comment_block"
+          "include": "#block_comment"
+        },
+        {
+          "include": "#line_comment"
+        },
+        {
+          "include": "#sigils"
+        },
+        {
+          "include": "#self"
+        },
+        {
+          "include": "#mut"
+        },
+        {
+          "include": "#ref_lifetime"
+        },
+        {
+          "include": "#core_types"
+        },
+        {
+          "include": "#core_marker"
+        },
+        {
+          "include": "#core_traits"
         },
         {
-          "include": "#rust_comment_doc_block"
+          "include": "#std_types"
+        },
+        {
+          "include": "#std_traits"
+        },
+        {
+          "include": "#type_params"
+        },
+        {
+          "include": "#const"
+        },
+        {
+          "include": "#where"
+        },
+        {
+          "include": "#unsafe"
+        },
+        {
+          "comment": "Function arguments",
+          "match": "fn",
+          "name": "keyword.other.fn.rust"
         }
       ]
     },
-    "rust_comment_doc_block": {
-      "begin": "/\\*[!\\*][^\\*/]",
-      "end": "\\*/",
-      "name": "comment.block.documentation.source.rust",
+    {
+      "comment": "Type declaration",
+      "begin": "\\b(enum|struct|trait)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+      "end": "[\\{\\(;]",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.rust"
+        },
+        "2": {
+          "name": "entity.name.type.rust"
+        }
+      },
       "patterns": [
         {
-          "include": "#rust_comment_block"
+          "include": "#block_comment"
+        },
+        {
+          "include": "#line_comment"
+        },
+        {
+          "include": "#core_traits"
+        },
+        {
+          "include": "#std_traits"
         },
         {
-          "include": "#rust_comment_doc_block"
+          "include": "#type_params"
+        },
+        {
+          "include": "#core_types"
+        },
+        {
+          "include": "#pub"
+        },
+        {
+          "include": "#where"
         }
       ]
     },
-    "rust_escaped_character": {
-      "match": "\\\\(x\\h{2}|u\\{\\h{1,6}\\}|n|r|t|0|\"|'|\\\\)",
-      "name": "constant.character.escape.source.rust"
-    },
-    "rust_raw_string": {
-      "begin": "r(#*)\"",
-      "end": "\"(\\1)",
-      "name": "string.quoted.double.raw.source.rust"
+    {
+      "comment": "Type alias",
+      "begin": "\\b(type)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+      "end": ";",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.rust"
+        },
+        "2": {
+          "name": "entity.name.type.rust"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#block_comment"
+        },
+        {
+          "include": "#line_comment"
+        },
+        {
+          "include": "#sigils"
+        },
+        {
+          "include": "#mut"
+        },
+        {
+          "include": "#lifetime"
+        },
+        {
+          "include": "#ref_lifetime"
+        },
+        {
+          "include": "#core_types"
+        },
+        {
+          "include": "#core_marker"
+        },
+        {
+          "include": "#core_traits"
+        },
+        {
+          "include": "#std_types"
+        },
+        {
+          "include": "#std_traits"
+        },
+        {
+          "include": "#type_params"
+        }
+      ]
     },
-    "rust_string": {
-      "begin": "\"",
-      "end": "\"",
-      "name": "string.quoted.double.source.rust",
+    {
+      "comment": "Implementation",
+      "begin": "\\b(impl)\\b",
+      "end": "\\{",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.rust"
+        }
+      },
       "patterns": [
         {
-          "include": "#rust_escaped_character"
+          "include": "#block_comment"
+        },
+        {
+          "include": "#line_comment"
+        },
+        {
+          "include": "#sigils"
+        },
+        {
+          "include": "#mut"
+        },
+        {
+          "include": "#ref_lifetime"
+        },
+        {
+          "include": "#core_types"
+        },
+        {
+          "include": "#core_marker"
+        },
+        {
+          "include": "#core_traits"
+        },
+        {
+          "include": "#std_types"
+        },
+        {
+          "include": "#std_traits"
+        },
+        {
+          "include": "#type_params"
+        },
+        {
+          "include": "#where"
+        },
+        {
+          "name": "storage.type.rust",
+          "match": "\\bfor\\b"
         }
       ]
     }
-  },
-  "scopeName": "source.rust",
-  "uuid": "4339386b-4d67-4f0e-9e78-09ecbcddf71d"
+  ]
 }