chore: query formatting

4 files changed, 717 insertions, 491 deletions

diff --git a/queries/nim/folds.scm b/queries/nim/folds.scm
index 466bcf5ae..fa0581a72 100644
--- a/queries/nim/folds.scm
+++ b/queries/nim/folds.scm
@@ -4,11 +4,9 @@
   (let_section)
   (type_section)
   (using_section)
-
   (object_declaration)
   (tuple_type)
   (enum_declaration)
-
   (case)
   (if)
   (when)
@@ -17,22 +15,18 @@
   (of_branch)
   (elif_branch)
   (else_branch)
-
   (for)
   (while)
   (block)
   (static_statement)
   (pragma_statement)
-
   (try)
   (except_branch)
   (finally_branch)
-
   (do_block)
   (call
     (argument_list
       (statement_list)))
-
   (proc_declaration)
   (func_declaration)
   (method_declaration)
@@ -40,10 +34,8 @@
   (converter_declaration)
   (template_declaration)
   (macro_declaration)
-
   (proc_expression)
   (func_expression)
   (iterator_expression)
-
   (concept_declaration)
 ] @fold
diff --git a/queries/nim/highlights.scm b/queries/nim/highlights.scm
index 1a7da2ba2..d868be072 100644
--- a/queries/nim/highlights.scm
+++ b/queries/nim/highlights.scm
@@ -1,59 +1,58 @@
 ; SPDX-FileCopyrightText: 2023 Leorize <leorize+oss@disroot.org>, aMOPel <>
 ; SPDX-License-Identifier: MPL-2.0
 ; SPDX-License-Identifier: Apache-2.0
-
 ; =============================================================================
 ; catch all rules
+((identifier) @variable
+  (#set! "priority" 99))
 
-((identifier) @variable (#set! "priority" 99))
 ; NOTE: we need priority, since (identifier) is most specific and we have to
 ; capture nodes containing (identifier) as a whole, while overruling the
 ; @variable capture.
-
 (type_expression) @type
+
 ; NOTE: has to be after
 ; ((identifier) @variable (#set! "priority" 99))
-
 ; overrule identifiers in pragmas in (proc_type)s and (pragma_expression)s
 (proc_type
-  pragmas:
-    (pragma_list) @variable)
+  pragmas: (pragma_list) @variable)
+
 (iterator_type
-  pragmas:
-    (pragma_list) @variable)
+  pragmas: (pragma_list) @variable)
+
 (type_expression
   (pragma_expression
-    right:
-      (pragma_list) @variable))
+    right: (pragma_list) @variable))
+
 ; NOTE: has to be after
 ; (type_expression) @type
 ; and before @keyword.directive and all literals
-
 ; constants/enums in array construction
 (array_construction
   (colon_expression
     left: (_) @constant))
-; NOTE: has to be before literals and punctuation etc.
 
+; NOTE: has to be before literals and punctuation etc.
 ; identifiers in "case" "of" branches have to be enums
 (case
   alternative:
     (of_branch
       values:
-        (expression_list (_) @constant)))
-; NOTE: has to be before literals and punctuation etc.
+        (expression_list
+          (_) @constant)))
 
+; NOTE: has to be before literals and punctuation etc.
 ; in variant objects with "case" "of"
 (variant_declaration
   alternative:
     (of_branch
       values:
-        (expression_list (_) @constant)))
-; NOTE: has to be before literals and punctuation etc.
+        (expression_list
+          (_) @constant)))
 
+; NOTE: has to be before literals and punctuation etc.
 ; =============================================================================
 ; @comment               ; line and block comments
