Julia queries: update grammar, major refactoring

languages.toml

@@ -571,7 +571,7 @@ indent = { tab-width = 4, unit = "    " }
 
 [[grammar]]
 name = "julia"
-source = { git = "https://github.com/tree-sitter/tree-sitter-julia", rev = "12ea597262125fc22fd2e91aa953ac69b19c26ca" }
+source = { git = "https://github.com/tree-sitter/tree-sitter-julia", rev = "fc60b7cce87da7a1b7f8cb0f9371c3dc8b684500" }
 
 [[language]]
 name = "java"

runtime/queries/julia/highlights.scm

@@ -1,110 +1,142 @@
+; ----------
+; Primitives
+; ----------
 
 [
-  (triple_string)
-  (string)
-] @string
+  (line_comment)
+  (block_comment)
+] @comment
 
-(string
-  prefix: (identifier) @constant.builtin)
+(((identifier) @constant.builtin) (match? @constant.builtin "^(nothing|missing|Inf|NaN)$"))
+(((identifier) @constant.builtin.boolean) (#eq? @constant.builtin.boolean "true"))
+(((identifier) @constant.builtin.boolean) (#eq? @constant.builtin.boolean "false"))
 
-(macro_identifier) @function.macro
-(macro_identifier (identifier) @function.macro) ; for any one using the variable highlight
-(macro_definition
-  name: (identifier) @function.macro
-  ["macro" "end" @keyword])
+(integer_literal) @constant.numeric.integer
+(float_literal) @constant.numeric.float
 
-(field_expression
-  (identifier)
-  (identifier) @variable.other.member .)
+(character_literal) @constant.character
+(escape_sequence) @constant.character.escape
+
+(string_literal) @string
+
+(prefixed_string_literal
+  prefix: (identifier) @function.macro) @string
+
+(quote_expression
+  (identifier) @string.special.symbol) 
+
+; -------------------
+; Modules and Imports
+; -------------------
+
+(module_definition
+  name: (identifier) @namespace)
+
+(import_statement
+  (identifier) @namespace)
+
+(selected_import
+  . (identifier) @namespace)
+
+(scoped_identifier
+  (identifier) @namespace)
+
+; -----
+; Types
+; -----
+
+(abstract_definition
+  name: (identifier) @type)
+
+(primitive_definition
+  name: (identifier) @type)
+
+(struct_definition
+  name: (identifier) @type)
+
+(struct_definition
+  . (_)
+    (identifier) @variable.other.member)
+
+(struct_definition
+  . (_)
+  (typed_expression
+    . (identifier) @variable.other.member))
+
+(type_parameter_list
+  (identifier) @type)
+
+(constrained_parameter
+  (identifier) @type)
+
+(subtype_clause
+  (identifier) @type)
+
+(typed_expression
+  (identifier) @type . )
+
+(parameterized_identifier
+  (identifier) @type)
+
+(type_argument_list
+  (identifier) @type)
+
+; -------------------
+; Function definition
+; -------------------
 
 (function_definition
   name: (identifier) @function)
-(call_expression
-  (identifier) @function)
-(call_expression
-  (field_expression (identifier) @function.method .))
-(broadcast_call_expression
-  (identifier) @function)
-(broadcast_call_expression
-  (field_expression (identifier) @function.method .))
+
 (parameter_list
   (identifier) @variable.parameter)
-(parameter_list
-  (optional_parameter .
-    (identifier) @variable.parameter))
-(typed_parameter
-  (identifier) @variable.parameter
-  (identifier) @type)
-(type_parameter_list
-  (identifier) @type)
+
 (typed_parameter
   (identifier) @variable.parameter
-  (parameterized_identifier) @type)
-(function_expression
+  (identifier)? @type)
+
+(optional_parameter
   . (identifier) @variable.parameter)
-(spread_parameter) @variable.parameter
+
 (spread_parameter
   (identifier) @variable.parameter)
-(named_argument
-    . (identifier) @variable.parameter)
-(argument_list
-  (typed_expression
-    (identifier) @variable.parameter
-    (identifier) @type))
-(argument_list
-  (typed_expression
-    (identifier) @variable.parameter
-    (parameterized_identifier) @type))
 
-;; Symbol expressions (:my-wanna-be-lisp-keyword)
-(quote_expression
- (identifier)) @string.special.symbol
+(function_expression
+  . (identifier) @variable.parameter)
 
-;; Parsing error! foo (::Type) get's parsed as two quote expressions
-(argument_list 
-  (quote_expression
-    (quote_expression
-      (identifier) @type)))
+; ---------------
+; Functions calls
+; ---------------
 
-(type_argument_list
-  (identifier) @type)
-(parameterized_identifier (_)) @type
-(argument_list
-  (typed_expression . (identifier) @variable.parameter))
+(call_expression
+  (identifier) @function)
 
-(typed_expression
-  (identifier) @type .)
-(typed_expression
-  (parameterized_identifier) @type .)
+(broadcast_call_expression
+  (identifier) @function)
 
-(struct_definition
-  name: (identifier) @type)
+(call_expression
+  (field_expression (identifier) @function .))
+
+(broadcast_call_expression
+  (field_expression (identifier) @function .))
+
+; ------
+; Macros
+; ------
+
+(macro_definition
+  name: (identifier) @function.macro)
 
-(number) @constant.numeric.integer
-(range_expression
-    (identifier) @constant.numeric.integer
-      (eq? @constant.numeric.integer "end"))
-(range_expression
-  (_
-    (identifier) @constant.numeric.integer
-      (eq? @constant.numeric.integer "end")))
-(coefficient_expression
-  (number)
-  (identifier) @constant.builtin)
-
-;; TODO: operators.
-;; Those are a bit difficult to implement since the respective nodes are hidden right now (_power_operator)
-;; and heavily use Unicode chars (support for those are bad in vim/lua regexes)
-;[;
-    ;(power_operator);
-    ;(times_operator);
-    ;(plus_operator);
-    ;(arrow_operator);
-    ;(comparison_operator);
-    ;(assign_operator);
-;] @operator ;
-
-"end" @keyword
+(macro_identifier
+  "@" @function.macro
+  (identifier) @function.macro)
+
+; --------
+; Keywords
+; --------
+
+(function_definition 
+  ["function" "end"] @keyword.function)
 
 (if_statement
   ["if" "end"] @keyword.control.conditional)
@@ -115,33 +147,6 @@
 (ternary_expression
   ["?" ":"] @keyword.control.conditional)
 
-(function_definition ["function" "end"] @keyword.function)
-
-(comment) @comment
-
-[
-  "const"
-  "return"
-  "macro"
-  "struct"
-  "primitive"
-  "type"
-] @keyword
-
-((identifier) @keyword (match? @keyword "global|local"))
-
-(compound_expression
-  ["begin" "end"] @keyword)
-(try_statement
-  ["try" "end" ] @keyword.control.exception)
-(finally_clause
-  "finally" @keyword.control.exception)
-(catch_clause
-  "catch" @keyword.control.exception)
-(quote_statement
-  ["quote" "end"] @keyword)
-(let_statement
-  ["let" "end"] @keyword)
 (for_statement
   ["for" "end"] @keyword.control.repeat)
 (while_statement
@@ -152,33 +157,90 @@
   "in" @keyword.control.repeat)
 (for_clause
   "for" @keyword.control.repeat)
-(do_clause
-  ["do" "end"] @keyword)
 
-(export_statement
-  ["export"] @keyword.control.import)
+(try_statement
+  ["try" "end" ] @keyword.control.exception)
+(finally_clause
+  "finally" @keyword.control.exception)
+(catch_clause
+  "catch" @keyword.control.exception)
 
 [
-  "using"
-  "module"
+  "export"
   "import"
+  "using"
 ] @keyword.control.import
 
-((identifier) @keyword.control.import (#eq? @keyword.control.import "baremodule"))
+[
+  "abstract"
+  "begin"
+  "const"
+  "do"
+  "end"
+  "let"
+  "macro"
+  "module"
+  "mutable"
+  "primitive"
+  "quote"
+  "return"
+  "struct"
+  "type"
+] @keyword
+
+; TODO: fix this
+((identifier) @keyword (match? @keyword "global|local"))
 
-(((identifier) @constant.builtin) (match? @constant.builtin "^(nothing|Inf|NaN)$"))
-(((identifier) @constant.builtin.boolean) (#eq? @constant.builtin.boolean "true"))
-(((identifier) @constant.builtin.boolean) (#eq? @constant.builtin.boolean "false"))
+; ---------
+; Operators
+; ---------
 
+[
+  (operator)
+  "::"
+  "<:"
+  ":"
+  "=>"
+  "..."
+  "$"
+] @operator
+
+; ------------
+; Punctuations
+; ------------
 
-["::" ":" "." "," "..." "!"] @punctuation.delimiter
-["[" "]" "(" ")" "{" "}"] @punctuation.bracket
+[
+  "."
+  "," 
+  ";"
+] @punctuation.delimiter
 
-["="] @operator
+[
+  "["
+  "]"
+  "("
+  ")" 
+  "{" 
+  "}"
+] @punctuation.bracket
+
+; ---------------------
+; Remaining identifiers
+; ---------------------
+
+; could also be namespace but this should cover the majority
+(field_expression
+  . (_)
+  (identifier) @variable.other.member)
+
+(const_statement
+  (variable_declaration
+    . (identifier) @constant))
+
+((identifier) @type
+  (match? @type "([A-Z][a-z0-9]+)+$"))
 
-(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][^_]"))
 ((identifier) @constant
-  (match? @constant "^[A-Z][A-Z_]{2}[A-Z_]*$"))
+  (match? @constant "^[A-Z][A-Z0-9_]+$"))
+
+(identifier) @variable