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

package/grammar/pat.js

@@ -0,0 +1,149 @@
+const {
+  sep1,
+  sep2,
+  sep,
+  parens,
+  braces,
+  brackets,
+  unboxed_tuple_full,
+  unboxed_sum_single,
+} = require('./util.js')
+
+module.exports = {
+
+  // ------------------------------------------------------------------------
+  // 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),
+    )),
+    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)),
+
+  _pat_signature: $ => prec.right('annotated', seq(
+    field('pattern', $.pattern),
+    $._type_annotation,
+  )),
+
+  _pat: $ => choice(
+    alias($._pat_signature, $.signature),
+    prec.right($.pattern),
+  ),
+
+  view_pattern: $ => seq(field('expression', $._exp), $._arrow, field('pattern', $._pat_texp)),
+
+  _pat_texp: $ => choice($.view_pattern, $._pat),
+
+}

package/grammar/patsyn.js

@@ -0,0 +1,42 @@
+const {
+  layout,
+  optional_where,
+} = require('./util.js')
+
+module.exports = {
+  // ------------------------------------------------------------------------
+  // pattern synonym
+  // ------------------------------------------------------------------------
+
+  _patsyn_signature: $ => seq(
+    field('synonym', choice($._con, alias($._con_binding_list, $.binding_list))),
+    $._colon2,
+    field('type', $.quantified_type),
+  ),
+
+  _patsyn_cons: $ => layout($, alias($.bind, $.constructor_synonym)),
+
+  /**
+   * This allows a `where` after any equation for parsing resilience, even though it's only valid for the arrow variant
+   * (explicitly bidirectional patterns).
+   * The `where` may also be empty.
+   */
+  _patsyn_equation: $ => seq(
+    field('synonym', $.pattern),
+    choice(
+      '=',
+      $._larrow,
+    ),
+    field('pattern', $._pat),
+    optional_where($, field('constructors', alias($._patsyn_cons, $.constructor_synonyms))),
+  ),
+
+  pattern_synonym: $ => seq(
+    'pattern',
+    choice(
+      alias($._patsyn_signature, $.signature),
+      alias($._patsyn_equation, $.equation),
+    ),
+  ),
+
+}

package/grammar/precedences.js

@@ -0,0 +1,109 @@
+module.exports = {
+
+  precedences: $ => [
+
+    // ------------------------------------------------
+    // associativity of expressions, patterns and types
+    // ------------------------------------------------
+
+    [
+      'projection',
+      'record',
+      'prefix',
+      'apply',
+      'negation',
+      'infix',
+      'implicit',
+      'fun',
+      'annotated',
+      $.quantified_type,
+    ],
+
+    // ------------------------------------------------
+    // negation
+    // ------------------------------------------------
+
+    [
+      $._pat_negation,
+      $.literal,
+    ],
+
+    // ------------------------------------------------
+    // function vs bind
+    // ------------------------------------------------
+
+    [
+      'bind',
+      'pat-name',
+    ],
+
+    // ------------------------------------------------
+    // qualified names
+    // ------------------------------------------------
+
+    /**
+     * Prioritize shifting over a tight infix dot over reducing to a qualified constructor or module.
+     */
+    [
+      'qualifying-module',
+      'qualified-id',
+    ],
+
+    /**
+     * Prioritize qualified variables over record field projection on constructors.
+     */
+    [
+      'qualifying-module',
+      'con',
+    ],
+
+    /**
+     * Prioritize qualified names over the infix operator dot in types.
+     */
+    [
+      'qualifying-module',
+      'type-name',
+    ],
+
+    // ------------------------------------------------
+    // types and constraints
+    // ------------------------------------------------
+
+    [
+      $.operator,
+      $._type_star,
+    ],
+
+    [
+      $._type_wildcard,
+      $._type_param_wildcard,
+    ],
+
+    [
+      $._constructor_ticked,
+      $._tycon_ticked,
+    ],
+
+    [
+      'qtype-single',
+      'qtype-curried',
+    ],
+
+    // ------------------------------------------------
+    // misc
+    // ------------------------------------------------
+
+    /**
+     * > f A a a = a
+     * > data A = A Int Int
+     *
+     * This should not be parsed as constructor application, but separate patterns.
+     */
+    [
+      'patterns',
+      'apply',
+    ],
+
+  ],
+
+}

package/grammar/th.js

@@ -0,0 +1,82 @@
+const {
+  layout_sort,
+} = require('./util.js')
+
+const quote_bracket = ($, quoter) => seq(
+  $._cond_quote_start,
+  '[',
+  field('quoter', quoter),
+    '|',
+)
+
+module.exports = {
+
+  // ------------------------------------------------------------------------
+  // splice
+  // ------------------------------------------------------------------------
+
+  /**
+   * Even though the doc states "arbitrary expression", it's very rare for any others than names and parenthesized
+   * expressions to occur, and it's very expensive to allow them.
+   * Even only allowing list and quotes adds a full megabyte to the parser size.
+   */
+  _splice_exp: $ => choice(
+    $._exp_name,
+    alias($._exp_parens, $.parens),
+    $.literal,
+  ),
+
+  _splice_dollars: $ => seq(
+    $._cond_splice,
+    choice('$', '$$'),
+  ),
+
+  splice: $ => seq($._splice_dollars, field('expression', $._splice_exp)),
+
+  /**
+   * Since `expression` includes `splice`, this allows for a top level dollar splice as well.
+   */
+  top_splice: $ => $.expression,
+
+  quoter: $ => $._varids,
+
+  /**
+   * `_cond_quote_start` (in `quote_bracket`) is a zero-width token emitted by the scanner.
+   * While the quoter and the bar may not be preceded by whitespace, this is not necessary to ensure here with
+   * `token.immediate` since the scanner already verifies it.
+   */
+  quasiquote: $ => seq(
+    quote_bracket($, $.quoter),
+    optional(field('body', $.quasiquote_body)),
+    choice(token('|]'), '⟧'),
+  ),
+
+  quoted_decls: $ => layout_sort($, $._cmd_layout_start_quote, field('declaration', $.declaration)),
+
+  /**
+  * An "expression quotation" is valid in an expression, and its body may contain an expression, type, pattern or
+  * declaration layout.
+  *
+  * Which of these are valid is decided by the quoter: `e`, `t`, `p` or `d`.
+  * If the quoter is empty, or the special oxford bracket character is used, the body is parsed as an expression.
+  */
+  _exp_quote: $ => seq(
+    choice(
+      seq(choice('⟦', quote_bracket($, optional('e'))), optional(alias($._exp, $.quoted_expression))),
+      seq(quote_bracket($, 't'), optional(alias($._ktype, $.quoted_type))),
+      seq(quote_bracket($, 'p'), optional(alias($._pat, $.quoted_pattern))),
+      seq(quote_bracket($, 'd'), optional($.quoted_decls)),
+    ),
+    choice(token('|]'), '⟧'),
+  ),
+
+  _exp_typed_quote: $ => seq(
+    $._cond_quote_start,
+    '[',
+    optional('e'),
+    '||',
+    optional(alias($._exp, $.quoted_expression)),
+    token('||]'),
+  ),
+
+}