-
 [
   (comment)
   (block_comment)
@@ -61,54 +60,75 @@
 
 ; =============================================================================
 ; @comment.documentation ; comments documenting code
+(documentation_comment
+  "##" @comment.documentation)
 
-(documentation_comment "##" @comment.documentation)
 (block_documentation_comment
   "##[" @comment.documentation
   "]##" @comment.documentation)
-; NOTE: leaving content uncaptured so markdown can be injected
 
+; NOTE: leaving content uncaptured so markdown can be injected
 ; =============================================================================
 ; @punctuation.delimiter ; delimiters (e.g. `;` / `.` / `,`)
-
-[ "." ";" "," ":" "=" ] @punctuation.delimiter
+[
+  "."
+  ";"
+  ","
+  ":"
+  "="
+] @punctuation.delimiter
 
 ; =============================================================================
 ; @operator              ; symbolic operators (e.g. `+` / `*`)
-
 (operator) @operator
 
-(assignment "=" @operator)
+(assignment
+  "=" @operator)
 
 ; =============================================================================
 ; @punctuation.bracket   ; brackets (e.g. `()` / `{}` / `[]`)
-
-[ "(" ")" "[" "[:" "]" "{" "}" ] @punctuation.bracket
+[
+  "("
+  ")"
+  "["
+  "[:"
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
 
 ; =============================================================================
 ; @keyword.directive               ; various preprocessor directives & shebangs
-
 [
   "macro"
   "template"
 ] @keyword.directive
 
-(pragma_list ["{." "}" ".}"] @keyword.directive)
-; NOTE: has to come after @punctuation.bracket
+(pragma_list
+  [
+    "{."
+    "}"
+    ".}"
+  ] @keyword.directive)
 
+; NOTE: has to come after @punctuation.bracket
 ; =============================================================================
 ; @punctuation.special   ; special symbols (e.g. `{}` in string interpolation)
+(accent_quoted
+  "`" @punctuation.special)
 
-(accent_quoted "`" @punctuation.special)
-
-(exported_symbol "*" @punctuation.special)
+(exported_symbol
+  "*" @punctuation.special)
 
 ; dereference operator
-(bracket_expression !right "[" @punctuation.special . "]" @punctuation.special)
+(bracket_expression
+  !right
+  "[" @punctuation.special
+  .
+  "]" @punctuation.special)
 
 ; =============================================================================
 ; @string               ; string literals
-
 [
   (interpreted_string_literal)
   (long_string_literal)
@@ -117,147 +137,189 @@
 ] @string
 
 ; injections in generalized_strings
-(generalized_string (string_content) @none)
+(generalized_string
+  (string_content) @none)
 
 ; format string injection in normal strings with & prefix
 (prefix_expression
-  operator: (operator) @_string_prefix .
-  (_ (string_content) @none)
+  operator: (operator) @_string_prefix
+  .
+  (_
+    (string_content) @none)
   (#eq? @_string_prefix "&"))
 
 ; emit pragma injection
 (pragma_statement
   (pragma_list
     (colon_expression
-      left: (identifier) @_emit_keyword (#eq? @_emit_keyword "emit")
-      right: (_ (string_content) @none))))
+      left: (identifier) @_emit_keyword
+      (#eq? @_emit_keyword "emit")
+      right:
+        (_
+          (string_content) @none))))
 
 ; =============================================================================
 ; @string.escape        ; escape sequences
-
 (escape_sequence) @string.escape
 
 ; =============================================================================
 ; @character            ; character literals
-
 (char_literal) @character
 
 ; =============================================================================
 ; @boolean              ; boolean literals
-
 ((identifier) @boolean
   (#any-of? @boolean "true" "false" "on" "off"))
 
 ; =============================================================================
 ; @number               ; numeric literals
-
 (integer_literal) @number
 
 (custom_numeric_literal) @number
 
 ; =============================================================================
 ; @number.float                ; floating-point number literals
-
 (float_literal) @number.float
 
 ; =============================================================================
 ; @function         ; function definitions
-
 (proc_declaration
-  name: [
-    (identifier) @function
-    (accent_quoted (identifier) @function)
-    (exported_symbol (identifier) @function)
-    (exported_symbol (accent_quoted (identifier) @function))
-  ])
+  name:
+    [
+      (identifier) @function
+      (accent_quoted
+        (identifier) @function)
+      (exported_symbol
+        (identifier) @function)
+      (exported_symbol
+        (accent_quoted
+          (identifier) @function))
+    ])
 
 (func_declaration
-  name: [
-    (identifier) @function
-    (accent_quoted (identifier) @function)
-    (exported_symbol (identifier) @function)
-    (exported_symbol (accent_quoted (identifier) @function))
-  ])
+  name:
+    [
+      (identifier) @function
+      (accent_quoted
+        (identifier) @function)
+      (exported_symbol
+        (identifier) @function)
+      (exported_symbol
+        (accent_quoted
+          (identifier) @function))
+    ])
 
 (iterator_declaration
-  name: [
-    (identifier) @function
-    (accent_quoted (identifier) @function)
-    (exported_symbol (identifier) @function)
-    (exported_symbol (accent_quoted (identifier) @function))
-  ])
+  name:
+    [
+      (identifier) @function
+      (accent_quoted
+        (identifier) @function)
+      (exported_symbol
+        (identifier) @function)
+      (exported_symbol
+        (accent_quoted
+          (identifier) @function))
+    ])
 
 (converter_declaration
-  name: [
-    (identifier) @function
-    (accent_quoted (identifier) @function)
-    (exported_symbol (identifier) @function)
-    (exported_symbol (accent_quoted (identifier) @function))
-  ])
+  name:
+    [
+      (identifier) @function
+      (accent_quoted
+        (identifier) @function)
+      (exported_symbol
+        (identifier) @function)
+      (exported_symbol
+        (accent_quoted
+          (identifier) @function))
+    ])
 
 ; =============================================================================
 ; @function.call    ; function calls
-
 (call
-  function: [
-    (identifier) @function.call
-    (accent_quoted (identifier) @function.call)
-    ; generic types
-    (bracket_expression left: (identifier) @function.call)
-    (bracket_expression left: (accent_quoted (identifier) @function.call))
-    ; dot accessor
-    (dot_expression right: (identifier) @function.call)
-    (dot_expression right: (accent_quoted (identifier) @function.call))
-    ; both
-    (bracket_expression left:
-      (dot_expression right: (identifier) @function.call))
-    (bracket_expression left:
-      (dot_expression right: (accent_quoted (identifier) @function.call)))
-  ])
+  function:
+    [
+      (identifier) @function.call
+      (accent_quoted
+        (identifier) @function.call)
+      ; generic types
+      (bracket_expression
+        left: (identifier) @function.call)
+      (bracket_expression
+        left:
+          (accent_quoted
+            (identifier) @function.call))
+      ; dot accessor
+      (dot_expression
+        right: (identifier) @function.call)
+      (dot_expression
+        right:
+          (accent_quoted
+            (identifier) @function.call))
+      ; both
+      (bracket_expression
+        left:
+          (dot_expression
+            right: (identifier) @function.call))
+      (bracket_expression
+        left:
+          (dot_expression
+            right:
+              (accent_quoted
+                (identifier) @function.call)))
+    ])
 
 (dot_generic_call
-  function: [
-    (identifier) @function.call
-    (accent_quoted (identifier) @function.call)
-  ])
+  function:
+    [
+      (identifier) @function.call
+      (accent_quoted
+        (identifier) @function.call)
+    ])
 
 ; generalized_string is a function call
 ; `identifier"string literal"`
 ; is short for
 ; `identifier(r"string literal")`
 (generalized_string
-  function: [
-    (identifier) @function.call
-    (accent_quoted (identifier) @function.call)
-  ])
+  function:
+    [
+      (identifier) @function.call
+      (accent_quoted
+        (identifier) @function.call)
+    ])
 
 ; call with leading literal
 (dot_expression
-  left: [
-    (nil_literal)
-    (integer_literal)
-    (float_literal)
-    (custom_numeric_literal)
-    (char_literal)
-    (interpreted_string_literal)
-    (long_string_literal)
-    (raw_string_literal)
-    (generalized_string)
-    (array_construction)
-    ; for sequences
-    (prefix_expression
-      operator: (operator) @_at
+  left:
+    [
+      (nil_literal)
+      (integer_literal)
+      (float_literal)
+      (custom_numeric_literal)
+      (char_literal)
+      (interpreted_string_literal)
+      (long_string_literal)
+      (raw_string_literal)
+      (generalized_string)
       (array_construction)
-      (#eq? @_at "@"))
-    (tuple_construction)
-    (curly_construction)
-  ]
-  right: [
-    (identifier) @function.call
-    (accent_quoted (identifier) @function.call)
-  ])
-; NOTE: will double capture as @function.call if it also has argument_list
+      ; for sequences
+      (prefix_expression
+        operator: (operator) @_at
+        (array_construction)
+        (#eq? @_at "@"))
+      (tuple_construction)
+      (curly_construction)
+    ]
+  right:
+    [
+      (identifier) @function.call
+      (accent_quoted
+        (identifier) @function.call)
+    ])
 
+; NOTE: will double capture as @function.call if it also has argument_list
 ; function.calls in `varargs[type, routine]`
 (bracket_expression
   left: (identifier) @_varargs
@@ -268,73 +330,104 @@
       .
       [
         (identifier) @function.call
-        (accent_quoted (identifier) @function.call)
-        (dot_expression right: (identifier) @function.call)
-        (dot_expression right: (accent_quoted (identifier) @function.call))
+        (accent_quoted
+          (identifier) @function.call)
+        (dot_expression
+          right: (identifier) @function.call)
+        (dot_expression
+          right:
+            (accent_quoted
+              (identifier) @function.call))
       ])
   (#eq? @_varargs "varargs"))
 
 ; =============================================================================
 ; @function.macro   ; preprocessor macros
-
 (template_declaration
-  name: [
-    (identifier) @function.macro
-    (accent_quoted (identifier) @function.macro)
-    (exported_symbol (identifier) @function.macro)
-    (exported_symbol (accent_quoted (identifier) @function.macro))
-  ])
+  name:
+    [
+      (identifier) @function.macro
+      (accent_quoted
+        (identifier) @function.macro)
+      (exported_symbol
+        (identifier) @function.macro)
+      (exported_symbol
+        (accent_quoted
+          (identifier) @function.macro))
+    ])
 
 (macro_declaration
-  name: [
-    (identifier) @function.macro
-    (accent_quoted (identifier) @function.macro)
-    (exported_symbol (identifier) @function.macro)
-    (exported_symbol (accent_quoted (identifier) @function.macro))
-  ])
+  name:
+    [
+      (identifier) @function.macro
+      (accent_quoted
+        (identifier) @function.macro)
+      (exported_symbol
+        (identifier) @function.macro)
+      (exported_symbol
+        (accent_quoted
+          (identifier) @function.macro))
+    ])
 
 ; =============================================================================
 ; @function.method           ; method definitions
-
 (method_declaration
-  name: [
-    (identifier) @function.method
-    (accent_quoted (identifier) @function.method)
-    (exported_symbol (identifier) @function.method)
-    (exported_symbol (accent_quoted (identifier) @function.method))
-  ])
+  name:
+    [
+      (identifier) @function.method
+      (accent_quoted
+        (identifier) @function.method)
+      (exported_symbol
+        (identifier) @function.method)
+      (exported_symbol
+        (accent_quoted
+          (identifier) @function.method))
+    ])
 
 ; =============================================================================
 ; @constructor      ; constructor calls and definitions
-
 (call
-  function: [
-    (identifier) @constructor
-    (accent_quoted (identifier) @constructor)
-    ; generic types
-    (bracket_expression left: (identifier) @constructor)
-    (bracket_expression left: (accent_quoted (identifier) @constructor))
-    ; dot accessor
-    (dot_expression right: (identifier) @constructor)
-    (dot_expression right: (accent_quoted (identifier) @constructor))
-    ; both
-    (bracket_expression left:
-      (dot_expression right: (identifier) @constructor))
-    (bracket_expression left:
-      (dot_expression right: (accent_quoted (identifier) @constructor)))
-  ]
+  function:
+    [
+      (identifier) @constructor
+      (accent_quoted
+        (identifier) @constructor)
+      ; generic types
+      (bracket_expression
+        left: (identifier) @constructor)
+      (bracket_expression
+        left:
+          (accent_quoted
+            (identifier) @constructor))
+      ; dot accessor
+      (dot_expression
+        right: (identifier) @constructor)
+      (dot_expression
+        right:
+          (accent_quoted
+            (identifier) @constructor))
+      ; both
+      (bracket_expression
+        left:
+          (dot_expression
+            right: (identifier) @constructor))
+      (bracket_expression
+        left:
+          (dot_expression
+            right:
+              (accent_quoted
+                (identifier) @constructor)))
+    ]
   (argument_list
     (colon_expression)+))
+
 ; NOTE: this cannot detect constructors with 0 arguments
 ; those will be matched as @function.call instead
-
 ; =============================================================================
 ; @keyword             ; various keywords
-
 ; unhandled but reserved keywords
 ; end
 ; interface
-
 ; static expression
 ; addr operator
 ((call
@@ -363,7 +456,6 @@
 
 ; =============================================================================
 ; @keyword.function    ; keywords that define a function (e.g. `func` in Go, `def` in Python)
-
 [
   "proc"
   "func"
@@ -374,7 +466,6 @@
 
 ; =============================================================================
 ; @keyword.operator    ; operators that are English words (e.g. `and` / `or`)
-
 [
   "and"
   "or"
@@ -396,7 +487,6 @@
 
 ; =============================================================================
 ; @keyword.return      ; keywords like `return` and `yield`
-
 [
   "return"
   "yield"
@@ -404,7 +494,6 @@
 
 ; =============================================================================
 ; @keyword.conditional         ; keywords related to conditionals (e.g. `if` / `else`)
-
 [
   "if"
   "when"
@@ -413,11 +502,11 @@
   "else"
 ] @keyword.conditional
 
-(of_branch "of" @keyword.conditional)
+(of_branch
+  "of" @keyword.conditional)
 
 ; =============================================================================
 ; @keyword.repeat              ; keywords related to loops (e.g. `for` / `while`)
-
 [
   "for"
   "while"
@@ -425,33 +514,35 @@
   "break"
 ] @keyword.repeat
 
-(for "in" @keyword.repeat)
+(for
+  "in" @keyword.repeat)
 
 ; =============================================================================
 ; @label               ; GOTO and other labels (e.g. `label:` in C)
-
 (block
-  label: [
-    (identifier) @label
-    (accent_quoted (identifier) @label)
-  ])
+  label:
+    [
+      (identifier) @label
+      (accent_quoted
+        (identifier) @label)
+    ])
 
 ; =============================================================================
 ; @keyword.import             ; keywords for including modules (e.g. `import` / `from` in Python)
-
 [
   "import"
   "include"
   "export"
 ] @keyword.import
 
-(import_from_statement "from" @keyword.import)
+(import_from_statement
+  "from" @keyword.import)
 
-(except_clause "except" @keyword.import)
+(except_clause
+  "except" @keyword.import)
 
 ; =============================================================================
 ; @keyword.exception           ; keywords related to exceptions (e.g. `throw` / `catch`)
-
 [
   "try"
   "except"
@@ -461,22 +552,26 @@
 
 ; =============================================================================
 ; @type            ; type or class definitions and annotations
-
 ; generic types when calling
 (call
-  function: (bracket_expression
-    right: (argument_list) @type))
+  function:
+    (bracket_expression
+      right: (argument_list) @type))
+
 ; NOTE: this also falsely matches
 ; when accessing and directly call elements from an array of routines
 ; eg `array_of_routines[index](arguments), but that is an uncommon case
-
 ; dot_generic_call `v.call[:type, type]()
 (dot_generic_call
   generic_arguments: (_) @type)
 
 ; right side of `is` operator is always type
 (infix_expression
-  operator: [ "is" "isnot" ]
+  operator:
+    [
+      "is"
+      "isnot"
+    ]
   right: (_) @type)
 
 ; except branch always contains types of errors
@@ -487,213 +582,285 @@
 ; overrule special case in (except_branch) with "as" operator
 ; `except module.exception[gen_type] as variable:`
 (except_branch
-  values: (expression_list
-    (infix_expression
-      operator: "as"
-      right: [
-        (identifier) @variable
-        (accent_quoted (identifier) @variable)
-      ])))
+  values:
+    (expression_list
+      (infix_expression
+        operator: "as"
+        right:
+          [
+            (identifier) @variable
+            (accent_quoted
+              (identifier) @variable)
+          ])))
 
 ; for inline tuple types
 ; `type a = tuple[a: int]`
 (tuple_type
   "tuple" @type
   (field_declaration_list))
+
 ; NOTE: this is consistent with other generic types like `seq[int]`
 ; but inconsistent with multiline tuple declaration,
 ; where `tuple` is captured as @keyword
-
 ; =============================================================================
 ; @variable.parameter        ; parameters of a function
-
 ; named parameters when calling
 ; call(parameter_name=arg)
 (argument_list
   (equal_expression
-    left: [
-      (identifier) @variable.parameter
-      (accent_quoted (identifier) @variable.parameter)
-    ]))
+    left:
+      [
+        (identifier) @variable.parameter
+        (accent_quoted
+          (identifier) @variable.parameter)
+      ]))
 
 ; parameters in function declaration
 (parameter_declaration_list
   (parameter_declaration
     (symbol_declaration_list
       (symbol_declaration
-        name: [
-          (identifier) @variable.parameter
-          (accent_quoted (identifier) @variable.parameter)
-        ]))))
-; NOTE: needs to be after @type
+        name:
+          [
+            (identifier) @variable.parameter
+            (accent_quoted
+              (identifier) @variable.parameter)
+          ]))))
 
