github-linguist 5.3.2 → 5.3.3

data/ext/linguist/lex.linguist_yy.h

@@ -11,7 +11,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 39
+#define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -49,6 +49,7 @@ typedef int16_t flex_int16_t;
 typedef uint16_t flex_uint16_t;
 typedef int32_t flex_int32_t;
 typedef uint32_t flex_uint32_t;
+typedef uint64_t flex_uint64_t;
 #else
 typedef signed char flex_int8_t;
 typedef short int flex_int16_t;
@@ -56,6 +57,7 @@ typedef int flex_int32_t;
 typedef unsigned char flex_uint8_t; 
 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
+#endif /* ! C99 */
 
 /* Limits of integral types. */
 #ifndef INT8_MIN
@@ -86,8 +88,6 @@ typedef unsigned int flex_uint32_t;
 #define UINT32_MAX             (4294967295U)
 #endif
 
-#endif /* ! C99 */
-
 #endif /* ! FLEXINT_H */
 
 #ifdef __cplusplus
@@ -130,15 +130,7 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
 #define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
 #endif
 
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
@@ -277,10 +269,6 @@ int linguist_yyget_lineno (yyscan_t yyscanner );
 
 void linguist_yyset_lineno (int line_number ,yyscan_t yyscanner );
 
-int linguist_yyget_column  (yyscan_t yyscanner );
-
-void linguist_yyset_column (int column_no ,yyscan_t yyscanner );
-
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
  */
@@ -307,12 +295,7 @@ static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
 #define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
 #endif
 
 /* Number of entries by which start-condition stack grows. */
@@ -345,9 +328,9 @@ extern int linguist_yylex (yyscan_t yyscanner);
 #undef YY_DECL
 #endif
 
-#line 117 "tokenizer.l"
+#line 118 "tokenizer.l"
 
 
-#line 352 "lex.linguist_yy.h"
+#line 335 "lex.linguist_yy.h"
 #undef linguist_yyIN_HEADER
 #endif /* linguist_yyHEADER_H */

data/ext/linguist/tokenizer.l

@@ -9,25 +9,25 @@
 
 #define eat_until_eol() do { \
     int c; \
-    while ((c = input(yyscanner)) != '\n' && c != EOF); \
-    if (c == EOF) \
-      yyterminate(); \
+    while ((c = input(yyscanner)) != '\n' && c != EOF && c); \
+    if (c == EOF || !c) \
+      return 0; \
   } while (0)
 
 #define eat_until_unescaped(q) do { \
     int c; \
-    while ((c = input(yyscanner)) != EOF) { \
+    while ((c = input(yyscanner)) != EOF && c) { \
       if (c == '\n') \
         break; \
       if (c == '\\') { \
         c = input(yyscanner); \
-        if (c == EOF) \
-          yyterminate(); \
+        if (c == EOF || !c) \
+          return 0; \
       } else if (c == q) \
         break; \
     } \
-    if (c == EOF) \
-      yyterminate(); \
+    if (c == EOF || !c) \
+      return 0; \
   } while (0)
 
 %}
@@ -84,7 +84,7 @@
 \"                                { eat_until_unescaped('"'); }
 '                                 { eat_until_unescaped('\''); }
 (0x[0-9a-fA-F]([0-9a-fA-F]|\.)*|[0-9]([0-9]|\.)*)([uU][lL]{0,2}|([eE][-+][0-9]*)?[fFlL]*) { /* nothing */ }
