Untangle existing code for grammar
This commit is contained in:
Kirill Andreev
parent
f1938eb2af
commit
78c408b76a
@ -1,471 +1,373 @@
|
|||||||
let sepBy1 = (sep, rule) =>
|
let sepBy1 = (sep, p) => seq(p, repeat(seq(sep, p)))
|
||||||
seq(
|
let sepBy = (sep, p) => optional(sepBy1(sep, p))
|
||||||
rule,
|
|
||||||
repeat(seq(sep, rule)),
|
|
||||||
optional(sep)
|
|
||||||
)
|
|
||||||
|
|
||||||
let sepBy = (sep, rule) => optional(sepBy1(sep, rule))
|
function mkOp($, opExpr) {
|
||||||
|
return seq(
|
||||||
let par = x => seq('(', x, ')')
|
field("arg1", $._expr),
|
||||||
let brackets = x => seq('[', x, ']')
|
field("op", opExpr),
|
||||||
|
field("arg2", $._expr)
|
||||||
let ne_injection = (Kind, element) =>
|
);
|
||||||
choice(
|
}
|
||||||
seq(
|
|
||||||
Kind,
|
|
||||||
sepBy1(';', element),
|
|
||||||
'end',
|
|
||||||
),
|
|
||||||
seq(
|
|
||||||
Kind,
|
|
||||||
'[',
|
|
||||||
sepBy1(';', element),
|
|
||||||
']',
|
|
||||||
),
|
|
||||||
)
|
|
||||||
|
|
||||||
let injection = (Kind, element) =>
|
|
||||||
choice(
|
|
||||||
seq(
|
|
||||||
Kind,
|
|
||||||
sepBy(';', element),
|
|
||||||
'end',
|
|
||||||
),
|
|
||||||
seq(
|
|
||||||
Kind,
|
|
||||||
'[',
|
|
||||||
sepBy(';', element),
|
|
||||||
']',
|
|
||||||
),
|
|
||||||
)
|
|
||||||
|
|
||||||
let tuple = x => seq(x, ',', x, repeat(seq(',', x)))
|
|
||||||
let list__ = x => brackets(sepBy(';', x))
|
|
||||||
|
|
||||||
let nseq = x => seq(x, repeat(x))
|
|
||||||
|
|
||||||
let op = (l, x, r, def) =>
|
|
||||||
choice(
|
|
||||||
seq(l, x, r),
|
|
||||||
def,
|
|
||||||
)
|
|
||||||
|
|
||||||
let rop = (l, x, r) => op(l, x, r, r)
|
|
||||||
let lop = (l, x, r) => op(l, x, r, l)
|
|
||||||
|
|
||||||
module.exports = grammar({
|
module.exports = grammar({
|
||||||
name: 'CAMLigo',
|
name: 'CameLigo',
|
||||||
|
extras: $ => [$.comment, $.ocaml_comment, /\s/],
|
||||||
word: $ => $.Keyword,
|
|
||||||
extras: $ => [$.ocaml_comment, $.comment, /\s/],
|
|
||||||
|
|
||||||
conflicts: $ => [[$.call, $.if_then_else]],
|
|
||||||
|
|
||||||
rules: {
|
rules: {
|
||||||
// debug: $ => $.expr,
|
|
||||||
|
|
||||||
// contract: $ => repeat($.declaration),
|
contract: $ => repeat($._declaration),
|
||||||
contract: $ => $.expr,
|
|
||||||
|
|
||||||
expr: $ =>
|
_declaration: $ => choice(
|
||||||
choice(
|
$.let_decl,
|
||||||
$.let_expr,
|
$.type_decl
|
||||||
$.op_call,
|
|
||||||
),
|
|
||||||
|
|
||||||
let_expr: $ =>
|
|
||||||
prec.left(0,
|
|
||||||
seq(
|
|
||||||
'let',
|
|
||||||
$.let_binding,
|
|
||||||
repeat($.attr),
|
|
||||||
'in',
|
|
||||||
$.expr,
|
|
||||||
),
|
|
||||||
),
|
|
||||||
|
|
||||||
op_call: $ =>
|
|
||||||
$.tuple,
|
|
||||||
|
|
||||||
tuple: $ => prec.left(2, rop($.tuple, ',', $.disj)),
|
|
||||||
disj: $ => prec.left(3, rop($.disj, $.or, $.conj)),
|
|
||||||
conj: $ => prec.left(4, rop($.conj, $.and, $.comp)),
|
|
||||||
comp: $ => prec.left(5, rop($.comp, $.compare, $.cat)),
|
|
||||||
cat: $ => prec.left(6, lop($.cons, $.catenate, $.cat)),
|
|
||||||
cons: $ => prec.right(7, lop($.add, $.consolidate, $.cons)),
|
|
||||||
add: $ => prec.left(8, rop($.add, $.plus, $.mult)),
|
|
||||||
mult: $ => prec.left(9, rop($.mult, $.times, $.unary)),
|
|
||||||
|
|
||||||
unary: $ =>
|
|
||||||
seq(
|
|
||||||
optional($.negate),
|
|
||||||
$.call,
|
|
||||||
),
|
|
||||||
|
|
||||||
or: $ => choice('||', 'or'),
|
|
||||||
and: $ => '&&',
|
|
||||||
compare: $ => choice('<', '<=', '>', '>=', '=', '<>'),
|
|
||||||
catenate: $ => '^',
|
|
||||||
consolidate: $ => '::',
|
|
||||||
plus: $ => choice('+', '-'),
|
|
||||||
times: $ => choice('*', '/', 'mod'),
|
|
||||||
negate: $ => choice('-', 'not'),
|
|
||||||
|
|
||||||
call: $ =>
|
|
||||||
prec.left(1,
|
|
||||||
choice(
|
|
||||||
seq($.call, $.term),
|
|
||||||
$.term,
|
|
||||||
),
|
|
||||||
),
|
|
||||||
|
|
||||||
term: $ =>
|
|
||||||
choice(
|
|
||||||
$.ref,
|
|
||||||
$.if_then_else,
|
|
||||||
$.literal,
|
|
||||||
$.match,
|
|
||||||
),
|
|
||||||
|
|
||||||
match: $ =>
|
|
||||||
prec.right(0,
|
|
||||||
seq(
|
|
||||||
'match',
|
|
||||||
$.expr,
|
|
||||||
'with',
|
|
||||||
optional('|'),
|
|
||||||
sepBy1('|', $.alt),
|
|
||||||
),
|
|
||||||
),
|
|
||||||
|
|
||||||
alt: $ =>
|
|
||||||
prec.right(0,
|
|
||||||
seq(
|
|
||||||
$.pattern,
|
|
||||||
'->',
|
|
||||||
$.expr,
|
|
||||||
),
|
|
||||||
),
|
|
||||||
|
|
||||||
literal: $ =>
|
|
||||||
choice(
|
|
||||||
$.Nat,
|
|
||||||
$.Int,
|
|
||||||
$.Tez,
|
|
||||||
$.String,
|
|
||||||
$.Bytes,
|
|
||||||
$.group,
|
|
||||||
$.annotation,
|
|
||||||
$.list,
|
|
||||||
$.lambda,
|
|
||||||
$.unit,
|
|
||||||
$.record,
|
|
||||||
$.record_update,
|
|
||||||
),
|
|
||||||
|
|
||||||
record: $ =>
|
|
||||||
seq(
|
|
||||||
'{',
|
|
||||||
sepBy1(';', $.record_field),
|
|
||||||
'}',
|
|
||||||
),
|
|
||||||
|
|
||||||
record_update: $ =>
|
|
||||||
seq(
|
|
||||||
'{',
|
|
||||||
$.name,
|
|
||||||
'with',
|
|
||||||
sepBy1(';', $.record_field_update),
|
|
||||||
'}',
|
|
||||||
),
|
|
||||||
|
|
||||||
record_field_update: $ =>
|
|
||||||
seq(
|
|
||||||
sepBy1('.', $.name),
|
|
||||||
'=',
|
|
||||||
$.expr,
|
|
||||||
),
|
|
||||||
|
|
||||||
record_field: $ =>
|
|
||||||
seq(
|
|
||||||
$.name,
|
|
||||||
'=',
|
|
||||||
$.expr,
|
|
||||||
),
|
|
||||||
|
|
||||||
unit: $ => seq('(', ')'),
|
|
||||||
|
|
||||||
lambda: $ =>
|
|
||||||
seq(
|
|
||||||
'fun',
|
|
||||||
repeat($.pattern_term),
|
|
||||||
'->',
|
|
||||||
$.expr,
|
|
||||||
),
|
|
||||||
|
|
||||||
list: $ =>
|
|
||||||
seq(
|
|
||||||
'[',
|
|
||||||
sepBy(';', $.expr),
|
|
||||||
']',
|
|
||||||
),
|
|
||||||
|
|
||||||
annotation: $ =>
|
|
||||||
seq(
|
|
||||||
'(',
|
|
||||||
$.expr,
|
|
||||||
':',
|
|
||||||
$.type_expr,
|
|
||||||
')',
|
|
||||||
),
|
|
||||||
|
|
||||||
group: $ =>
|
|
||||||
seq(
|
|
||||||
'(',
|
|
||||||
$.expr,
|
|
||||||
')',
|
|
||||||
),
|
|
||||||
|
|
||||||
if_then_else: $ =>
|
|
||||||
prec.right(0,
|
|
||||||
seq(
|
|
||||||
'if',
|
|
||||||
$.expr,
|
|
||||||
'then',
|
|
||||||
$.expr,
|
|
||||||
'else',
|
|
||||||
$.expr,
|
|
||||||
),
|
|
||||||
),
|
|
||||||
|
|
||||||
ref: $ =>
|
|
||||||
choice(
|
|
||||||
$.module_qualified,
|
|
||||||
$.struct_qualified,
|
|
||||||
$.name,
|
|
||||||
$.constr,
|
|
||||||
),
|
|
||||||
|
|
||||||
module_qualified: $ =>
|
|
||||||
seq(
|
|
||||||
$.constr,
|
|
||||||
'.',
|
|
||||||
$.name,
|
|
||||||
),
|
|
||||||
|
|
||||||
struct_qualified: $ =>
|
|
||||||
seq(
|
|
||||||
$.name,
|
|
||||||
nseq(seq('.', $.accessor)),
|
|
||||||
),
|
|
||||||
|
|
||||||
accessor: $ => choice($.name, $.Int),
|
|
||||||
|
|
||||||
declaration: $ =>
|
|
||||||
choice(
|
|
||||||
$.type_decl,
|
|
||||||
$.let_declaration,
|
|
||||||
),
|
|
||||||
|
|
||||||
type_decl: $ =>
|
|
||||||
seq(
|
|
||||||
'type',
|
|
||||||
$.type_name,
|
|
||||||
'=',
|
|
||||||
$.type_expr,
|
|
||||||
),
|
|
||||||
|
|
||||||
type_expr: $ =>
|
|
||||||
choice(
|
|
||||||
$.fun_type,
|
|
||||||
$.sum_type,
|
|
||||||
$.record_type,
|
|
||||||
),
|
|
||||||
|
|
||||||
fun_type: $ =>
|
|
||||||
seq(
|
|
||||||
$.cartesian,
|
|
||||||
optional(seq('->', $.fun_type)),
|
|
||||||
),
|
|
||||||
|
|
||||||
cartesian: $ =>
|
|
||||||
prec.left(1,
|
|
||||||
seq(
|
|
||||||
$.core_type,
|
|
||||||
optional(seq('*', sepBy('*', $.core_type))),
|
|
||||||
),
|
|
||||||
),
|
|
||||||
|
|
||||||
core_type: $ =>
|
|
||||||
choice(
|
|
||||||
$.type_name,
|
|
||||||
par($.type_expr),
|
|
||||||
$.module_type_name,
|
|
||||||
$.type_application
|
|
||||||
),
|
|
||||||
|
|
||||||
module_type_name: $ =>
|
|
||||||
seq(
|
|
||||||
$.module_name,
|
|
||||||
'.',
|
|
||||||
$.type_name,
|
|
||||||
),
|
|
||||||
|
|
||||||
type_application: $ =>
|
|
||||||
seq(
|
|
||||||
choice($.core_type, $.type_tuple),
|
|
||||||
$.type_name,
|
|
||||||
),
|
|
||||||
|
|
||||||
type_tuple: $ =>
|
|
||||||
par(tuple($.type_expr)),
|
|
||||||
|
|
||||||
sum_type: $ =>
|
|
||||||
seq(
|
|
||||||
optional('|'),
|
|
||||||
sepBy1('|', $.variant),
|
|
||||||
),
|
|
||||||
|
|
||||||
variant: $ =>
|
|
||||||
seq(
|
|
||||||
$.constr,
|
|
||||||
optional(seq('of', $.fun_type)),
|
|
||||||
),
|
|
||||||
|
|
||||||
record_type: $ =>
|
|
||||||
seq(
|
|
||||||
'{',
|
|
||||||
sepBy(';', $.field_decl),
|
|
||||||
'}',
|
|
||||||
),
|
|
||||||
|
|
||||||
field_decl: $ =>
|
|
||||||
seq(
|
|
||||||
$.field_name,
|
|
||||||
':',
|
|
||||||
$.type_expr,
|
|
||||||
),
|
|
||||||
|
|
||||||
let_declaration: $ =>
|
|
||||||
seq(
|
|
||||||
'let',
|
|
||||||
optional($.rec),
|
|
||||||
$.let_binding,
|
|
||||||
repeat($.attr),
|
|
||||||
),
|
|
||||||
|
|
||||||
let_binding: $ =>
|
|
||||||
choice(
|
|
||||||
seq(
|
|
||||||
$.name,
|
|
||||||
nseq($.pattern_term),
|
|
||||||
optional($.type_annotation),
|
|
||||||
'=',
|
|
||||||
$.expr,
|
|
||||||
),
|
|
||||||
seq(
|
|
||||||
$.pattern,
|
|
||||||
optional($.type_annotation),
|
|
||||||
'=',
|
|
||||||
$.expr,
|
|
||||||
),
|
|
||||||
),
|
|
||||||
|
|
||||||
type_annotation: $ => seq(':', $.type_expr),
|
|
||||||
|
|
||||||
pattern_term: $ =>
|
|
||||||
choice(
|
|
||||||
$.pattern_record,
|
|
||||||
$.constr,
|
|
||||||
$.pattern_list,
|
|
||||||
$.pattern_constant,
|
|
||||||
$.name,
|
|
||||||
$.pattern_grouped,
|
|
||||||
),
|
|
||||||
|
|
||||||
pattern_grouped: $ =>
|
|
||||||
seq(
|
|
||||||
'(',
|
|
||||||
$.pattern,
|
|
||||||
optional($.type_annotation),
|
|
||||||
')',
|
|
||||||
),
|
|
||||||
|
|
||||||
pattern_list: $ => list__($.pattern),
|
|
||||||
pattern_constant: $ =>
|
|
||||||
choice(
|
|
||||||
$.Nat,
|
|
||||||
$.String,
|
|
||||||
$.Bytes,
|
|
||||||
$.Int,
|
|
||||||
),
|
|
||||||
|
|
||||||
pattern_record: $ =>
|
|
||||||
seq(
|
|
||||||
'{',
|
|
||||||
sepBy1(';', $.pattern_record_field),
|
|
||||||
'}',
|
|
||||||
),
|
|
||||||
|
|
||||||
pattern_record_field: $ =>
|
|
||||||
seq(
|
|
||||||
$.name,
|
|
||||||
'=',
|
|
||||||
$.pattern,
|
|
||||||
),
|
|
||||||
|
|
||||||
pattern: $ => sepBy1('::', $.pattern_tuple),
|
|
||||||
pattern_tuple: $ => sepBy1(',', $.construct),
|
|
||||||
|
|
||||||
construct: $ =>
|
|
||||||
choice(
|
|
||||||
seq($.constr, nseq($.pattern_term)),
|
|
||||||
$.pattern_term,
|
|
||||||
),
|
|
||||||
|
|
||||||
///////////////////////////////////////////
|
|
||||||
|
|
||||||
type_name: $ => $.ident,
|
|
||||||
field_name: $ => $.ident,
|
|
||||||
fun_name: $ => $.ident,
|
|
||||||
struct_name: $ => $.ident,
|
|
||||||
var: $ => $.ident,
|
|
||||||
module_name: $ => $.Name_Capital,
|
|
||||||
constr: $ => $.Name_Capital,
|
|
||||||
ident: $ => $.Name,
|
|
||||||
name: $ => $.Name,
|
|
||||||
|
|
||||||
comment: $ => /\/\/[^\n]*\n/,
|
|
||||||
|
|
||||||
ocaml_comment: $ => seq(
|
|
||||||
'(*',
|
|
||||||
repeat(choice(
|
|
||||||
$.ocaml_comment,
|
|
||||||
/[^\(]|\(?!\*/,
|
|
||||||
)),
|
|
||||||
'*)'
|
|
||||||
),
|
),
|
||||||
|
|
||||||
include: $ => seq('#include', $.String),
|
type_annot: $ => seq(
|
||||||
|
":",
|
||||||
|
field("annotExpr", $.type_expr)
|
||||||
|
),
|
||||||
|
|
||||||
String: $ => /\"(\\.|[^"])*\"/,
|
argument: $ => seq(
|
||||||
Int: $ => /-?([1-9][0-9_]*|0)/,
|
"(",
|
||||||
Nat: $ => /([1-9][0-9_]*|0)n/,
|
field("argPattern", $._pattern),
|
||||||
Tez: $ => /([1-9][0-9_]*|0)(\.[0-9_]+)?(tz|tez|mutez)/,
|
field("argAnnot", $.type_annot),
|
||||||
Bytes: $ => /0x[0-9a-fA-F]+/,
|
")"
|
||||||
Name: $ => /[a-z][a-zA-Z0-9_]*/,
|
),
|
||||||
|
|
||||||
|
let_decl: $ => seq(
|
||||||
|
"let",
|
||||||
|
field("binder", $._binder),
|
||||||
|
optional(field("bindAnnot", $.type_annot)),
|
||||||
|
"=",
|
||||||
|
field("letExpr",$._let_expr)
|
||||||
|
),
|
||||||
|
|
||||||
|
_binder: $ => choice(
|
||||||
|
field("letBinds", $.let_binds),
|
||||||
|
field("letPat", $.let_pat)
|
||||||
|
),
|
||||||
|
|
||||||
|
//========== EXPR ============
|
||||||
|
|
||||||
|
_let_expr: $ => choice(
|
||||||
|
$.let_expr1,
|
||||||
|
$._expr
|
||||||
|
),
|
||||||
|
|
||||||
|
let_binds: $ => prec(1, seq(
|
||||||
|
optional(field("recursive", "rec")),
|
||||||
|
field("bindName", $.Name),
|
||||||
|
repeat(field("bindArgument", $.argument))
|
||||||
|
)),
|
||||||
|
|
||||||
|
let_pat: $ => $._pattern,
|
||||||
|
|
||||||
|
let_expr1: $ => seq(
|
||||||
|
"let",
|
||||||
|
choice(field("letBinds", $.let_binds), field("letPat", $.let_pat)),
|
||||||
|
optional(field("bindAnnot", $.type_annot)),
|
||||||
|
"=",
|
||||||
|
field("letExpr",$._expr),
|
||||||
|
"in",
|
||||||
|
field("innerExpr", $._let_expr)
|
||||||
|
),
|
||||||
|
|
||||||
|
// [1;2]
|
||||||
|
list_pattern: $ => seq(
|
||||||
|
"[",
|
||||||
|
sepBy1(';', field("patternListItem", $._pattern)),
|
||||||
|
"]"
|
||||||
|
),
|
||||||
|
|
||||||
|
// a :: b
|
||||||
|
list_con_pattern: $ => prec.right(9, seq(
|
||||||
|
field("patX", $._pattern),
|
||||||
|
"::",
|
||||||
|
field("patXs", $._pattern)
|
||||||
|
)),
|
||||||
|
|
||||||
|
// a, b, c
|
||||||
|
tup_pattern: $ => prec.right(8,seq(
|
||||||
|
field("tuplePatternItem", $._pattern),
|
||||||
|
",",
|
||||||
|
sepBy1(",", field("tuplePatternItem", $._pattern))
|
||||||
|
)),
|
||||||
|
|
||||||
|
_pattern: $ => choice(
|
||||||
|
$.Name,
|
||||||
|
$.paren_pattern,
|
||||||
|
$.con_pattern,
|
||||||
|
$._literal,
|
||||||
|
$.list_pattern,
|
||||||
|
$.list_con_pattern,
|
||||||
|
$.tup_pattern,
|
||||||
|
"_"
|
||||||
|
),
|
||||||
|
|
||||||
|
con_pattern: $ => prec(10,
|
||||||
|
seq(
|
||||||
|
field("conPattern", $.data_con),
|
||||||
|
optional(field("conArgPattern",$._pattern))
|
||||||
|
)
|
||||||
|
),
|
||||||
|
|
||||||
|
paren_pattern: $ => seq(
|
||||||
|
"(",
|
||||||
|
field("innerPattern", $._pattern),
|
||||||
|
")"
|
||||||
|
),
|
||||||
|
|
||||||
|
call: $ => choice(
|
||||||
|
$.unary_op_app,
|
||||||
|
$._mod_op_app,
|
||||||
|
$._mul_op_app,
|
||||||
|
$._add_op_app,
|
||||||
|
$._list_con_op_app,
|
||||||
|
$._string_cat_op_app,
|
||||||
|
$._bool_op_app,
|
||||||
|
$._comp_op_app
|
||||||
|
),
|
||||||
|
|
||||||
|
_mod_op_app: $ => prec.left(16, mkOp($, "mod")),
|
||||||
|
_mul_op_app: $ => prec.left(15, mkOp($, choice("/", "*"))),
|
||||||
|
_add_op_app: $ => prec.left(14, mkOp($, choice("-", "+"))),
|
||||||
|
_list_con_op_app: $ => prec.right(13, mkOp($, "::")),
|
||||||
|
_string_cat_op_app: $ => prec.right(12, mkOp($, "^")),
|
||||||
|
_bool_op_app: $ => prec.left(11, mkOp($, choice("&&", "||"))),
|
||||||
|
_comp_op_app: $ => prec.left(10, mkOp($, choice("=", "<>", "==", "<", "<=", ">", ">="))),
|
||||||
|
|
||||||
|
// - a
|
||||||
|
unary_op_app: $ => prec(19, choice(
|
||||||
|
seq(field("unaryOp", "-"), field("arg", $._expr))),
|
||||||
|
),
|
||||||
|
|
||||||
|
// f a
|
||||||
|
fun_app: $ => prec.left(20, seq(field("appF", $.sub_expr), field("appArg",$.sub_expr))),
|
||||||
|
|
||||||
|
// a.0
|
||||||
|
index_accessor: $ => prec.right(21, seq(field("exp", $.sub_expr), ".", field("ix", $.sub_expr))),
|
||||||
|
|
||||||
|
// { p with a = b; c = d }
|
||||||
|
rec_expr: $ => seq(
|
||||||
|
"{",
|
||||||
|
optional(seq(field("updateTarget", $.Name), "with")),
|
||||||
|
field("assignment", $.rec_assignment),
|
||||||
|
repeat(seq(";", field("assignment", $.rec_assignment))),
|
||||||
|
optional(";"),
|
||||||
|
"}"
|
||||||
|
),
|
||||||
|
// a = b;
|
||||||
|
rec_assignment: $ => seq(
|
||||||
|
field("assignmentLabel", $._expr),
|
||||||
|
"=",
|
||||||
|
field("assignmentExpr", $._expr),
|
||||||
|
),
|
||||||
|
|
||||||
|
// if a then b else c
|
||||||
|
if_expr: $ => seq(
|
||||||
|
"if",
|
||||||
|
field("condition", $._expr),
|
||||||
|
"then",
|
||||||
|
field("thenBranch", $._expr),
|
||||||
|
"else",
|
||||||
|
field("elseBranch", $._expr)
|
||||||
|
),
|
||||||
|
|
||||||
|
// match x with ...
|
||||||
|
match_expr: $ => prec.right(1,seq(
|
||||||
|
"match",
|
||||||
|
field("matchTarget", $._expr),
|
||||||
|
"with",
|
||||||
|
optional('|'),
|
||||||
|
sepBy('|', field("matching", $.matching))
|
||||||
|
)),
|
||||||
|
|
||||||
|
// Dog as x -> f x
|
||||||
|
matching: $ => seq(
|
||||||
|
field("pattern", $._pattern),
|
||||||
|
"->",
|
||||||
|
field("matchingExpr", $._expr)
|
||||||
|
),
|
||||||
|
|
||||||
|
lambda_expr: $ => seq(
|
||||||
|
"fun",
|
||||||
|
repeat1(field("arg", $.argument)),
|
||||||
|
"->",
|
||||||
|
field("body", $._expr)
|
||||||
|
),
|
||||||
|
|
||||||
|
list_expr: $ => seq(
|
||||||
|
"[",
|
||||||
|
sepBy(";", field("item", $._expr)),
|
||||||
|
"]"
|
||||||
|
),
|
||||||
|
|
||||||
|
tup_expr: $ => prec.right(9,seq(
|
||||||
|
field("fst", $._expr),
|
||||||
|
",",
|
||||||
|
field("snd", $._expr),
|
||||||
|
)),
|
||||||
|
|
||||||
|
_expr: $ => choice(
|
||||||
|
$.call,
|
||||||
|
$.sub_expr,
|
||||||
|
$.tup_expr
|
||||||
|
),
|
||||||
|
|
||||||
|
sub_expr: $ => choice(
|
||||||
|
$.fun_app,
|
||||||
|
$.paren_expr,
|
||||||
|
$.Name,
|
||||||
|
$.Name_Capital,
|
||||||
|
$._literal,
|
||||||
|
$.rec_expr,
|
||||||
|
$.if_expr,
|
||||||
|
$.lambda_expr,
|
||||||
|
$.match_expr,
|
||||||
|
$.list_expr,
|
||||||
|
$.index_accessor
|
||||||
|
),
|
||||||
|
|
||||||
|
paren_expr: $ => seq(
|
||||||
|
"(",
|
||||||
|
field("innerExpr", $._expr),
|
||||||
|
optional(field("exprAnnot", $.type_annot)),
|
||||||
|
")"
|
||||||
|
),
|
||||||
|
|
||||||
|
|
||||||
|
//========== TYPE_EXPR ============
|
||||||
|
// t, test, string, integer
|
||||||
|
type_con: $ => $.TypeName,
|
||||||
|
// Red, Green, Blue, Cat
|
||||||
|
data_con: $ => $.Name_Capital,
|
||||||
|
// a t, (a, b) t
|
||||||
|
type_app: $ => prec(10,seq(
|
||||||
|
choice(
|
||||||
|
field("argument", $.type_expr),
|
||||||
|
seq(
|
||||||
|
"(",
|
||||||
|
sepBy1(",", field("argument", $.type_expr)),
|
||||||
|
")"
|
||||||
|
)
|
||||||
|
),
|
||||||
|
field("typeAppCon", $.type_con)
|
||||||
|
)),
|
||||||
|
// string * integer
|
||||||
|
type_product: $ => prec.right(5, seq(
|
||||||
|
field("fst", $.type_expr),
|
||||||
|
"*",
|
||||||
|
field("snd", $.type_expr)
|
||||||
|
)),
|
||||||
|
|
||||||
|
// int -> string
|
||||||
|
type_fun: $ => prec.right(8, seq(
|
||||||
|
field("domain", $.type_expr),
|
||||||
|
"->",
|
||||||
|
field("codomain", $.type_expr)
|
||||||
|
)),
|
||||||
|
|
||||||
|
type_expr: $ => choice(
|
||||||
|
$.type_fun,
|
||||||
|
$.type_product,
|
||||||
|
$.type_app,
|
||||||
|
$.type_con,
|
||||||
|
$.paren_type_expr,
|
||||||
|
),
|
||||||
|
|
||||||
|
paren_type_expr: $ => seq(
|
||||||
|
"(",
|
||||||
|
field("innerTypeExpr", $.type_expr),
|
||||||
|
")"
|
||||||
|
),
|
||||||
|
|
||||||
|
// Cat of string, Person of string * string
|
||||||
|
variant: $ => seq(
|
||||||
|
field("constructor", $.data_con),
|
||||||
|
optional(seq(
|
||||||
|
"of",
|
||||||
|
field("constructor_data", $.type_expr)
|
||||||
|
))
|
||||||
|
),
|
||||||
|
|
||||||
|
// Cat of string | Personn of string * string
|
||||||
|
type_sum: $ => seq(
|
||||||
|
sepBy1('|', field("variant", $.variant)),
|
||||||
|
),
|
||||||
|
|
||||||
|
// field : string * int
|
||||||
|
_label: $ => $.FieldName,
|
||||||
|
|
||||||
|
type_rec_field: $ => seq(
|
||||||
|
field("recLabel", $._label),
|
||||||
|
":",
|
||||||
|
field("labelType", $.type_expr)
|
||||||
|
),
|
||||||
|
|
||||||
|
// { field1 : a; field2 : b }
|
||||||
|
type_rec: $ => seq(
|
||||||
|
"{",
|
||||||
|
sepBy(";", field("recField", $.type_rec_field)),
|
||||||
|
optional(";"),
|
||||||
|
"}"
|
||||||
|
),
|
||||||
|
|
||||||
|
type_def_body: $ => choice(
|
||||||
|
$.type_sum,
|
||||||
|
$.type_expr,
|
||||||
|
$.type_rec
|
||||||
|
),
|
||||||
|
|
||||||
|
type_def: $ => seq(
|
||||||
|
field("typeName", $.type_con),
|
||||||
|
"=",
|
||||||
|
field("typeValue", $.type_def_body)
|
||||||
|
),
|
||||||
|
|
||||||
|
type_decl: $ => seq(
|
||||||
|
"type",
|
||||||
|
field("typeDef", $.type_def)
|
||||||
|
),
|
||||||
|
|
||||||
|
_literal: $ => choice(
|
||||||
|
$.String,
|
||||||
|
$.Int,
|
||||||
|
$.Nat,
|
||||||
|
$.Tez,
|
||||||
|
$.Bytes,
|
||||||
|
$.True,
|
||||||
|
$.False,
|
||||||
|
$.Unit
|
||||||
|
),
|
||||||
|
|
||||||
|
String: $ => /\"(\\.|[^"])*\"/,
|
||||||
|
Int: $ => /-?([1-9][0-9_]*|0)/,
|
||||||
|
Nat: $ => /([1-9][0-9_]*|0)n/,
|
||||||
|
Tez: $ => /([1-9][0-9_]*|0)(\.[0-9_]+)?(tz|tez|mutez)/,
|
||||||
|
Bytes: $ => /0x[0-9a-fA-F]+/,
|
||||||
|
Name: $ => /[a-z][a-zA-Z0-9_]*/,
|
||||||
|
TypeName: $ => /[a-z][a-zA-Z0-9_]*/,
|
||||||
|
FieldName: $ => /[a-z][a-zA-Z0-9_]*/,
|
||||||
Name_Capital: $ => /[A-Z][a-zA-Z0-9_]*/,
|
Name_Capital: $ => /[A-Z][a-zA-Z0-9_]*/,
|
||||||
Keyword: $ => /[A-Za-z][a-z]*/,
|
Keyword: $ => /[A-Za-z][a-z]*/,
|
||||||
|
|
||||||
False: $ => 'False',
|
False: $ => 'false',
|
||||||
True: $ => 'True',
|
True: $ => 'true',
|
||||||
Unit: $ => 'Unit',
|
Unit: $ => '()',
|
||||||
None: $ => 'None',
|
|
||||||
Some: $ => 'Some',
|
|
||||||
skip: $ => 'skip',
|
|
||||||
rec: $ => 'rec',
|
|
||||||
|
|
||||||
attr: $ => seq('[@@', $.name, ']'),
|
comment: $ => /\/\/[^\n]*\n/,
|
||||||
|
ocaml_comment: $ =>
|
||||||
|
seq(
|
||||||
|
'(*',
|
||||||
|
repeat(choice(
|
||||||
|
$.ocaml_comment,
|
||||||
|
/'([^'\\]|\\[\\"'ntbr ]|\\[0-9][0-9][0-9]|\\x[0-9A-Fa-f][0-9A-Fa-f]|\\o[0-3][0-7][0-7])'/,
|
||||||
|
/"([^\\"]|\\(.|\n))*"/,
|
||||||
|
/[A-Za-z_][a-zA-Z0-9_']*/,
|
||||||
|
/[^('"{*A-Za-z_]+/,
|
||||||
|
'(', "'", '*',
|
||||||
|
)),
|
||||||
|
'*)'
|
||||||
|
),
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user