Refactor: Remove redundant forall_keyword from various definitions

- Eliminated unnecessary forall_keyword nodes from function and block definitions in function.txt, basic_concepts.txt, functions.txt, general-description.txt, and statements.txt to streamline the syntax tree.
- Adjusted formatting in struct.txt for consistency in identifier declarations.
- Updated author email in tree-sitter.json for Georgii Plotnikov.

Author: 0xGeorgii

Cargo.toml

@@ -20,7 +20,7 @@ include = ["bindings/rust/*", "grammar.js", "queries/*", "src/*"]
 path = "bindings/rust/lib.rs"
 
 [dependencies]
-tree-sitter = ">=0.24.6"
+tree-sitter = ">=0.25.6"
 
 [build-dependencies]
-cc = "1.2.6"
+cc = "1.2.26"

grammar.js

@@ -185,7 +185,7 @@ module.exports = grammar({
       choice($.attribute_access_operator, $.expand_operator),
       field('name', $._simple_name),
     )),
-    
+
     function_call_expression: $ => prec.dynamic(PRECEDENCE.FUNC_CALL, seq(
       field('function', $._lval_expression),
       optional(field('type_parameters', alias($.type_argument_list, $.type_parameters))),
@@ -207,14 +207,14 @@ module.exports = grammar({
       $._expression,
       $._terminal_symbol
     ),
-    
+
     assign_statement: $ => prec.left(seq(
       field('left', $._lval_expression),
       $.assign_operator,
       field('right', $._expression),
       $._terminal_symbol,
     )),
-    
+
     assert_statement: $ => seq(
       'assert',
       $._expression,
@@ -374,28 +374,28 @@ module.exports = grammar({
     ),
 
     ignore_argument: $ => seq(
-      '_', 
+      '_',
       $._typedef_symbol,
       field('type', $._type)
     ),
 
     assume_block: $ => seq(
-      'assume',
+      $._assume_keyword,
       field('body', $.block),
     ),
 
     forall_block: $ => seq(
-      $.forall_keyword,
+      $._forall_keyword,
       field('body', $.block),
     ),
 
     exists_block: $ => seq(
-      'exists',
+      $._exists_keyword,
       field('body', $.block),
     ),
-    
+
     unique_block: $ => seq(
-      'unique',
+      $._unique_keyword,
       field('body', $.block),
     ),
 
@@ -445,7 +445,10 @@ module.exports = grammar({
     ),
 
     function_keyword: _ => 'fn',
-    forall_keyword: _ => 'forall',
+    _forall_keyword: _ => 'forall',
+    _assume_keyword: _ => 'assume',
+    _exists_keyword: _ => 'exists',
+    _unique_keyword: _ => 'unique',
     uzumaki_keyword: _ => '@',
     mut_keyword: _ => 'mut',
 
@@ -483,9 +486,9 @@ module.exports = grammar({
     _rcb_symbol: _ => '}',
     _lrb_symbol: _ => '(',
     _rrb_symbol: _ => ')',
-    _comma_symbol: $ => ',',
-    _typedef_symbol: $ => ':',
-    _terminal_symbol: $ => ';',
+    _comma_symbol: _ => ',',
+    _typedef_symbol: _ => ':',
+    _terminal_symbol: _ => ';',
 
 
     bool_literal: _ => choice(
@@ -503,7 +506,7 @@ module.exports = grammar({
 
     number_literal: $ => seq(optional('-'), /\d+/),
 
-    unit_literal: $ => '()',
+    unit_literal: _ => '()',
 
     array_literal: $ => seq(
       '[',
@@ -544,7 +547,6 @@ module.exports = grammar({
     type_argument_list_definition: $ => seq(
       '<',
       choice(
-        repeat(','),
         sep1(field('type', $.identifier), $._comma_symbol),
       ),
       '>',
@@ -553,7 +555,6 @@ module.exports = grammar({
     type_argument_list: $ => seq(
       '<',
       choice(
-        repeat(','),
         sep1(field('type', $._type), $._comma_symbol),
       ),
       '>',

package-lock.json

@@ -54,10 +54,10 @@
     }
   },
   "devDependencies": {
-    "eslint": "9.27.0",
+    "eslint": "9.28.0",
     "eslint-config-google": "^0.14.0",
     "prebuildify": "^6.0.1",
-    "tree-sitter-cli": "0.25.4"
+    "tree-sitter-cli": "0.25.5"
   },
   "files": [
     "grammar.js",

package.json

@@ -1,80 +1,77 @@
 ;; Comments
 (comment) @comment
 
-;; Punctuation symbols
-[ ";" ":" "," "{" "}" "(" ")" "[" "]" "<" ">" ] @punctuation
-
-[ "struct" "enum" "const" "spec" "return" "self" "loop" "let" "assume" "exists" "unique" "if" "else" "break" "use" "from" "assert" "type" "external" ] @keyword
-
-;; Operators (node types from grammar.js)
-(assign_operator) @operator
-(rightarrow_operator) @operator
-(expand_operator) @operator
-(attribute_access_operator) @operator
-(add_operator) @operator
-(sub_operator) @operator
-(mul_operator) @operator
-(pow_operator) @operator
-(mod_operator) @operator
-(equals_operator) @operator
-(not_equals_operator) @operator
-(less_operator) @operator
-(greater_operator) @operator
-(less_equal_operator) @operator
-(greater_equal_operator) @operator
-(and_operator) @operator
-(or_operator) @operator
-(bit_and_operator) @operator
-(bit_or_operator) @operator
-(bit_xor_operator) @operator
-(shift_left_operator) @operator
-(shift_right_operator) @operator
-(unary_not) @operator
-
-;; Keywords (token nodes)
-
-((function_keyword) @keyword)
-((forall_keyword) @keyword)
-((mut_keyword) @keyword)
-
-;; Boolean literals
-(bool_literal) @boolean
+;; Punctuation
+
+[ ";" "," ] @punctuation.delimiter
+[ "(" ")" "{" "}" "[" "]" ] @punctuation.bracket
+"->" @punctuation.special
+
+;; Keywords
+"const" @keyword.modifier
+
+(forall_block
+  ("forall" @keyword.modifier))
+
+(assume_block
+  ("assume" @keyword.modifier) )
+
+(unique_block
+  ("unique" @keyword.modifier) )
 
+(exists_block
+  ("exists" @keyword.modifier))
+
+"spec" @keyword.type
+"struct" @keyword.type
+"enum" @keyword.type
+"return" @keyword.return
+(function_keyword) @keyword.function
+[ "use" "external" ] @keyword.import
+[ "if" "else" ] @keyword.conditional
+"let" @keyword
+"type" @keyword
 ;; Types
-(type_i8) @type (type_i16) @type (type_i32) @type (type_i64) @type
-(type_u8) @type (type_u16) @type (type_u32) @type (type_u64) @type
-(type_bool) @type (type_unit) @type
+
+(type_i8) @type.builtin
+(type_i16) @type.builtin
+(type_i32) @type.builtin
+(type_i64) @type.builtin
+(type_u8) @type.builtin
+(type_u16) @type.builtin
+(type_u32) @type.builtin
+(type_u64) @type.builtin
+(type_bool) @type.builtin
+(type_unit) @type.builtin
+(type_array) @type.builtin
+(type_fn) @type.builtin
 
 ;; Literals
-(string_literal) @string
 (number_literal) @number
-(unit_literal) @constant
-(uzumaki_keyword) @constant
-
-;; Identifiers
-(identifier) @identifier
+(bool_literal) @boolean
+(unit_literal) @number.float
 
-;; Name definitions
-(variable_definition_statement
-  name: (identifier) @variable)
+;; Definitions
 (constant_definition
   name: (identifier) @constant)
+
+(enum_definition
+  name: (identifier) @type.definition
+  variant: (identifier) @variable.member)
+
 (function_definition
   name: (identifier) @function)
-(external_function_definition
-  name: (identifier) @function)
-(type_definition_statement
-  name: (identifier) @type.definition)
-(enum_definition
-  name: (identifier) @type.definition)
+
 (struct_definition
+  name: (identifier) @type.definition
+  (struct_field
+    name: (identifier) @variable.member
+    type: (identifier) @type))
+
+(spec_definition
   name: (identifier) @type.definition)
-(member_access_expression
-  expression: ( (identifier) @type.definition)
-)
+
+;; Expressions
 (function_call_expression
-  function: ( (identifier) @function)
-)
-(qualified_name
-  qualifier: ( (identifier) @type.definition)
-  name: (identifier) @type.definition)
+  function: (identifier) @function.call)
+