Align queries with 'nvim-treesitter'

I fear the upstream queries may be broken, somehow, as they don't work
with `--apply-all-captures` which should match the "last query wins"
matching behaviour of `nvim-treesitter`.

I also removed `locals.scm`, as `tree-sitter` and `nvim-treesitter` don't
agree on how to write it, and I don't really care about it.

It does mean that the highlights can't tell the difference between `int`
the built-in and `int` the type alias anymore, but that's a small
edge-case (and `nvim-treesitter` didn't support it anyway).

Makefile

@@ -1,16 +1,17 @@
-.PHONE: all
+.PHONY: all
 all:
 	tree-sitter generate
 
-.PHONE: test
+.PHONY: test
 test: all
 	tree-sitter test
 	nvim-test
 
-.PHONE: update-tests
+.PHONY: update-tests
 update-tests: all
 	tree-sitter test -u
 
+.PHONY: playground
 playground:
 	nix shell pkgs#emscripten --command tree-sitter build-wasm
 	tree-sitter playground

flake.lock

@@ -1,28 +1,31 @@
 {
   "nodes": {
     "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
       "locked": {
-        "lastModified": 1667395993,
-        "narHash": "sha256-nuEHfE/LcWyuSWnS8t12N1wc105Qtau+/OdUAjtQ0rA=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "5aed5285a952e0b949eb3ba02c12fa4fcfef535f",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
         "owner": "numtide",
-        "ref": "master",
+        "ref": "main",
         "repo": "flake-utils",
         "type": "github"
       }
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1669045945,
-        "narHash": "sha256-BQxzijvZpLQ7R+KuQzCPcFgIS6OK0Onb29pYFe2pzJo=",
+        "lastModified": 1712482522,
+        "narHash": "sha256-Ai/xNgZpbwGcw0TSXwEPwwbPi8Iu906sB9M9z3o6UgA=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "6b5019a48f876f3288efc626fa8b70ad0c64eb46",
+        "rev": "efe8ce06ca261f370d672def5b1e0be300c726e1",
         "type": "github"
       },
       "original": {
@@ -62,6 +65,21 @@
         "nixpkgs": "nixpkgs",
         "pre-commit-hooks": "pre-commit-hooks"
       }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
     }
   },
   "root": "root",

flake.nix

@@ -6,7 +6,7 @@
       type = "github";
       owner = "numtide";
       repo = "flake-utils";
-      ref = "master";
+      ref = "main";
     };
 
     nixpkgs = {

queries/folds.scm

@@ -8,9 +8,7 @@
   (let_expression)
   (function_declaration)
   (primitive_declaration)
-
   (record_type)
-
   (class_declaration)
   (class_type)
   (method_declaration)

queries/highlights.scm

@@ -1,23 +1,22 @@
 ; Built-ins {{{
 ((function_call
   function: (identifier) @function.builtin)
-  (#match? @function.builtin "^(chr|concat|exit|flush|getchar|not|ord|print|print_err|print_int|size|strcmp|streq|substring)$")
-  (#is-not? local))
+  (#any-of? @function.builtin
+    "chr" "concat" "exit" "flush" "getchar" "not" "ord" "print" "print_err" "print_int" "size"
+    "strcmp" "streq" "substring"))
 
 ((type_identifier) @type.builtin
-  (#match? @type.builtin "^(int|string|Object)$")
-  (#is-not? local))
+  (#any-of? @type.builtin "int" "string" "Object"))
 
 ((identifier) @variable.builtin
-  (#match? @variable.builtin "^self$")
-  (#is-not? local))
-; }}}
+  (#eq? @variable.builtin "self"))
 
+; }}}
 ; Keywords {{{
 [
- "function"
- "method"
- "primitive"
+  "function"
+  "primitive"
+  "method"
 ] @keyword.function
 
 [
@@ -27,14 +26,9 @@
   "while"
 ] @keyword.repeat
 
-[
- "new"
-] @keyword.constructor
+"new" @keyword.operator
 
-
-[
-  "import"
-] @include
+"import" @keyword.import
 
 [
   "array"
@@ -48,73 +42,80 @@
   "then"
   "type"
   "var"
-
-  "class"
   "extends"
-
   "_cast"
   "_chunks"
   "_exp"
   "_lvalue"
   "_namety"
 ] @keyword
-; }}}
 
+"class" @keyword.type
+
+; }}}
 ; Operators {{{
 (operator) @operator
 
 [
- ","
- ";"
- ":"
- "."
+  ","
+  ";"
+  ":"
+  "."
 ] @punctuation.delimiter
 
 [
- "("
- ")"
- "["
- "]"
- "{"
- "}"
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
 ] @punctuation.bracket
-; }}}
 
+; }}}
 ; Functions and methods {{{
 (function_call
   function: (identifier) @function)
+
 (function_declaration
   name: (identifier) @function)
+
 (primitive_declaration
   name: (identifier) @function)
 
 (method_call
-  method: (identifier) @method)
+  method: (identifier) @function.method)
+
 (method_declaration
-  name: (identifier) @method)
+  name: (identifier) @function.method)
 
 (parameters
-  name: (identifier) @parameter)
-; }}}
+  name: (identifier) @variable.parameter)
 