+; NOTE: needs to be after @type
 ; generic types when declaring
 ((generic_parameter_list
   (parameter_declaration
     (symbol_declaration_list
       (symbol_declaration
-        name: [
-          (identifier) @variable.parameter
-          (accent_quoted (identifier) @variable.parameter)
-        ])))))
+        name:
+          [
+            (identifier) @variable.parameter
+            (accent_quoted
+              (identifier) @variable.parameter)
+          ])))))
 
 ; for loop variables
 (for
   left:
     (symbol_declaration_list
       (symbol_declaration
-        name: [
-          (identifier) @variable.parameter
-          (accent_quoted (identifier) @variable.parameter)
-        ])))
+        name:
+          [
+            (identifier) @variable.parameter
+            (accent_quoted
+              (identifier) @variable.parameter)
+          ])))
 
 ((tuple_deconstruct_declaration
   (symbol_declaration
-    name: [
-      (identifier) @variable.parameter
-      (accent_quoted (identifier) @variable.parameter)
-    ])) @_tuple_decons
+    name:
+      [
+        (identifier) @variable.parameter
+        (accent_quoted
+          (identifier) @variable.parameter)
+      ])) @_tuple_decons
   (#has-ancestor? @_tuple_decons for))
 
 (concept_declaration
   parameters:
-    (parameter_list [
-      (identifier) @variable.parameter
-      (accent_quoted (identifier) @variable.parameter)
-    ]))
-(var_parameter [
-  (identifier) @variable.parameter
-  (accent_quoted (identifier) @variable.parameter)
-])
-(type_parameter [
-  (identifier) @variable.parameter
-  (accent_quoted (identifier) @variable.parameter)
-])
-(static_parameter [
-  (identifier) @variable.parameter
-  (accent_quoted (identifier) @variable.parameter)
-])
-(ref_parameter [
-  (identifier) @variable.parameter
-  (accent_quoted (identifier) @variable.parameter)
-])
-(pointer_parameter [
-  (identifier) @variable.parameter
-  (accent_quoted (identifier) @variable.parameter)
-])
+    (parameter_list
+      [
+        (identifier) @variable.parameter
+        (accent_quoted
+          (identifier) @variable.parameter)
+      ]))
+
+(var_parameter
+  [
+    (identifier) @variable.parameter
+    (accent_quoted
+      (identifier) @variable.parameter)
+  ])
+
+(type_parameter
+  [
+    (identifier) @variable.parameter
+    (accent_quoted
+      (identifier) @variable.parameter)
+  ])
+
+(static_parameter
+  [
+    (identifier) @variable.parameter
+    (accent_quoted
+      (identifier) @variable.parameter)
+  ])
+
+(ref_parameter
+  [
+    (identifier) @variable.parameter
+    (accent_quoted
+      (identifier) @variable.parameter)
+  ])
 
