@willbooster/tree-sitter-haskell 8.1.0 → 8.3.0

package/README.md

@@ -79,6 +79,8 @@ 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 [hsc2hs](https://github.com/haskell/hsc2hs) source in `.hsc` files, load `tree-sitter-hsc.wasm` instead. This dialect parses C directives and the doubled hashes that hsc2hs turns into literal hashes. Its node schema is `hsc/src/node-types.json`. Combine the ordinary queries with the matching suffixes in `hsc/queries/` for directive highlighting and C-body injections.
+
 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 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.
@@ -96,7 +98,7 @@ fuzzed with:
 ```toml
 [dependencies]
 tree-sitter = { package = "willbooster-tree-sitter", version = "7.0.5" }
-tree-sitter-haskell = { package = "willbooster-tree-sitter-haskell", version = "7" }
+tree-sitter-haskell = { package = "willbooster-tree-sitter-haskell", version = "8" }
 ```
 
 ```rust
@@ -104,6 +106,8 @@ let mut parser = tree_sitter::Parser::new();
 parser.set_language(&tree_sitter_haskell::LANGUAGE.into())?;
 ```
 
+For `.hsc` files in Rust, select `HSC_LANGUAGE` and `HSC_NODE_TYPES`. Use `HSC_HIGHLIGHTS_QUERY` and `HSC_INJECTIONS_QUERY` for the combined queries; `TAGS_QUERY` and `LOCALS_QUERY` are shared with ordinary Haskell.
+
 ## Development
 
 ```sh
@@ -125,7 +129,7 @@ well (e.g. `script/tree-sitter parse file.hs`).
 `bun run generate` records a fresh generation profile from the applicable `test/corpus` cases and Git-tracked
 files in `examples/`, then generates compact parser tables. The parser also embeds metadata from `tree-sitter.json`. After changing a grammar file,
 `tree-sitter.json`, a corpus case, or a tracked example,
-regenerate and commit `src/`. Stage added or removed examples with `git add -A examples` before generation so the profile uses the intended file list.
+regenerate and commit `src/` and `hsc/src/`. Stage added or removed examples with `git add -A examples` before generation so the profile uses the intended file list.
 Profiles in `.tmp/generation-profiles/` are temporary and must not be committed. `bun run build-wasm`, `bun run build/ci`,
 and the release build regenerate the parsers before compiling them.
 

package/grammar/data.js

@@ -70,7 +70,7 @@ module.exports = {
    */
   gadt_constructor: $ => seq(
     choice(
-      field('name', $._con),
+      field('name', $._decl_con),
       field('names', alias($._con_binding_list, $.binding_list)),
     ),
     $._colon2,
@@ -97,7 +97,7 @@ module.exports = {
   _field_type: $ => choice($.strict_field, $.lazy_field, $.type),
 
   _datacon_prefix: $ => seq(
-    field('name', $._con),
+    field('name', $._decl_con),
     repeat(prec('patterns', field('field', $._field_type))),
   ),
 
@@ -109,7 +109,7 @@ module.exports = {
   )),
 
   _datacon_record: $ => seq(
-    field('name', $._constructor),
+    field('name', $._decl_constructor),
     field('fields', alias($._record_fields, $.fields)),
   ),
 
@@ -169,7 +169,7 @@ module.exports = {
   _newtype_con_field: $ =>  $.type,
 
   newtype_constructor: $ => seq(
-    field('name', $._con),
+    field('name', $._decl_con),
     field('field', choice(
       alias($._newtype_con_field, $.field),
       alias($._record_fields, $.record),

package/grammar/decl.js

@@ -5,6 +5,8 @@ const {
   layout,
 } = require('./util.js')
 
+const foreignMacro = /[A-Z][A-Za-z_0-9]*/
+
 const binding = ($, pattern) => prec('bind', seq(
   choice(
     field('pattern', pattern),
@@ -17,10 +19,6 @@ const binding = ($, pattern) => prec('bind', seq(
 
 module.exports = {
 
-  // ------------------------------------------------------------------------
-  // fixity
-  // ------------------------------------------------------------------------
-
   _fun_arrow_prec: _ => seq('-', '1'),
 
   // GHC.Types special decl
@@ -39,10 +37,6 @@ module.exports = {
     ),
   ),
 
-  // ------------------------------------------------------------------------
-  // signature
-  // ------------------------------------------------------------------------
-
   _con_binding_list: $ => sep2(',', field('name', $._con)),
 
   _var_binding_list: $ => sep2(',', field('name', $._var)),
@@ -55,10 +49,6 @@ module.exports = {
     $._type_annotation,
   ),
 
-  // ------------------------------------------------------------------------
-  // function and pattern bind
-  // ------------------------------------------------------------------------
-
   _simple_bind_match: $ => seq('=', field('expression', $._exp)),
 
   _bind_match: $ => seq(
@@ -91,14 +81,6 @@ module.exports = {
     $._function_head_parens,
   ),
 
-  /**
-   * The difference between a `function` with an `infix` head and a `bind` with `pat_infix` is that the former is for
-   * _declaring_ a `varop` and the latter uses a `conop` to pattern match on the rhs expression.
-   * The former may not have a type annotation, while the latter may.
-   *
-   * > a <> b = undefined
-   * > h : t :: [Int] = undefined
-   */
   _function_head_infix: $ => seq(
     field('left_operand', $.pattern),
     optional($._cond_no_section_op),
@@ -118,10 +100,6 @@ module.exports = {
 
   _binding_name_parens: $ => parens($, choice($._var, $._binding_name_parens)),
 
-  /**
-   * The `implicit_variable` here is for:
-   * g = let ?par = Impy 5 in f
-   */
   bind: $ => binding($, $._pat),
 
   _module_bind: $ => binding($, $._binding_pat),
@@ -147,48 +125,67 @@ module.exports = {
 
   _where_binds: $ => seq($._where, optional(field('binds', $.local_binds))),
 
-  // ------------------------------------------------------------------------
-  // foreign
-  // ------------------------------------------------------------------------
-
-  calling_convention: _ => token(choice(
+  _foreign_calling_keyword: _ => token(choice(
     'ccall',
     'stdcall',
     'capi',
     'prim',
     'javascript',
-    /[A-Z_]+/, // It's common in GHC to use a cpp #define for this
   )),
 
-  safety: _ => token(choice(
+  _foreign_safety_keyword: _ => token(choice(
     'unsafe',
     'safe',
     'interruptible',
   )),
 
+  _foreign_macro: _ => token(prec(-1, foreignMacro)),
+
+  _foreign_underscore_identifier: _ => token(/_[A-Za-z_0-9]+/),
+
+  _foreign_calling_convention: $ => choice(
+    alias('_', $.calling_convention),
+    alias($._foreign_calling_keyword, $.calling_convention),
+    alias($._foreign_macro, $.calling_convention),
+    alias($._foreign_underscore_identifier, $.calling_convention),
+  ),
+
+  _foreign_safety: $ => choice(
+    alias('_', $.safety),
+    alias($._foreign_safety_keyword, $.safety),
+    alias($._foreign_macro, $.safety),
+    alias($._foreign_underscore_identifier, $.safety),
+  ),
+
+  _foreign_underscore_signature: $ => seq(
+    field('name', alias($._foreign_underscore_identifier, $.variable)),
+    $._type_annotation,
+  ),
+
+  _foreign_signature: $ => choice(
+    $.signature,
+    alias($._foreign_underscore_signature, $.signature),
+  ),
+
   entity: $ => $.string,
 
   foreign_import: $ => seq(
     'foreign',
     'import',
-    field('calling_convention', $.calling_convention),
-    optional(field('safety', $.safety)),
+    field('calling_convention', $._foreign_calling_convention),
+    optional(field('safety', $._foreign_safety)),
     optional(field('entity', $.entity)),
-    field('signature', $.signature),
+    field('signature', $._foreign_signature),
   ),
 
   foreign_export: $ => seq(
     'foreign',
     'export',
-    field('calling_convention', $.calling_convention),
+    field('calling_convention', $._foreign_calling_convention),
     optional(field('entity', $.entity)),
-    field('signature', $.signature),
+    field('signature', $._foreign_signature),
   ),
 
-  // ------------------------------------------------------------------------
-  // default
-  // ------------------------------------------------------------------------
-
   default_types: $ => seq('default', parens($, optional(sep1(',', field('type', $._ktype))))),
 
 }

package/grammar/id.js

@@ -37,11 +37,13 @@ module.exports = {
   // ------------------------------------------------------------------------
 
   _constructor: $ => alias($.name, $.constructor),
+  _decl_constructor: $ => $._constructor,
   _qualified_constructor: $ => qualified($, $._constructor),
   _qconid: $ => alias($._qualified_constructor, $.qualified),
   _conids: $ => choice($._qconid, $._constructor),
 
   _con: $ => choice($._constructor, $._pconsym),
+  _decl_con: $ => $._con,
   _qcon: $ => choice($._qconid, $._pqconsym),
   _cons: $ => choice(prec('con', $._con), $._qcon),
 

package/grammar/lexeme.js

@@ -6,15 +6,15 @@ const varid_start_char = /[_\p{Ll}\p{Lo}]/
 
 const conid_start_char = /[\p{Lu}\p{Lt}]/
 
-module.exports = {
+module.exports = (hash = '#') => ({
 
-  variable: _ => token(seq(varid_start_char, id_char, /#*/)),
+  variable: _ => token(seq(varid_start_char, id_char, hash === '#' ? /#*/ : /(##)*/)),
 
   implicit_variable: _ => token(seq('?', varid_start_char, id_char)),
 
-  name: _ => token(seq(conid_start_char, id_char, /#*/)),
+  name: _ => token(seq(conid_start_char, id_char, hash === '#' ? /#*/ : /(##)*/)),
 
-  label: _ => token(seq('#', choice(/[\pL\p{Mn}\pN_']+/, quoted_string(
+  label: _ => token(seq(hash, choice(/[\pL\p{Mn}\pN_']+/, quoted_string(
     /[^\p{C}\p{Zl}\p{Zp}\\"]/,
     /\\(?:[abfnrtv\\"'&]|\^[@-_]|[0-9]+|o[0-7]+|x[0-9a-fA-F]+|NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC[1-4]|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL)/,
   )))),
@@ -52,12 +52,12 @@ module.exports = {
   _bracket_open: $ => seq('[', $._cmd_texp_start),
   _bracket_close: $ => seq(']', $._cmd_texp_end),
 
-  _unboxed_open: $ => seq(optional($._unboxed_label_start), alias(seq($._paren_open, token.immediate('#')), '(#')),
-  _unboxed_close: $ => seq('#)', $._cmd_texp_end),
+  _unboxed_open: $ => seq(optional($._unboxed_label_start), alias(seq($._paren_open, token.immediate(hash)), '(#')),
+  _unboxed_close: $ => seq(`${hash})`, $._cmd_texp_end),
   _unboxed_bar: _ => choice('|', token.immediate('|')),
 
   _where: $ => seq(optional($._phantom_where), 'where'),
 
   _bar: $ => seq(optional($._phantom_bar), '|'),
 
-}
+})

package/grammar/literal.js

@@ -9,9 +9,11 @@ const {
 const decimal = /[0-9][0-9_]*/
 const exponent = /[eE][+-]?[0-9_]+/
 const hex_exponent = /[pP][+-]?[0-9a-fA-F_]+/
-const magic_hash = rule => token(seq(rule, optional(token.immediate(/##?/))))
 
-module.exports = {
+
+module.exports = (hashSuffix = /##?/) => {
+  const magic_hash = rule => token(seq(rule, optional(token.immediate(hashSuffix))))
+  return {
 
   float: _ => magic_hash(
     seq(
@@ -100,3 +102,4 @@ module.exports = {
   ),
 
 }
+}

package/grammar.js

@@ -9,8 +9,8 @@ const
   general = require('./grammar/general.js'),
   id = require('./grammar/id.js'),
   inline = require('./grammar/inline.js'),
-  lexeme = require('./grammar/lexeme.js'),
-  literal = require('./grammar/literal.js'),
+  lexeme = require('./grammar/lexeme.js')(),
+  literal = require('./grammar/literal.js')(),
   module_ = require('./grammar/module.js'),
   operator = require('./grammar/operator.js'),
   pat = require('./grammar/pat.js'),

package/hsc/grammar.js

@@ -0,0 +1,69 @@
+const haskell = require('../grammar.js')
+const literal = require('../grammar/literal.js')
+const lexeme = require('../grammar/lexeme.js')
+
+const braced = ($, close) => seq(
+  $._cond_hsc_hash,
+  '#',
+  optional($._hsc_name_space),
+  token.immediate('{'),
+  $._cmd_hsc_brace_open,
+  optional($._hsc_braced_space),
+  field('name', $.hsc_directive_name),
+  field('body', alias($.hsc_args_nested, $.hsc_args)),
+  close,
+  $._cmd_brace_close,
+)
+
+module.exports = grammar(haskell, {
+  name: 'hsc',
+
+  externals: ($, previous) => [
+    ...previous.slice(0, -1),
+    $._cmd_hsc_brace_open,
+    $._cond_hsc_hash,
+    $.hsc_args_nested,
+    $.hsc_args_newline,
+    previous[previous.length - 1],
+  ],
+
+  conflicts: ($, previous) => [
+    ...previous,
+    [$._foreign_safety, $.entity],
+  ],
+
+  rules: {
+    ...literal(/(?:##){1,2}/),
+    ...lexeme('##'),
+
+    _operator_hash_head: _ => seq(
+      choice('##', token.immediate('##')),
+      optional(choice(token.immediate('##'), token.immediate('|'))),
+    ),
+
+    _foreign_calling_convention: ($, previous) => choice(previous, $.hsc),
+    _foreign_safety: ($, previous) => choice(previous, $.hsc),
+    _ie_entity: ($, previous) => choice(previous, $.hsc),
+    entity: ($, previous) => choice(previous, $.hsc),
+    literal: ($, previous) => choice(previous, $._hsc_literal),
+    _var: ($, previous) => choice(previous, $.hsc),
+    _tycon: ($, previous) => choice(previous, $.hsc),
+    _decl_con: ($, previous) => choice(previous, $.hsc),
+    _decl_constructor: ($, previous) => choice(previous, $.hsc),
+
+    hsc: $ => choice(
+      braced($, '}'),
+      seq(
+        $._cond_hsc_hash,
+        '#',
+        optional($._hsc_name_space),
+        field('name', $.hsc_directive_name),
+        field('body', alias($.hsc_args_newline, $.hsc_args)),
+      ),
+    ),
+    _hsc_literal: $ => braced($, choice('}##', '}####')),
+    _hsc_name_space: _ => token.immediate(/(?:[\t\v\f\r\p{Zs}\x85\u2028\u2029]|\\\r?\n)+/),
+    _hsc_braced_space: _ => token.immediate(/(?:\p{White_Space}|\\\r?\n)+/),
+    hsc_directive_name: _ => token.immediate(prec(-1, /[\pL_](?:[\pL\pN_]|\\\r?\n)*/)),
+  },
+})

package/hsc/queries/highlights.scm

@@ -0,0 +1 @@
+(hsc_directive_name) @function.macro

package/hsc/queries/injections.scm

@@ -0,0 +1,2 @@
+((hsc_args) @injection.content
+  (#set! injection.language "c"))