-\<[^ \t\n\r<>]+/>|" "[^<>\n]{0,2048}>               {
+\<[[:alnum:]_!./?-]+              {
     if (strcmp(yytext, "<!--") == 0) {
      BEGIN(xml_comment);
     } else {
@@ -93,8 +93,8 @@
       return 1;
     }
   }
-<sgml>[[:alnum:]_]+=/\"           { feed_token(strdup(yytext), REGULAR_TOKEN); input(yyscanner); eat_until_unescaped('"'); return 1; }
-<sgml>[[:alnum:]_]+=/'            { feed_token(strdup(yytext), REGULAR_TOKEN); input(yyscanner); eat_until_unescaped('\''); return 1; }
+<sgml>[[:alnum:]_]+=\"            { feed_token(strndup(yytext, strlen(yytext) - 1), REGULAR_TOKEN); eat_until_unescaped('"'); return 1; }
+<sgml>[[:alnum:]_]+='             { feed_token(strndup(yytext, strlen(yytext) - 1), REGULAR_TOKEN); eat_until_unescaped('\''); return 1; }
 <sgml>[[:alnum:]_]+=[[:alnum:]_]* { feed_token(strdup(yytext), REGULAR_TOKEN); *(strchr(yyextra->token, '=') + 1) = 0; return 1; }
 <sgml>[[:alnum:]_]+               { feed_token(strdup(yytext), REGULAR_TOKEN); return 1; }
 <sgml>\>                          { BEGIN(INITIAL); }

data/grammars/source.julia.console.json

