refactor(highlights/julia): Update definitions

See https://github.com/tree-sitter/tree-sitter-julia/pull/54

Remove a bunch of patterns with `argument_list`. No longer necessary
with `short_function_definition`.

Other minor changes including:

- Add boolean literals See
  https://github.com/tree-sitter/tree-sitter-julia/pull/44
- Update highlights for operators (for bindings, type operators, etc)

- Update lockfile

2 files changed, 135 insertions, 96 deletions

diff --git a/lockfile.json b/lockfile.json
index 4e97da7ea..52c93a0d2 100644
--- a/lockfile.json
+++ b/lockfile.json
@@ -186,7 +186,7 @@
     "revision": "0475a5017ad7dc84845d1d33187f2321abcb261d"
   },
   "julia": {
-    "revision": "0572cebf7b8e8ef5990b4d1e7f44f0b36f62922c"
+    "revision": "8fb38abff74652c4faddbf04d2d5bbbc6b4bae25"
   },
   "kotlin": {
     "revision": "a4f71eb9b8c9b19ded3e0e9470be4b1b77c2b569"
diff --git a/queries/julia/highlights.scm b/queries/julia/highlights.scm
index 1b7e5b72c..f0e53c2c3 100644
--- a/queries/julia/highlights.scm
+++ b/queries/julia/highlights.scm
@@ -1,106 +1,113 @@
-(identifier) @variable
+;;; Identifiers
 
-(operator) @operator
-(range_expression ":" @operator)
-(pair_expression "=>" @operator)
+(identifier) @variable
 
-;; In case you want type highlighting based on Julia naming conventions (this might collide with mathematical notation)
-;((identifier) @type ; exception: mark `A_foo` sort of identifiers as variables
-  ;(match? @type "^[A-Z][^_]"))
+; ;; If you want type highlighting based on Julia naming conventions (this might collide with mathematical notation)
+; ((identifier) @type
+;   (match? @type "^[A-Z][^_]"))  ; exception: Highlight `A_foo` sort of identifiers as variables
 
 (macro_identifier) @function.macro
-(macro_identifier (identifier) @function.macro) ; for any one using the variable highlight
+(macro_identifier
+  (identifier) @function.macro) ; for any one using the variable highlight
+
 (macro_definition
-  name: (identifier) @function.macro
-  ["macro" "end" @keyword])
+  name: (identifier) @function.macro)
+
+(quote_expression ":" (identifier)) @symbol
+
+
+;;; Fields and indexes
 
 (field_expression
-  (identifier)
   (identifier) @field .)
 
+(subscript_expression
+  (_)
+  (range_expression
+    (identifier) @constant.builtin .)
+  (#eq? @constant.builtin "end"))
+
+
+;;; Function names
+
+;; definitions
+
 (function_definition
   name: (identifier) @function)
+(short_function_definition
+  name: (identifier) @function)
+
+(function_definition
+  name: (scoped_identifier (identifier) @function .))
+(short_function_definition
+  name: (scoped_identifier (identifier) @function .))
+
+;; calls
+
 (call_expression
   (identifier) @function.call)
 (call_expression
-  (field_expression (identifier) @method.call .))
+  (field_expression (identifier) @function.call .))
+
 (broadcast_call_expression
   (identifier) @function.call)
 (broadcast_call_expression
-  (field_expression (identifier) @method.call .))
+  (field_expression (identifier) @function.call .))
+
+
+;;; Parameters
+
 (parameter_list
   (identifier) @parameter)
-(parameter_list
-  (optional_parameter .
-    (identifier) @parameter))
+(optional_parameter .
+  (identifier) @parameter)
+(slurp_parameter
+  (identifier) @parameter)
+
 (typed_parameter
-  (identifier) @parameter
-  (identifier) @type)
-(type_parameter_list
-  (identifier) @type)
+  parameter: (identifier) @parameter
+  type: (_) @type)
 (typed_parameter
-  (identifier) @parameter
-  (parameterized_identifier) @type)
-(function_expression
-  . (identifier) @parameter)
-(spread_parameter) @parameter
-(spread_parameter
-  (identifier) @parameter)
-(named_argument
-    . (identifier) @parameter)
-(argument_list
-  (typed_expression
-    (identifier) @parameter
-    (identifier) @type))
-(argument_list
-  (typed_expression
-    (identifier) @parameter
-    (parameterized_identifier) @type))
+  type: (_) @type)
 
-;; Symbol expressions (:my-wanna-be-lisp-keyword)
-(quote_expression
- (identifier)) @symbol
+(function_expression
+  . (identifier) @parameter) ; Single parameter arrow functions
 
-;; Parsing error! foo (::Type) gets parsed as two quote expressions
-(argument_list
-  (quote_expression
-    (quote_expression
-      (identifier) @type)))
 
