more tree-sitter-y and await expr

tree-sitter/grammar.js

@@ -12,7 +12,7 @@ module.exports = grammar({
 
   reserved: {
     toplevel_kw: $ =>
-    ['type', 'with', 'extensible', 'extend', 'union', 'def'],
+    ['type', 'with', 'extensible', 'extend', 'union', 'def', 'await', 'if', 'then', 'else', 'in', 'match'],
   },
 
   extras: ($) => [
@@ -24,6 +24,7 @@ module.exports = grammar({
 
   precedences: _ => [
     [
+      "ident",
       "exponent",
       "multiplication",
       "negate",
@@ -35,12 +36,13 @@ module.exports = grammar({
       "let",
       "new_match_arm",
       "match_arm",
+      "await",
       "tag",
     ],
   ],
 
   conflicts: $ => [
-    [$.match_expr, $.match_expr],
+    [$.match_expr, $.match_expr], // TODO
   ],
 
   rules: {
@@ -172,8 +174,8 @@ module.exports = grammar({
     list_expression: $ =>
       seq(
         '[',
-        repeat(seq($.expression, ',')),
-        optional($.expression),
+        repeat(seq($._expression, ',')),
+        optional($._expression),
         ']'),
 
     field_access: $ => prec.left(
@@ -181,13 +183,14 @@ module.exports = grammar({
 
     function_call: $ => prec.left(1,
       seq($._atom, '(',
-        repeat(seq($.expression, ',')), optional($.expression),
+        repeat(seq($._expression, ',')), optional($._expression),
         ')')),
 
-    ident_expr: $ => $.identifier,
+    ident_expr: $ => prec("ident",
+      $.path),
 
     record_expr_field: $ =>
-      seq($.identifier, ':', $.expression),
+      seq($.identifier, ':', $._expression),
 
     record_expr: $ => seq(
       '{',
@@ -196,7 +199,7 @@ module.exports = grammar({
       '}'),
 
     _atom: $ => choice(
-      prec(0, seq('(', $.expression, ')')),
+      prec(0, seq('(', $._expression, ')')),
       $.ident_expr,
       $.char_literal,
       $.string_literal,
@@ -209,86 +212,90 @@ module.exports = grammar({
 
     let_binding: $ => prec("let", seq(
       'let',
-      $.identifier,
+      field('name', $.identifier),
       '=',
-      $.expression,
+      field('value', $._expression),
       optional('in'),
-      $.expression,
+      field('body', $._expression),
     )),
 
     await_binding: $ => prec("let", seq(
       'await',
-      $.identifier,
+      field('name', $.identifier),
       '=',
-      $.expression,
+      field('value', $._expression),
       optional('in'),
-      $.expression,
+      field('body', $._expression),
     )),
 
     type_downcast: $ => seq(
-      $._atom,
+      field('expr', $._atom),
       '::',
-      $._type,
+      field('as', $._type),
     ),
 
     lambda: $ => prec.right(4, seq(
-      $.identifier,
-      optional(seq(':', $._type_non_fn)),
+      field('arg', $.identifier),
+      optional(seq(':', field('arg_type', $._type_non_fn))),
       '->',
-      $.expression
+      field('body', $._expression)
     )),
 
     with_expr: $ => prec.left("with",
-      seq($.expression, 'with', $._atom)),
+      seq($._expression, 'with', $._atom)),
 
     and_expr: $ => prec.left("with",
-      seq($.expression, 'and', $._atom)),
+      seq($._expression, 'and', $._atom)),
 
     if_expr: $ => prec("if",
-      seq('if', $.expression, 'then', $.expression, 'else', $.expression)),
+      seq('if', $._expression, 'then', $._expression, 'else', $._expression)),
 
     sub_expr: $ => prec.left("addition",
-      seq($.expression, '-', $.expression)),
+      seq($._expression, '-', $._expression)),
     add_expr: $ => prec.left("addition",
-      seq($.expression, '+', $.expression)),
+      seq($._expression, '+', $._expression)),
 
     divide_expr: $ => prec.left("multiplication",
-      seq($.expression, '/', $.expression)),
+      seq($._expression, '/', $._expression)),
     multiply_expr: $ => prec.left("multiplication",
-      seq($.expression, '*', $.expression)),
+      seq($._expression, '*', $._expression)),
 
     equal_expr: $ => prec.left("equal",
-      seq($.expression, '=', $.expression)),
+      seq($._expression, '=', $._expression)),
 
     concat_expr: $ => prec.left("concat",
-      seq($.expression, '++', $.expression)),
+      seq($._expression, '++', $._expression)),
 
     compose_expr: $ => prec.left("concat",
-      seq($.expression, '=>', $.expression)),
+      seq($._expression, '=>', $._expression)),
 
     exponent_expr: $ => prec.left("exponent",
-      seq($.expression, '^', $._atom)),
+      seq($._expression, '^', $._atom)),
 
     match_arm: $ => prec("match_arm",
       seq(
         field('cases', seq($._atom, repeat(seq('|', $._atom)))),
-        '->', $.expression)),
+        '->', $._expression)),
 
     match_expr: $ =>
-      seq('match', $.expression, 'with',
+      seq('match', $._expression, 'with',
         $.match_arm,
         prec("new_match_arm", repeat(seq('|', $.match_arm)))),
 
     negate_expr: $ => prec.right("negate",
-      seq('-', $.expression)),
+      seq('-', $._expression)),
 
     tag_expr: $ => prec.right("tag",
-      seq($.tag, $.expression)),
+      seq($.tag, $._expression)),
 
-    expression: $ => choice(
+    await_expr: $ => prec.right("await",
+      seq('await', $._expression)),
+
+    _expression: $ => choice(
       $._atom,
       $.let_binding,
       $.await_binding,
+      $.await_expr,
       $.type_downcast,
       $.lambda,
       $.with_expr,
@@ -309,12 +316,13 @@ module.exports = grammar({
     ),
 
     def: $ => seq(
-      'def', $.path,
+      'def',
+      field('name', $.path),
       choice(
-        seq(':', $._type),
+        seq(':', field('signature', $._type)),
         seq(
-          optional(seq(':', $._type)),
-          seq('=', $.expression),
+          optional(seq(':', field('signature', $._type))),
+          seq('=', field('value', $._expression)),
         )
       ),
     ),