highglight(rust): use new query syntax

queries/rust/highlights.scm

@@ -6,7 +6,13 @@
 
 ; Assume all-caps names are constants
 ((identifier) @constant
- (match? @constant "^[A-Z][A-Z\\d_]+$'"))
+ (#match? @constant "^[A-Z][A-Z\\d_]+$'"))
+
+; Other identifiers
+
+(type_identifier) @type
+(primitive_type) @type.builtin
+(field_identifier) @field
 
 
 ; Function calls
@@ -14,11 +20,7 @@
   function: (identifier) @function)
 (call_expression
   function: (field_expression
-    field: (field_identifier) @method))
+    field: (field_identifier) @function))
-(call_expression
-  function: (scoped_identifier
-    "::"
-    name: (identifier) @function))
 
 (generic_function
   function: (identifier) @function)
@@ -27,19 +29,32 @@
     name: (identifier) @function))
 (generic_function
   function: (field_expression
-    field: (field_identifier) @method))
+    field: (field_identifier) @function))
 
 ; Assume other uppercase names are enum constructors
-((identifier) @constructor
+([(identifier) (field_identifier)] @constant
- (match? @constructor "^[A-Z]"))
+ (#match? @constant "^[A-Z]"))
 
 ; Assume that uppercase names in paths are types
 ((scoped_identifier
   path: (identifier) @type)
- (match? @type "^[A-Z]"))
+ (#match? @type "^[A-Z]"))
 ((scoped_identifier
     name: (identifier) @type)
- (match? @type "^[A-Z]"))
+ (#match? @type "^[A-Z]"))
+
+;; Correct enum constructors
+(call_expression
+  function: (scoped_identifier
+    "::"
+    name: (identifier) @constant)
+  (#match? @constant "^[A-Z]"))
+
+;; Assume that all `#[derive]` arguments are types
+(meta_item
+  (identifier) @meta
+  arguments: (meta_arguments (meta_item (identifier) @type))
+  (#eq? @meta "derive"))
 
 (macro_invocation
   macro: (identifier) @function.macro
@@ -50,19 +65,17 @@
 (function_item (identifier) @function)
 (function_signature_item (identifier) @function)
 
-; Other identifiers
+[
+(line_comment)
+(block_comment)
+ ] @comment
 
-(type_identifier) @type
+[
-(primitive_type) @type.builtin
+"("
-(field_identifier) @field
+")"
-
+"["
-(line_comment) @comment
+"]"
-(block_comment) @comment
+ ] @punctuation.bracket
-
-"(" @punctuation.bracket
-")" @punctuation.bracket
-"[" @punctuation.bracket
-"]" @punctuation.bracket
 
 (type_arguments
   "<" @punctuation.bracket
@@ -71,56 +84,72 @@
   "<" @punctuation.bracket
   ">" @punctuation.bracket)
 
-"::" @punctuation.delimiter
+[
-"." @punctuation.delimiter
+"::"
-";" @punctuation.delimiter
+"."
+";"
+ ] @punctuation.delimiter
 
 (parameter (identifier) @parameter)
 
 (lifetime (identifier) @label)
 
-"break" @keyword
+(self) @variable.builtin
-"const" @keyword
+
-"continue" @conditional
+[
-"default" @keyword
+"break"
-"dyn" @keyword
+"const"
-"else" @conditional
+"default"
-"enum" @keyword
+"dyn"
-"extern" @keyword
+"enum"
-"fn" @keyword
+"extern"
-"for" @repeat
+"fn"
-"if" @conditional
+"impl"
-"impl" @keyword
+"let"
-"in" @repeat
+"macro_rules!"
-"let" @keyword
+"match"
-"loop" @repeat
+"mod"
-"macro_rules!" @keyword
+"move"
-"match" @keyword
+"pub"
-"mod" @keyword
+"ref"
-"move" @keyword
+"return"
-"pub" @keyword
+"static"
-"ref" @keyword
+"struct"
-"return" @keyword
+"trait"
-"static" @keyword
+"type"
-"struct" @structure
+"union"
-"trait" @keyword
+"unsafe"
-"type" @keyword
+"use"
-"union" @keyword
+"where"
-"unsafe" @keyword
+(mutable_specifier)
-"use" @keyword
+(super)
-"where" @keyword
+; TODO(vigoux): attribute items should have some kind of injections
-"while" @repeat
+(attribute_item)
-(mutable_specifier) @keyword
+(inner_attribute_item)
+ ] @keyword
+
 (use_list (self) @keyword)
 (scoped_use_list (self) @keyword)
 (scoped_identifier (self) @keyword)
-(super) @keyword
 
-(self) @variable.builtin
+[
+"continue"
+"else"
+"if"
+] @conditional
 
-(char_literal) @string
+[
-(string_literal) @string
+"for"
-(raw_string_literal) @string
+"in"
+"loop"
+"while"
+] @repeat
+
+[
+(char_literal)
+(string_literal)
+(raw_string_literal)
+] @string
 
 (boolean_literal) @boolean
 (integer_literal) @number
@@ -128,12 +157,11 @@
 
 (escape_sequence) @string.escape
 
-; TODO(vigoux): attribute items should have some kind of injections
+[
-(attribute_item) @keyword
+"as"
-(inner_attribute_item) @keyword
+"*"
+"&"
+"'"
+ ] @operator
 
-"as" @operator
-"*" @operator
-"&" @operator
-"'" @operator
 (closure_parameters "|" @operator "|" @operator)