@willbooster/tree-sitter-haskell 0.0.0-stage → 1.0.0

package/grammar/id.js

@@ -0,0 +1,132 @@
+const {
+  parens,
+  ticked,
+  promoted,
+  qualified,
+} = require('./util.js')
+
+module.exports = {
+  // ------------------------------------------------------------------------
+  // var
+  // ------------------------------------------------------------------------
+
+  _qualified_variable: $ => qualified($, $.variable),
+  _qvarid: $ => alias($._qualified_variable, $.qualified),
+  _varids: $ => choice($._qvarid, $.variable),
+
+  _var: $ => choice($.variable, $._pvarsym),
+  _qvar: $ => choice($._qvarid, $._pqvarsym),
+  _vars: $ => choice($._var, $._qvar),
+
+  _variable_ticked: $ => ticked($.variable),
+
+  _varop: $ => choice($.operator, alias($._variable_ticked, $.infix_id)),
+
+  _qvariable_ticked: $ => ticked($._qvarid),
+
+  _varids_ticked: $ => alias(
+    choice(
+      $._variable_ticked,
+      $._qvariable_ticked,
+    ),
+    $.infix_id,
+  ),
+
+  // ------------------------------------------------------------------------
+  // con
+  // ------------------------------------------------------------------------
+
+  _constructor: $ => alias($.name, $.constructor),
+  _qualified_constructor: $ => qualified($, $._constructor),
+  _qconid: $ => alias($._qualified_constructor, $.qualified),
+  _conids: $ => choice($._qconid, $._constructor),
+
+  _con: $ => choice($._constructor, $._pconsym),
+  _qcon: $ => choice($._qconid, $._pqconsym),
+  _cons: $ => choice(prec('con', $._con), $._qcon),
+
+  _constructor_ticked: $ => ticked($._constructor),
+  _conop: $ => choice($._constructor_operator_alias, alias($._constructor_ticked, $.infix_id)),
+
+  _qconstructor_ticked: $ => ticked($._qconid),
+
+  _conids_ticked: $ => alias(
+    choice(
+      $._constructor_ticked,
+      $._qconstructor_ticked,
+    ),
+    $.infix_id,
+  ),
+
+  // ------------------------------------------------------------------------
+  // tycon
+  // ------------------------------------------------------------------------
+
+  _tyconid: $ => $.name,
+  _qualified_type: $ => qualified($, $._tyconid),
+  _qtyconid: $ => alias($._qualified_type, $.qualified),
+  _tyconids: $ => choice($._qtyconid, $._tyconid),
+
+  _tycon_arrow: $ => parens($, alias($._arrow, $.operator)),
+  _qualified_arrow: $ => qualified($, alias($._arrow, $.operator)),
+  _qtycon_arrow: $ => parens($, alias($._qualified_arrow, $.qualified)),
+
+  _tycon: $ => choice($._tyconid, $._pvarsym, alias($._tycon_arrow, $.prefix_id), $._pconsym),
+  _qtycon: $ => choice($._qtyconid, alias($._qtycon_arrow, $.prefix_id), $._pqsym),
+  _tycons: $ => choice($._tycon, $._qtycon),
+
+  _promoted_tycons_alias: $ => seq('\'', $._cons),
+
+  _promoted_tycons: $ => alias($._promoted_tycons_alias, $.promoted),
+
+  _tycon_ticked: $ => ticked($._tyconid),
+  _qtycon_ticked: $ => ticked($._qtyconid),
+
+  _tyconids_ticked: $ => alias(
+    choice(
+      $._tycon_ticked,
+      $._qtycon_ticked,
+    ),
+    $.infix_id,
+  ),
+
+  _tyconops: $ => choice(
+    $._sym,
+    $._qsym,
+    $._operator_minus,
+    $._tyconids_ticked,
+  ),
+
+  /**
+   * Lenient parsing: `varsym` is not legal (like `'++`).
+   */
+  _promoted_tyconops_alias: $ => promoted($._tyconops),
+
+  _promoted_tyconops: $ => alias($._promoted_tyconops_alias, $.promoted),
+
+  _tyops: $ => choice(
+    $._tyconops,
+    $._promoted_tyconops,
+  ),
+
+  // ------------------------------------------------------------------------
+  // op
+  // ------------------------------------------------------------------------
+
+  _op_ticked: $ => choice(
+    $._varids_ticked,
+    $._conids_ticked,
+  ),
+
+  _ops: $ => choice(
+    $.operator,
+    $._qvarsym,
+    $.constructor_operator,
+    $._qconsym,
+    $._op_ticked,
+  ),
+
+  _name: $ => choice($._var, $._con),
+  _qname: $ => choice($._vars, $._cons),
+
+}

