Rewritten Rust `highlights.scm` (#425)

* rewrote Rust highlights.scm

* wip

* wip

* wip

* wip

* fixed type highlighting

* wip

* rewrite again

* moved operators

* missing newline

* missing newline

* update book

* fix constructor highlighting

* fix constructor highlighting

* fix const highlighting

* better constructor highlighting

* remove dup, bug was my locals.scm file

* fixed docs

* merge

* fixed for highlighting

* add yield

* remove yield

* added yield back

* fixed yield highlighting

* unecessary

book/src/themes.md

@@ -51,6 +51,7 @@ Possible keys:
 | `attribute`              |                                     |
 | `keyword`                |                                     |
 | `keyword.directive`      | Preprocessor directives (\#if in C) |
+| `keyword.control`        | Control flow                        |
 | `namespace`              |                                     |
 | `punctuation`            |                                     |
 | `punctuation.delimiter`  |                                     |

helix-core/src/syntax.rs

@@ -161,7 +161,7 @@ impl LanguageConfiguration {
 
         let injections_query = read_query(&language, "injections.scm");
 
-        let locals_query = "";
+        let locals_query = read_query(&language, "locals.scm");
 
         if highlights_query.is_empty() {
             None
@@ -171,7 +171,7 @@ impl LanguageConfiguration {
                 language,
                 &highlights_query,
                 &injections_query,
-                locals_query,
+                &locals_query,
             )
             .unwrap(); // TODO: no unwrap
             config.configure(scopes);

runtime/queries/rust/highlights.scm

@@ -1,214 +1,336 @@
-; Identifier conventions
+; -------
+; Tree-Sitter doesn't allow overrides in regards to captures,
+; though it is possible to affect the child node of a captured
+; node. Thus, the approach here is to flip the order so that
+; overrides are unnecessary.
+; -------
 
 
-; Assume all-caps names are constants
+
+; -------
+; Types
+; -------
+
+; ---
+; Primitives
+; ---
+
+(escape_sequence) @escape
+(primitive_type) @type.builtin
+(boolean_literal) @constant.builtin
+[
+  (integer_literal)
+  (float_literal)
+] @number
+[
+  (char_literal)
+  (string_literal)
+  (raw_string_literal)
+] @string
+[
+  (line_comment)
+  (block_comment)
+] @comment
+
+; ---
+; Extraneous
+; ---
+
+(self) @variable.builtin
+(enum_variant (identifier) @type.enum.variant)
+
+(field_initializer
+  (field_identifier) @property)
+(shorthand_field_initializer) @variable
+(shorthand_field_identifier) @variable
+
+(lifetime
+  "'" @label
+  (identifier) @label)
+(loop_label
+  (identifier) @type)
+
+; ---
+; Punctuation
+; ---
+
+[
+  "::"
+  "."
+  ";"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+] @punctuation.bracket
+(type_arguments
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+(type_parameters
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+; ---
+; Parameters
+; ---
+
+(parameter
+	pattern: (identifier) @variable.parameter)
+(closure_parameters
+	(identifier) @variable.parameter)
+
+
+
+; -------
+; Keywords
+; -------
+
+(for_expression
+  "for" @keyword.control)
+((identifier) @keyword.control
+  (#match? @keyword.control "^yield$"))
+[
+  "while"
+  "loop"
+  "in"
+  "break"
+  "continue"
+
+  "match"
+  "if"
+  "else"
+  "return"
+
+  "await"
+] @keyword.control
+
+[
+  (crate)
+  (super)
+  "as"
+  "use"
+  "pub"
+  "mod"
+  "extern"
+
+  "fn"
+  "struct"
+  "enum"
+  "impl"
+  "where"
+  "trait"
+  "for"
+
+  "type"
+  "union"
+  "unsafe"
+  "default"
+  "macro_rules!"
+
+  "let"
+  "ref"
+  "move"
+
+  "dyn"
+  "static"
+  "const"
+  "async"
+] @keyword
+
+(mutable_specifier) @keyword.mut
+
+
+
+; -------
+; Guess Other Types
+; -------
+
 ((identifier) @constant
  (#match? @constant "^[A-Z][A-Z\\d_]+$"))
 
-; Assume other uppercase names are enum constructors
+; ---
-(enum_variant) @type.enum.variant
+; PascalCase identifiers in call_expressions (e.g. `Ok()`)
-((identifier) @constructor
+; are assumed to be enum constructors.
- (#match? @constructor "^[A-Z]"))
+; ---
 
-; Assume that uppercase names in paths are types
+(call_expression
-(mod_item
+  function: [
- name: (identifier) @namespace)
+    ((identifier) @type.variant
-(scoped_identifier
+      (#match? @type.variant "^[A-Z]"))
-  path: (identifier) @namespace)
-(scoped_identifier
     (scoped_identifier
-  name: (identifier) @namespace))
+      name: ((identifier) @type.variant
-(scoped_type_identifier
+        (#match? @type.variant "^[A-Z]")))
-  path: (identifier) @namespace)
+  ])
-(scoped_type_identifier
+
+; ---
+; Assume that types in match arms are enums and not
+; tuple structs. Same for `if let` expressions.
+; ---
+
+(match_pattern
     (scoped_identifier
-  name: (identifier) @namespace))
+      name: (identifier) @constructor))
+(tuple_struct_pattern
+    type: [
+      ((identifier) @constructor)
+      (scoped_identifier  
+        name: (identifier) @constructor)
+      ])
+(struct_pattern
+  type: [
+    ((type_identifier) @constructor)
+    (scoped_type_identifier
+      name: (type_identifier) @constructor)
+    ])
 
-((scoped_identifier
+; ---
-  path: (identifier) @type)
+; Other PascalCase identifiers are assumed to be structs.
- (#match? @type "^[A-Z]"))
+; ---
-((scoped_identifier
+
-  path: (scoped_identifier
+((identifier) @type
-    name: (identifier) @type))
   (#match? @type "^[A-Z]"))
 
-; Namespaces
 
-(crate) @namespace
-(extern_crate_declaration
-    (crate)
-    name: (identifier) @namespace)
-(scoped_use_list
-  path: (identifier) @namespace)
-(scoped_use_list
-  path: (scoped_identifier
-            (identifier) @namespace))
-(use_list (scoped_identifier (identifier) @namespace . (_)))
 
-; Function calls
+; -------
+; Functions
+; -------
 
 (call_expression
-  function: (identifier) @function)
+  function: [
-(call_expression
+    ((identifier) @function)
-  function: (field_expression
+    (scoped_identifier
-    field: (field_identifier) @function.method))
+      name: (identifier) @function)
-(call_expression
+    (field_expression
-  function: (scoped_identifier
+      field: (field_identifier) @function)
-    "::"
+  ])
-    name: (identifier) @function))
-
-(generic_function
-  function: (identifier) @function)
-(generic_function
-  function: (scoped_identifier
-    name: (identifier) @function))
 (generic_function
-  function: (field_expression
+  function: [
-    field: (field_identifier) @function.method))
+    ((identifier) @function)
+    (scoped_identifier
+      name: (identifier) @function)
+    (field_expression
+      field: (field_identifier) @function.method)
+  ])
+
+(function_item
+  name: (identifier) @function)
+
+; ---
+; Macros
+; ---
 
+(meta_item
+  (identifier) @attribute)
+(attribute_item) @attribute
+(inner_attribute_item) @attribute
+
+(macro_definition
+  name: (identifier) @function.macro)
 (macro_invocation
-  macro: (identifier) @function.macro
+  macro: [
+    ((identifier) @function.macro)
+    (scoped_identifier
+      name: (identifier) @function.macro)
+  ]
   "!" @function.macro)
-(macro_invocation
-  macro: (scoped_identifier
-           (identifier) @function.macro .))
-
-; (metavariable) @variable
-(metavariable) @function.macro
 
-"$" @function.macro
+(metavariable) @variable.parameter
+(fragment_specifier) @variable.parameter
 
-; Function definitions
 
-(function_item (identifier) @function)
-(function_signature_item (identifier) @function)
 
-; Other identifiers
+; -------
+; Operators
+; -------
 
-(type_identifier) @type
+[
-(primitive_type) @type.builtin
+  "*"
-(field_identifier) @property
+  "'"
+  "->"
+  "=>"
+  "<="
+  "="
+  "=="
+  "!"
+  "!="
+  "%"
+  "%="
+  "&"
+  "&="
+  "&&"
+  "|"
+  "|="
+  "||"
+  "^"
+  "^="
+  "*"
+  "*="
+  "-"
+  "-="
+  "+"
+  "+="
+  "/"
+  "/="
+  ">"
+  "<"
+  ">="
+  ">>"
+  "<<"
+  ">>="
+  "@"
+  ".."
+  "..="
+  "'"
+] @operator
 
-(line_comment) @comment
-(block_comment) @comment
 
-"(" @punctuation.bracket
-")" @punctuation.bracket
-"[" @punctuation.bracket
-"]" @punctuation.bracket
 
-(type_arguments
+; -------
-  "<" @punctuation.bracket
+; Paths
-  ">" @punctuation.bracket)
+; -------
-(type_parameters
-  "<" @punctuation.bracket
-  ">" @punctuation.bracket)
-
-"::" @punctuation.delimiter
-"." @punctuation.delimiter
-";" @punctuation.delimiter
-
-(parameter (identifier) @variable.parameter)
-(closure_parameters (_) @variable.parameter)
-
-(lifetime (identifier) @label)
-
-"async" @keyword
-"break" @keyword
-"const" @keyword
-"continue" @keyword
-(crate) @keyword
-"default" @keyword
-"dyn" @keyword
-"else" @keyword
-"enum" @keyword
-"extern" @keyword
-"fn" @keyword
-"for" @keyword
-"if" @keyword
-"impl" @keyword
-"in" @keyword
-"let" @keyword
-"let" @keyword
-"loop" @keyword
-"macro_rules!" @keyword
-"match" @keyword
-"mod" @keyword
-"move" @keyword
-"pub" @keyword
-"ref" @keyword
-"return" @keyword
-"static" @keyword
-"struct" @keyword
-"trait" @keyword
-"type" @keyword
-"union" @keyword
-"unsafe" @keyword
-"use" @keyword
-"where" @keyword
-"while" @keyword
-(mutable_specifier) @keyword.mut
-(use_list (self) @keyword)
-(scoped_use_list (self) @keyword)
-(scoped_identifier (self) @keyword)
-(super) @keyword
-"as" @keyword
 
-(self) @variable.builtin
+(use_declaration
+  argument: (identifier) @namespace)
+(use_wildcard
+  (identifier) @namespace)
+(extern_crate_declaration
+  name: (identifier) @namespace)
+(mod_item
+  name: (identifier) @namespace)
+(scoped_use_list
+  path: (identifier)? @namespace)
+(use_list
+  (identifier) @namespace)
+(use_as_clause
+  path: (identifier)? @namespace
+  alias: (identifier) @namespace)
 
-[
+; ---
-(char_literal)
+; Remaining Paths
-(string_literal)
+; ---
-(raw_string_literal)
-] @string
 
-(boolean_literal) @constant.builtin
+(scoped_identifier
-(integer_literal) @number
+  path: (identifier)? @namespace
-(float_literal) @number
+  name: (identifier) @namespace)
+(scoped_type_identifier
+  path: (identifier) @namespace)
 
-(escape_sequence) @escape
 
-(attribute_item) @attribute
-(inner_attribute_item) @attribute
 
-[
+; -------
-"*"
+; Remaining Identifiers
-"'"
+; -------
-"->"
-"=>"
-"<="
-"="
-"=="
-"!"
-"!="
-"%"
-"%="
-"&"
-"&="
-"&&"
-"|"
-"|="
-"||"
-"^"
-"^="
-"*"
-"*="
-"-"
-"-="
-"+"
-"+="
-"/"
-"/="
-">"
-"<"
-">="
-">>"
-"<<"
-">>="
-"@"
-".."
-"..="
-"'"
-] @operator
 
 "?" @special
+
+(type_identifier) @type
+(identifier) @variable
+(field_identifier) @variable