@@ -0,0 +1,52 @@
+{
+  "scopeName": "source.julia.console",
+  "name": "Julia Console",
+  "comment": "Not sure what this will be used for... Maybe if we have a REPL someday",
+  "patterns": [
+    {
+      "match": "^(julia>|\\.{3}|In \\[\\d+\\]:) (.+)$",
+      "captures": {
+        "1": {
+          "name": "punctuation.separator.prompt.julia.console"
+        },
+        "2": {
+          "patterns": [
+            {
+              "include": "source.julia"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "match": "^(shell>) (.+)$",
+      "captures": {
+        "1": {
+          "name": "punctuation.separator.prompt.shell.julia.console"
+        },
+        "2": {
+          "patterns": [
+            {
+              "include": "source.shell"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "match": "^(help\\?>) (.+)$",
+      "captures": {
+        "1": {
+          "name": "punctuation.separator.prompt.help.julia.console"
+        },
+        "2": {
+          "patterns": [
+            {
+              "include": "source.julia"
+            }
+          ]
+        }
+      }
+    }
+  ]
+}

data/grammars/source.julia.json

@@ -1,15 +1,13 @@
 {
-  "comment": "\n\tTODO:\n\t* syntax types, tuple types, union\n\t* take out ::Type\n\t",
+  "comment": "Reference to the Oniguruma Regex libraray:\n  https://github.com/kkos/oniguruma/blob/master/doc/RE\n\nTODO:\n* Once 0.4 is released, simplify type matches (no explicit 'Union', parens, etc.)\n* take out ::Type\n* Add more regex stuff.\n* Some in comments throughout the grammar\n",
   "fileTypes": [
     "jl"
   ],
   "firstLineMatch": "^#!.*\\bjulia\\s*$",
-  "keyEquivalent": "^~J",
+  "foldingStartMarker": "^\\s*(?:if|while|for|begin|function|macro|module|baremodule|type|immutable|struct|try|let)\\b(?!.*\\bend\\b).*$",
+  "foldingStopMarker": "^\\s*(?:end)\\b.*$",
   "name": "Julia",
   "patterns": [
-    {
-      "include": "#symbol"
-    },
     {
       "include": "#operator"
     },
@@ -22,9 +20,6 @@
     {
       "include": "#bracket"
     },
-    {
-      "include": "#type_decl"
-    },
     {
       "include": "#function_decl"
     },
@@ -39,6 +34,12 @@
     },
     {
       "include": "#comment"
+    },
+    {
+      "include": "#type_decl"
+    },
+    {
+      "include": "#symbol"
     }
   ],
   "repository": {
@@ -91,12 +92,13 @@
           "name": "comment.block.number-sign-equals.julia"
         },
         {
-          "captures": {
-            "1": {
+          "begin": "#",
+          "beginCaptures": {
+            "0": {
               "name": "punctuation.definition.comment.julia"
             }
           },
-          "match": "(?<!\\$)(#)(?!\\{).*$\\n?",
+          "end": "\\n",
           "name": "comment.line.number-sign.julia"
         }
       ]
@@ -104,10 +106,13 @@
     "function_call": {
       "patterns": [
         {
-          "begin": "([a-zA-Z0-9_]+!?)\\w*\\(",
+          "begin": "([[:alpha:]_][[:word:]⁺-ₜ!′]*)({(?:[^{}]|{(?:[^{}]|{[^{}]*})*})*})?\\.?\\(",
           "beginCaptures": {
             "1": {
               "name": "support.function.julia"
+            },
+            "2": {
+              "name": "support.type.julia"
             }
           },
           "end": "\\)(('|(\\.'))*\\.?')?",
@@ -135,7 +140,8 @@
               "name": "support.type.julia"
             }
           },
-          "match": "([\\w.!]+)({[^}]*})?\\((?=.*\\)\\s*=(?!=))"
+          "match": "([[:alpha:]_][[:word:]⁺-ₜ!′]*)({(?:[^{}]|{(?:[^{}]|{[^{}]*})*})*})?\\((?=.*\\)(::[^\\s]+)?(\\s*\\bwhere\\b\\s*[^\\s]+)?\\s*?=(?![=>]))",
+          "comment": "This is different from the one in tpoisot's package"
         },
         {
           "captures": {
@@ -143,40 +149,68 @@
               "name": "keyword.other.julia"
             },
             "2": {
-              "name": "entity.name.function.julia"
+              "name": "keyword.operator.dots.julia"
             },
             "3": {
+              "name": "entity.name.function.julia"
+            },
+            "4": {
               "name": "support.type.julia"
             }
           },
-          "match": "\\b(function|macro)\\s+([\\w.!]+)({[^}]*})?\\("
+          "match": "\\b(function|macro)\\s+(?:[[:alpha:]_][[:word:]⁺-ₜ!′]*(\\.))?([[:alpha:]_][[:word:]⁺-ₜ!′]*)({(?:[^{}]|{(?:[^{}]|{[^{}]*})*})*})?\\(",
+          "comment": "similar regex to previous, but with keyword not 1-line syntax"
         }
       ]
     },
     "keyword": {
       "patterns": [
         {
-          "match": "\\b(?:function|(mutable\\s+)?struct|macro|quote|((primitive|abstract)\\s+)?type|immutable|module|baremodule|new|where)\\b",
+          "match": "\\b(?<![:_])(?:function|@generated|type|immutable|mutable|struct|macro|quote|abstract|bitstype|typealias|module|baremodule|new|where)\\b",
           "name": "keyword.other.julia"
         },
         {
-          "match": "\\b(?:if|else|elseif|while|for|in|isa|begin|let|end|do|try|catch|finally|return|break|continue)\\b",
+          "match": "\\b(?<![:_])(?:if|else|elseif|while|for|begin|let|do|try|catch|finally|return|break|continue)\\b",
           "name": "keyword.control.julia"
         },
         {
-          "match": "\\b(?:global|local|const|export|import|importall|using)\\b",
+          "match": "\\b(?<![:_])end\\b",
+          "name": "keyword.control.end.julia"
+        },
+        {
+          "match": "\\b(?<![:_])(?:global|local|const)\\b",
           "name": "storage.modifier.variable.julia"
         },
         {
-          "match": "@\\w+\\b",
+          "match": "\\b(?<![:_])(?:export)\\b",
+          "name": "keyword.control.export.julia"
+        },
+        {
+          "match": "\\b(?<![:_])(?:import)\\b",
+          "name": "keyword.control.import.julia"
+        },
+        {
+          "match": "\\b(?<![:_])(?:importall)\\b",
+          "name": "keyword.control.importall.julia"
+        },
+        {
+          "match": "\\b(?<![:_])(?:using)\\b",
+          "name": "keyword.control.using.julia"
+        },
+        {
+          "match": "(@[[:alpha:]_][[:word:]⁺-ₜ!′]*)",
           "name": "support.function.macro.julia"
+        },
+        {
+          "match": "\\b(Argument|Assertion|Bounds|Divide|Domain|EOF|Inexact|Key|Load|Memory|Method|OutOfMemory|Overflow|Parse|StackOverflow|System|Type|UV|UndefRef|UndefVar)Error\\b",
+          "name": "support.type.exception.julia"
         }
       ]
     },
     "number": {
       "patterns": [
         {
-          "match": "((\\b0(x|X)[0-9a-fA-F](_?[0-9a-fA-F])*)|(\\b0o[0-7](_?[0-7])*)|(\\b0b[0-1](_?[0-1])*)|((\\b[0-9](_?[0-9])*\\.?(_?[0-9]*))|(\\.[0-9](_?[0-9])*))((e|E)(\\+|-)?(_?[0-9])*)?(im)?|\\bInf(32)?\\b|\\bNaN(32)?\\b)",
+          "match": "((\\b0(x|X)[0-9a-fA-F](_?[0-9a-fA-F])*)|(\\b0o[0-7](_?[0-7])*)|(\\b0b[0-1](_?[0-1])*)|((\\b[0-9](_?[0-9])*\\.?(_?[0-9]*))|(\\.[0-9](_?[0-9])*))([eE][+-]?[0-9](_?[0-9])*)?(im)?|\\bInf(32)?\\b|\\bNaN(32)?\\b)",
           "name": "constant.numeric.julia"
         },
         {
@@ -188,51 +222,62 @@
     "operator": {
       "patterns": [
         {
-          "match": "(?:=|:=|\\+=|-=|\\*=|/=|//=|\\.//=|\\.\\*=|\\\\=|\\.\\\\=|^=|\\.^=|%=|\\|=|&=|\\$=|<<=|>>=)",
+          "match": "(?:->|<-|-->|=>)",
+          "name": "keyword.operator.arrow.julia"
+        },
+        {
+          "match": "(?::=|\\+=|-=|\\*=|//=|/=|\\.//=|\\./=|\\.\\*=|\\\\=|\\.\\\\=|\\^=|\\.\\^=|%=|\\.%=|÷=|\\.÷=|\\|=|&=|\\$=|<<=|>>=|>>>=|=(?!=))",
           "name": "keyword.operator.update.julia"
         },
         {
-          "match": "(?:::(?:(?:Union)?\\([^)]*\\)|\\w+(?:{[^}]*})?))(?:\\.\\.\\.)?",
-          "name": "support.type.julia"
+          "match": "(?:<<|>>>|>>|\\.>>>|\\.>>|\\.<<)",
+          "name": "keyword.operator.shift.julia"
         },
         {
-          "match": "(?:\\?|:)",
-          "name": "keyword.operator.ternary.julia"
+          "match": "(?:\\s*(::|<:)\\s*((?:(?:Union)?\\([^)]*\\)|[[:alpha:]_][[:word:]⁺-ₜ!′\\.]*(?:{(?:[^{}]|{(?:[^{}]|{[^{}]*})*})*})?)))(?:\\.\\.\\.)?",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.relation.julia"
+            },
+            "2": {
+              "name": "support.type.julia"
+            }
+          }
         },
         {
-          "match": "(?:\\|\\||&&|!)",
-          "name": "keyword.operator.boolean.julia"
+          "match": "(?:===|(?<=\\s)in(?=\\s)|\\.==|!==|!=|\\.>=|\\.>|\\.<|==|\\.!=|\\.=|\\.!|<:|:>|(?<!>)>=|(?<!<)<=|\\.<=|>|<)",
+          "name": "keyword.operator.relation.julia"
         },
         {
-          "match": "(?:->|<-|-->)",
-          "name": "keyword.operator.arrow.julia"
+          "match": "(?:\\?:)",
+          "name": "keyword.operator.ternary.julia"
         },
         {
-          "match": "(?:>|<|>=|<=|==|!=|\\.>|\\.<|\\.>=|\\.>=|\\.==|\\.!=|\\.=|\\.!|<:|:>)",
-          "name": "keyword.operator.relation.julia"
+          "match": "(?:\\|\\||&&|(?<![[:word:]])!)",
+          "name": "keyword.operator.boolean.julia"
         },
         {
           "match": "(?::)",
           "name": "keyword.operator.range.julia"
         },
         {
-          "match": "(?:<<|>>)",
-          "name": "keyword.operator.shift.julia"
+          "match": "(?:\\|>)",
+          "name": "keyword.operator.applies.julia"
         },
         {
           "match": "(?:\\||\\&|~)",
           "name": "keyword.operator.bitwise.julia"
         },
         {
-          "match": "(?:\\+|-|\\*|\\.\\*|/|\\./|//|\\.//|%|\\.%|\\\\|\\.\\\\|\\^|\\.\\^)",
+          "match": "(?:\\+\\+|--|\\+|\\.\\+|-|\\.\\-|\\*|\\.\\*|//(?!=)|\\.//(?!=)|/|\\./|%|\\.%|\\\\|\\.\\\\|\\^|\\.\\^)",
           "name": "keyword.operator.arithmetic.julia"
         },
         {
-          "match": "(?:::)",
+          "match": "(?:::|(?<=\\s)isa(?=\\s))",
           "name": "keyword.operator.isa.julia"
         },
         {
-          "match": "(?:\\.(?=[a-zA-Z])|\\.\\.+)",
+          "match": "(?:\\.(?=(?:@|_|\\p{L}))|\\.\\.+)",
           "name": "keyword.operator.dots.julia"
         },
         {
@@ -245,12 +290,12 @@
               "name": "keyword.operator.transposed-variable.julia"
             }
           },
-          "match": "(\\w+)(('|(\\.'))*\\.?')"
+          "match": "([[:alpha:]_][[:word:]⁺-ₜ!′]*)(('|(\\.'))*\\.?')"
         },
         {
           "captures": {
             "1": {
-              "name": "keyword.bracket.end.julia"
+              "name": "bracket.end.julia"
             },
             "2": {
               "name": "keyword.operator.transposed-matrix.julia"
@@ -261,7 +306,7 @@
         {
           "captures": {
             "1": {
-              "name": "keyword.bracket.end.julia"
+              "name": "bracket.end.julia"
             },
             "2": {
               "name": "keyword.operator.transposed-parens.julia"
@@ -273,6 +318,91 @@
     },
     "string": {
       "patterns": [
+        {
+          "begin": "(i?cxx)(\"\"\")",
+          "beginCaptures": {
+            "1": {
+              "name": "support.function.macro.julia"
+            },
+            "2": {
+              "name": "punctuation.definition.string.begin.julia"
+            }
+          },
+          "end": "\"\"\"",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.julia"
+            }
+          },
+          "name": "embed.cxx.julia",
+          "contentName": "source.cpp",
+          "patterns": [
+            {
+              "include": "source.cpp"
+            },
+            {
+              "include": "#string_dollar_sign_interpolate"
+            }
+          ]
+        },
+        {
+          "begin": "((i?cxxt?)|([rpv]cpp))(\")",
+          "beginCaptures": {
+            "1": {
+              "name": "support.function.macro.julia"
+            },
+            "4": {
+              "name": "punctuation.definition.string.begin.julia"
+            }
+          },
+          "end": "\"",
+          "name": "embed.cxx.julia",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.julia"
+            }
+          },
+          "contentName": "source.cpp",
+          "patterns": [
+            {
+              "include": "source.cpp"
+            },
+            {
+              "include": "#string_dollar_sign_interpolate"
+            }
+          ]
+        },
+        {
+          "begin": "^\\s?([[:alpha:]_][[:word:]⁺-ₜ!′]*)?(\"\"\")\\s?$",
+          "beginCaptures": {
+            "1": {
+              "name": "support.function.macro.julia"
+            },
+            "2": {
+              "name": "punctuation.definition.string.begin.julia"
+            }
+          },
+          "end": "\\s?^\\s*(\"\"\")\\s?",
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.definition.string.end.julia"
+            }
+          },
+          "name": "string.docstring.julia",
+          "contentName": "source.gfm",
+          "comment": "This only matches docstrings that start and end with triple quotes on\ntheir own line in the void",
+          "patterns": [
+            {
+              "include": "source.gfm"
+            },
+            {
+              "include": "#string_escaped_char"
+            },
+            {
+              "include": "#string_dollar_sign_interpolate"
+            }
+          ]
+        },
         {
           "begin": "'",
           "beginCaptures": {
@@ -294,6 +424,31 @@
           ]
         },
         {
+          "begin": "\"\"\"",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.multiline.begin.julia"
+            }
+          },
+          "end": "\"\"\"",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.multiline.end.julia"
+            }
+          },
+          "name": "string.quoted.triple.double.julia",
+          "comment": "TODO: decide on a name for this scope",
+          "patterns": [
+            {
+              "include": "#string_escaped_char"
+            },
+            {
+              "include": "#string_dollar_sign_interpolate"
+            }
+          ]
+        },
+        {
+          "name": "string.quoted.double.julia",
           "begin": "\"",
           "beginCaptures": {
             "0": {
@@ -306,7 +461,34 @@
               "name": "punctuation.definition.string.end.julia"
             }
           },
-          "name": "string.quoted.double.julia",
+          "comment": "String with single pair of double quotes. Regex matches isolated double quote",
+          "patterns": [
+            {
+              "include": "#string_escaped_char"
+            },
+            {
+              "include": "#string_dollar_sign_interpolate"
+            }
+          ]
+        },
+        {
+          "begin": "r\"",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.regexp.begin.julia"
+            }
+          },
+          "end": "(\")([imsx]{0,4})?",
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.definition.string.regexp.end.julia"
+            },
+            "2": {
+              "comment": "I took this scope name from python regex grammar",
+              "name": "keyword.other.option-toggle.regexp.julia"
+            }
+          },
+          "name": "string.regexp.julia",
           "patterns": [
             {
               "include": "#string_escaped_char"
@@ -314,13 +496,13 @@
           ]
         },
         {
-          "begin": "\\b\\w+\"",
+          "begin": "\\b[[:alpha:]_][[:word:]⁺-ₜ!′]*\"",
           "beginCaptures": {
             "0": {
               "name": "punctuation.definition.string.begin.julia"
             }
           },
-          "end": "\"\\w*",
+          "end": "\"([[:alpha:]_][[:word:]⁺-ₜ!′]*)?",
           "endCaptures": {
             "0": {
               "name": "punctuation.definition.string.end.julia"
@@ -329,7 +511,7 @@
           "name": "string.quoted.other.julia",
           "patterns": [
             {
-              "include": "#string_custom_escaped_char"
+              "include": "#string_escaped_char"
             }
           ]
         },
@@ -346,36 +528,103 @@
               "name": "punctuation.definition.string.end.julia"
             }
           },
-          "name": "string.interpolated.julia",
+          "name": "string.interpolated.backtick.julia",
+          "patterns": [
+            {
+              "include": "#string_escaped_char"
+            },
+            {
+              "include": "#string_dollar_sign_interpolate"
+            }
+          ]
+        },
+        {
+          "begin": "(@doc) ((?:doc)?\"\"\")",
+          "beginCaptures": {
+            "1": {
+              "name": "support.function.macro.julia"
+            },
+            "2": {
+              "name": "punctuation.definition.string.begin.julia"
+            }
+          },
+          "end": "(\"\"\") ?(->)?",
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.definition.string.end.julia"
+            },
+            "2": {
+              "name": "keyword.operator.arrow.julia"
+            }
+          },
+          "name": "string.docstring.julia",
+          "contentName": "source.gfm",
           "patterns": [
             {
               "include": "#string_escaped_char"
+            },
+            {
+              "include": "source.gfm"
+            },
+            {
+              "include": "#string_dollar_sign_interpolate"
             }
           ]
         }
       ]
     },
