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

package/grammar/data.js

@@ -0,0 +1,241 @@
+const {
+  sep1,
+  sep,
+  braces,
+  layout,
+  unboxed_sum_single,
+  qualified,
+  context,
+  forall,
+} = require('./util.js')
+
+module.exports = {
+
+  // ------------------------------------------------------------------------
+  // fields
+  // ------------------------------------------------------------------------
+
+  field_name: $ => $.variable,
+  _qfield_name: $ => qualified($, $.field_name),
+  _field_names: $ => choice($.field_name, alias($._qfield_name, $.qualified)),
+
+  field_path: $ => seq(
+    field('field', $._field_names),
+    repeat1(seq($._tight_dot, field('subfield', $.field_name))),
+  ),
+
+  _field_spec: $ => choice(
+    $._field_names,
+    $.field_path,
+  ),
+
+  field: $ => prec('annotated', seq(
+    sep1(',', field('name', $.field_name)),
+    $._colon2,
+    field('type', $._parameter_type),
+  )),
+
+  _record_fields: $ => braces($, sep(',', field('field', $.field)), optional(',')),
+
+  // ------------------------------------------------------------------------
+  // deriving
+  // ------------------------------------------------------------------------
+
+  via: $ => seq('via', field('type', $.quantified_type)),
+
+  deriving_strategy: _ => choice('stock', 'newtype', 'anyclass'),
+
+  deriving: $ => seq(
+    optional($._phantom_deriving),
+    'deriving',
+    optional(field('strategy', $.deriving_strategy)),
+    field('classes', $.constraint),
+    optional(field('via', $.via)),
+  ),
+
+  // ------------------------------------------------------------------------
+  // gadt
+  // ------------------------------------------------------------------------
+
+  _gadt_con_prefix: $ => field('type', $.quantified_type),
+
+  _gadt_con_record: $ => seq(
+    field('fields', alias($._record_fields, $.fields)),
+    field('arrow', $._fun_arrow),
+    field('type', $.quantified_type),
+  ),
+
+  /**
+   * GADT constructors only allow single foralls and contexts
+   */
+  gadt_constructor: $ => seq(
+    choice(
+      field('name', $._con),
+      field('names', alias($._con_binding_list, $.binding_list)),
+    ),
+    $._colon2,
+    forall($),
+    context($),
+    field('type', choice(
+      alias($._gadt_con_prefix, $.prefix),
+      alias($._gadt_con_record, $.record),
+    )),
+  ),
+
+  gadt_constructors: $ => layout($, field('constructor', $.gadt_constructor)),
+
+  _gadt: $ => seq(
+    optional($._kind_annotation),
+    $._where,
+    optional(field('constructors', $.gadt_constructors)),
+  ),
+
+  // ------------------------------------------------------------------------
+  // data type
+  // ------------------------------------------------------------------------
+
+  _field_type: $ => choice($.strict_field, $.lazy_field, $.type),
+
+  _datacon_prefix: $ => seq(
+    field('name', $._con),
+    repeat(prec('patterns', field('field', $._field_type))),
+  ),
+
+  _datacon_infix: $ => prec('infix', seq(
+    $._cond_data_infix,
+    field('left_operand', $._field_type),
+    field('operator', $._conop),
+    field('right_operand', $._field_type),
+  )),
+
+  _datacon_record: $ => seq(
+    field('name', $._constructor),
+    field('fields', alias($._record_fields, $.fields)),
+  ),
+
+  _datacon_unboxed_sum: $ => unboxed_sum_single($, $.quantified_type),
+
+  /**
+   * Special constructors occurring in GHC code
+   */
+  _datacon_special: $ => choice(
+    $.unit,
+    $.unboxed_unit,
+    alias($._plist, $.empty_list),
+    alias($._type_tuple, $.tuple),
+    alias($._type_unboxed_tuple, $.unboxed_tuple),
+    alias($._datacon_unboxed_sum, $.unboxed_sum),
+  ),
+
+  /**
+   * data constructors only allow single foralls and contexts
+   */
+  data_constructor: $ => seq(
+    forall($),
+    context($),
+    field('constructor', choice(
+      alias($._datacon_prefix, $.prefix),
+      alias($._datacon_infix, $.infix),
+      alias($._datacon_record, $.record),
+      alias($._datacon_special, $.special),
+    )),
+  ),
+
+  data_constructors: $ => sep1($._bar, field('constructor', $.data_constructor)),
+
+  _data_rhs: $ => choice(
+    $._kind_annotation,
+    seq('=', field('constructors', $.data_constructors)),
+    $._gadt,
+  ),
+
+  _data: $ => seq(
+    context($),
+    $._type_head,
+    optional($._data_rhs),
+    repeat(field('deriving', $.deriving)),
+  ),
+
+  data_type: $ => seq(
+    optional('type'),
+    'data',
+    $._data,
+  ),
+
+  // ------------------------------------------------------------------------
+  // newtype
+  // ------------------------------------------------------------------------
+
+  _newtype_con_field: $ =>  $.type,
+
+  newtype_constructor: $ => seq(
+    field('name', $._con),
+    field('field', choice(
+      alias($._newtype_con_field, $.field),
+      alias($._record_fields, $.record),
+    )),
+  ),
+
+  _newtype: $ => seq(
+    choice(
+      seq('=', field('constructor', $.newtype_constructor)),
+      $._gadt,
+    ),
+    repeat(field('deriving', $.deriving)),
+  ),
+
+  newtype: $ => seq(
+    'newtype',
+    context($),
+    $._type_head,
+    $._newtype,
+  ),
+
+  // ------------------------------------------------------------------------
+  // data family
+  // ------------------------------------------------------------------------
+
+  _datafam: $ => seq(
+    $._type_head,
+    optional($._kind_annotation),
+  ),
+
+  data_family: $ => seq(
+    'data',
+    'family',
+    $._datafam,
+  ),
+
+  _inst_adt: $ => seq(
+    forall($),
+    context($),
+    $._type_instance_head,
+    optional($._data_rhs),
+    repeat(field('deriving', $.deriving)),
+  ),
+
+  decl_inst_adt: $ => seq(
+    'data',
+    'instance',
+    $._inst_adt,
+  ),
+
+  _inst_newtype: $ => seq(
+    forall($),
+    context($),
+    $._type_instance_head,
+    $._newtype,
+  ),
+
+  decl_inst_newtype: $ => seq(
+    'newtype',
+    'instance',
+    $._inst_newtype,
+  ),
+
+  data_instance: $ => choice(
+    alias($.decl_inst_adt, $.data_type),
+    alias($.decl_inst_newtype, $.newtype),
+  ),
+
+}