+; }}}
 ; Declarations {{{
 (import_declaration
   file: (string_literal) @string.special.path)
-; }}}
 
+; }}}
 ; Literals {{{
 (nil_literal) @constant.builtin
-(integer_literal) @number
-(string_literal) @string
-(escape_sequence) @string.escape
-; }}}
 
+(integer_literal) @number
+
+(string_literal) @string
+
+(escape_sequence) @string.escape
+
+; }}}
 ; Misc {{{
-(comment) @comment
+(comment) @comment ; @spell
 
 (type_identifier) @type
-(field_identifier) @property
-(identifier) @variable
-; }}}
 
+(field_identifier) @variable.member
+
+(identifier) @variable
+
+; }}}
 ; vim: sw=2 foldmethod=marker

queries/indents.scm

@@ -1,69 +1,104 @@
 ; Control flow {{{
-(if_expression) @indent
-"then" @branch
-"else" @branch
+(if_expression) @indent.begin
 
-(while_expression) @indent
-"do" @branch
+"then" @indent.branch
+
+"else" @indent.branch
+
+(while_expression) @indent.begin
+
+"do" @indent.branch
+
+(for_expression) @indent.begin
+
+"to" @indent.branch
 
-(for_expression) @indent
-"to" @branch
 ; }}}
-
 ; Class {{{
-(class_declaration) @indent
-(class_declaration "}" @indent_end)
+(class_declaration) @indent.begin
+
+(class_declaration
+  "}" @indent.end)
+
+(class_type) @indent.begin
+
+(class_type
+  "}" @indent.end)
 
-(class_type) @indent
-(class_type "}" @indent_end)
 ; }}}
-
 ; Groups {{{
-(let_expression) @indent
-"in" @branch
-"end" @branch
-(let_expression "end" @indent_end)
+(let_expression) @indent.begin
+
+"in" @indent.branch
+
+"end" @indent.branch
+
+(let_expression
+  "end" @indent.end)
+
+(sequence_expression) @indent.begin
+
+")" @indent.branch
+
+(sequence_expression
+  ")" @indent.end)
 
-(sequence_expression) @indent
-")" @branch
-(sequence_expression ")" @indent_end)
 ; }}}
-
 ; Functions and methods {{{
-(parameters) @indent
-(parameters ")" @indent_end)
+(parameters) @indent.begin
 
-(function_call) @indent
-(method_call) @indent
-")" @branch
+(parameters
+  ")" @indent.end)
+
+(function_call) @indent.begin
+
+(function_call
+  ")" @indent.end)
+
+(method_call) @indent.begin
+
+")" @indent.branch
+
+(function_declaration) @indent.begin
+
+(primitive_declaration) @indent.begin
+
+(method_declaration) @indent.begin
 
-(function_declaration) @indent
-(primitive_declaration) @indent
-(method_declaration) @indent
 ; }}}
-
 ; Values and expressions {{{
-(array_value) @indent
-"]" @branch
-(array_value "]" @indent_end)
+(array_value) @indent.begin
 
-(array_expression) @indent
-"of" @branch
+"]" @indent.branch
 
-(record_expression) @indent
-"}" @branch
-(record_expression "}" @indent_end)
+(array_value
+  "]" @indent.end)
 
-(record_type) @indent
-"}" @branch
-(record_type "}" @indent_end)
+(array_expression) @indent.begin
+
+"of" @indent.branch
+
+(record_expression) @indent.begin
+
+"}" @indent.branch
+
+(record_expression
+  "}" @indent.end)
+
+(record_type) @indent.begin
+
+"}" @indent.branch
+
+(record_type
+  "}" @indent.end)
+
+(variable_declaration) @indent.begin
 
-(variable_declaration) @indent
 ; }}}
-
 ; Misc{{{
-(comment) @ignore
-(string_literal) @ignore
-; }}}
+(comment) @indent.ignore
 
+(string_literal) @indent.ignore
+
+; }}}
 ; vim: sw=2 foldmethod=marker

queries/injections.scm

