@willbooster/tree-sitter-haskell 7.0.2 → 8.0.0

package/grammar/externals.js

@@ -169,6 +169,8 @@ module.exports = {
     $._varsym,
     $._consym,
 
+    $._unboxed_label_start,
+
     // The newline is used as a dummy symbol that is emitted whenever the scanner has to update its state even though
     // the current position must be parsed by the grammar.
     /\n/,

package/grammar/lexeme.js

@@ -1,3 +1,5 @@
+const { quoted_string } = require('./util.js')
+
 const id_char = /[\pL\p{Mn}\pN_']*/
 
 const varid_start_char = /[_\p{Ll}\p{Lo}]/
@@ -12,7 +14,10 @@ module.exports = {
 
   name: _ => token(seq(conid_start_char, id_char, /#*/)),
 
-  label: _ => token(seq('#', varid_start_char, id_char)),
+  label: _ => token(seq('#', 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)/,
+  )))),
 
   _carrow: _ => choice('=>', '⇒'),
   _arrow: _ => choice('->', '→'),
@@ -47,8 +52,7 @@ module.exports = {
   _bracket_open: $ => seq('[', $._cmd_texp_start),
   _bracket_close: $ => seq(']', $._cmd_texp_end),
 
-  // Sadly, this does not have the effect of creating a single terminal for the bracket :'(
-  _unboxed_open: $ => alias(seq($._paren_open, token.immediate('#')), '(#'),
+  _unboxed_open: $ => seq(optional($._unboxed_label_start), alias(seq($._paren_open, token.immediate('#')), '(#')),
   _unboxed_close: $ => seq('#)', $._cmd_texp_end),
   _unboxed_bar: _ => choice('|', token.immediate('|')),
 

package/grammar/literal.js

@@ -2,18 +2,17 @@ const {
   parens,
   brackets,
   unboxed,
+  quoted_string,
+  string_gap,
 } = require('./util.js')
 
 const decimal = /[0-9][0-9_]*/
 const exponent = /[eE][+-]?[0-9_]+/
 const hex_exponent = /[pP][+-]?[0-9a-fA-F_]+/
-const escaped = /\\(\^)?./
-const string_gap = /\\\p{White_Space}+\\/
 const magic_hash = rule => token(seq(rule, optional(token.immediate(/##?/))))
 
 module.exports = {
 
-  // the `choice` here is necessary to avoid integers being parsed as floats
   float: _ => magic_hash(
     seq(
       decimal,
@@ -33,15 +32,7 @@ module.exports = {
 
   string: _ => magic_hash(
     choice(
-      seq(
-        '"',
-        repeat(choice(
-          /[^\\"\n]/,
-          escaped,
-          /\\\n\s*\\/,
-        )),
-        '"',
-      ),
+      quoted_string(/[^\\"\n]/, /\\(\^)?./),
       seq(
         '"""',
         repeat(seq(

package/grammar/util.js

@@ -1,16 +1,16 @@
-// ------------------------------------------------------------------------
-// structure
-// ------------------------------------------------------------------------
-
 const sep1 = (s, rule) => seq(rule, repeat(seq(s, rule)))
 
 const sep2 = (s, rule) => seq(rule, repeat1(seq(s, rule)))
 
 const sep = (s, rule) => optional(sep1(s, rule))
 
-// ------------------------------------------------------------------------
-// syntax
-// ------------------------------------------------------------------------
+const string_gap = /\\\p{White_Space}+\\/
+
+const quoted_string = (character, escape) => seq(
+  '"',
+  repeat(choice(character, escape, string_gap)),
+  '"',
+)
 
 const parens = ($, ...rule) => seq($._paren_open, ...rule, $._paren_close)
 
@@ -30,13 +30,6 @@ const semi_opt = $ => optional(semi($))
 
 const semis = ($, rule) => sep1(semi($), rule)
 
-// ------------------------------------------------------------------------
-// layout
-// ------------------------------------------------------------------------
-
-/**
- * More general variant of `layout_sort`.
- */
 const layout_sort_single = ($, start, rule) => seq(
   choice(start, alias($._cmd_layout_start_explicit, '{')),
   rule,
@@ -44,12 +37,8 @@ const layout_sort_single = ($, start, rule) => seq(
 )
 
 /**
- * Wrap a repeated rule in a layout.
- * This is used for `where`, `let`, `of`, `if` and `do`, and the toplevel module.
- * The `start` rule must be one of the externals starting with `_cmd_layout_<type>`, which instruct the scanner to push
- * a layout context with the current column as its indentation.
- * When a `_cond_layout_end` or `_cond_layout_semicolon` is encountered by the scanner, the recorded indent is compared
- * to the current one to make a decision.
+ * The start rule must be a `_cmd_layout_<type>` external so the scanner can push a layout context.
+ * Layout-start externals make the scanner record the current column; conditional end and semicolon tokens compare it.
  */
 const layout_sort = ($, start, rule) => seq(
   choice(start, alias($._cmd_layout_start_explicit, '{')),
@@ -62,29 +51,14 @@ const layout_sort = ($, start, rule) => seq(
 )
 
 /**
- * Same as `layout`, but using `layout_sort_single`.
- * This is necessary for braces without repeating layout elements.
- * Usually it is enough to just use `braces` for this (e.g. records), but if the rule is in a choice with a full
- * layout, we need to allow the layout start token since the scanner emits that unconditionally based on preceding
- * tokens.
+ * The scanner emits a layout-start token unconditionally after layout introducers, including single-element alternatives.
  */
 const layout_single = ($, rule) => layout_sort_single($, $._cmd_layout_start, rule)
 
-/**
- * Alias for `layout_sort` using the common layout type for the start token, which corresponds to declarations and GADT
- * constructors.
- */
 const layout = ($, rule) => layout_sort($, $._cmd_layout_start, rule)
 
-// ------------------------------------------------------------------------
-// unboxed
-// ------------------------------------------------------------------------
-
 const unboxed = ($, ...rules) => seq($._unboxed_open, ...rules, $._unboxed_close)
 
-/**
- * At least one element is filled, for expressions.
- */
 const unboxed_tuple_nonempty = ($, rule) => unboxed(
   $,
   repeat(','),
@@ -92,14 +66,8 @@ const unboxed_tuple_nonempty = ($, rule) => unboxed(
   repeat(seq(',', optional(field('element', rule))))
 )
 
-/**
- * All elements are filled in, for types and patterns.
- */
 const unboxed_tuple_full = ($, rule) => unboxed($, sep1(',', field('element', rule)))
 
-/**
- * Exactly one element is filled in, used by expressions, patterns and the special data constructors.
- */
 const unboxed_sum_single = ($, rule) => unboxed(
   $,
   choice(
@@ -109,21 +77,10 @@ const unboxed_sum_single = ($, rule) => unboxed(
   repeat($._unboxed_bar),
 )
 
-/**
- * All elements are filled in, for types.
- */
 const unboxed_sum_full = ($, rule) => unboxed($, sep2($._unboxed_bar, field('element', rule)))
 
-// ------------------------------------------------------------------------
-// where
-// ------------------------------------------------------------------------
-
 const optional_where = ($, rule) => optional(seq($._where, optional(rule)))
 
-// ------------------------------------------------------------------------
-// misc
-// ------------------------------------------------------------------------
-
 const qualified = ($, id) => prec('qualified-id', seq(
   field('module', alias($._qualifying_module, $.module)),
   field('id', id),
@@ -137,6 +94,8 @@ module.exports = {
   sep1,
   sep2,
   sep,
+  quoted_string,
+  string_gap,
   parens,
   braces,
   brackets,

package/package.json

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

package/tree-sitter.json

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