77 case Tag::D_angle_l: \
78 case Tag::D_brckt_l: \
79 case Tag::D_curly_l: \
80 case Tag::D_paren_l: \
85 case Tag::D_brckt_l: \
90 case Tag::D_brckt_l: \
94using namespace std::string_literals;
105 auto track = tracker();
108 if (ahead().isa(Tag::K_import) || ahead().isa(Tag::K_plugin)) {
109 if (
auto import = parse_import_or_plugin()) imports.emplace_back(std::move(
import));
114 auto decls = parse_decls();
115 bool where = ahead().isa(Tag::K_where);
116 expect(Tag::EoF,
"module");
117 auto mod = ptr<Module>(track, std::move(imports), std::move(decls));
118 if (where)
ast().
note(mod->loc().anew_finis(),
"did you accidentally end your declaration expression with a ';'?");
123 auto name = dbg.sym();
124 auto filename = fs::path(name.view());
125 driver().VLOG(
"import: {}", name);
127 if (!filename.has_extension()) filename.replace_extension(
"mim");
130 for (
const auto& path :
driver().search_paths()) {
131 std::error_code ignore;
132 rel_path = path / filename;
133 if (
bool reg_file = fs::is_regular_file(rel_path, ignore); reg_file && !ignore)
break;
134 rel_path = path / name.view() / filename;
135 if (
bool reg_file = fs::is_regular_file(rel_path, ignore); reg_file && !ignore)
break;
138 if (
auto path =
driver().add_import(std::move(rel_path), name)) {
139 auto ifs = std::ifstream(*path);
140 return import(ifs, dbg.loc(), path, md);
146 driver().VLOG(
"reading: {}", path ? path->string() :
"<unknown file>"s);
148 ast().
error(loc,
"cannot read file {}", *path);
152 auto state = std::tuple(curr_, ahead_, lexer_);
153 auto lexer =
Lexer(
ast(), is, path, md);
156 auto mod = parse_module();
157 std::tie(curr_, ahead_, lexer_) = state;
172 auto track = tracker();
173 auto tag = lex().tag();
174 auto name = expect(Tag::M_id,
"{} name", tag == Tag::K_import ?
"import" :
"plugin");
175 auto dbg = name.dbg();
176 expect(Tag::T_semicolon,
"end of {}", tag == Tag::K_import ?
"import" :
"plugin");
177 if (
auto module = tag == Tag::K_import ?
import(dbg) :
plugin(dbg))
178 return ptr<Import>(track, tag, name.dbg(), std::move(module));
182Dbg Parser::parse_id(std::string_view ctxt) {
183 if (
auto id = accept(Tag::M_id))
return id.dbg();
184 syntax_err(
"identifier", ctxt);
185 return {curr_,
driver().sym(
"<error>")};
188Dbg Parser::parse_name(std::string_view ctxt) {
189 if (
auto tok = accept(Tag::M_anx))
return tok.dbg();
190 if (
auto tok = accept(Tag::M_id))
return tok.dbg();
191 syntax_err(
"identifier or annex name", ctxt);
192 return Dbg(curr_,
ast().sym(
"<error>"));
195Ptr<Expr> Parser::parse_type_ascr(std::string_view ctxt) {
196 if (accept(Tag::T_colon))
return parse_expr(ctxt);
197 if (ctxt.empty())
return nullptr;
198 syntax_err(
"':'", ctxt);
199 return ptr<ErrorExpr>(curr_);
207 auto track = tracker();
208 auto lhs = parse_primary_expr(ctxt);
209 return parse_infix_expr(track, std::move(lhs), curr_prec);
215 switch (ahead().tag()) {
216 case Tag::T_extract: {
219 if (
auto tok = accept(Tag::M_id))
220 lhs = ptr<ExtractExpr>(track, std::move(lhs), tok.dbg());
223 lhs = ptr<ExtractExpr>(track, std::move(lhs), std::move(rhs));
231 lhs = ptr<ArrowExpr>(track, std::move(lhs), std::move(rhs));
238 types.emplace_back(std::move(lhs));
241 types.emplace_back(std::move(t));
242 }
while (accept(Tag::T_union));
243 lhs = ptr<UnionExpr>(track, std::move(types));
250 lhs = ptr<InjExpr>(track, std::move(lhs), std::move(rhs));
256 auto rhs = parse_expr(
"explicit argument to an application",
Expr::Prec::App);
257 lhs = ptr<AppExpr>(track,
true, std::move(lhs), std::move(rhs));
262 switch (ahead().tag()) {
264 ast().
warn(ahead().loc(),
"you are passing a declaration expression as argument");
265 ast().
note(lhs->loc(),
"to this expression");
267 "if this was your intention, consider to parenthesize the declaration expression");
268 ast().
note(lhs->loc().anew_finis(),
"otherwise, you are probably missing a ';'");
272 lhs = ptr<AppExpr>(track,
false, std::move(lhs), std::move(rhs));
278 auto decls = parse_decls();
279 lhs = ptr<DeclExpr>(track, std::move(decls), std::move(lhs),
true);
281 bool where = ahead().tag() == Tag::K_where;
282 expect(Tag::K_end,
"end of a where declaration block");
284 ast().
note(lhs->loc().anew_finis(),
285 "did you accidentally end your declaration expression with a ';'?");
295 auto track = tracker();
296 expect(Tag::D_paren_l,
"opening paren for insert arguments");
297 auto tuple = parse_expr(
"the tuple to insert into");
298 expect(Tag::T_comma,
"comma after tuple to insert into");
299 auto index = parse_expr(
"insert index");
300 expect(Tag::T_comma,
"comma after insert index");
301 auto value = parse_expr(
"insert value");
302 expect(Tag::D_paren_r,
"closing paren for insert arguments");
303 return ptr<InsertExpr>(track, std::move(tuple), std::move(index), std::move(value));
307 auto track = tracker();
308 expect(Tag::D_curly_l,
"opening curly bracket for singleton type");
309 auto inhabitant = parse_expr(
"singleton type");
310 expect(Tag::D_curly_r,
"closing curly bracket for singleton type");
311 return ptr<UniqExpr>(track, std::move(inhabitant));
315 auto track = tracker();
316 expect(Tag::K_match,
"opening match for union destruction");
317 auto scrutinee = parse_expr(
"destroyed union element");
318 expect(Tag::K_with,
"match");
320 parse_list(
"match branches", Tag::D_brace_l, [&]() {
321 auto track = tracker();
322 auto ptrn = parse_ptrn(Paren_Style,
"right-hand side of a match-arm",
Expr::Prec::Bot);
323 expect(Tag::T_fat_arrow,
"arm of a match-expression");
324 auto body = parse_expr(
"arm of a match-expression");
325 arms.emplace_back(ptr<MatchExpr::Arm>(track, std::move(ptrn), std::move(body)));
327 return ptr<MatchExpr>(track, std::move(scrutinee), std::move(arms));
330Ptr<Expr> Parser::parse_primary_expr(std::string_view ctxt) {
332 switch (ahead().tag()) {
333 case Tag::C_PRIMARY:
return ptr<PrimaryExpr>(lex());
334 case Tag::C_ID:
return ptr<IdExpr>(lex().dbg());
335 case Tag::C_LIT:
return parse_lit_expr();
336 case Tag::C_DECL:
return parse_decl_expr();
337 case Tag::C_PI:
return parse_pi_expr();
338 case Tag::C_LM:
return parse_lam_expr();
339 case Tag::K_ins:
return parse_insert_expr();
340 case Tag::K_ret:
return parse_ret_expr();
341 case Tag::D_curly_l:
return parse_uniq_expr();
343 case Tag::D_angle_l:
return parse_seq_expr();
344 case Tag::D_brckt_l:
return parse_sigma_expr();
345 case Tag::D_paren_l:
return parse_tuple_expr();
346 case Tag::K_Type:
return parse_type_expr();
347 case Tag::K_match:
return parse_match_expr();
349 if (ctxt.empty())
return nullptr;
350 syntax_err(
"primary expression", ctxt);
353 return ptr<ErrorExpr>(curr_);
357 auto track = tracker();
358 bool is_arr = accept(Tag::D_quote_l) ? true : (eat(Tag::D_angle_l),
false);
360 std::deque<std::pair<Ptr<IdPtrn>,
Ptr<Expr>>> shapes;
364 if (ahead(0).isa(Tag::M_id) && ahead(1).isa(Tag::T_colon)) {
365 dbg = eat(Tag::M_id).dbg();
369 auto expr = parse_expr(is_arr ?
"shape of an array" :
"shape of a pack");
371 shapes.emplace_back(std::move(ptrn), std::move(expr));
372 }
while (accept(Tag::T_comma));
374 expect(Tag::T_semicolon, is_arr ?
"array" :
"pack");
375 auto body = parse_expr(is_arr ?
"body of an array" :
"body of a pack");
376 expect(is_arr ? Tag::D_quote_r : Tag::D_angle_r,
377 is_arr ?
"closing delimiter of an array" :
"closing delimiter of a pack");
379 for (
auto& [ptrn, expr] : shapes | std::ranges::views::reverse)
380 body = ptr<SeqExpr>(track, is_arr, std::move(ptrn), std::move(body));
386 auto track = tracker();
387 auto decls = parse_decls();
388 auto expr = parse_expr(
"final expression of a declaration expression");
389 return ptr<DeclExpr>(track, std::move(decls), std::move(expr),
false);
393 auto track = tracker();
396 return ptr<LitExpr>(track, tok, std::move(type));
400 auto track = tracker();
401 auto ptrn = parse_tuple_ptrn(Brckt_Style);
402 switch (ahead().tag()) {
405 auto alias = ptr<AliasPtrn>(track, std::move(ptrn), parse_name(
"alias pattern"));
406 return parse_pi_expr(std::move(alias));
408 case Tag::C_CURRIED_B:
409 case Tag::T_arrow:
return parse_pi_expr(std::move(ptrn));
410 default:
return ptr<SigmaExpr>(std::move(ptrn));
415 auto track = tracker();
417 parse_list(
"tuple", Tag::D_paren_l, [&]() { elems.emplace_back(parse_expr(
"tuple element")); });
418 return ptr<TupleExpr>(track, std::move(elems));
422 auto track = tracker();
425 return ptr<TypeExpr>(track, std::move(level));
429 auto track = tracker();
430 auto tag = ahead().tag();
431 auto entity =
"dependent function type"s;
433 if (accept(Tag::K_Cn))
434 entity =
"continuation type";
435 else if (accept(Tag::K_Fn))
436 entity =
"returning continuation type";
438 auto domt = tracker();
440 auto ptrn = parse_ptrn(Brckt_Style | Implicit,
"domain of a "s + entity, prec);
441 auto dom = ptr<PiExpr::Dom>(domt, std::move(ptrn));
443 auto codom = tag != Tag::K_Cn
444 ? (expect(Tag::T_arrow, entity), parse_expr(
"codomain of a "s + entity,
Expr::Prec::Arrow))
447 if (tag == Tag::K_Fn) dom->add_ret(
ast(), codom ? std::move(codom) : ptr<HoleExpr>(curr_));
448 return ptr<PiExpr>(track, tag, std::move(dom), std::move(codom));
452 auto track = tracker(ptrn->loc());
453 auto entity =
"dependent function type"s;
454 auto dom = ptr<PiExpr::Dom>(ptrn->loc(), std::move(ptrn));
455 expect(Tag::T_arrow, entity);
457 return ptr<PiExpr>(track, Tag::Nil, std::move(dom), std::move(codom));
460Ptr<Expr> Parser::parse_lam_expr() {
return ptr<LamExpr>(parse_lam_decl()); }
463 auto track = tracker();
465 auto ptrn = parse_ptrn(Paren_Style,
"binding pattern of a ret expression");
466 expect(Tag::T_assign,
"ret expression");
467 auto callee = parse_expr(
"continuation expression of a ret expression");
468 expect(Tag::T_dollar,
"separator of a ret expression");
469 auto arg = parse_expr(
"argument of ret expression");
470 expect(Tag::T_semicolon,
"ret expression");
471 auto body = parse_expr(
"body of a ret expression");
472 return ptr<RetExpr>(track, std::move(ptrn), std::move(callee), std::move(arg), std::move(body));
480 auto track = tracker();
481 auto ptrn = parse_ptrn_(style, ctxt, prec);
482 if (accept(Tag::K_as))
return ptr<AliasPtrn>(track, std::move(ptrn), parse_name(
"alias pattern"));
487 auto track = tracker();
492 if (is_paren_style(style) && ahead().isa(Tag::D_paren_l))
return parse_tuple_ptrn(style);
493 if (is_implicit(style) && ahead().isa(Tag::D_brace_l))
return parse_tuple_ptrn(style);
494 if (ahead().isa(Tag::D_brckt_l))
return parse_tuple_ptrn(Brckt_Style);
496 if (ahead(0).isa(Tag::M_id)) {
497 if (ahead(1).isa(Tag::T_colon)) {
499 auto dbg = eat(Tag::M_id).dbg();
501 auto type = parse_expr(ctxt, prec);
502 return ptr<IdPtrn>(track, dbg, std::move(type));
503 }
else if (is_paren_style(style)) {
506 auto dbg = eat(Tag::M_id).dbg();
507 return ptr<IdPtrn>(track, dbg,
nullptr);
510 auto type = parse_expr(ctxt, prec);
511 return ptr<IdPtrn>(track,
type->loc().anew_begin(), std::move(type));
513 }
else if (is_brket_style(style)) {
515 auto type = parse_expr(ctxt, prec);
516 auto loc =
type->loc().anew_begin();
517 return ptr<IdPtrn>(track, Dbg(loc), std::move(type));
518 }
else if (!ctxt.empty()) {
520 syntax_err(
"pattern", ctxt);
521 return ptr<ErrorPtrn>(curr_);
528 auto track = tracker();
529 auto delim_l = ahead().tag();
532 parse_list(
"tuple pattern", delim_l, [&]() {
533 auto track = tracker();
536 if (ahead(0).isa(Tag::M_id) && ahead(1).isa(Tag::M_id)) {
538 while (
auto tok = accept(Tag::M_id)) dbgs.emplace_back(tok.dbg());
540 if (accept(Tag::T_colon)) {
541 auto dbg = dbgs.back();
542 auto type = parse_expr(
"type of an identifier group within a tuple pattern");
543 auto id = ptr<IdPtrn>(dbg.loc() +
type->loc().finis, dbg, std::move(type));
545 for (
auto dbg : dbgs | std::views::take(dbgs.size() - 1))
546 ptrns.emplace_back(ptr<GrpPtrn>(dbg,
id.
get()));
547 ptrns.emplace_back(std::move(
id));
552 Ptr<Expr> lhs = ptr<IdExpr>(dbgs.front());
553 for (
auto dbg : dbgs | std::views::drop(1)) {
554 auto rhs = ptr<IdExpr>(dbg);
555 lhs = ptr<AppExpr>(track,
false, std::move(lhs), std::move(rhs));
560 ptrn = parse_ptrn(style & Style_Bit,
"element of a tuple pattern");
562 if (is_brket_style(style)) {
564 if (ahead().isa(Tag::T_arrow)) {
565 auto loc = ptrn->loc();
566 auto expr = parse_pi_expr(std::move(ptrn));
567 ptrn = ptr<IdPtrn>(loc, Dbg(loc.anew_begin(), Sym()), std::move(expr));
570 auto addr = expr.get();
571 expr = parse_infix_expr(track, std::move(expr));
572 if (expr.get() != addr) {
573 auto loc = expr->loc();
574 ptrn = ptr<IdPtrn>(loc, Dbg(loc.anew_begin(), Sym()), std::move(expr));
582 ptrns.emplace_back(std::move(ptrn));
585 return ptr<TuplePtrn>(track, delim_l, std::move(ptrns));
596 switch (ahead().tag()) {
597 case Tag::T_semicolon: lex();
break;
598 case Tag::K_axm: decls.emplace_back(parse_axm_decl());
break;
600 case Tag::K_cfun: decls.emplace_back(parse_c_decl());
break;
601 case Tag::K_let: decls.emplace_back(parse_let_decl());
break;
602 case Tag::K_rec: decls.emplace_back(parse_rec_decl(
true));
break;
605 case Tag::K_lam: decls.emplace_back(parse_lam_decl());
break;
606 default:
return decls;
613 auto track = tracker();
617 if (
auto name = expect(Tag::M_anx,
"annex name of an axm"))
620 dbg = Dbg(curr_,
ast().sym(
"<error annex name>"));
622 std::deque<Ptrs<AxmDecl::Alias>> subs;
623 if (ahead().isa(Tag::D_paren_l)) {
624 parse_list(
"tag list of an axm", Tag::D_paren_l, [&]() {
625 auto& aliases = subs.emplace_back();
626 aliases.emplace_back(ptr<AxmDecl::Alias>(parse_id(
"tag of an axm")));
627 while (accept(Tag::T_assign)) aliases.emplace_back(ptr<AxmDecl::Alias>(parse_id(
"alias of an axm tag")));
631 auto type = parse_type_ascr(
"type ascription of an axm");
633 if (ahead(0).isa(Tag::T_comma) && ahead(1).isa(Tag::M_id)) {
635 normalizer = lex().dbg();
637 if (accept(Tag::T_comma)) {
638 if (
auto c = expect(Tag::L_u,
"curry counter for axm")) curry =
c;
639 if (accept(Tag::T_comma)) {
640 if (
auto t = expect(Tag::L_u,
"trip count for axm")) trip =
t;
644 return ptr<AxmDecl>(track, dbg, std::move(subs), std::move(type), normalizer, curry, trip);
648 auto track = tracker();
652 if (
auto anx = accept(Tok::Tag::M_anx)) {
653 auto type = parse_type_ascr();
654 ptrn = ptr<IdPtrn>(track, anx.dbg(), std::move(type));
656 ptrn = parse_ptrn(Paren_Style,
"binding pattern of a let declaration",
Expr::Prec::Bot);
659 expect(Tag::T_assign,
"let");
660 auto type = parse_type_ascr();
661 auto value = parse_expr(
"value of a let declaration");
662 return ptr<LetDecl>(track, std::move(ptrn), std::move(value));
666 auto track = tracker();
667 auto tag = lex().tag();
668 auto id = expect(Tag::M_id,
"C function declaration");
669 auto dom = parse_ptrn(Brckt_Style,
"domain of a C function"s,
Expr::Prec::App);
671 if (tag == Tag::K_cfun) {
672 expect(Tag::T_colon,
"codomain of a C function");
673 codom = parse_expr(
"codomain of a C function");
675 return ptr<CDecl>(track, tag,
id.dbg(), std::move(dom), std::move(codom));
679 auto track = tracker();
680 eat(first ? Tag::K_rec : Tag::K_and);
681 auto dbg = parse_name(
"recursive declaration");
682 auto type = accept(Tag::T_colon) ? parse_expr(
"type of a recursive declaration") : ptr<HoleExpr>(curr_);
683 expect(Tag::T_assign,
"recursive declaration");
684 auto body = parse_expr(
"body of a recursive declaration");
685 auto next = ahead().isa(Tag::K_and) ? parse_and_decl() : nullptr;
686 return ptr<RecDecl>(track, dbg, std::move(type), std::move(body), std::move(next));
690 auto track = tracker();
691 auto tag = lex().tag();
693 bool external = (bool)accept(Tag::K_extern);
699 case Tag::T_lm: decl =
false; entity =
"function expression";
break;
700 case Tag::K_cn: decl =
false; entity =
"continuation expression";
break;
701 case Tag::K_fn: decl =
false; entity =
"returning continuation expression";
break;
702 case Tag::K_lam: decl = true ; entity =
"function declaration";
break;
703 case Tag::K_con: decl = true ; entity =
"continuation declaration";
break;
704 case Tag::K_fun: decl = true ; entity =
"returning continuation declaration";
break;
705 default: fe::unreachable();
709 auto dbg = decl ? parse_name(entity) : Dbg();
712 auto track = tracker();
713 auto ptrn = parse_ptrn(Paren_Style | Implicit,
"domain pattern of a "s + entity, prec);
714 auto filter = accept(Tag::T_at) ? parse_expr(
"filter") : nullptr;
715 doms.emplace_back(ptr<LamDecl::Dom>(track, std::move(ptrn), std::move(filter)));
717 switch (ahead().tag()) {
718 case Tag::C_CURRIED_P:
continue;
724 auto codom = accept(Tag::T_colon) ? parse_expr(
"codomain of a "s + entity,
Expr::Prec::Arrow) : nullptr;
725 if (tag == Tag::K_fn || tag == Tag::K_fun)
726 doms.back()->add_ret(
ast(), codom ? std::move(codom) : ptr<HoleExpr>(curr_));
728 expect(Tag::T_assign,
"body of a "s + entity);
729 auto body = parse_expr(
"body of a "s + entity);
730 auto next = ahead().isa(Tag::K_and) ? parse_and_decl() : nullptr;
732 return ptr<LamDecl>(track, tag, external, dbg, std::move(doms), std::move(codom), std::move(body), std::move(next));
736 switch (ahead(1).tag()) {
737 case Tag::C_LAM:
return lex(), parse_lam_decl();
738 default:
return parse_rec_decl(
false);
Error & note(Loc loc, const char *fmt, Args &&... args) const
Error & warn(Loc loc, const char *fmt, Args &&... args) const
static Ptr< IdPtrn > make_type(AST &ast, Ptr< Expr > &&type)
static Ptr< IdPtrn > make_id(AST &ast, Dbg dbg, Ptr< Expr > &&type)
Ptr< Module > import(std::string_view sv)
Ptr< Module > plugin(Dbg)
static Ptr< Ptrn > to_ptrn(Ptr< Expr > &&)
static Ptr< Expr > to_expr(AST &, Ptr< Ptrn > &&)
fe::Arena::Ptr< const T > Ptr
std::deque< Ptr< T > > Ptrs
constexpr decltype(auto) get(Span< T, N > span) noexcept