Add queries to rust bindings

I should try using those bindings to write tests for currently untested
queries...

Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "tree-sitter-tiger"
-description = "tiger grammar for the tree-sitter parsing library"
+description = "Tiger grammar for the tree-sitter parsing library"
 version = "0.0.1"
 keywords = ["incremental", "parsing", "tiger"]
 categories = ["parsing", "text-editors"]
-repository = "https://github.com/tree-sitter/tree-sitter-tiger"
+repository = "https://gitea.belanyi.fr/ambroisie/tree-sitter-tiger"
 edition = "2018"
 license = "MIT"
 

binding.gyp

@@ -9,7 +9,7 @@
       "sources": [
         "bindings/node/binding.cc",
         "src/parser.c",
-        # If your language uses an external scanner, add it here.
+        "src/scanner.c",
       ],
       "cflags_c": [
         "-std=c99",

bindings/rust/build.rs

@@ -13,11 +13,9 @@ fn main() {
     // If your language uses an external scanner written in C,
     // then include this block of code:
 
-    /*
     let scanner_path = src_dir.join("scanner.c");
     c_config.file(&scanner_path);
     println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
-    */
 
     c_config.compile("parser");
     println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap());

bindings/rust/lib.rs

@@ -35,10 +35,13 @@ pub const NODE_TYPES: &'static str = include_str!("../../src/node-types.json");
 
 // Uncomment these to include any queries that this grammar contains
 
-// pub const HIGHLIGHTS_QUERY: &'static str = include_str!("../../queries/highlights.scm");
-// pub const INJECTIONS_QUERY: &'static str = include_str!("../../queries/injections.scm");
-// pub const LOCALS_QUERY: &'static str = include_str!("../../queries/locals.scm");
-// pub const TAGS_QUERY: &'static str = include_str!("../../queries/tags.scm");
+pub const FOLDS_QUERY: &'static str = include_str!("../../queries/folds.scm");
+pub const HIGHLIGHTS_QUERY: &'static str = include_str!("../../queries/highlights.scm");
+pub const INDENTS_QUERY: &'static str = include_str!("../../queries/indents.scm");
+pub const INJECTIONS_QUERY: &'static str = include_str!("../../queries/injections.scm");
+pub const LOCALS_QUERY: &'static str = include_str!("../../queries/locals.scm");
+pub const TAGS_QUERY: &'static str = include_str!("../../queries/tags.scm");
+pub const TEXTOBJECTS_QUERY: &'static str = include_str!("../../queries/textobjects.scm");
 
 #[cfg(test)]
 mod tests {

grammar.js

@@ -338,4 +338,4 @@ module.exports = grammar({
   }
 });
 
-// vim: sw=2
+// vim: foldmethod=marker sw=2

queries/folds.scm

@@ -0,0 +1,18 @@
+[
+  (array_expression)
+  (record_expression)
+  (sequence_expression)
+  (if_expression)
+  (while_expression)
+  (for_expression)
+  (let_expression)
+  (function_declaration)
+  (primitive_declaration)
+] @fold
+
+[
+ (comment)
+ (string_literal)
+] @ignore
+
+; vim: sw=2 foldmethod=marker

queries/highlights.scm

@@ -3,6 +3,10 @@
   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))
+
+((type_identifier) @type.builtin
+  (#match? @type.builtin "^(int|string)$")
+  (#is-not? local))
 ; }}}
 
 ; Keywords {{{

queries/indents.scm

@@ -0,0 +1,18 @@
+; Control flow {{{
+(if_expression
+  consequence: (_) @indent)
+"else" @branch
+
+(while_expression
+  body: (_) @indent)
+
+(for_expression
+  body: (_) @indent)
+; }}}
+
+; Misc{{{
+(comment) @ignore
+(string_literal) @ignore
+; }}}
+
+; vim: sw=2 foldmethod=marker

queries/injections.scm

@@ -0,0 +1,3 @@
+(comment) @comment
+
+; vim: sw=2 foldmethod=marker

queries/locals.scm

@@ -1,3 +1,9 @@
+; 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)

queries/tags.scm

@@ -0,0 +1,11 @@
+; Functions {{{
+(function_declaration
+  name: (identifier) @name) @definition.function
+(primitive_declaration
+  name: (identifier) @name) @definition.function
+
+(function_call
+  function: (identifier) @name) @reference.call
+; }}}
+
+; vim: sw=2 foldmethod=marker

queries/textobjects.scm

@@ -0,0 +1,28 @@
+; Functions {{{
+ (function_declaration
+   parameters: ((_) @parameter.inner)* @parameter.outer
+   body: (_) @function.inner) @function.outer
+ (primitive_declaration
+   parameters: ((_) @parameter.inner)* @parameter.outer) @function.outer
+
+(function_call
+  arguments: ((_) @call.inner)*) @call.outer
+; }}}
+
+; Control flow {{{
+(if_expression
+  consequence: (_) @conditional.inner
+  alternative: (_)? @conditional.inner) @conditional.outer
+
+(while_expression
+  body: (_) @loop.inner) @loop.outer
+
+(for_expression
+  body: (_) @loop.inner) @loop.outer
+; }}}
+
+; Misc {{{
+(comment) @comment.outer
+; }}}
+
+; vim: sw=2 foldmethod=marker

test/highlight/built-ins.tig

@@ -3,11 +3,23 @@ let
   /*       ^ function.builtin */
 
   primitive exit(ret: int) /* Shadowing the prelude-included built-in */
+  /*                  ^ type.builtin */
 
   var b := exit(0)
   /*       ^ function */
 
+  type int = string /* Shadowing the built-in type */
+  /*         ^ type.builtin */
+
+  var c : int := "This is an \"int\""
+  /*      ^ type.builtin (not sure why it isn't 'type')*/
 in
+  let
+    var c : int := "This is an int"
+    /*      ^ type.builtin (not sure why it isn't 'type')*/
+  in
+  end;
+
   exit(1);
   /* <- function */
 

test/highlight/identifiers.tig

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

test/tags/functions.tig

@@ -0,0 +1,12 @@
+let
+  primitive print(s: string)
+  /*        ^ definition.function */
+
+  function func(a: int) : int = (print("Hello World!"); a)
+  /*       ^ definition.function */
+in
+  print("Hello World!\n");
+  /* <- reference.call */
+  func(42)
+  /* <- reference.call */
+end