+(pointer_parameter
+  [
+    (identifier) @variable.parameter
+    (accent_quoted
+      (identifier) @variable.parameter)
+  ])
 
 ; =============================================================================
 ; @type.definition ; type definitions (e.g. `typedef` in C)
-
 (type_section
   (type_declaration
     (type_symbol_declaration
-      name: [
-        (identifier) @type.definition
-        (accent_quoted (identifier) @type.definition)
-        (exported_symbol (identifier) @type.definition)
-        (exported_symbol (accent_quoted (identifier) @type.definition))
-      ])))
+      name:
+        [
+          (identifier) @type.definition
+          (accent_quoted
+            (identifier) @type.definition)
+          (exported_symbol
+            (identifier) @type.definition)
+          (exported_symbol
+            (accent_quoted
+              (identifier) @type.definition))
+        ])))
 
 ; =============================================================================
 ; @type.qualifier  ; type qualifiers (e.g. `const`)
+(var_type
+  "var" @type.qualifier)
+
+(out_type
+  "out" @type.qualifier)
 
-(var_type "var" @type.qualifier)
-(out_type "out" @type.qualifier)
-(distinct_type "distinct" @type.qualifier)
-(ref_type "ref" @type.qualifier)
-(pointer_type "ptr" @type.qualifier)
+(distinct_type
+  "distinct" @type.qualifier)
 
