@willbooster/tree-sitter-haskell 9.0.0 → 11.0.0

package/README.md

@@ -5,7 +5,7 @@
 [![Test](https://github.com/WillBooster/tree-sitter-haskell/actions/workflows/test.yml/badge.svg)](https://github.com/WillBooster/tree-sitter-haskell/actions/workflows/test.yml)
 [![Test rust](https://github.com/WillBooster/tree-sitter-haskell/actions/workflows/test-rust.yml/badge.svg)](https://github.com/WillBooster/tree-sitter-haskell/actions/workflows/test-rust.yml)
 [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
-[![wbfy](https://img.shields.io/badge/wbfy-20.41.8-1e90ff.svg)](https://github.com/WillBooster/shared/tree/main/packages/wbfy)
+[![wbfy](https://img.shields.io/badge/wbfy-20.43.2-1e90ff.svg)](https://github.com/WillBooster/shared/tree/main/packages/wbfy)
 [![crates.io](https://img.shields.io/crates/v/willbooster-tree-sitter-haskell.svg)](https://crates.io/crates/willbooster-tree-sitter-haskell)
 
 Haskell grammar for [tree-sitter](https://github.com/tree-sitter/tree-sitter), forked from
@@ -13,10 +13,9 @@ Haskell grammar for [tree-sitter](https://github.com/tree-sitter/tree-sitter), f
 to its authors and contributors. This is not an official release of that project.
 
 This fork is based on upstream's version 0.23.1 grammar and generates the parser with the
-[WillBooster/tree-sitter](https://github.com/WillBooster/tree-sitter) generator. The parser carries that fork's own ABI number, so it loads only with that fork's runtime, version 7.0.7 or later in the 7.x series; upstream's runtime rejects it.
+[WillBooster/tree-sitter](https://github.com/WillBooster/tree-sitter) generator. The parser carries that fork's own ABI number. This package supports the fork's runtime version 10.0.1 or later in the 10.x series; upstream's runtime rejects it.
 [Upstream's README at that version](https://github.com/tree-sitter/tree-sitter-haskell/blob/v0.23.1/README.md) lists
-the supported language extensions and, under "Querying", explains how to query the grammar's supertypes; it is the
-readme that the comments in `grammar.js` refer to.
+the supported language extensions. The fork's node and query contracts are described below.
 
 ## Differences from upstream
 
@@ -40,7 +39,7 @@ reports an error: the lexers of the WillBooster/tree-sitter generator let charac
 ## Usage
 
 The npm package ships `tree-sitter-haskell.wasm` for
-[@willbooster/web-tree-sitter](https://www.npmjs.com/package/@willbooster/web-tree-sitter) version 7.0.7 or later in the 7.x series, which runs in Node.js, Bun, browsers, and Cloudflare Workers. In Node.js and Bun, load the grammar from its path:
+[@willbooster/web-tree-sitter](https://www.npmjs.com/package/@willbooster/web-tree-sitter) version 10.0.1 or later in the 10.x series, which runs in Node.js, Bun, browsers, and Cloudflare Workers. In Node.js and Bun, load the grammar from its path:
 
 ```js
 import { fileURLToPath } from 'node:url';
@@ -88,7 +87,11 @@ Declaration names and variable/operator callees remain indexed through nested pa
 
 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`.
+Operator uses retain unresolved source order. Expressions use `operator_chain` with repeated `operand` and `operator` fields: `6 * 7 == 42` has operands `6`, `7`, `42` and operators `*`, `==`. Application stays inside an operand; explicit parentheses and greedy block bodies retain their own grouping. A `prefix_operator` field records each named `prefix_negation` token at its source position, including unary-only chains. Its semantic extent depends on fixities and language extensions, so the tree does not assign it an operand subtree.
+
+Type, pattern and constraint operators use `infix_chain` with repeated `operand` and `operator` fields, even for a single operator. Function, type and data declaration heads retain the `infix` node because they define one operator. Instance and standalone deriving implementation tags identify a class only for a single-operator head; multi-operator heads require fixity resolution by the caller.
+
+Queries distinguish operands through the `expression_operand`, `type_operand`, `pattern_operand`, `binding_pattern_operand` and `constraint_operand` supertypes. For example, `(expression_operand/variable)` selects an expression variable and `(binding_pattern_operand/variable)` selects an explicit module-binding name. Match chains directly with `(operator_chain)` or `(infix_chain)` and their fields. The concrete operand node names remain shared across contexts. 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.
 
@@ -98,8 +101,8 @@ fuzzed with:
 
 ```toml
 [dependencies]
-tree-sitter = { package = "willbooster-tree-sitter", version = "7.0.7" }
-tree-sitter-haskell = { package = "willbooster-tree-sitter-haskell", version = "8" }
+tree-sitter = { package = "willbooster-tree-sitter", version = "10.0.1" }
+tree-sitter-haskell = { package = "willbooster-tree-sitter-haskell", version = "11" }
 ```
 
 ```rust

package/grammar/conflicts.js

@@ -4,25 +4,28 @@ module.exports = {
     // GHC DisambECP (notes Ambiguous syntactic categories, PatBuilder and Declaration/signature overlap)
     // 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],
-    [$._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],
+    [$.expression_operand, $.pattern_operand, $.binding_pattern_operand],
+    [$.expression_operand, $.pattern_operand],
+    [$.expression_operand, $.binding_pattern_operand],
+    [$.pattern_operand, $.binding_pattern_operand],
+    [$.prefix_negation, $._pat_negation],
+    [$._type_apply, $._type_infix_chain],
+    [$._type_infix_chain],
+    [$._grouped_name, $.expression_operand, $.pattern_operand, $._binding_name_parens],
+    [$.pattern_operand, $._binding_name_parens],
+    [$._grouped_name, $.expression_operand, $.pattern_operand, $._function_name, $._binding_name_parens],
+    [$._grouped_name, $.expression_operand, $.binding_pattern_operand],
+    [$._grouped_name, $.expression_operand, $.pattern_operand],
+    [$.pattern_operand, $._function_name, $._binding_name_parens],
+    [$._grouped_name, $.expression_operand, $.pattern_operand, $.binding_pattern_operand],
+    [$.pattern_operand, $.signature],
+    [$.pattern_operand, $._function_name],
+    [$.expression_operand, $.pattern_operand, $._function_name],
+    [$._grouped_name, $.expression_operand],
+    [$._grouped_name, $.expression_operand, $.pattern_operand, $.binding_pattern_operand, $._function_name, $._binding_name_parens],
+    [$.binding_pattern_operand, $.signature],
+    [$.pattern_operand, $.binding_pattern_operand, $._function_name],
+    [$.expression_operand, $.pattern_operand, $.binding_pattern_operand, $._function_name],
     // The hash opening an unboxed tuple can also begin a symbolic operator.
     [$._operator_hash_head, $._unboxed_open],
   ],

package/grammar/context.js

@@ -10,16 +10,11 @@ module.exports = {
   // ------------------------------------------------------------------------
 
   _class_apply: $ => prec.left('apply', seq(
-    field('constructor', $.constraint),
+    field('constructor', $.constraint_operand),
     field('argument', $._type_apply_arg),
   )),
 
-  _class_infix: $ => prec.right('infix', seq(
-    $._cond_infix,
-    field('left_operand', $.type),
-    field('operator', $._tyops),
-    field('right_operand', $.type),
-  )),
+  _class_infix_chain: $ => seq($._cond_infix, $._type_infix_chain),
 
   _ctr_parens: $ => parens($, $.constraints),
 
@@ -34,9 +29,8 @@ module.exports = {
    */
   implicit_parameter: $ => prec.left(seq(field('name', $.implicit_variable), $._type_annotation)),
 
-  constraint: $ => choice(
+  constraint_operand: $ => choice(
     $._type_name,
-    alias($._class_infix, $.infix),
     alias($._class_apply, $.apply),
     alias($._ctr_parens, $.parens),
     alias($._ctr_tuple, $.tuple),
@@ -44,6 +38,11 @@ module.exports = {
     $._universal,
   ),
 
+  constraint: $ => choice(
+    alias($._class_infix_chain, $.infix_chain),
+    $.constraint_operand,
+  ),
+
   _ctr_forall: $ => prec('fun', seq($._forall_body, '.', field('constraint', $.constraints))),
 
   _ctr_context: $ => prec('fun', seq($._context_inline, field('constraint', $.constraints))),

package/grammar/exp.js

@@ -258,7 +258,7 @@ module.exports = {
   ),
 
   _exp_record: $ => prec('record', seq(
-    field('expression', $.expression),
+    field('expression', $.expression_operand),
     braces($, sep(',', field('field', $.field_update)))),
   ),
 
@@ -271,7 +271,7 @@ module.exports = {
 
   _exp_projection: $ => seq(
     prec('projection', seq(
-      field('expression', $.expression),
+      field('expression', $.expression_operand),
       $._tight_dot,
     )),
     field('field', $.field_name),
@@ -288,9 +288,9 @@ module.exports = {
   parenthesized_name: $ => prec.dynamic(1, parens($, $._grouped_name)),
 
   _exp_apply: $ => prec.left('apply', seq(
-    field('function', $.expression),
+    field('function', $.expression_operand),
     field('argument', choice(
-      $.expression,
+      $.expression_operand,
       alias($._at_type, $.type_application),
       $.explicit_type,
     )),
@@ -326,43 +326,40 @@ module.exports = {
     field('right_operand', $.expression),
   ),
 
-  _exp_negation: $ => seq(
-    field('minus', '-'),
-    prec('negation', field('expression', $.expression)),
-  ),
+  prefix_negation: _ => '-',
 
-  /**
-   * Infix expressions have severe conflicts with several structures:
-   *
-   * - Negation is supposed to bind less tight than application and tighter than infix, which requires an unsolvable
-   *   precedence configuration
-   * - Qualified operators cannot be identified with single-token lookahead, which causes ambiguity with function
-   *   application
-   * - Left operator sections require infix expressions in their operand to reduce before the section operator, but
-   *   single-token lookahead also makes this decision impossible
-   *
-   * All of these are solved with external symbols.
-   * Consult `grammar/externals.js` for more information.
-   */
-  _exp_infix: $ => prec.right('infix', seq(
-    field('left_operand', $.expression),
+  _exp_infix_operator: $ => seq(
     optional($._cond_no_section_op),
     field('operator', choice(
       seq($._cond_minus, $._operator_minus),
       $._exp_op,
       seq($._cond_qualified_op, $._qsym),
     )),
-    field('right_operand', $.expression),
+  ),
+
+  _exp_chain_operand: $ => seq(
+    repeat(field('prefix_operator', $.prefix_negation)),
+    field('operand', $.expression_operand),
+  ),
+
+  _exp_operator_chain: $ => prec.right('infix', choice(
+    seq(
+      repeat1(field('prefix_operator', $.prefix_negation)),
+      field('operand', $.expression_operand),
+      repeat(prec.right('infix', seq($._exp_infix_operator, $._exp_chain_operand))),
+    ),
+    seq(
+      field('operand', $.expression_operand),
+      repeat1(prec.right('infix', seq($._exp_infix_operator, $._exp_chain_operand))),
+    ),
   )),
 
   // ------------------------------------------------------------------------
   // top level
   // ------------------------------------------------------------------------
 
-  expression: $ => choice(
+  expression_operand: $ => choice(
     $.parenthesized_name,
-    alias($._exp_infix, $.infix),
-    alias($._exp_negation, $.negation),
     alias($._exp_apply, $.apply),
     alias($._exp_record, $.record),
     alias($._exp_projection, $.projection),
@@ -392,6 +389,11 @@ module.exports = {
     $._universal,
   ),
 
+  expression: $ => choice(
+    alias($._exp_operator_chain, $.operator_chain),
+    $.expression_operand,
+  ),
+
   _exp_signature: $ => prec.right('annotated', seq(
     field('expression', $.expression),
     $._type_annotation,

package/grammar/externals.js

@@ -141,13 +141,6 @@ module.exports = {
     // Without this, we would get wrong token ranges for the operator.
     $._cond_no_section_op,
 
-    // This symbol always succeeds when a minus is ahead.
-    // Infix expressions with minus as the operator conflict with function application.
-    // `a - b` can be parsed as `a (- b)`, which would normally be solved by a simple precedence entry, but is
-    // impossible to express because it contradicts another conflict: Negation in the left operand, `- a + b`, which
-    // must be parsed as `(- a) + b`.
-    // Simply sequencing this external before the operator solves this conflict, because a minus following an expression
-    // can never be negation; it can only occur at the beginning of an expression.
     $._cond_minus,
 
     /**

package/grammar/inline.js

@@ -1,6 +1,12 @@
 module.exports = {
 
   inline: $ => [
+    $.expression,
+    $.pattern,
+    $.binding_pattern,
+    $.type,
+    $.constraint,
+
 
     // ------------------------------------------------
     // variable
@@ -43,6 +49,7 @@ module.exports = {
     // expression
     // ------------------------------------------------
 
+    $._exp_chain_operand,
     $._exp_name,
     $._exp_typed_hole,
     $._exp_greedy,

package/grammar/pat.js

@@ -34,7 +34,7 @@ const patternRules = (name, recordField) => {
     // ------------------------------------------------------------------------
 
     [name('_pat_record')]: $ => prec('record', seq(
-      field('constructor', rule($, 'pattern')),
+      field('constructor', rule($, 'pattern_operand')),
       braces($, sep(',', field('field', recordField($)))),
     )),
 
@@ -48,11 +48,11 @@ const patternRules = (name, recordField) => {
      *
      * > f (A a) = exp
      *
-     * Because of the "single choice disambiguated with named precedences" approach used for `pattern`, the left node in
+     * Because of the "single choice disambiguated with named precedences" approach used for `pattern_operand`, 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
+     * Giving the reduction of `_var` to `pattern_operand` 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
@@ -64,26 +64,26 @@ const patternRules = (name, recordField) => {
       $._cons,
     ),
 
-    [name('_pat_as')]: $ => prec('prefix', seq(field('bind', $.variable), $._tight_at, field('pattern', rule($, 'pattern')))),
+    [name('_pat_as')]: $ => prec('prefix', seq(field('bind', $.variable), $._tight_at, field('pattern', rule($, 'pattern_operand')))),
 
     [name('_pat_wildcard')]: _ => '_',
 
-    [name('_pat_strict')]: $ => prec('prefix', seq($._any_prefix_bang, field('pattern', rule($, 'pattern')))),
+    [name('_pat_strict')]: $ => prec('prefix', seq($._any_prefix_bang, field('pattern', rule($, 'pattern_operand')))),
 
-    [name('_pat_irrefutable')]: $ => prec('prefix', seq($._any_prefix_tilde, field('pattern', rule($, 'pattern')))),
+    [name('_pat_irrefutable')]: $ => prec('prefix', seq($._any_prefix_tilde, field('pattern', rule($, 'pattern_operand')))),
 
     // ------------------------------------------------------------------------
     // application
     // ------------------------------------------------------------------------
 
     [name('_pat_apply_arg')]: $ => choice(
-      rule($, 'pattern'),
+      rule($, 'pattern_operand'),
       alias($._at_type, $.type_binder),
       $.explicit_type,
     ),
 
     [name('_pat_apply')]: $ => prec.left('apply', seq(
-      field('function', rule($, 'pattern')),
+      field('function', rule($, 'pattern_operand')),
       field('argument', rule($, '_pat_apply_arg')),
     )),
 
@@ -93,23 +93,25 @@ const patternRules = (name, recordField) => {
 
     [name('_pat_negation')]: $ => seq('-', field('number', $._number)),
 
-    [name('_pat_infix')]: $ => prec.right('infix', seq(
-      field('left_operand', rule($, 'pattern')),
+    [name('_pat_infix_operator')]: $ => seq(
       optional($._cond_no_section_op),
       field('operator', choice(
         $.constructor_operator,
         $._conids_ticked,
         seq($._cond_qualified_op, $._qconsym),
       )),
-      field('right_operand', rule($, 'pattern')),
+    ),
+
+    [name('_pat_infix_chain')]: $ => prec.right('infix', seq(
+      field('operand', rule($, 'pattern_operand')),
+      repeat1(prec.right('infix', seq(rule($, '_pat_infix_operator'), field('operand', rule($, 'pattern_operand'))))),
     )),
 
     // ------------------------------------------------------------------------
     // top level
     // ------------------------------------------------------------------------
 
-    [name('pattern')]: $ => choice(
-      alias(rule($, '_pat_infix'), $.infix),
+    [name('pattern_operand')]: $ => choice(
       alias(rule($, '_pat_negation'), $.negation),
       alias(rule($, '_pat_apply'), $.apply),
       rule($, '_pat_name'),
@@ -127,6 +129,11 @@ const patternRules = (name, recordField) => {
       $._universal,
     ),
 
+    [name('pattern')]: $ => choice(
+      alias(rule($, '_pat_infix_chain'), $.infix_chain),
+      rule($, 'pattern_operand'),
+    ),
+
     [name('_pat_signature')]: $ => prec.right('annotated', seq(
       field('pattern', rule($, 'pattern')),
       $._type_annotation,

package/grammar/precedences.js

@@ -11,7 +11,6 @@ module.exports = {
       'record',
       'prefix',
       'apply',
-      'negation',
       'infix',
       'implicit',
       'fun',

package/grammar/type.js

@@ -94,12 +94,12 @@ module.exports = {
   // application
   // ------------------------------------------------------------------------
 
-  _at_type: $ => prefix_at($, field('type', $.type)),
+  _at_type: $ => prefix_at($, field('type', $.type_operand)),
 
-  _type_apply_arg: $ => choice($.type, alias($._at_type, $.kind_application)),
+  _type_apply_arg: $ => choice($.type_operand, alias($._at_type, $.kind_application)),
 
   _type_apply: $ => prec.left('apply', seq(
-    field('constructor', $.type),
+    field('constructor', $.type_operand),
     field('argument', $._type_apply_arg),
   )),
 
@@ -107,17 +107,16 @@ module.exports = {
   // infix
   // ------------------------------------------------------------------------
 
-  _type_infix: $ => prec.right('infix', seq(
-    field('left_operand', $.type),
-    field('operator', $._tyops),
-    field('right_operand', $.type),
+  _type_infix_chain: $ => prec.right('infix', seq(
+    field('operand', $.type_operand),
+    repeat1(seq(field('operator', $._tyops), field('operand', $.type_operand))),
   )),
 
   // ------------------------------------------------------------------------
   // unquantified type
   // ------------------------------------------------------------------------
 
-  type: $ => choice(
+  type_operand: $ => choice(
     $._type_name,
     alias($._type_star, $.star),
     alias($._type_wildcard, $.wildcard),
@@ -128,11 +127,15 @@ module.exports = {
     alias($._type_unboxed_tuple, $.unboxed_tuple),
     alias($._type_unboxed_sum, $.unboxed_sum),
     alias($._type_tuple, $.tuple),
-    alias($._type_infix, $.infix),
     alias($._type_apply, $.apply),
     $._universal,
   ),
 
+  type: $ => choice(
+    alias($._type_infix_chain, $.infix_chain),
+    $.type_operand,
+  ),
+
   // ------------------------------------------------------------------------
   // forall
   // ------------------------------------------------------------------------
@@ -318,7 +321,7 @@ module.exports = {
 
   _type_instance_head: $ => choice(
     seq($._type_instance_head_params, optional(field('patterns', $.type_patterns))),
-    seq($._cond_infix, field('head', alias($._type_infix, $.infix))),
+    seq($._cond_infix, field('head', alias($._type_infix_chain, $.infix_chain))),
   ),
 
   // ------------------------------------------------------------------------

package/grammar.js

@@ -64,23 +64,14 @@ module.exports = grammar({
     $.pragma,
   ],
 
-  /**
-   * Rules with leading underscore are generally omitted from the AST, and can therefore not be used in queries.
-   * The rules listed in this attribute are omitted from the AST, but their names can be used in queries in place of
-   * their children; as well as in combination with them, using the syntax `expression/variable`.
-   * This is most useful for choice rules that represent syntactic categories, like expressions, patterns, and types in
-   * Haskell.
-   *
-   * See the readme for a detailed explanation.
-   */
   supertypes: $ => [
-    $.expression,
-    $.pattern,
-    $.binding_pattern,
+    $.expression_operand,
+    $.pattern_operand,
+    $.binding_pattern_operand,
     $.binding_field_pattern,
-    $.type,
+    $.type_operand,
     $.quantified_type,
-    $.constraint,
+    $.constraint_operand,
     $.constraints,
     $.type_param,
     $.declaration,