package/grammar/decl.js

@@ -0,0 +1,184 @@
+const {
+  sep1,
+  sep2,
+  parens,
+  layout,
+} = require('./util.js')
+
+module.exports = {
+
+  // ------------------------------------------------------------------------
+  // fixity
+  // ------------------------------------------------------------------------
+
+  _fun_arrow_prec: _ => seq('-', '1'),
+
+  // GHC.Types special decl
+  _fun_arrow_fixity: $ => seq(
+    field('associativity', 'infixr'),
+    field('precedence', alias($._fun_arrow_prec, $.integer)),
+    field('operator', alias('->', $.operator)),
+  ),
+
+  fixity: $ => choice(
+    $._fun_arrow_fixity,
+    seq(
+      field('associativity', choice('infixl', 'infixr', 'infix')),
+      field('precedence', optional($.integer)),
+      field('operator', sep1(',', choice($._operator_minus, $._varop, $._conop))),
+    ),
+  ),
+
+  // ------------------------------------------------------------------------
+  // signature
+  // ------------------------------------------------------------------------
+
+  _con_binding_list: $ => sep2(',', field('name', $._con)),
+
+  _var_binding_list: $ => sep2(',', field('name', $._var)),
+
+  signature: $ => seq(
+    choice(
+      field('name', $._var),
+      field('names', alias($._var_binding_list, $.binding_list)),
+    ),
+    $._type_annotation,
+  ),
+
+  // ------------------------------------------------------------------------
+  // function and pattern bind
+  // ------------------------------------------------------------------------
+
+  _simple_bind_match: $ => seq('=', field('expression', $._exp)),
+
+  _bind_match: $ => seq(
+    $._guards,
+    '=',
+    $._cmd_texp_end,
+    field('expression', $._exp),
+  ),
+
+  _bind_matches: $ => seq(
+    choice(
+      field('match', alias($._simple_bind_match, $.match)),
+      repeat1(field('match', alias($._bind_match, $.match))),
+    ),
+    optional($._where_binds),
+  ),
+
+  _function_name: $ => field('name', $._var),
+
+  function_head_parens: $ => parens(
+    $,
+    choice(
+      $._function_head,
+      $._function_head_patterns,
+    ),
+  ),
+
+  _function_head_patterns: $ => choice(
+    $._function_name,
+    field('parens', $.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),
+    field('operator', choice(seq($._cond_minus, $._operator_minus), $._varop)),
+    field('right_operand', $.pattern),
+  ),
+
+  _function_head: $ => choice(
+    seq($._function_head_patterns, field('patterns', $.patterns)),
+    alias($._function_head_infix, $.infix),
+  ),
+
+  function: $ => seq(
+    $._function_head,
+    $._bind_matches,
+  ),
+
+  /**
+   * The `implicit_variable` here is for:
+   * g = let ?par = Impy 5 in f
+   */
+  bind: $ => prec('bind', seq(
+    choice(
+      field('pattern', $._pat),
+      field('name', $._var),
+      field('implicit', $.implicit_variable),
+    ),
+    $._bind_matches,
+  )),
+
+  /**
+   * This is a supertype.
+   */
+  decl: $ => choice(
+    $.signature,
+    $.function,
+    $.bind,
+  ),
+
+  _local_decl: $ => choice(
+    $.fixity,
+    $.decl,
+  ),
+
+  local_binds: $ => layout($, field('decl', $._local_decl)),
+
+  _where_binds: $ => seq($._where, optional(field('binds', $.local_binds))),
+
+  // ------------------------------------------------------------------------
+  // foreign
+  // ------------------------------------------------------------------------
+
+  calling_convention: _ => token(choice(
+    'ccall',
+    'stdcall',
+    'capi',
+    'prim',
+    'javascript',
+    /[A-Z_]+/, // It's common in GHC to use a cpp #define for this
+  )),
+
+  safety: _ => token(choice(
+    'unsafe',
+    'safe',
+    'interruptible',
+  )),
+
+  entity: $ => $.string,
+
+  foreign_import: $ => seq(
+    'foreign',
+    'import',
+    field('calling_convention', $.calling_convention),
+    optional(field('safety', $.safety)),
+    optional(field('entity', $.entity)),
+    field('signature', $.signature),
+  ),
+
+  foreign_export: $ => seq(
+    'foreign',
+    'export',
+    field('calling_convention', $.calling_convention),
+    optional(field('entity', $.entity)),
+    field('signature', $.signature),
+  ),
+
+  // ------------------------------------------------------------------------
+  // default
+  // ------------------------------------------------------------------------
+
+  default_types: $ => seq('default', parens($, optional(sep1(',', field('type', $._ktype))))),
+
+}