fixed grammar, grammar injections, wip topiary formatter

tree-sitter/grammar.js

@@ -59,8 +59,13 @@ module.exports = grammar({
     section_comment: $ =>
       token(seq("###", /.*/)),
 
+    doc_comment_value: $ =>
+      choice(
+        token.immediate(/\n/),
+        token.immediate(/[^\n]*\n?/)),
+
     doc_comment: $ =>
-      repeat1(seq('## ', token.immediate(/.*/))),
+      repeat1(seq('##', token.immediate(/ */), $.doc_comment_value)),
 
     definition: $ => seq(
       optional(field('doc', $.doc_comment)),
@@ -81,13 +86,13 @@ module.exports = grammar({
       field('what', $.path),
       'with',
       field('tag', $.tag),
-      field('ty', $._type)),
+      field('ty', $.type)),
 
     full_partial_type_definition: $ => seq(
       "type",
       "?", field('name', $.path),
       "=",
-      field('type', $._type)
+      field('type', $.type)
     ),
 
     type_definition: $ => seq(
@@ -102,18 +107,18 @@ module.exports = grammar({
       )),
       field('name', $.path),
       "=",
-      field('type', $._type)
+      field('type', $.type)
     ),
 
-    _type_atom: $ => choice(
+    type_atom: $ => choice(
       $.just_type,
       $.partial_type,
-      seq('(', $._type, ')'),
+      seq('(', $.type, ')'),
       $.record_type,
     ),
 
     _type_non_fn: $ => choice(
-      $._type_atom,
+      $.type_atom,
       $.tagged_type,
       $.union_type,
       $.partial_union_type,
@@ -122,20 +127,20 @@ module.exports = grammar({
       $.recursive_type,
     ),
 
-    _type: $ => choice(
+    type: $ => choice(
       $._type_non_fn,
       $.fn_type,
     ),
 
     union_type: $ => prec.left(1,
       seq(
-        field('left', $._type),
+        field('left', $.type),
         '|',
-        field('right', $._type))),
+        field('right', $.type))),
 
     partial_union_type: $ => prec.left(1,
       seq(
-        field('left', $._type),
+        field('left', $.type),
         '|', '...',
         field('partial', $.partial_type))),
 
@@ -143,17 +148,17 @@ module.exports = grammar({
     tagged_type: $ => prec.right(3,
       seq(field('tag', $.tag), optional(
         field('type', choice(
-          $._type_atom,
+          $.type_atom,
           $.parametrized_type))))),
 
     multi_type_parameters: $ => seq('[',
-      field('arg', $._type),
-      repeat(seq(',', field('arg', $._type))),
+      field('arg', $.type),
+      repeat(seq(',', field('arg', $.type))),
       ']'),
     parametrized_type: $ => prec.left(4, seq(
       field('nest', choice(
         $.multi_type_parameters,
-        $._type_atom,
+        $.type_atom,
       )),
       repeat(field('nest', $.path)),
       field('type', $.path),
@@ -163,22 +168,22 @@ module.exports = grammar({
       field('arg', $.identifier),
       repeat(seq(',', field('arg', $.identifier))),
       ':',
-      field('type', $._type)),
+      field('type', $.type)),
 
     recursive_type: $ => seq('&',
       field('name', $.identifier),
-      field('type', $._type)),
+      field('type', $.type)),
 
     partial_type: $ => seq('?', $.identifier),
 
     fn_type: $ => prec.left(-10,
-      seq(field('arg', $._type), '->', field('res', $._type))),
+      seq(field('arg', $.type), '->', field('res', $.type))),
 
     just_type: $ => prec(-1, $.path),
 
     // TODO: doc comments
 
-    record_type_field: $ => seq(field('name', $.identifier), ':', field('type', $._type)),
+    record_type_field: $ => seq(field('name', $.identifier), ':', field('type', $.type)),
     record_type: $ => seq(
       '{',
       repeat(seq(field('field', $.record_type_field), ',')),
@@ -214,26 +219,26 @@ module.exports = grammar({
     list_expression: $ =>
       seq(
         '[',
-        repeat(seq($._expression, ',')),
-        optional($._expression),
+        repeat(seq($.expression, ',')),
+        optional($.expression),
         ']'),
 
     field_access: $ => prec.left(
-      seq(field('expr', $._atom), ':', field('field', $.identifier))),
+      seq(field('expr', $.atom), ':', field('field', $.identifier))),
 
     function_call: $ => prec.left("function_call",
       seq(
-        field('fn', $._atom),
+        field('fn', $.atom),
         '(',
-        repeat(seq(field('arg', $._expression), ',')),
-        optional(field('arg', $._expression)),
+        repeat(seq(field('arg', $.expression), ',')),
+        optional(field('arg', $.expression)),
         ')')),
 
     ident_expr: $ => prec("ident",
       $.path),
 
     record_expr_field: $ =>
-      seq(field('field', $.identifier), ':', field('value', $._expression)),
+      seq(field('field', $.identifier), ':', field('value', $.expression)),
 
     record_expr: $ => seq(
       '{',
@@ -241,8 +246,8 @@ module.exports = grammar({
       optional($.record_expr_field),
       '}'),
 
-    _atom: $ => choice(
-      prec("parentrized", seq('(', $._expression, ')')),
+    atom: $ => choice(
+      prec("parentrized", seq('(', $.expression, ')')),
       $.ident_expr,
       $.char_literal,
       $.string_literal,
@@ -257,93 +262,93 @@ module.exports = grammar({
       'let',
       field('name', $.identifier),
       '=',
-      field('value', $._expression),
+      field('value', $.expression),
       optional('in'),
-      field('body', $._expression),
+      field('body', $.expression),
     )),
 
     await_binding: $ => prec("let", seq(
       'await',
       field('name', $.identifier),
       '=',
-      field('value', $._expression),
+      field('value', $.expression),
       optional('in'),
-      field('body', $._expression),
+      field('body', $.expression),
     )),
 
     type_downcast: $ => seq(
-      field('expr', $._atom),
+      field('expr', $.atom),
       '::',
-      field('as', $._type),
+      field('as', $.type),
     ),
 
     lambda: $ => prec.right(4, seq(
       field('arg', $.identifier),
       optional(seq(':', field('arg_type', $._type_non_fn))),
       '->',
-      field('body', $._expression)
+      field('body', $.expression)
     )),
 
     and_expr: $ => prec.left("with",
       seq(
-        field('left', $._expression),
+        field('left', $.expression),
         'and',
-        field('right', $._atom))),
+        field('right', $.atom))),
 
     if_expr: $ => prec("if",
       seq(
         'if',
-        field('condition', $._expression),
+        field('condition', $.expression),
         'then',
-        field('then', $._expression),
+        field('then', $.expression),
         'else',
-        field('else', $._expression))),
+        field('else', $.expression))),
 
     sub_expr: $ => prec.left("addition",
-      seq(field('left', $._expression), '-', field('right', $._expression))),
+      seq(field('left', $.expression), '-', field('right', $.expression))),
     add_expr: $ => prec.left("addition",
-      seq(field('left', $._expression), '+', field('right', $._expression))),
+      seq(field('left', $.expression), '+', field('right', $.expression))),
 
     divide_expr: $ => prec.left("multiplication",
-      seq(field('left', $._expression), '/', field('right', $._expression))),
+      seq(field('left', $.expression), '/', field('right', $.expression))),
     multiply_expr: $ => prec.left("multiplication",
-      seq(field('left', $._expression), '*', field('right', $._expression))),
+      seq(field('left', $.expression), '*', field('right', $.expression))),
 
     equal_expr: $ => prec.left("equal",
-      seq(field('left', $._expression), '=', field('right', $._expression))),
+      seq(field('left', $.expression), '=', field('right', $.expression))),
 
     concat_expr: $ => prec.left("concat",
-      seq(field('left', $._expression), '++', field('right', $._expression))),
+      seq(field('left', $.expression), '++', field('right', $.expression))),
 
     compose_expr: $ => prec.left("concat",
-      seq(field('left', $._expression), '=>', field('right', $._expression))),
+      seq(field('left', $.expression), '=>', field('right', $.expression))),
 
     exponent_expr: $ => prec.left("exponent",
-      seq(field('left', $._expression), '^', field('right', $._atom))),
+      seq(field('left', $.expression), '^', field('right', $.atom))),
 
     match_arm: $ => prec("match_arm",
       seq(
-        field('cases', seq($._atom, repeat(seq('|', $._atom)))),
-        '->', field('expr', $._atom))),
+        field('cases', seq($.atom, repeat(seq('|', $.atom)))),
+        '->', field('expr', $.atom))),
 
     match_expr: $ =>
