@willbooster/tree-sitter-haskell 6.0.4 → 7.0.1

package/README.md

@@ -29,10 +29,6 @@ The fork's main differences from upstream 0.23.1 are:
   Unmarked continuation lines remain in their preceding Haddock block, including space or tab indentation and LF or CRLF newlines.
   First-column ordinary comments combine with LF line endings.
   CRLF and indented ordinary comments remain separate comment nodes.
-- **`queries/highlights.scm`**: three patterns that match fields of the supertype `decl` are written through its
-  subtypes (`decl/function`, `decl/bind`, `decl/signature`), as upstream's repository has them since
-  `tree-sitter/tree-sitter-haskell@0b2ebf7`. A parser of ABI 15 or later carries the supertypes, and the runtime then
-  rejects the 0.23.1 patterns as impossible; upstream's own CLI 0.27.0 does so as well.
 - **`test/corpus/varsym.txt`**: the expected recovery tree for the invalid `f = a | a` input matches this generator; the input still reports an error.
 - **`test/corpus/null-characters.txt`** is added, because the fuzz job checks that every NUL character of the corpus
   reaches the fuzz seeds and upstream's corpus has none.
@@ -83,12 +79,14 @@ parser.setLanguage(await Language.load(haskell));
 
 The package also ships `grammar.js` with the files in `grammar/` it loads, the queries in `queries/`, and the node types in `src/node-types.json`.
 
-For code navigation, use `queries/tags.scm` (or `TAGS_QUERY` in Rust). It indexes module headers, top-level named functions and simple named bindings, named types and classes, class and instance methods, and syntactic variable/operator calls. A signature and each equation have separate definition locations. Call references identify the called name without resolving its binding.
+For code navigation, use `queries/tags.scm` (or `TAGS_QUERY` in Rust). It indexes module headers, top-level named functions and bindings, named types and classes, class and instance methods, and syntactic variable/operator calls. A signature and each equation have separate definition locations. Call references identify the called name without resolving its binding.
 
-Declaration names and variable/operator callees remain indexed through nested parentheses. Class and instance equations retain their method roles; grouping a value without applying it does not create a call reference. Destructuring bindings, local pattern bindings and constructors (including pattern synonyms) are not indexed.
+Declaration names and variable/operator callees remain indexed through nested parentheses. Class and instance equations retain their method roles; grouping a value without applying it does not create a call reference. Destructuring bindings contribute their explicit names at every nesting depth, including as-pattern binders and record puns. Local pattern bindings, names bound by patterns inside declaration quotes and constructors (including pattern synonyms) are not indexed.
 
 Function and type declaration-head parentheses are anonymous syntax: the enclosing declaration directly exposes its `name`, parameter groups and infix `head` fields. Parentheses inside parameters and types retain their existing nodes. A grouped variable name, including a qualified name, uses one `parenthesized_name` node with a direct name child, independent of grouping depth. A symbolic variable operator keeps its required prefix parentheses in `prefix_id`: `(<+>)` and `(Demo.<+>)` remain `prefix_id`, while redundant grouping such as `((<+>))` adds one `parenthesized_name` wrapper around that node. This also applies to unapplied names; only function position creates a call reference or call highlight. A parenthesized simple binding name uses `parenthesized_name` in the `bind` node's `name` field, retaining one wrapper at any grouping depth. Complex expressions retain ordinary `parens` nodes. These changes affect public syntax trees.
 