-(var_parameter "var" @type.qualifier)
-(type_parameter "type" @type.qualifier)
-(static_parameter "static" @type.qualifier)
-(ref_parameter "ref" @type.qualifier)
-(pointer_parameter "ptr" @type.qualifier)
+(ref_type
+  "ref" @type.qualifier)
+
+(pointer_type
+  "ptr" @type.qualifier)
+
+(var_parameter
+  "var" @type.qualifier)
+
+(type_parameter
+  "type" @type.qualifier)
+
+(static_parameter
+  "static" @type.qualifier)
+
+(ref_parameter
+  "ref" @type.qualifier)
+
+(pointer_parameter
+  "ptr" @type.qualifier)
 
 ; =============================================================================
 ; @variable.member           ; object and struct fields
-
 ; fields in object/tuple declaration
 (field_declaration
   (symbol_declaration_list
     (symbol_declaration
-      name: [
-        (identifier) @variable.member
-        (accent_quoted (identifier) @variable.member)
-        (exported_symbol (identifier) @variable.member)
-        (exported_symbol (accent_quoted (identifier) @variable.member))
-      ])))
+      name:
+        [
+          (identifier) @variable.member
+          (accent_quoted
+            (identifier) @variable.member)
+          (exported_symbol
+            (identifier) @variable.member)
+          (exported_symbol
+            (accent_quoted
+              (identifier) @variable.member))
+        ])))
 
 ; fields in object construction
 (call
   (argument_list
     (colon_expression
-      left: [
-        (identifier) @variable.member
-        (accent_quoted (identifier) @variable.member)
-      ])))
+      left:
+        [
+          (identifier) @variable.member
+          (accent_quoted
+            (identifier) @variable.member)
+        ])))
 
 ; fields in tuple construction
 (tuple_construction
   (colon_expression
-    left: [
-      (identifier) @variable.member
-      (accent_quoted (identifier) @variable.member)
-    ]))
+    left:
+      [
+        (identifier) @variable.member
+        (accent_quoted
+          (identifier) @variable.member)
+      ]))
 
 (variant_declaration
   (variant_discriminator_declaration
     (symbol_declaration_list
       (symbol_declaration
-        name: [
-          (identifier) @variable.member
-          (accent_quoted (identifier) @variable.member)
-          (exported_symbol (identifier) @variable.member)
-          (exported_symbol (accent_quoted (identifier) @variable.member))
-        ]))))
+        name:
+          [
+            (identifier) @variable.member
+            (accent_quoted
+              (identifier) @variable.member)
+            (exported_symbol
+              (identifier) @variable.member)
+            (exported_symbol
+              (accent_quoted
+                (identifier) @variable.member))
+          ]))))
 
 ; =============================================================================
 ; @variable.builtin ; built-in variable names (e.g. `this`)