-      seq('match', field('on', $._expression), 'with',
+      seq('match', field('on', $.expression), 'with',
         field('arm', $.match_arm),
         prec("new_match_arm", repeat(seq('|', field('arm', $.match_arm))))),
 
     negate_expr: $ => prec.right("negate",
-      seq('-', field('expr', $._expression))),
+      seq('-', field('expr', $.expression))),
 
     tag_expr: $ => prec.right("tag",
       seq(
         field('tag', $.tag),
-        field('expr', $._expression))),
+        field('expr', $.expression))),
 
     await_expr: $ => prec.right("await",
-      seq('await', field('expr', $._expression))),
+      seq('await', field('expr', $.expression))),
 
-    _expression: $ => choice(
-      prec("expr_atom", $._atom),
+    expression: $ => choice(
+      prec("expr_atom", $.atom),
       $.let_binding,
       $.await_binding,
       $.await_expr,
@@ -369,10 +374,10 @@ module.exports = grammar({
       'def',
       field('name', $.path),
       choice(
-        seq(':', field('signature', $._type)),
+        seq(':', field('signature', $.type)),
         seq(
-          optional(seq(':', field('signature', $._type))),
-          seq('=', field('value', $._expression)),
+          optional(seq(':', field('signature', $.type))),
+          seq('=', field('value', $.expression)),
         )
       ),
     ),