@@ -1,9 +1,3 @@
2−;; In case you want type highlighting based on Julia naming conventions (this might collide with mathematical notation)
3−;((identifier) @type ; exception: mark `A_foo` sort of identifiers as variables
4− ;(match? @type "^[A-Z][^_]"))
5−((identifier) @constant
6− (match? @constant "^[A-Z][A-Z_]{2}[A-Z_]*$"))
9 (triple_string)
3 (triple_string)
@@ -28,43 +22,43 @@
28(call_expression
22(call_expression
29 (identifier) @function)
23 (identifier) @function)
30(call_expression
24(call_expression
31− (field_expression (identifier) @method .))
25+ (field_expression (identifier) @function.method .))
32(broadcast_call_expression
26(broadcast_call_expression
33 (identifier) @function)
27 (identifier) @function)
34(broadcast_call_expression
28(broadcast_call_expression
35− (field_expression (identifier) @method .))
29+ (field_expression (identifier) @function.method .))
36(parameter_list
30(parameter_list
37− (identifier) @parameter)
31+ (identifier) @variable.parameter)
38(parameter_list
32(parameter_list
39 (optional_parameter .
33 (optional_parameter .
40− (identifier) @parameter))
34+ (identifier) @variable.parameter))
41(typed_parameter
35(typed_parameter
42− (identifier) @parameter
36+ (identifier) @variable.parameter
43 (identifier) @type)
37 (identifier) @type)
44(type_parameter_list
38(type_parameter_list
45 (identifier) @type)
39 (identifier) @type)
46(typed_parameter
40(typed_parameter
47− (identifier) @parameter
41+ (identifier) @variable.parameter
48 (parameterized_identifier) @type)
42 (parameterized_identifier) @type)
49(function_expression
43(function_expression
50− . (identifier) @parameter)
44+ . (identifier) @variable.parameter)
51−(spread_parameter) @parameter
45+(spread_parameter) @variable.parameter
52(spread_parameter
46(spread_parameter
53− (identifier) @parameter)
47+ (identifier) @variable.parameter)
54(named_argument
48(named_argument
55− . (identifier) @parameter)
49+ . (identifier) @variable.parameter)
56(argument_list
50(argument_list
57 (typed_expression
51 (typed_expression
58− (identifier) @parameter
52+ (identifier) @variable.parameter
59 (identifier) @type))
53 (identifier) @type))
60(argument_list
54(argument_list
61 (typed_expression
55 (typed_expression
62− (identifier) @parameter
56+ (identifier) @variable.parameter
63 (parameterized_identifier) @type))
57 (parameterized_identifier) @type))
65;; Symbol expressions (:my-wanna-be-lisp-keyword)
59;; Symbol expressions (:my-wanna-be-lisp-keyword)
66(quote_expression
60(quote_expression
67− (identifier)) @symbol
61+ (identifier)) @string.special.symbol
69;; Parsing error! foo (::Type) get's parsed as two quote expressions
63;; Parsing error! foo (::Type) get's parsed as two quote expressions
70(argument_list
64(argument_list
@@ -76,7 +70,7 @@
76 (identifier) @type)
70 (identifier) @type)
77(parameterized_identifier (_)) @type
71(parameterized_identifier (_)) @type
78(argument_list
72(argument_list
79− (typed_expression . (identifier) @parameter))
73+ (typed_expression . (identifier) @variable.parameter))
81(typed_expression
75(typed_expression
82 (identifier) @type .)
76 (identifier) @type .)
@@ -113,13 +107,13 @@
113"end" @keyword
107"end" @keyword
115(if_statement
109(if_statement
116− ["if" "end"] @conditional)
110+ ["if" "end"] @keyword.control.conditional)
117(elseif_clause
111(elseif_clause
118− ["elseif"] @conditional)
112+ ["elseif"] @keyword.control.conditional)
119(else_clause
113(else_clause
120− ["else"] @conditional)
114+ ["else"] @keyword.control.conditional)
121(ternary_expression
115(ternary_expression
122− ["?" ":"] @conditional)
116+ ["?" ":"] @keyword.control.conditional)
124(function_definition ["function" "end"] @keyword.function)
118(function_definition ["function" "end"] @keyword.function)
@@ -134,47 +128,57 @@
135] @keyword
129] @keyword
137−((identifier) @keyword (#any-of? @keyword "global" "local"))
131+((identifier) @keyword (match? @keyword "global|local"))
139(compound_expression
133(compound_expression
140 ["begin" "end"] @keyword)
134 ["begin" "end"] @keyword)
141(try_statement
135(try_statement
142− ["try" "end" ] @exception)
136+ ["try" "end" ] @keyword.control.exception)
143(finally_clause
137(finally_clause
144− "finally" @exception)
138+ "finally" @keyword.control.exception)
145(catch_clause
139(catch_clause
146− "catch" @exception)
140+ "catch" @keyword.control.exception)
147(quote_statement
141(quote_statement
148 ["quote" "end"] @keyword)
142 ["quote" "end"] @keyword)
149(let_statement
143(let_statement
150 ["let" "end"] @keyword)
144 ["let" "end"] @keyword)
151(for_statement
145(for_statement
152− ["for" "end"] @repeat)
146+ ["for" "end"] @keyword.control.repeat)
153(while_statement
147(while_statement
154− ["while" "end"] @repeat)
148+ ["while" "end"] @keyword.control.repeat)
155−(break_statement) @repeat
149+(break_statement) @keyword.control.repeat
156−(continue_statement) @repeat
150+(continue_statement) @keyword.control.repeat
157(for_binding
151(for_binding
158− "in" @repeat)
152+ "in" @keyword.control.repeat)
159(for_clause
153(for_clause
160− "for" @repeat)
154+ "for" @keyword.control.repeat)
161(do_clause
155(do_clause
162 ["do" "end"] @keyword)
156 ["do" "end"] @keyword)
164(export_statement
158(export_statement
165− ["export"] @include)
159+ ["export"] @keyword.control.import)
171−] @include
165+] @keyword.control.import
173−((identifier) @include (#eq? @include "baremodule"))
167+((identifier) @keyword.control.import (#eq? @keyword.control.import "baremodule"))
175(((identifier) @constant.builtin) (match? @constant.builtin "^(nothing|Inf|NaN)$"))
169(((identifier) @constant.builtin) (match? @constant.builtin "^(nothing|Inf|NaN)$"))
176−(((identifier) @boolean) (eq? @boolean "true"))
170+(((identifier) @constant.builtin.boolean) (#eq? @constant.builtin.boolean "true"))
177−(((identifier) @boolean) (eq? @boolean "false"))
171+(((identifier) @constant.builtin.boolean) (#eq? @constant.builtin.boolean "false"))
179["::" ":" "." "," "..." "!"] @punctuation.delimiter
174["::" ":" "." "," "..." "!"] @punctuation.delimiter
180["[" "]" "(" ")" "{" "}"] @punctuation.bracket
175["[" "]" "(" ")" "{" "}"] @punctuation.bracket
179+(identifier) @variable
180+;; In case you want type highlighting based on Julia naming conventions (this might collide with mathematical notation)
181+;((identifier) @type ; exception: mark `A_foo` sort of identifiers as variables
182+ ;(match? @type "^[A-Z][^_]"))
183+((identifier) @constant
184+ (match? @constant "^[A-Z][A-Z_]{2}[A-Z_]*$"))