+Module binding patterns use the `binding_pattern` supertype; ordinary patterns use `pattern`. Both retain the same concrete node names. A `binding_field_pattern/field_pattern` with a `field` field and no `pattern` field is a module binding record pun. The `decl` supertype covers bindings in local blocks and declaration quotes; module declarations use `declaration`.
+
 In a repository checkout, configure the CLI parser directories to include the grammar, then run `script/tree-sitter tags file.hs` to inspect the tags.
 
 In Rust, depend on the [crate](https://crates.io/crates/willbooster-tree-sitter-haskell) and on
@@ -98,7 +96,7 @@ fuzzed with:
 ```toml
 [dependencies]
 tree-sitter = { package = "willbooster-tree-sitter", version = "7.0.5" }
-tree-sitter-haskell = { package = "willbooster-tree-sitter-haskell", version = "6" }
+tree-sitter-haskell = { package = "willbooster-tree-sitter-haskell", version = "7" }
 ```
 
 ```rust

package/grammar/conflicts.js

@@ -5,16 +5,24 @@ module.exports = {
     // disambiguates expressions, patterns and declaration heads after parsing; these alternatives must remain
     // available until following syntax determines their role, including for top-level expression splices.
     [$._function_name, $.pattern],
+    [$._function_name, $.pattern, $.binding_pattern],
     [$._function_name, $.pattern, $.expression],
-    [$._grouped_name, $._function_name, $.pattern, $.expression],
+    [$._function_name, $.pattern, $.binding_pattern, $.expression],
     [$._grouped_name, $.expression],
     [$._grouped_name, $.pattern, $.expression],
+    [$._grouped_name, $.binding_pattern, $.expression],
+    [$._grouped_name, $.pattern, $.binding_pattern, $.expression],
     [$._grouped_name, $.expression, $.pattern, $._function_name, $._binding_name_parens],
+    [$._grouped_name, $.expression, $.pattern, $.binding_pattern, $._function_name, $._binding_name_parens],
     [$.pattern, $._function_name, $._binding_name_parens],
     [$.pattern, $._binding_name_parens],
     [$._grouped_name, $.expression, $.pattern, $._binding_name_parens],
     [$.pattern, $.expression],
+    [$.binding_pattern, $.expression],
+    [$.pattern, $.binding_pattern, $.expression],
+    [$.pattern, $.binding_pattern],
     [$.signature, $.pattern],
+    [$.signature, $.binding_pattern],
     // The hash opening an unboxed tuple can also begin a symbolic operator.
     [$._operator_hash_head, $._unboxed_open],
   ],

package/grammar/decl.js

@@ -5,6 +5,16 @@ const {
   layout,
 } = require('./util.js')
 
+const binding = ($, pattern) => prec('bind', seq(
+  choice(
+    field('pattern', pattern),
+    field('name', $._var),
+    field('name', alias($._binding_name_parens, $.parenthesized_name)),
+    field('implicit', $.implicit_variable),
+  ),
+  $._bind_matches,
+))
+
 module.exports = {
 
   // ------------------------------------------------------------------------
@@ -112,15 +122,15 @@ module.exports = {
    * The `implicit_variable` here is for:
    * g = let ?par = Impy 5 in f
    */
-  bind: $ => prec('bind', seq(
-    choice(
-      field('pattern', $._pat),
-      field('name', $._var),
-      field('name', alias($._binding_name_parens, $.parenthesized_name)),
-      field('implicit', $.implicit_variable),
-    ),
-    $._bind_matches,
-  )),
+  bind: $ => binding($, $._pat),
+
+  _module_bind: $ => binding($, $._binding_pat),
+
+  _module_decl: $ => choice(
+    $.signature,
+    $.function,
+    alias($._module_bind, $.bind),
+  ),
 
   decl: $ => choice(
     $.signature,

package/grammar/inline.js

@@ -56,6 +56,9 @@ module.exports = {
     $._pat_name,
     $._pat_texp,
     $._pat_wildcard,
+    $._binding_pat_apply_arg,
+    $._binding_pat_name,
+    $._binding_pat_texp,
 
     // ------------------------------------------------
     // type

package/grammar/module.js

@@ -7,6 +7,28 @@ const {
   semis,
 } = require('./util.js')
 
+const declaration = ($, bindings) => choice(
+    bindings,
+    $.type_synonym,
+    $.kind_signature,
+    $.type_family,
+    $.type_instance,
+    $.role_annotation,
+    $.data_type,
+    $.newtype,
+    $.data_family,
+    $.data_instance,
+    $.class,
+    $.instance,
+    $.default_types,
+    $.deriving_instance,
+    $.pattern_synonym,
+    $.foreign_import,
+    $.foreign_export,
+    $.fixity,
+    $.top_splice,
+  )
+
 module.exports = {
 
   // ------------------------------------------------------------------------
@@ -122,29 +144,8 @@ module.exports = {
     alias($._cond_layout_end_explicit, '}'),
   ),
 
-  /**
-   * This is a supertype.
-   */
-  declaration: $ => choice(
-    $.decl,
-    $.type_synonym,
-    $.kind_signature,
-    $.type_family,
-    $.type_instance,
-    $.role_annotation,
-    $.data_type,
-    $.newtype,
-    $.data_family,
-    $.data_instance,
-    $.class,
-    $.instance,
-    $.default_types,
-    $.deriving_instance,
-    $.pattern_synonym,
-    $.foreign_import,
-    $.foreign_export,
-    $.fixity,
-    $.top_splice,
-  ),
+  declaration: $ => declaration($, $._module_decl),
+
+  _quoted_declaration: $ => declaration($, $.decl),
 
 }

package/grammar/pat.js

@@ -9,141 +9,161 @@ const {
   unboxed_sum_single,
 } = require('./util.js')
 
-module.exports = {
+const patternRules = (name, recordField) => {
+  const rule = ($, key) => $[name(key)]
+  return {
+
+    // ------------------------------------------------------------------------
+    // tuples and parens
+    // ------------------------------------------------------------------------
+
+    [name('_pat_parens')]: $ => parens($, field('pattern', rule($, '_pat_texp'))),
+
+    [name('_pat_tuple_elems')]: $ => sep2(',', field('element', rule($, '_pat_texp'))),
+
+    [name('_pat_tuple')]: $ => parens($, rule($, '_pat_tuple_elems')),
+
+    [name('_pat_unboxed_tuple')]: $ => unboxed_tuple_full($, rule($, '_pat_texp')),
 
-  // ------------------------------------------------------------------------
-  // tuples and parens
-  // ------------------------------------------------------------------------
-
-  _pat_parens: $ => parens($, field('pattern', $._pat_texp)),
-
-  _pat_tuple_elems: $ => sep2(',', field('element', $._pat_texp)),
-
-  _pat_tuple: $ => parens($, $._pat_tuple_elems),
-
-  _pat_unboxed_tuple: $ => unboxed_tuple_full($, $._pat_texp),
-
-  _pat_unboxed_sum: $ => unboxed_sum_single($, $._pat_texp),
-
-  _pat_list: $ => brackets($, sep1(',', field('element', $._pat_texp)), optional(',')),
-
-  // ------------------------------------------------------------------------
-  // record
-  // ------------------------------------------------------------------------
-
-  field_pattern: $ => choice(
-    alias('..', $.wildcard),
-    seq(field('field', $._field_names), optional(seq('=', field('pattern', $._pat_texp)))),
-  ),
-
-  _pat_record: $ => prec('record', seq(
-    field('constructor', $.pattern),
-    braces($, sep(',', field('field', $.field_pattern))),
-  )),
-
-  // ------------------------------------------------------------------------
-  // misc
-  // ------------------------------------------------------------------------
-
-  /**
-   * This dynamic precedence penalty is relevant for the conflict between `function` and `bind`.
-   * Consider:
-   *
-   * > f (A a) = exp
-   *
-   * Because of the "single choice disambiguated with named precedences" approach used for `pattern`, the left node in
-   * `pat_apply` can be a variable, even though it's not valid Haskell.
-   * While the static prec 'pat-name' covers this at generation time, Haskell's ambiguity requires us to use a runtime
-   * conflict for `function`/`bind`, where static prec is ineffective.
-   * Giving the reduction of `_var` to `pattern` a strong negative dynamic prec ensures that the runtime branch for
-   * `bind` has lower precedence because of `f`, so `function` always wins.
-   *
-   * While `bind` usually has a lower score than `function` anyway in this situation because it is slightly more
-   * complex, there are never any guarantees for runtime conflicts.
-   * In particular, the presence of minor parse errors later in the declaration can tip the scales randomly.
-   */
-  _pat_name: $ => choice(
-    prec('pat-name', prec.dynamic(-1000, $._var)),
-    $._cons,
-  ),
-
-  _pat_as: $ => prec('prefix', seq(field('bind', $.variable), $._tight_at, field('pattern', $.pattern))),
-
-  _pat_wildcard: _ => '_',
-
-  _pat_strict: $ => prec('prefix', seq($._any_prefix_bang, field('pattern', $.pattern))),
-
-  _pat_irrefutable: $ => prec('prefix', seq($._any_prefix_tilde, field('pattern', $.pattern))),
-
-  // ------------------------------------------------------------------------
-  // application
-  // ------------------------------------------------------------------------
-
-  _pat_apply_arg: $ => choice(
-    $.pattern,
-    alias($._at_type, $.type_binder),
-    $.explicit_type,
-  ),
-
-  _pat_apply: $ => prec.left('apply', seq(
-    field('function', $.pattern),
-    field('argument', $._pat_apply_arg),
-  )),
-
-  // ------------------------------------------------------------------------
-  // operators
-  // ------------------------------------------------------------------------
-
-  _pat_negation: $ => seq('-', field('number', $._number)),
-
-  _pat_infix: $ => prec.right('infix', seq(
-    field('left_operand', $.pattern),
-    optional($._cond_no_section_op),
-    field('operator', choice(
-      $.constructor_operator,
-      $._conids_ticked,
-      seq($._cond_qualified_op, $._qconsym),
+    [name('_pat_unboxed_sum')]: $ => unboxed_sum_single($, rule($, '_pat_texp')),
+
+    [name('_pat_list')]: $ => brackets($, sep1(',', field('element', rule($, '_pat_texp'))), optional(',')),
+
+    // ------------------------------------------------------------------------
+    // record
+    // ------------------------------------------------------------------------
+
+    [name('_pat_record')]: $ => prec('record', seq(
+      field('constructor', rule($, 'pattern')),
+      braces($, sep(',', field('field', recordField($)))),
     )),
-    field('right_operand', $.pattern),
-  )),
-
-  // ------------------------------------------------------------------------
-  // top level
-  // ------------------------------------------------------------------------
-
-  pattern: $ => choice(
-    alias($._pat_infix, $.infix),
-    alias($._pat_negation, $.negation),
-    alias($._pat_apply, $.apply),
-    $._pat_name,
-    alias($._pat_as, $.as),
-    alias($._pat_record, $.record),
-    alias($._pat_wildcard, $.wildcard),
-    alias($._pat_parens, $.parens),
-    alias($._pat_tuple, $.tuple),
-    alias($._pat_unboxed_tuple, $.unboxed_tuple),
-    alias($._pat_unboxed_sum, $.unboxed_sum),
-    alias($._pat_list, $.list),
-    alias($._plist, $.list),
-    alias($._pat_strict, $.strict),
-    alias($._pat_irrefutable, $.irrefutable),
-    $._universal,
-  ),
 
-  patterns: $ => repeat1(prec('patterns', $._pat_apply_arg)),
+    // ------------------------------------------------------------------------
+    // misc
+    // ------------------------------------------------------------------------
+
+    /**
+     * This dynamic precedence penalty is relevant for the conflict between `function` and `bind`.
+     * Consider:
+     *
+     * > f (A a) = exp
+     *
+     * Because of the "single choice disambiguated with named precedences" approach used for `pattern`, the left node in
+     * `pat_apply` can be a variable, even though it's not valid Haskell.
+     * While the static prec 'pat-name' covers this at generation time, Haskell's ambiguity requires us to use a runtime
+     * conflict for `function`/`bind`, where static prec is ineffective.
+     * Giving the reduction of `_var` to `pattern` a strong negative dynamic prec ensures that the runtime branch for
+     * `bind` has lower precedence because of `f`, so `function` always wins.
+     *
+     * While `bind` usually has a lower score than `function` anyway in this situation because it is slightly more
+     * complex, there are never any guarantees for runtime conflicts.
+     * In particular, the presence of minor parse errors later in the declaration can tip the scales randomly.
+     */
+    [name('_pat_name')]: $ => choice(
+      prec('pat-name', prec.dynamic(-1000, $._var)),
+      $._cons,
+    ),
+
+    [name('_pat_as')]: $ => prec('prefix', seq(field('bind', $.variable), $._tight_at, field('pattern', rule($, 'pattern')))),
+
+    [name('_pat_wildcard')]: _ => '_',
+
+    [name('_pat_strict')]: $ => prec('prefix', seq($._any_prefix_bang, field('pattern', rule($, 'pattern')))),
+
+    [name('_pat_irrefutable')]: $ => prec('prefix', seq($._any_prefix_tilde, field('pattern', rule($, 'pattern')))),
+
+    // ------------------------------------------------------------------------
+    // application
+    // ------------------------------------------------------------------------
+
+    [name('_pat_apply_arg')]: $ => choice(
+      rule($, 'pattern'),
+      alias($._at_type, $.type_binder),
+      $.explicit_type,
+    ),
+
+    [name('_pat_apply')]: $ => prec.left('apply', seq(
+      field('function', rule($, 'pattern')),
+      field('argument', rule($, '_pat_apply_arg')),
+    )),
 
-  _pat_signature: $ => prec.right('annotated', seq(
-    field('pattern', $.pattern),
-    $._type_annotation,
-  )),
+    // ------------------------------------------------------------------------
+    // operators
+    // ------------------------------------------------------------------------
+
+    [name('_pat_negation')]: $ => seq('-', field('number', $._number)),
+
+    [name('_pat_infix')]: $ => prec.right('infix', seq(
+      field('left_operand', rule($, 'pattern')),
+      optional($._cond_no_section_op),
+      field('operator', choice(
+        $.constructor_operator,
+        $._conids_ticked,
+        seq($._cond_qualified_op, $._qconsym),
+      )),
+      field('right_operand', rule($, 'pattern')),
+    )),
+
+    // ------------------------------------------------------------------------
+    // top level
+    // ------------------------------------------------------------------------
+
+    [name('pattern')]: $ => choice(
+      alias(rule($, '_pat_infix'), $.infix),
+      alias(rule($, '_pat_negation'), $.negation),
+      alias(rule($, '_pat_apply'), $.apply),
+      rule($, '_pat_name'),
+      alias(rule($, '_pat_as'), $.as),
+      alias(rule($, '_pat_record'), $.record),
+      alias(rule($, '_pat_wildcard'), $.wildcard),
+      alias(rule($, '_pat_parens'), $.parens),
+      alias(rule($, '_pat_tuple'), $.tuple),
+      alias(rule($, '_pat_unboxed_tuple'), $.unboxed_tuple),
+      alias(rule($, '_pat_unboxed_sum'), $.unboxed_sum),
+      alias(rule($, '_pat_list'), $.list),
+      alias($._plist, $.list),
+      alias(rule($, '_pat_strict'), $.strict),
+      alias(rule($, '_pat_irrefutable'), $.irrefutable),
+      $._universal,
+    ),
+
+    [name('_pat_signature')]: $ => prec.right('annotated', seq(
+      field('pattern', rule($, 'pattern')),
+      $._type_annotation,
+    )),
 
-  _pat: $ => choice(
-    alias($._pat_signature, $.signature),
-    prec.right($.pattern),
-  ),
+    [name('_pat')]: $ => choice(
+      alias(rule($, '_pat_signature'), $.signature),
+      prec.right(rule($, 'pattern')),
+    ),
 
-  view_pattern: $ => seq(field('expression', $._exp), $._arrow, field('pattern', $._pat_texp)),
+    [name('view_pattern')]: $ => seq(field('expression', $._exp), $._arrow, field('pattern', rule($, '_pat_texp'))),
 
-  _pat_texp: $ => choice($.view_pattern, $._pat),
+    [name('_pat_texp')]: $ => choice(
+      alias(rule($, 'view_pattern'), $.view_pattern),
+      rule($, '_pat'),
+    ),
 
+  }
+}
+
+const bindingRuleName = name => {
+  if (['_pat_negation', '_pat_wildcard'].includes(name)) return name
+  if (name === 'view_pattern') return '_binding_view_pattern'
+  return name.startsWith('_') ? `_binding${name}` : `binding_${name}`
+}
+
+const recordField = ($, pattern) => choice(
+  alias('..', $.wildcard),
+  seq(field('field', $._field_names), optional(seq('=', field('pattern', pattern)))),
+)
+
+module.exports = {
+  ...patternRules(name => name, $ => $.field_pattern),
+  ...patternRules(bindingRuleName, $ => $.binding_field_pattern),
+
+  binding_field_pattern: $ => choice(alias($._binding_field_pattern, $.field_pattern)),
+  _binding_field_pattern: $ => recordField($, $._binding_pat_texp),
+  field_pattern: $ => recordField($, $._pat_texp),
+  patterns: $ => repeat1(prec('patterns', $._pat_apply_arg)),
 }

package/grammar/th.js

@@ -51,7 +51,7 @@ module.exports = {
     choice(token('|]'), '⟧'),
   ),
 
-  quoted_decls: $ => layout_sort($, $._cmd_layout_start_quote, field('declaration', $.declaration)),
+  quoted_decls: $ => layout_sort($, $._cmd_layout_start_quote, field('declaration', $._quoted_declaration)),
 
   /**
   * An "expression quotation" is valid in an expression, and its body may contain an expression, type, pattern or

package/grammar.js

@@ -74,6 +74,8 @@ module.exports = grammar({
   supertypes: $ => [
     $.expression,
     $.pattern,
+    $.binding_pattern,
+    $.binding_field_pattern,
     $.type,
     $.quantified_type,
     $.constraint,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willbooster/tree-sitter-haskell",
-  "version": "6.0.4",
+  "version": "7.0.1",
   "description": "Haskell grammar for tree-sitter",
   "keywords": [
     "incremental",

package/queries/highlights.scm

@@ -2,9 +2,9 @@
 ; and don't override destructured parameters
 (variable) @variable
 
-(pattern/wildcard) @variable
+[(pattern/wildcard) (binding_pattern/wildcard)] @variable
 
-(decl/function
+(function
   patterns: (patterns
     (_) @variable.parameter))
 
@@ -12,7 +12,7 @@
   (_)+ @variable.parameter
   "->")
 
-(decl/function
+(function
   (infix
     (pattern) @variable.parameter))
 
@@ -116,55 +116,58 @@
 ] @keyword
 
 [
-  (decl/function name: (variable) @function)
-  (decl/bind name: (variable) @function)
-  (decl/signature name: (variable) @function)
-  (decl/signature names: (binding_list (variable) @function))
+  (function name: (variable) @function)
+  (bind name: (variable) @function)
+  (signature name: (variable) @function)
+  (signature names: (binding_list (variable) @function))
 ]
 
-(decl/bind
+(bind
   name: (variable) @variable)
 
-(decl/signature
+(signature
   name: (variable) @variable
   type: (type))
 
-((decl/signature
+((signature
   name: (variable) @_name
   type: (type))
   .
   [
-    (decl/function name: (variable) @variable)
-    (decl/bind name: (variable) @variable)
+    (function name: (variable) @variable)
+    (bind name: (variable) @variable)
   ]
     match: (_)
   (#eq? @_name @variable))
 
-(decl/signature
+(signature
   name: (variable) @function
   type: (type/apply
     constructor: (name) @_type)
   (#eq? @_type "IO"))
 
-((decl/signature
+((signature
   name: (variable) @_name
   type: (type/apply
     constructor: (name) @_type)
   (#eq? @_type "IO"))
   .
   [
-    (decl/function name: (variable) @function)
-    (decl/bind name: (variable) @function)
+    (function name: (variable) @function)
+    (bind name: (variable) @function)
   ]
     match: (_)
   (#eq? @_name @function))
 
-((decl/signature) @function
+([
+  (signature name: (_))
+  (signature names: (_))
+] @function
   .
-  (decl/function
+  (function
     name: (variable) @function))
 
-(decl/bind
+(bind
   name: (variable) @function
   (match
     expression: (expression/lambda)))
@@ -263,7 +266,7 @@
   ]
   (#any-of? @_op "." ">>>" "***" ">=>" "<=<"))
 
-(decl/function
+(function
   name: (variable) @function
   (match
     expression: (infix
@@ -310,23 +313,23 @@
       (variable) @variable)
   ])
 
-(decl/bind
+(bind
   name: (variable) @function
   (#eq? @function "main"))
 
 (signature
-  pattern: (pattern/variable) @function
+  pattern: [(pattern/variable) (binding_pattern/variable)] @function
   type: (quantified_type))
 
-(decl/signature
+(signature
   name: (variable) @function
   type: (quantified_type))
 
-((decl/signature
+((signature
   name: (variable) @_name
   type: (quantified_type))
   .
-  (decl/bind
+  (bind
     (variable) @function)
   (#eq? @function @_name))
 

package/queries/locals.scm

@@ -1,6 +1,6 @@
 (signature name: (variable)) @local.definition
 (function name: (variable)) @local.definition
-(pattern/variable) @local.definition
+[(pattern/variable) (binding_pattern/variable)] @local.definition
 (expression/variable) @local.reference
 (expression/parenthesized_name (variable) @local.reference)
 (_ name: (parenthesized_name (variable) @local.definition))

package/queries/tags.scm

@@ -15,6 +15,14 @@
     (parenthesized_name [(variable) @name (prefix_id (operator) @name)])
   ]) @definition.variable)
 
+(binding_pattern/variable) @name @definition.variable
+(binding_pattern/prefix_id (operator) @name) @definition.variable
+(binding_pattern/as bind: (variable) @name) @definition.variable
+
+(binding_field_pattern/field_pattern
+  !pattern
+  field: [(field_name) @name (qualified id: (field_name) @name)]) @definition.variable
+
 [
   (class_declarations
     [

package/src/node-types.json

@@ -1,4 +1,120 @@
 [
+  {
+    "type": "binding_field_pattern",
+    "named": true,
+    "subtypes": [
+      {
+        "type": "field_pattern",
+        "named": true
+      }
+    ]
+  },
+  {
+    "type": "binding_pattern",
+    "named": true,
+    "subtypes": [
+      {
+        "type": "apply",
+        "named": true
+      },
+      {
+        "type": "as",
+        "named": true
+      },
+      {
+        "type": "constructor",
+        "named": true
+      },
+      {
+        "type": "infix",
+        "named": true
+      },
+      {
+        "type": "irrefutable",
+        "named": true
+      },
+      {
+        "type": "list",
+        "named": true
+      },
+      {
+        "type": "literal",
+        "named": true
+      },
+      {
+        "type": "negation",
+        "named": true
+      },
+      {
+        "type": "parens",
+        "named": true
+      },
+      {
+        "type": "prefix_id",
+        "named": true
+      },
+      {
+        "type": "prefix_tuple",
+        "named": true
+      },
+      {
+        "type": "prefix_unboxed_sum",
+        "named": true
+      },
+      {
+        "type": "prefix_unboxed_tuple",
+        "named": true
+      },
+      {
+        "type": "qualified",
+        "named": true
+      },
+      {
+        "type": "quasiquote",
+        "named": true
+      },
+      {
+        "type": "record",
+        "named": true
+      },
+      {
+        "type": "splice",
+        "named": true
+      },
+      {
+        "type": "strict",
+        "named": true
+      },
+      {
+        "type": "tuple",
+        "named": true
+      },
+      {
+        "type": "unboxed_sum",
+        "named": true
+      },
+      {
+        "type": "unboxed_tuple",
+        "named": true
+      },
+      {
+        "type": "unboxed_unit",
+        "named": true
+      },
+      {
+        "type": "unit",
+        "named": true
+      },
+      {
+        "type": "variable",
+        "named": true
+      },
+      {
+        "type": "wildcard",
+        "named": true
+      }
+    ]
+  },
   {
     "type": "class_decl",
     "named": true,
@@ -155,6 +271,10 @@
     "type": "declaration",
     "named": true,
     "subtypes": [
+      {
+        "type": "bind",
+        "named": true
+      },
       {
         "type": "class",
         "named": true
@@ -171,10 +291,6 @@
         "type": "data_type",
         "named": true
       },
-      {
-        "type": "decl",
-        "named": true
-      },
       {
         "type": "default_types",
         "named": true
@@ -195,6 +311,10 @@
         "type": "foreign_import",
         "named": true
       },
+      {
+        "type": "function",
+        "named": true
+      },
       {
         "type": "instance",
         "named": true
@@ -215,6 +335,10 @@
         "type": "role_annotation",
         "named": true
       },
+      {
+        "type": "signature",
+        "named": true
+      },
       {
         "type": "top_splice",
         "named": true
@@ -879,6 +1003,10 @@
         "multiple": false,
         "required": true,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "explicit_type",
             "named": true
@@ -927,6 +1055,10 @@
         "multiple": false,
         "required": false,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "expression",
             "named": true
@@ -1005,6 +1137,10 @@
         "multiple": false,
         "required": true,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "pattern",
             "named": true
@@ -1127,6 +1263,10 @@
         "multiple": false,
         "required": false,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "pattern",
             "named": true
@@ -2439,6 +2579,10 @@
         "multiple": false,
         "required": false,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "pattern",
             "named": true
@@ -3370,6 +3514,10 @@
         "multiple": false,
         "required": true,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "expression",
             "named": true
@@ -3426,6 +3574,10 @@
         "multiple": false,
         "required": true,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "expression",
             "named": true
@@ -3614,6 +3766,10 @@
         "multiple": false,
         "required": true,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "pattern",
             "named": true
@@ -3932,6 +4088,10 @@
         "multiple": true,
         "required": false,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "expression",
             "named": true
@@ -4361,6 +4521,10 @@
         "multiple": false,
         "required": false,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "pattern",
             "named": true
@@ -4903,7 +5067,79 @@
         "required": false,
         "types": [
           {
-            "type": "declaration",
+            "type": "class",
+            "named": true
+          },
+          {
+            "type": "data_family",
+            "named": true
+          },
+          {
+            "type": "data_instance",
+            "named": true
+          },
+          {
+            "type": "data_type",
+            "named": true
+          },
+          {
+            "type": "decl",
+            "named": true
+          },
+          {
+            "type": "default_types",
+            "named": true
+          },
+          {
+            "type": "deriving_instance",
+            "named": true
+          },
+          {
+            "type": "fixity",
+            "named": true
+          },
+          {
+            "type": "foreign_export",
+            "named": true
+          },
+          {
+            "type": "foreign_import",
+            "named": true
+          },
+          {
+            "type": "instance",
+            "named": true
+          },
+          {
+            "type": "kind_signature",
+            "named": true
+          },
+          {
+            "type": "newtype",
+            "named": true
+          },
+          {
+            "type": "pattern_synonym",
+            "named": true
+          },
+          {
+            "type": "role_annotation",
+            "named": true
+          },
+          {
+            "type": "top_splice",
+            "named": true
+          },
+          {
+            "type": "type_family",
+            "named": true
+          },
+          {
+            "type": "type_instance",
+            "named": true
+          },
+          {
+            "type": "type_synonym",
             "named": true
           }
         ]
@@ -5024,6 +5260,10 @@
         "multiple": false,
         "required": false,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "pattern",
             "named": true
@@ -5045,11 +5285,11 @@
         "required": false,
         "types": [
           {
-            "type": "field",
+            "type": "binding_field_pattern",
             "named": true
           },
           {
-            "type": "field_pattern",
+            "type": "field",
             "named": true
           },
           {
@@ -5224,6 +5464,10 @@
         "multiple": false,
         "required": false,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "pattern",
             "named": true
@@ -5352,6 +5596,10 @@
         "multiple": false,
         "required": true,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "pattern",
             "named": true
@@ -5471,6 +5719,10 @@
         "multiple": true,
         "required": false,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "expression",
             "named": true
@@ -5886,6 +6138,10 @@
         "multiple": true,
         "required": true,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "expression",
             "named": true
@@ -5918,6 +6174,10 @@
         "multiple": true,
         "required": true,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "expression",
             "named": true
@@ -5990,6 +6250,10 @@
         "multiple": false,
         "required": true,
         "types": [
+          {
+            "type": "binding_pattern",
+            "named": true
+          },
           {
             "type": "pattern",
             "named": true

package/tree-sitter.json

@@ -16,7 +16,7 @@
     }
   ],
   "metadata": {
-    "version": "6.0.4",
+    "version": "7.0.1",
     "license": "MIT",
     "description": "Haskell grammar for tree-sitter",
     "authors": [