-
 (blank_identifier) @variable.builtin
 
 ((identifier) @variable.builtin
   (#eq? @variable.builtin "result"))
+
 ; NOTE: technically needs `has-ancestor some routine declaration` but it's
 ; not worth it
-
 ; =============================================================================
 ; @constant         ; constant identifiers
-
 ; enum declaration
 (enum_field_declaration
   (symbol_declaration
-    name: [
-      (identifier) @constant
-      (accent_quoted (identifier) @constant)
-    ]))
+    name:
+      [
+        (identifier) @constant
+        (accent_quoted
+          (identifier) @constant)
+      ]))
 
 ; constant declaration
 (const_section
   (variable_declaration
     (symbol_declaration_list
       (symbol_declaration
-        name: [
-          (identifier) @constant
-          (accent_quoted (identifier) @constant)
-          (exported_symbol (identifier) @constant)
-          (exported_symbol (accent_quoted (identifier) @constant))
-        ]))))
+        name:
+          [
+            (identifier) @constant
+            (accent_quoted
+              (identifier) @constant)
+            (exported_symbol
+              (identifier) @constant)
+            (exported_symbol
+              (accent_quoted
+                (identifier) @constant))
+          ]))))
 
 ((tuple_deconstruct_declaration
   (symbol_declaration
-    name: [
-      (identifier) @constant
-      (accent_quoted (identifier) @constant)
-      (exported_symbol (identifier) @constant)
-      (exported_symbol (accent_quoted (identifier) @constant))
-    ])) @_tuple_decons
+    name:
+      [
+        (identifier) @constant
+        (accent_quoted
+          (identifier) @constant)
+        (exported_symbol
+          (identifier) @constant)
+        (exported_symbol
+          (accent_quoted
+            (identifier) @constant))
+      ])) @_tuple_decons
   (#has-ancestor? @_tuple_decons const_section))
 
 ; constants x and y in `array[x..y, type]`
@@ -703,37 +870,48 @@
     (argument_list
       .
       (infix_expression
-        right: [
-          (identifier) @constant
-          (accent_quoted (identifier) @constant)
-          (dot_expression right: (identifier) @constant)
-          (dot_expression right: (accent_quoted (identifier) @constant))
-        ]))
+        right:
+          [
+            (identifier) @constant
+            (accent_quoted
+              (identifier) @constant)
+            (dot_expression
+              right: (identifier) @constant)
+            (dot_expression
+              right:
+                (accent_quoted
+                  (identifier) @constant))
+          ]))
   (#any-of? @_array "array" "range"))
+
 (bracket_expression
   left: (identifier) @_array
   right:
     (argument_list
       .
       (infix_expression
-        left: [
-          (identifier) @constant
-          (accent_quoted (identifier) @constant)
-          (dot_expression right: (identifier) @constant)
-          (dot_expression right: (accent_quoted (identifier) @constant))
-        ]))
+        left:
+          [
+            (identifier) @constant
+            (accent_quoted
+              (identifier) @constant)
+            (dot_expression
+              right: (identifier) @constant)
+            (dot_expression
+              right:
+                (accent_quoted
+                  (identifier) @constant))
+          ]))
   (#any-of? @_array "array" "range"))
+
 ; NOTE: can only do this for (infix_expression)s, since standalone identifiers
 ; could be ordinal types and constants
-
 ; =============================================================================
 ; @constant.builtin ; built-in constant values
-
 (nil_literal) @constant.builtin
 
 ; =============================================================================
 ; @module        ; modules or namespaces
-
 (import_statement
   (expression_list
     (identifier) @module))
@@ -748,16 +926,19 @@
   (expression_list
     (infix_expression
       operator: (operator) @_operator
-      right: [
-        (identifier) @module
-        (array_construction (identifier) @module)
-      ]))
+      right:
+        [
+          (identifier) @module
+          (array_construction
+            (identifier) @module)
+        ]))
   (#eq? @_operator "/"))
 
 (import_from_statement
-  module: (infix_expression
-    operator: (operator) @_operator
-    right: (identifier) @module)
+  module:
+    (infix_expression
+      operator: (operator) @_operator
+      right: (identifier) @module)
   (#eq? @_operator "/"))
 
 (export_statement
@@ -766,15 +947,17 @@
 
 ; =============================================================================
 ; overrule things
-
 ; left identifier in dot_expression
-(dot_expression left: [
-  (identifier) @none
-  (accent_quoted (identifier) @none)
-])
+(dot_expression
+  left:
+    [
+      (identifier) @none
+      (accent_quoted
+        (identifier) @none)
+    ])
+
 ; NOTE: we can't know what the left identifier is, so better leave it alone
 ; for consistency
-
 ; discard literals is like a comment
 (discard_statement
   "discard" @comment
diff --git a/queries/nim/injections.scm b/queries/nim/injections.scm
index 5e347e965..776d36e3a 100644
--- a/queries/nim/injections.scm
+++ b/queries/nim/injections.scm
@@ -1,24 +1,27 @@
 ; =============================================================================
 ; generalized_strings
-
 ; regex in generalized_strings
 (generalized_string
-  function: (identifier) @_string_prefix .
+  function: (identifier) @_string_prefix
+  .
   (string_content) @injection.content
   (#set! injection.language "regex")
   (#any-of? @_string_prefix "re" "rex"))
 
 ; format string in generalized_strings
 (generalized_string
-  function: (identifier) @_string_prefix .
+  function: (identifier) @_string_prefix
+  .
   (string_content) @injection.content
   (#set! injection.language "nim_format_string")
   (#eq? @_string_prefix "fmt"))
 
 ; format string in normal strings with & prefix
 (prefix_expression
-  operator: (operator) @_string_prefix .
-  (_ (string_content) @injection.content)
+  operator: (operator) @_string_prefix
+  .
+  (_
+    (string_content) @injection.content)
   (#set! injection.language "nim_format_string")
   (#eq? @_string_prefix "&"))
 
@@ -31,45 +34,47 @@
 
 ; =============================================================================
 ; emit pragma
-
 ; C / CPP / OBJC / JAVASCRIPT
 ; a `#<no whitespace><language name>`
 ; has to directly precede the {.emit: "<language code>".} pragma
-
 ; eg.:
 ; #objc
 ; {.emit: "<objc code>".}
 ; OR
 ; #javascript
 ; {.emit: "<javascript code>".}
-
 ; normal strings
-((comment (comment_content) @injection.language)
+((comment
+  (comment_content) @injection.language)
   .
   (pragma_statement
     (pragma_list
       (colon_expression
-        left: (identifier) @_emit_keyword (#eq? @_emit_keyword "emit")
-        right: (_ (string_content) @injection.content)))))
-
+        left: (identifier) @_emit_keyword
+        (#eq? @_emit_keyword "emit")
+        right:
+          (_
+            (string_content) @injection.content)))))
 
 ; =============================================================================
 ; asm statement
-
 ; works same as emit pragma, needs preceding comment with language name
-((comment (comment_content) @injection.language)
+((comment
+  (comment_content) @injection.language)
   .
-  (assembly_statement (_ (string_content) @injection.content)))
+  (assembly_statement
+    (_
+      (string_content) @injection.content)))
 
 ; =============================================================================
 ; comments
-
 ; NOTE: ts "comment" parser heavily impacts performance
-
 ; markdown parser in documentation_comment
-(documentation_comment (comment_content) @injection.content
+(documentation_comment
+  (comment_content) @injection.content
   (#set! injection.language "markdown_inline"))
 
 ; markdown parser in block_documentation_comment
-(block_documentation_comment (comment_content) @injection.content
+(block_documentation_comment
+  (comment_content) @injection.content
   (#set! injection.language "markdown"))
diff --git a/queries/nim/locals.scm b/queries/nim/locals.scm
index 4ca6f6d44..d4d89b048 100644
--- a/queries/nim/locals.scm
+++ b/queries/nim/locals.scm
@@ -1,198 +1,243 @@
-
 ; ==============================================================================
 ; @local.definition            ; various definitions
-
 (block
-  label: [
-    (identifier) @local.definition
-    (accent_quoted) @local.definition
-  ])
+  label:
+    [
+      (identifier) @local.definition
+      (accent_quoted) @local.definition
+    ])
 
 ; ==============================================================================
 ; @local.definition.constant   ; constants
-
 (const_section
   (variable_declaration
     (symbol_declaration_list
       (symbol_declaration
-        name: [
-          (identifier) @local.definition.constant
-          (accent_quoted) @local.definition.constant
-          (exported_symbol (identifier) @local.definition.constant)
-          (exported_symbol (accent_quoted) @local.definition.constant)
-        ]))
+        name:
+          [
+            (identifier) @local.definition.constant
+            (accent_quoted) @local.definition.constant
+            (exported_symbol
+              (identifier) @local.definition.constant)
+            (exported_symbol
+              (accent_quoted) @local.definition.constant)
+          ]))
     type: (type_expression)? @local.definition.associated))
 
 ; ==============================================================================
 ; @local.definition.function   ; functions
-
 (proc_declaration
-  name: [
-    (identifier) @local.definition.function
-    (accent_quoted) @local.definition.function
-    (exported_symbol (identifier) @local.definition.function)
-    (exported_symbol (accent_quoted) @local.definition.function)
-  ]
+  name:
+    [
+      (identifier) @local.definition.function
+      (accent_quoted) @local.definition.function
+      (exported_symbol
+        (identifier) @local.definition.function)
+      (exported_symbol
+        (accent_quoted) @local.definition.function)
+    ]
   (#set! "definition.function.scope" "parent"))
 
 (func_declaration
-  name: [
-    (identifier) @local.definition.function
-    (accent_quoted) @local.definition.function
-    (exported_symbol (identifier) @local.definition.function)
-    (exported_symbol (accent_quoted) @local.definition.function)
-  ]
+  name:
+    [
+      (identifier) @local.definition.function
+      (accent_quoted) @local.definition.function
+      (exported_symbol
+        (identifier) @local.definition.function)
+      (exported_symbol
+        (accent_quoted) @local.definition.function)
+    ]
   (#set! "definition.function.scope" "parent"))
 
 (iterator_declaration
-  name: [
-    (identifier) @local.definition.function
-    (accent_quoted) @local.definition.function
-    (exported_symbol (identifier) @local.definition.function)
-    (exported_symbol (accent_quoted) @local.definition.function)
-  ]
+  name:
+    [
+      (identifier) @local.definition.function
+      (accent_quoted) @local.definition.function
+      (exported_symbol
+        (identifier) @local.definition.function)
+      (exported_symbol
+        (accent_quoted) @local.definition.function)
+    ]
   (#set! "definition.function.scope" "parent"))
 
 (converter_declaration
-  name: [
-    (identifier) @local.definition.function
-    (accent_quoted) @local.definition.function
-    (exported_symbol (identifier) @local.definition.function)
-    (exported_symbol (accent_quoted) @local.definition.function)
-  ]
+  name:
+    [
+      (identifier) @local.definition.function
+      (accent_quoted) @local.definition.function
+      (exported_symbol
+        (identifier) @local.definition.function)
+      (exported_symbol
+        (accent_quoted) @local.definition.function)
+    ]
   (#set! "definition.function.scope" "parent"))
 
 ; ==============================================================================
 ; @local.definition.method     ; methods
-
 (method_declaration
-  name: [
-    (identifier) @local.definition.method
-    (accent_quoted) @local.definition.method
-    (exported_symbol (identifier) @local.definition.method)
-    (exported_symbol (accent_quoted) @local.definition.method)
-  ]
+  name:
+    [
+      (identifier) @local.definition.method
+      (accent_quoted) @local.definition.method
+      (exported_symbol
+        (identifier) @local.definition.method)
+      (exported_symbol
+        (accent_quoted) @local.definition.method)
+    ]
   (#set! "definition.method.scope" "parent"))
 
 ; ==============================================================================
 ; @local.definition.var        ; variables
-
 (var_section
   (variable_declaration
     (symbol_declaration_list
       (symbol_declaration
-        name: [
-          (identifier) @local.definition.var
-          (accent_quoted) @local.definition.var
-          (exported_symbol (identifier) @local.definition.var)
-          (exported_symbol (accent_quoted) @local.definition.var)
-        ]))
+        name:
+          [
+            (identifier) @local.definition.var
+            (accent_quoted) @local.definition.var
+            (exported_symbol
+              (identifier) @local.definition.var)
+            (exported_symbol
+              (accent_quoted) @local.definition.var)
+          ]))
     type: (type_expression)? @local.definition.associated))
 
 (let_section
   (variable_declaration
     (symbol_declaration_list
       (symbol_declaration
-        name: [
-          (identifier) @local.definition.var
-          (accent_quoted) @local.definition.var
-          (exported_symbol (identifier) @local.definition.var)
-          (exported_symbol (accent_quoted) @local.definition.var)
-        ]))
+        name:
+          [
+            (identifier) @local.definition.var
+            (accent_quoted) @local.definition.var
+            (exported_symbol
+              (identifier) @local.definition.var)
+            (exported_symbol
+              (accent_quoted) @local.definition.var)
+          ]))
     type: (type_expression)? @local.definition.associated))
 
 (for
   (symbol_declaration_list
     (symbol_declaration
-      name: [
-        (identifier) @local.definition.var
-        (accent_quoted) @local.definition.var
-      ])))
+      name:
+        [
+          (identifier) @local.definition.var
+          (accent_quoted) @local.definition.var
+        ])))
 
 (try
   (except_branch
-    values: (expression_list
-      (infix_expression
-        right: [
-          (identifier) @local.definition.var
-          (accent_quoted) @local.definition.var
-        ]))))
+    values:
+      (expression_list
+        (infix_expression
+          right:
+            [
+              (identifier) @local.definition.var
+              (accent_quoted) @local.definition.var
+            ]))))
 
 ; ==============================================================================
 ; @local.definition.parameter  ; parameters
-
 (parameter_declaration
   (symbol_declaration_list
     (symbol_declaration
-      name: [
-        (identifier) @local.definition.parameter
-        (accent_quoted) @local.definition.parameter
-      ]))
+      name:
+        [
+          (identifier) @local.definition.parameter
+          (accent_quoted) @local.definition.parameter
+        ]))
   type: (type_expression)? @local.definition.associated)
 
 (concept_declaration
   parameters:
-    (parameter_list [
-      (identifier) @local.definition.parameter
-      (accent_quoted (identifier) @local.definition.parameter)
-    ]))
-(var_parameter [
-  (identifier) @local.definition.parameter
-  (accent_quoted (identifier) @local.definition.parameter)
-])
-(type_parameter [
-  (identifier) @local.definition.parameter
-  (accent_quoted (identifier) @local.definition.parameter)
-])
-(static_parameter [
-  (identifier) @local.definition.parameter
-  (accent_quoted (identifier) @local.definition.parameter)
-])
-(ref_parameter [
-  (identifier) @local.definition.parameter
-  (accent_quoted (identifier) @local.definition.parameter)
-])
-(pointer_parameter [
-  (identifier) @local.definition.parameter
-  (accent_quoted (identifier) @local.definition.parameter)
-])
+    (parameter_list
+      [
+        (identifier) @local.definition.parameter
+        (accent_quoted
+          (identifier) @local.definition.parameter)
+      ]))
+
+(var_parameter
+  [
+    (identifier) @local.definition.parameter
+    (accent_quoted
+      (identifier) @local.definition.parameter)
+  ])
+
+(type_parameter
+  [
+    (identifier) @local.definition.parameter
+    (accent_quoted
+      (identifier) @local.definition.parameter)
+  ])
+
+(static_parameter
+  [
+    (identifier) @local.definition.parameter
+    (accent_quoted
+      (identifier) @local.definition.parameter)
+  ])
+
+(ref_parameter
+  [
+    (identifier) @local.definition.parameter
+    (accent_quoted
+      (identifier) @local.definition.parameter)
+  ])
+
+(pointer_parameter
+  [
+    (identifier) @local.definition.parameter
+    (accent_quoted
+      (identifier) @local.definition.parameter)
+  ])
 
 ; ==============================================================================
 ; @local.definition.macro      ; preprocessor macros
-
 (template_declaration
-  name: [
-    (identifier) @local.definition.macro
-    (accent_quoted) @local.definition.macro
-    (exported_symbol (identifier) @local.definition.macro)
-    (exported_symbol (accent_quoted) @local.definition.macro)
-  ]
+  name:
+    [
+      (identifier) @local.definition.macro
+      (accent_quoted) @local.definition.macro
+      (exported_symbol
+        (identifier) @local.definition.macro)
+      (exported_symbol
+        (accent_quoted) @local.definition.macro)
+    ]
   (#set! "definition.macro.scope" "parent"))
 
 (macro_declaration
-  name: [
-    (identifier) @local.definition.macro
-    (accent_quoted) @local.definition.macro
-    (exported_symbol (identifier) @local.definition.macro)
-    (exported_symbol (accent_quoted) @local.definition.macro)
-  ]
+  name:
+    [
+      (identifier) @local.definition.macro
+      (accent_quoted) @local.definition.macro
+      (exported_symbol
+        (identifier) @local.definition.macro)
+      (exported_symbol
+        (accent_quoted) @local.definition.macro)
+    ]
   (#set! "definition.macro.scope" "parent"))
 
 ; ==============================================================================
 ; @local.definition.type       ; types or classes
-
 (type_declaration
   (type_symbol_declaration
-    name: [
-      (identifier) @local.definition.type
-      (accent_quoted) @local.definition.type
-      (exported_symbol (identifier) @local.definition.type)
-      (exported_symbol (accent_quoted) @local.definition.type)
-    ]))
+    name:
+      [
+        (identifier) @local.definition.type
+        (accent_quoted) @local.definition.type
+        (exported_symbol
+          (identifier) @local.definition.type)
+        (exported_symbol
+          (accent_quoted) @local.definition.type)
+      ]))
 
 ; ==============================================================================
 ; @local.definition.field      ; fields or properties
-
 ; object_declaration
 ; variant_declaration
 ; conditional_declaration
@@ -201,29 +246,31 @@
 (field_declaration
   (symbol_declaration_list
     (symbol_declaration
-      name: [
-        (identifier) @local.definition.field
-        (accent_quoted) @local.definition.field
-        (exported_symbol (identifier) @local.definition.field)
-        (exported_symbol (accent_quoted) @local.definition.field)
-      ]))
+      name:
+        [
+          (identifier) @local.definition.field
+          (accent_quoted) @local.definition.field
+          (exported_symbol
+            (identifier) @local.definition.field)
+          (exported_symbol
+            (accent_quoted) @local.definition.field)
+        ]))
   type: (type_expression)? @local.definition.associated)
 
 ; ==============================================================================
 ; @local.definition.enum       ; enumerations
-
 (enum_declaration
   (enum_field_declaration
     (symbol_declaration
-      name: [
-        (identifier) @local.definition.enum
-        (accent_quoted) @local.definition.enum
-      ])))
+      name:
+        [
+          (identifier) @local.definition.enum
+          (accent_quoted) @local.definition.enum
+        ])))
 
 ; ==============================================================================
 ; @local.definition.namespace  ; modules or namespaces
 ; @local.definition.import     ; imported names
-
 (import_statement
   (expression_list
     (identifier) @local.definition.namespace))
@@ -238,28 +285,30 @@
   (expression_list
     (infix_expression
       operator: (operator) @_operator
-      right: [
-        (identifier) @local.definition.namespace
-        (array_construction (identifier) @local.definition.namespace)
-      ]))
+      right:
+        [
+          (identifier) @local.definition.namespace
+          (array_construction
+            (identifier) @local.definition.namespace)
+        ]))
   (#eq? @_operator "/"))
 
 (import_from_statement
-  module: (infix_expression
-    operator: (operator) @_operator
-    right: (identifier) @local.definition.namespace)
-  (expression_list [
-    (identifier) @local.definition.import
-    (accent_quoted) @local.definition.import
-  ])
+  module:
+    (infix_expression
+      operator: (operator) @_operator
+      right: (identifier) @local.definition.namespace)
+  (expression_list
+    [
+      (identifier) @local.definition.import
+      (accent_quoted) @local.definition.import
+    ])
   (#eq? @_operator "/"))
 
 ; ==============================================================================
 ; @local.scope                 ; scope block
-
 ; (when)
 ; NOTE: `when` does actually not create a scope
-
 (if
   consequence: (statement_list) @local.scope
   alternative: (elif_branch)* @local.scope
@@ -280,7 +329,6 @@
   (while)
   (block)
   (static_statement)
-
   (proc_declaration)
   (func_declaration)
   (method_declaration)
@@ -288,16 +336,14 @@
   (converter_declaration)
   (template_declaration)
   (macro_declaration)
-
   (proc_expression)
   (func_expression)
   (iterator_expression)
-
   (concept_declaration)
 ] @local.scope
 
 ; ==============================================================================
 ; @local.reference             ; identifier reference
-
 (identifier) @local.reference
+
 (accent_quoted) @local.reference