package/grammar/inline.js

@@ -0,0 +1,99 @@
+module.exports = {
+
+  inline: $ => [
+
+    // ------------------------------------------------
+    // variable
+    // ------------------------------------------------
+
+    $._var,
+    $._vars,
+    $._varids,
+    $._varids_ticked,
+    $._varop,
+
+    // ------------------------------------------------
+    // constructor
+    // ------------------------------------------------
+
+    $._constructor,
+    $._con,
+    $._qcon,
+    $._cons,
+    $._conids,
+    $._conids_ticked,
+    $._conop,
+    $._op_ticked,
+    $._modid,
+
+    // ------------------------------------------------
+    // operator
+    // ------------------------------------------------
+
+    $._qvarsym,
+    $._qconsym,
+    $._sym,
+    $._qsym,
+    $._pqsym,
+    $._any_prefix_dot,
+    $._any_tight_dot,
+    $._unboxed_bar,
+
+    // ------------------------------------------------
+    // expression
+    // ------------------------------------------------
+
+    $._exp_name,
+    $._exp_greedy,
+    $._let,
+
+    // ------------------------------------------------
+    // pattern
+    // ------------------------------------------------
+
+    $._pat_apply_arg,
+    $._pat_name,
+    $._pat_texp,
+
+    // ------------------------------------------------
+    // type
+    // ------------------------------------------------
+
+    $._tyconid,
+    $._tyconids,
+    $._tycon,
+    $._qtycon,
+    $._tycons,
+    $._tyconops,
+    $._tyops,
+
+    $._type_name,
+    $._forall,
+    $._type_apply_arg,
+    $._parameter_type,
+    $._field_type,
+    $._type_head,
+    $._type_instance_head,
+    $._type_annotation,
+    $._kind_annotation,
+
+    // ------------------------------------------------
+    // literal
+    // ------------------------------------------------
+
+    $._number,
+    $._stringly,
+    $._unit_cons,
+    $._tuple_cons,
+    $._universal,
+
+    // ------------------------------------------------
+    // decl
+    // ------------------------------------------------
+
+    $._function_head_patterns,
+    $._function_head,
+
+  ],
+
+}

package/grammar/lexeme.js