-(type_argument_list
-  (identifier) @type)
-(parameterized_identifier (_)) @type
-(argument_list
-  (typed_expression . (identifier) @parameter))
+;;; Types
 
-(typed_expression
-  (identifier) @type .)
-(typed_expression
-  (parameterized_identifier) @type .)
+;; Definitions
 
 (abstract_definition
   name: (identifier) @type)
+(primitive_definition
+  name: (identifier) @type)
 (struct_definition
   name: (identifier) @type)
 
-(subscript_expression
-  (_)
-  (range_expression
-    (identifier) @constant.builtin .)
-  (#eq? @constant.builtin "end"))
+;; Annotations
 
-"end" @keyword
+(parameterized_identifier (_) @type)
 
-(if_statement
-  ["if" "end"] @conditional)
-(elseif_clause
-  ["elseif"] @conditional)
-(else_clause
-  ["else"] @conditional)
-(ternary_expression
-  ["?" ":"] @conditional)
+(type_parameter_list
+  (identifier) @type)
+
+(type_argument_list
+  (identifier) @type)
 
-(function_definition ["function" "end"] @keyword.function)
+(typed_expression
+  (identifier) @type .)
+
+(function_definition
+  return_type: (identifier) @type)
+(short_function_definition
+  return_type: (identifier) @type)
+
+(where_clause
+  (identifier) @type) ; where clause without braces
+
+
+;;; Keywords
 
 [
   "abstract"
@@ -110,51 +117,91 @@
   "struct"
   "type"
   "mutable"
+  "where"
 ] @keyword
 
-"return" @keyword.return
+"end" @keyword
 
-((identifier) @keyword (#any-of? @keyword "global" "local"))
+((identifier) @keyword (#any-of? @keyword "global" "local")) ; Grammar error
 
 (compound_expression
   ["begin" "end"] @keyword)
+(quote_statement
+  ["quote" "end"] @keyword)
+(let_statement
+  ["let" "end"] @keyword)
+
+(if_statement
+  ["if" "end"] @conditional)
+(elseif_clause
+  ["elseif"] @conditional)
+(else_clause
+  ["else"] @conditional)
+(ternary_expression
+  ["?" ":"] @conditional)
+
 (try_statement
-  ["try" "end" ] @exception)
+  ["try" "end"] @exception)
 (finally_clause
   "finally" @exception)
 (catch_clause
   "catch" @exception)
-(quote_statement
-  ["quote" "end"] @keyword)
-(let_statement
-  ["let" "end"] @keyword)
+
 (for_statement
   ["for" "end"] @repeat)
 (while_statement
   ["while" "end"] @repeat)
-(break_statement) @repeat
-(continue_statement) @repeat
 (for_clause
   "for" @repeat)
+[
+  (break_statement)
+  (continue_statement)
+] @repeat
+
+(module_definition
+  ["module" "baremodule" "end"] @include)
+(import_statement
+  ["import" "using"] @include)
+(export_statement
+  "export" @include)
+
+(macro_definition
+  ["macro" "end" @keyword])
+
+(function_definition
+  ["function" "end"] @keyword.function)
 (do_clause
-  ["do" "end"] @keyword)
+  ["do" "end"] @keyword.function)
+(function_expression
+  "->" @keyword.function)
+(return_statement
+  "return" @keyword.return)
 
-"in" @keyword.operator
 
-(export_statement
-  ["export"] @include)
+;;; Operators & Punctuation
 
-(import_statement
-  ["import" "using"] @include)
+(operator) @operator
+(for_binding ["in" "=" "∈"] @operator)
+(pair_expression "=>" @operator)
+(range_expression ":" @operator)
 
-(module_definition
-  ["module" "end"] @include)
+(slurp_parameter "..." @operator)
+(spread_expression "..." @operator)
 
-((identifier) @include (#eq? @include "baremodule"))
+"." @operator
+["::" "<:"] @operator
+
+["," ";"] @punctuation.delimiter
+["(" ")" "[" "]" "{" "}"] @punctuation.bracket
 
 
 ;;; Literals
 
+[
+  (true)
+  (false)
+] @boolean
+
 (integer_literal) @number
 (float_literal) @float
 
@@ -162,9 +209,6 @@
   (#any-of? @float "NaN" "NaN16" "NaN32"
                    "Inf" "Inf16" "Inf32"))
 
-((identifier) @boolean
-  (#any-of? @boolean "true" "false"))
-
 ((identifier) @constant.builtin
   (#any-of? @constant.builtin "nothing" "missing"))
 
@@ -184,8 +228,3 @@
   (block_comment)
 ] @comment
 
-;;; Punctuation
-
-(quote_expression ":" @symbol)
-["::" "." "," "..."] @punctuation.delimiter
-["[" "]" "(" ")" "{" "}"] @punctuation.bracket