@@ -1,3 +1,4 @@
-(comment) @comment
+((comment) @injection.content
+  (#set! injection.language "comment"))
 
 ; vim: sw=2 foldmethod=marker

queries/locals.scm

@@ -1,35 +0,0 @@
-; See this issue [1] for support for "lazy scoping" which is somewhat needed
-; for Tiger semantics (e.g: one can call a function before it has been defined
-; top-to-bottom).
-;
-; [1]: https://github.com/tree-sitter/tree-sitter/issues/918
-
-; Scopes {{{
-[
- (for_expression)
- (let_expression)
- (function_declaration)
-] @local.scope
-; }}}
-
-; Definitions {{{
-(type_declaration
-  name: (identifier) @local.definition)
-
-(parameters
-  name: (identifier) @local.definition)
-
-(function_declaration
-  name: (identifier) @local.definition)
-(primitive_declaration
-  name: (identifier) @local.definition)
-
-(variable_declaration
-  name: (identifier) @local.definition)
-; }}}
-
-; References {{{
-(identifier) @local.reference
-; }}}
-
-; vim: sw=2 foldmethod=marker

src/tree_sitter/parser.h

@@ -13,9 +13,8 @@ extern "C" {
 #define ts_builtin_sym_end 0
 #define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
 
-typedef uint16_t TSStateId;
-
 #ifndef TREE_SITTER_API_H_
+typedef uint16_t TSStateId;
 typedef uint16_t TSSymbol;
 typedef uint16_t TSFieldId;
 typedef struct TSLanguage TSLanguage;
@@ -130,9 +129,16 @@ struct TSLanguage {
  *  Lexer Macros
  */
 
+#ifdef _MSC_VER
+#define UNUSED __pragma(warning(suppress : 4101))
+#else
+#define UNUSED __attribute__((unused))
+#endif
+
 #define START_LEXER()           \
   bool result = false;          \
   bool skip = false;            \
+  UNUSED                        \
   bool eof = false;             \
   int32_t lookahead;            \
   goto start;                   \
@@ -166,7 +172,7 @@ struct TSLanguage {
  *  Parse Table Macros
  */
 
-#define SMALL_STATE(id) id - LARGE_STATE_COUNT
+#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT)
 
 #define STATE(id) id
 
@@ -176,7 +182,7 @@ struct TSLanguage {
   {{                                  \
     .shift = {                        \
       .type = TSParseActionTypeShift, \
-      .state = state_value            \
+      .state = (state_value)          \
     }                                 \
   }}
 
@@ -184,7 +190,7 @@ struct TSLanguage {
   {{                                  \
     .shift = {                        \
       .type = TSParseActionTypeShift, \
-      .state = state_value,           \
+      .state = (state_value),         \
       .repetition = true              \
     }                                 \
   }}

test/highlight/built-ins.tig

@@ -6,7 +6,7 @@ let
   /*                  ^ type.builtin */
 
   var b := exit(0)
-  /*       ^ function */
+  /*       ^ function.builtin */
 
   type int = string /* Shadowing the built-in type */
   /*         ^ type.builtin */
@@ -30,13 +30,13 @@ in
   end;
 
   exit(1);
-  /* <- function */
+  /* <- function.builtin */
 
   print("shadowing is fun");
   /* <- function.builtin */
 
   self;
-  /* <- variable */
+  /* <- variable.builtin */
 
   b := print
   /*   ^ variable */

test/highlight/functions.tig

@@ -1,8 +1,8 @@
 primitive print(s: string)
 /*        ^ function */
-/*              ^ parameter */
+/*              ^ variable.parameter */
 
 function func(a: int) : int = (print("Hello World!"); a)
 /*       ^ function */
-/*            ^ parameter */
-/*                             ^ function */
+/*            ^ variable.parameter */
+/*                             ^ function.builtin */

test/highlight/identifiers.tig

@@ -6,24 +6,24 @@ type int_array = array of int
 /*                        ^ type.builtin */
 
 type record = {a: int, b: string}
-/*             ^ property */
+/*             ^ variable.member */
 /*                ^ type.builtin */
-/*                     ^ property */
+/*                     ^ variable.member */
 /*                        ^ type.builtin */
 
 var record := record {a = 12, b = "27"}
 /*  ^ variable */
 /*            ^ type */
-/*                    ^ property */
-/*                            ^ property */
+/*                    ^ variable.member */
+/*                            ^ variable.member */
 
 var array := int_array[12] of 27;
 /*  ^ variable */
 /*           ^ type */
 
 primitive func(a: int, b: string) : array
-/*             ^ parameter */
+/*             ^ variable.parameter */
 /*                ^ type.builtin */
-/*                     ^ parameter */
+/*                     ^ variable.parameter */
 /*                        ^ type.builtin */
 /*                                  ^ type */

test/highlight/imports.tig

@@ -1,3 +1,3 @@
 import "lib.tih"
-/* <- include */
+/* <- keyword.import */
 /*      ^ string.special.path */

test/highlight/keywords.tig

@@ -10,7 +10,7 @@ let
   /* <- keyword.function */
 
   import "lib.tih"
-  /* <- include */
+  /* <- keyword.import */
 
   type array_of_int = array of int
   /* <- keyword */

test/highlight/object-oriented.tig

@@ -1,11 +1,11 @@
 let
   class A extends Object {}
-  /* <- keyword */
+  /* <- keyword.type */
   /*      ^ keyword */
   /*              ^ type.builtin */
 
   type B = class extends A {
-  /*       ^ keyword */
+  /*       ^ keyword.type */
   /*             ^ keyword */
   /*                     ^ type */
 
@@ -13,16 +13,16 @@ let
 
     method meth() : int = self.a
     /* <- keyword.function */
-    /*     ^ method */
+    /*     ^ function.method */
     /*                    ^ variable.builtin */
   }
 
   var object := new B
-  /*            ^ keyword.constructor */
+  /*            ^ keyword.operator */
 in
   object.a := 27;
-  /*     ^ property */
+  /*     ^ variable.member */
 
   object.meth()
-  /*     ^ method */
+  /*     ^ function.method */
 end