-    "string_custom_escaped_char": {
+    "string_escaped_char": {
       "patterns": [
         {
-          "match": "\\\\\"",
+          "match": "\\\\(\\\\|[0-3]\\d{,2}|[4-7]\\d?|x[a-fA-F0-9]{,2}|u[a-fA-F0-9]{,4}|U[a-fA-F0-9]{,8}|.)",
           "name": "constant.character.escape.julia"
         }
       ]
     },
-    "string_escaped_char": {
+    "string_dollar_sign_interpolate": {
       "patterns": [
         {
-          "match": "\\\\(\\\\|[0-3]\\d{0,2}|[4-7]\\d?|x[a-fA-F0-9]{0,2}|u[a-fA-F0-9]{0,4}|U[a-fA-F0-9]{0,8}|.)",
-          "name": "constant.character.escape.julia"
+          "match": "\\$[[:alpha:]_][[:word:]⁺-ₜ!′]*",
+          "name": "variable.interpolation.julia"
+        },
+        {
+          "begin": "\\$\\(",
+          "end": "\\)",
+          "name": "variable.interpolation.julia",
+          "comment": "`punctuation.section.embedded`, `constant.escape`,\n& `meta.embedded.line` were considered but appear to have even spottier\nsupport among popular syntaxes.",
+          "patterns": [
+            {
+              "include": "#nest_parens_and_self"
+            },
+            {
+              "include": "$self"
+            }
+          ]
+        }
+      ]
+    },
+    "nest_parens_and_self": {
+      "patterns": [
+        {
+          "begin": "\\(",
+          "end": "\\)",
+          "patterns": [
+            {
+              "include": "#nest_parens_and_self"
+            }
+          ]
+        },
+        {
+          "include": "$self"
         }
       ]
     },
     "symbol": {
       "patterns": [
         {
-          "match": "(?<![a-zA-Z0-9:<]:):[a-zA-Z_][a-zA-Z0-9_]*\\b",
-          "name": "constant.other.symbol.julia"
+          "match": "(?<![a-zA-Z0-9:<]:)(?<=:)[[:alpha:]_][[:word:]⁺-ₜ!′]*",
+          "name": "constant.other.symbol.julia",
+          "comment": "This is string.quoted.symbol.julia in tpoisot's package"
         }
       ]
     },
@@ -384,24 +633,20 @@
         {
           "captures": {
             "1": {
-              "name": "keyword.control.type.julia"
-            },
-            "2": {
               "name": "entity.name.type.julia"
             },
-            "3": {
+            "2": {
               "name": "entity.other.inherited-class.julia"
             },
-            "4": {
+            "3": {
               "name": "punctuation.separator.inheritance.julia"
             }
           },
-          "match": "(((primitive|abstract)\\s+)?type|(mutable\\s+)?struct|immutable)\\s+(\\w+)(\\s*(<:)\\s*\\w+(?:{.*})?)?",
+          "match": "(?>!:_)(?:type|immutable|struct)\\s+([[:alpha:]_][[:word:]⁺-ₜ!′]*)(\\s*(<:)\\s*[[:alpha:]_][[:word:]⁺-ₜ!′]*(?:{.*})?)?",
           "name": "meta.type.julia"
         }
       ]
     }
   },
-  "scopeName": "source.julia",
-  "uuid": "F5D95417-DF9F-48AD-92DF-21CE62F7C31B"
+  "scopeName": "source.julia"
 }