377 lines
8.9 KiB
JavaScript
377 lines
8.9 KiB
JavaScript
/**
|
|
* @file Parser for the Crepuscular(ray) functional programming language
|
|
* @author Alexander Nutz <alexander.nutz@vxcc.dev>
|
|
* @license MIT
|
|
*/
|
|
|
|
/// <reference types="tree-sitter-cli/dsl" />
|
|
// @ts-check
|
|
|
|
module.exports = grammar({
|
|
name: "crepuscular",
|
|
|
|
reserved: {
|
|
toplevel_kw: $ =>
|
|
['type', 'with', 'extensible', 'extend', 'union', 'def', 'await', 'if', 'then', 'else', 'in', 'match'],
|
|
},
|
|
|
|
extras: ($) => [
|
|
/\s/, // whitespace
|
|
$.comment,
|
|
],
|
|
|
|
word: $ => $._identifier_tok,
|
|
|
|
precedences: _ => [
|
|
[
|
|
"parentrized",
|
|
"function_call",
|
|
"expr_atom",
|
|
|
|
"ident",
|
|
"exponent",
|
|
"multiplication",
|
|
"negate",
|
|
"addition",
|
|
"concat",
|
|
"with",
|
|
"equal",
|
|
"if",
|
|
"let",
|
|
"match_arm",
|
|
"new_match_arm",
|
|
"await",
|
|
"tag",
|
|
],
|
|
],
|
|
|
|
rules: {
|
|
source_file: $ => repeat($.definition),
|
|
|
|
_identifier_tok: $ => token(/[a-zA-Z_]+[a-zA-Z0-9_]*/),
|
|
identifier: $ => reserved('toplevel_kw', $._identifier_tok),
|
|
path: $ => prec.left(seq($.identifier, repeat(seq('.', $.identifier)))),
|
|
|
|
comment: $ =>
|
|
token(seq("# ", /.*/)),
|
|
|
|
doc_comment: $ =>
|
|
repeat1(seq('## ', token.immediate(/.*/))),
|
|
|
|
definition: $ => seq(
|
|
optional(field('doc', $.doc_comment)),
|
|
field('body', choice(
|
|
$.full_partial_type_definition,
|
|
$.type_definition,
|
|
$.extensible_union,
|
|
$.extend_decl,
|
|
$.def,
|
|
)),
|
|
),
|
|
|
|
extensible_union: $ => seq(
|
|
'extensible', 'union', $.path),
|
|
|
|
extend_decl: $ => seq(
|
|
'extend',
|
|
field('what', $.path),
|
|
'with',
|
|
field('tag', $.tag),
|
|
field('ty', $._type)),
|
|
|
|
full_partial_type_definition: $ => seq(
|
|
"type",
|
|
"?", field('name', $.path),
|
|
"=",
|
|
field('type', $._type)
|
|
),
|
|
|
|
type_definition: $ => seq(
|
|
"type",
|
|
optional(choice(
|
|
field('arg', $.identifier),
|
|
seq(
|
|
'[',
|
|
repeat(seq(field('arg', $.identifier), ',')),
|
|
field('arg', $.identifier),
|
|
']'),
|
|
)),
|
|
field('name', $.path),
|
|
"=",
|
|
field('type', $._type)
|
|
),
|
|
|
|
_type_atom: $ => choice(
|
|
$.just_type,
|
|
$.partial_type,
|
|
seq('(', $._type, ')'),
|
|
$.record_type,
|
|
),
|
|
|
|
_type_non_fn: $ => choice(
|
|
$._type_atom,
|
|
$.tagged_type,
|
|
$.union_type,
|
|
$.partial_union_type,
|
|
$.parametrized_type,
|
|
$.with_type,
|
|
$.recursive_type,
|
|
),
|
|
|
|
_type: $ => choice(
|
|
$._type_non_fn,
|
|
$.fn_type,
|
|
),
|
|
|
|
union_type: $ => prec.left(1,
|
|
seq(
|
|
field('left', $._type),
|
|
'|',
|
|
field('right', $._type))),
|
|
|
|
partial_union_type: $ => prec.left(1,
|
|
seq(
|
|
field('left', $._type),
|
|
'|', '...',
|
|
field('partial', $.partial_type))),
|
|
|
|
tag: $ => new RustRegex("'(?:[a-zA-Z_][a-zA-Z0-9_]*(?:[.][a-zA-Z_0-9]+)*)"),
|
|
tagged_type: $ => prec.right(3,
|
|
seq(field('tag', $.tag), optional(
|
|
field('type', choice(
|
|
$._type_atom,
|
|
$.parametrized_type))))),
|
|
|
|
multi_type_parameters: $ => seq('[',
|
|
field('arg', $._type),
|
|
repeat(seq(',', field('arg', $._type))),
|
|
']'),
|
|
parametrized_type: $ => prec.left(4, seq(
|
|
field('nest', choice(
|
|
$.multi_type_parameters,
|
|
$._type_atom,
|
|
)),
|
|
repeat(field('nest', $.path)),
|
|
field('type', $.path),
|
|
)),
|
|
|
|
with_type: $ => seq('with',
|
|
field('arg', $.identifier),
|
|
repeat(seq(',', field('arg', $.identifier))),
|
|
':',
|
|
field('type', $._type)),
|
|
|
|
recursive_type: $ => seq('&',
|
|
field('name', $.identifier),
|
|
field('type', $._type)),
|
|
|
|
partial_type: $ => seq('?', $.identifier),
|
|
|
|
fn_type: $ => prec.left(-10,
|
|
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: $ => seq(
|
|
'{',
|
|
repeat(seq(field('field', $.record_type_field), ',')),
|
|
optional(choice(
|
|
field('field', $.record_type_field),
|
|
seq('...', field('partial', $.partial_type)),
|
|
)),
|
|
'}'),
|
|
|
|
escape_sequence: $ =>
|
|
token.immediate(
|
|
seq('\\', /[tbrnf0"'\\]/)),
|
|
|
|
char_middle: $ => /./,
|
|
string_middle: $ => /[^\\"]+/,
|
|
|
|
char_literal: $ =>
|
|
seq('\'', choice($.escape_sequence, $.char_middle), '\''),
|
|
|
|
// TODO: fstrings
|
|
string_literal: $ =>
|
|
seq('"', repeat(choice($.escape_sequence, $.string_middle)), '"'),
|
|
|
|
num_literal: $ =>
|
|
seq(
|
|
choice(
|
|
/[0-9]+/,
|
|
/\-[0-9]+/
|
|
),
|
|
optional(token.immediate(/[.][0-9]+/))
|
|
),
|
|
|
|
list_expression: $ =>
|
|
seq(
|
|
'[',
|
|
repeat(seq($._expression, ',')),
|
|
optional($._expression),
|
|
']'),
|
|
|
|
field_access: $ => prec.left(
|
|
seq(field('expr', $._atom), ':', field('field', $.identifier))),
|
|
|
|
function_call: $ => prec.left("function_call",
|
|
seq(
|
|
field('fn', $._atom),
|
|
'(',
|
|
repeat(seq(field('arg', $._expression), ',')),
|
|
optional(field('arg', $._expression)),
|
|
')')),
|
|
|
|
ident_expr: $ => prec("ident",
|
|
$.path),
|
|
|
|
record_expr_field: $ =>
|
|
seq(field('field', $.identifier), ':', field('value', $._expression)),
|
|
|
|
record_expr: $ => seq(
|
|
'{',
|
|
repeat(seq($.record_expr_field, ',')),
|
|
optional($.record_expr_field),
|
|
'}'),
|
|
|
|
_atom: $ => choice(
|
|
prec("parentrized", seq('(', $._expression, ')')),
|
|
$.ident_expr,
|
|
$.char_literal,
|
|
$.string_literal,
|
|
$.num_literal,
|
|
$.list_expression,
|
|
$.field_access,
|
|
$.function_call,
|
|
$.record_expr,
|
|
),
|
|
|
|
let_binding: $ => prec("let", seq(
|
|
'let',
|
|
field('name', $.identifier),
|
|
'=',
|
|
field('value', $._expression),
|
|
optional('in'),
|
|
field('body', $._expression),
|
|
)),
|
|
|
|
await_binding: $ => prec("let", seq(
|
|
'await',
|
|
field('name', $.identifier),
|
|
'=',
|
|
field('value', $._expression),
|
|
optional('in'),
|
|
field('body', $._expression),
|
|
)),
|
|
|
|
type_downcast: $ => seq(
|
|
field('expr', $._atom),
|
|
'::',
|
|
field('as', $._type),
|
|
),
|
|
|
|
lambda: $ => prec.right(4, seq(
|
|
field('arg', $.identifier),
|
|
optional(seq(':', field('arg_type', $._type_non_fn))),
|
|
'->',
|
|
field('body', $._expression)
|
|
)),
|
|
|
|
and_expr: $ => prec.left("with",
|
|
seq(
|
|
field('left', $._expression),
|
|
'and',
|
|
field('right', $._atom))),
|
|
|
|
if_expr: $ => prec("if",
|
|
seq(
|
|
'if',
|
|
field('condition', $._expression),
|
|
'then',
|
|
field('then', $._expression),
|
|
'else',
|
|
field('else', $._expression))),
|
|
|
|
sub_expr: $ => prec.left("addition",
|
|
seq(field('left', $._expression), '-', field('right', $._expression))),
|
|
add_expr: $ => prec.left("addition",
|
|
seq(field('left', $._expression), '+', field('right', $._expression))),
|
|
|
|
divide_expr: $ => prec.left("multiplication",
|
|
seq(field('left', $._expression), '/', field('right', $._expression))),
|
|
multiply_expr: $ => prec.left("multiplication",
|
|
seq(field('left', $._expression), '*', field('right', $._expression))),
|
|
|
|
equal_expr: $ => prec.left("equal",
|
|
seq(field('left', $._expression), '=', field('right', $._expression))),
|
|
|
|
concat_expr: $ => prec.left("concat",
|
|
seq(field('left', $._expression), '++', field('right', $._expression))),
|
|
|
|
compose_expr: $ => prec.left("concat",
|
|
seq(field('left', $._expression), '=>', field('right', $._expression))),
|
|
|
|
exponent_expr: $ => prec.left("exponent",
|
|
seq(field('left', $._expression), '^', field('right', $._atom))),
|
|
|
|
match_arm: $ => prec("match_arm",
|
|
seq(
|
|
field('cases', seq($._atom, repeat(seq('|', $._atom)))),
|
|
'->', field('expr', $._atom))),
|
|
|
|
match_expr: $ =>
|
|
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))),
|
|
|
|
tag_expr: $ => prec.right("tag",
|
|
seq(
|
|
field('tag', $.tag),
|
|
field('expr', $._expression))),
|
|
|
|
await_expr: $ => prec.right("await",
|
|
seq('await', field('expr', $._expression))),
|
|
|
|
_expression: $ => choice(
|
|
prec("expr_atom", $._atom),
|
|
$.let_binding,
|
|
$.await_binding,
|
|
$.await_expr,
|
|
$.type_downcast,
|
|
$.lambda,
|
|
$.and_expr,
|
|
$.if_expr,
|
|
$.tag_expr,
|
|
$.match_expr,
|
|
|
|
$.add_expr,
|
|
$.sub_expr,
|
|
$.divide_expr,
|
|
$.multiply_expr,
|
|
$.concat_expr,
|
|
$.compose_expr,
|
|
$.equal_expr,
|
|
$.exponent_expr,
|
|
$.negate_expr,
|
|
),
|
|
|
|
def: $ => seq(
|
|
'def',
|
|
field('name', $.path),
|
|
choice(
|
|
seq(':', field('signature', $._type)),
|
|
seq(
|
|
optional(seq(':', field('signature', $._type))),
|
|
seq('=', field('value', $._expression)),
|
|
)
|
|
),
|
|
),
|
|
}
|
|
});
|