@@ -0,0 +1,59 @@
+const id_char = /[\pL\p{Mn}\pN_']*/
+
+const varid_start_char = /[_\p{Ll}\p{Lo}]/
+
+const conid_start_char = /[\p{Lu}\p{Lt}]/
+
+module.exports = {
+
+  variable: _ => token(seq(varid_start_char, id_char, /#*/)),
+
+  implicit_variable: _ => token(seq('?', varid_start_char, id_char)),
+
+  name: _ => token(seq(conid_start_char, id_char, /#*/)),
+
+  label: _ => token(seq('#', varid_start_char, id_char)),
+
+  _carrow: _ => choice('=>', '⇒'),
+  _arrow: _ => choice('->', '→'),
+  _linear_arrow: _ => choice('->.', '⊸'),
+  _larrow: _ => choice('<-', '←'),
+  _colon2: _ => choice('::', '∷'),
+  _promote: _ => '\'',
+
+  _qual_dot: $ => seq($._cond_qual_dot, '.'),
+  _tight_dot: $ => seq($._cond_tight_dot, '.'),
+  _any_tight_dot: $ => choice($._qual_dot, $._tight_dot),
+  _prefix_dot: $ => seq($._cond_prefix_dot, '.'),
+  _any_prefix_dot: $ => choice($._qual_dot, $._prefix_dot),
+
+  _tight_at: $ => seq($._cond_tight_at, '@'),
+  _prefix_at: $ => seq($._cond_prefix_at, '@'),
+
+  _prefix_bang: $ => seq($._cond_prefix_bang, '!'),
+  _tight_bang: $ => seq($._cond_tight_bang, '!'),
+  _any_prefix_bang: $ => choice($._prefix_bang, $._tight_bang),
+
+  _prefix_tilde: $ => seq($._cond_prefix_tilde, '~'),
+  _tight_tilde: $ => seq($._cond_tight_tilde, '~'),
+  _any_prefix_tilde: $ => choice($._prefix_tilde, $._tight_tilde),
+
+  _prefix_percent: $ => seq($._cond_prefix_percent, '%'),
+
+  _dotdot: $ => seq($._cond_dotdot, '..'),
+
+  _paren_open: $ => seq(alias(/\(/, '('), $._cmd_texp_start),
+  _paren_close: $ => seq(alias(/\)/, ')'), $._cmd_texp_end),
+  _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_close: $ => seq('#)', $._cmd_texp_end),
+  _unboxed_bar: _ => choice('|', token.immediate('|')),
+
+  _where: $ => seq(optional($._phantom_where), 'where'),
+
+  _bar: $ => seq(optional($._phantom_bar), '|'),
+
+}

package/grammar/literal.js

@@ -0,0 +1,102 @@
+const {
+  parens,
+  brackets,
+  unboxed,
+} = require('./util.js')
+
+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 = {
+
+  // ------------------------------------------------------------------------
+  // literals
+  // ------------------------------------------------------------------------
+
+  // the `choice` here is necessary to avoid integers being parsed as floats
+  float: _ => magic_hash(
+    seq(
+      decimal,
+      choice(
+        seq(/\.[0-9_]+/, optional(exponent)),
+        exponent,
+      ),
+    ),
+  ),
+
+  char: _ => magic_hash(
+    choice(
+      /'[^']'/,
+      /'\\[^ ]*'/,
+    ),
+  ),
+
+  string: _ => magic_hash(
+    seq(
+      '"',
+      repeat(choice(
+        /[^\\"\n]/,
+        /\\(\^)?./,
+        /\\\n\s*\\/,
+      )),
+      '"',
+    ),
+  ),
+
+  _integer_literal: _ => magic_hash(decimal),
+  _binary_literal: _ => magic_hash(/0[bB][01_]+/),
+  _octal_literal: _ => magic_hash(/0[oO][0-7]+/),
+
+  _hex_literal: _ => magic_hash(
+    seq(
+      /0[xX][0-9a-fA-F_]+/,
+      optional(/\.[0-9a-fA-F_]+/),
+      optional(hex_exponent),
+    )
+  ),
+
+  integer: $ => choice(
+    $._binary_literal,
+    $._integer_literal,
+    $._octal_literal,
+    $._hex_literal,
+  ),
+
+  _stringly: $ => choice(
+    $.string,
+    $.char,
+  ),
+
+  _number: $ => choice(
+    $.integer,
+    $.float,
+  ),
+
+  _plist: $ => brackets($),
+
+  unit: $ => parens($),
+  unboxed_unit: $ => unboxed($),
+
+  prefix_tuple: $ => parens($, repeat1(',')),
+  prefix_unboxed_tuple: $ => unboxed($, repeat1(',')),
+  prefix_unboxed_sum: $ => unboxed($, repeat1($._unboxed_bar)),
+
+  literal: $ => choice(
+    $._stringly,
+    $._number,
+  ),
+
+  _unit_cons: $ => choice(
+    $.unit,
+    $.unboxed_unit,
+  ),
+
+  _tuple_cons: $ => choice(
+    $.prefix_tuple,
+    $.prefix_unboxed_tuple,
+    $.prefix_unboxed_sum,
+  ),
+
+}

package/grammar/module.js

@@ -0,0 +1,150 @@
+const {
+  sep1,
+  sep,
+  parens,
+  semi,
+  semi_opt,
+  semis,
+} = require('./util.js')
+
+module.exports = {
+
+  // ------------------------------------------------------------------------
+  // module names
+  // ------------------------------------------------------------------------
+
+  _modid: $ => alias($.name, $.module_id),
+
+  _modid_prefix: $ => prec('qualifying-module', seq($._modid, $._any_tight_dot)),
+
+  _qualifying_module: $ => repeat1($._modid_prefix),
+
+  module: $ => seq(repeat($._modid_prefix), $._modid),
+
+  // ------------------------------------------------------------------------
+  // import/export
+  // ------------------------------------------------------------------------
+
+  namespace: _ => choice('pattern', 'type'),
+
+  _child_type: $ => seq(field('namespace', 'type'), field('type', $._tyconids)),
+
+  _child: $ => choice(
+    alias($._child_type, $.associated_type),
+    $._qname,
+  ),
+
+  children: $ => parens($, sep(',', field('element', choice(alias('..', $.all_names), $._child)))),
+
+  _ie_entity: $ => seq(
+    optional(field('namespace', $.namespace)),
+    choice(
+      field('variable', $._varids),
+      field('type', $._tyconids),
+      field('operator', choice($._sym_prefix, $._pqsym)),
+    ),
+    optional(field('children', $.children)),
+  ),
+
+  // ------------------------------------------------------------------------
+  // import
+  // ------------------------------------------------------------------------
+
+  import_list: $ => parens(
+    $,
+    sep(',', field('name', alias($._ie_entity, $.import_name))),
+    optional(','),
+  ),
+
+  import: $ => seq(
+    'import',
+    optional('qualified'),
+    optional(field('package', alias($.string, $.import_package))),
+    field('module', $.module),
+    optional('qualified'),
+    optional(seq('as', field('alias', $.module))),
+    optional(seq(
+      optional('hiding'),
+      field('names', $.import_list),
+    )),
+  ),
+
+  // ------------------------------------------------------------------------
+  // export
+  // ------------------------------------------------------------------------
+
+  module_export: $ => seq('module', field('module', $.module)),
+
+  exports: $ => parens(
+    $,
+    optional(sep1(',', choice(field('export', alias($._ie_entity, $.export)), $.module_export))),
+    optional(','),
+  ),
+
+  // ------------------------------------------------------------------------
+  // module body / sections
+  // ------------------------------------------------------------------------
+
+  header: $ => seq(
+    'module',
+    field('module', $.module),
+    field('exports', optional($.exports)),
+    $._where,
+  ),
+
+  imports: $ => seq(semis($, field('import', $.import)), semi($)),
+
+  /**
+   * Using `semi` at the end instead of `semi_opt` increases parser size by a full megabyte!!
+   *
+   * This allows imports after the first declaration to prevent the tree from jittering while typing an import:
+   *
+   * > import A
+   * > imp
+   * > import B
+   *
+   * The partially typed `imp` will be parsed as a `top_splice`, which forces `imports` to reduce after `import A`.
+   * The rest of the file will then be part of `declarations` and all following imports will be broken until the keyword
+   * has been completed.
+   */
+  declarations: $ => seq($.declaration, repeat(seq(semi($), choice($.declaration, $.import))), semi_opt($)),
+
+  _body: $ => seq(
+    choice($._cmd_layout_start, alias($._cmd_layout_start_explicit, '{')),
+    semi_opt($),
+    field('imports', optional($.imports)),
+    field('declarations', optional($.declarations)),
+    $._layout_end,
+  ),
+
+  _layout_end: $ => choice(
+    $._cond_layout_end,
+    alias($._cond_layout_end_explicit, '}'),
+  ),
+
+  /**
+   * This is a supertype.
+   */
+  declaration: $ => choice(
+    $.decl,
+    $.type_synomym,
+    $.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,
+  ),
+
+}

package/grammar/operator.js

@@ -0,0 +1,75 @@
+const {
+  parens,
+  qualified,
+} = require('./util.js')
+
+module.exports = {
+
+  // ------------------------------------------------------------------------
+  // var
+  // ------------------------------------------------------------------------
+
+  _operator_qual_dot_head: $ => seq($._cond_qual_dot, $._varsym),
+
+  _operator_hash_head: _ => seq(
+    choice('#', token.immediate('#')),
+    optional(choice(token.immediate('#'), token.immediate('|'))),
+  ),
+
+  operator: $ => choice(
+    seq(optional($._cond_prefix_dot), $._varsym),
+    $._operator_hash_head,
+    '*',
+  ),
+
+  _operator_alias: $ => $.operator,
+
+  _operator_minus: $ => alias('-', $.operator),
+
+  _varsym_prefix: $ => parens(
+    $,
+    choice(
+      $.operator,
+      $._operator_minus,
+      alias($._operator_qual_dot_head, $.operator),
+    ),
+  ),
+
+  _pvarsym: $ => alias($._varsym_prefix, $.prefix_id),
+
+  _qualified_varsym: $ => qualified($, choice($.operator, $._operator_minus)),
+  _qvarsym: $ => alias($._qualified_varsym, $.qualified),
+
+  _qvarsym_prefix: $ => parens($, $._qvarsym),
+  _pqvarsym: $ => alias($._qvarsym_prefix, $.prefix_id),
+
+  // ------------------------------------------------------------------------
+  // con
+  // ------------------------------------------------------------------------
+
+  constructor_operator: $ => $._consym,
+
+  _constructor_operator_alias: $ => $.constructor_operator,
+
+  _consym_prefix: $ => parens($, $.constructor_operator),
+  _pconsym: $ => alias($._consym_prefix, $.prefix_id),
+
+  _qualified_consym: $ => qualified($, $.constructor_operator),
+  _qconsym: $ => alias($._qualified_consym, $.qualified),
+
+  _qconsym_prefix: $ => parens($, $._qconsym),
+  _pqconsym: $ => alias($._qconsym_prefix, $.prefix_id),
+
+  // ------------------------------------------------------------------------
+  // op
+  // ------------------------------------------------------------------------
+
+  _sym: $ => choice($._operator_alias, $._constructor_operator_alias),
+
+  _sym_prefix: $ => choice($._pvarsym, $._pconsym),
+
+  _qsym: $ => choice($._qvarsym, $._qconsym),
+
+  _pqsym: $ => choice($._pqvarsym, $._pqconsym),
+
+}