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;
171 auto track = tracker();
172 auto tag = lex().tag();
173 auto name = expect(Tag::M_id,
"{} name", tag == Tag::K_import ?
"import" :
"plugin");
174 auto dbg = name.dbg();
175 expect(Tag::T_semicolon,
"end of {}", tag == Tag::K_import ?
"import" :
"plugin");
176 if (
auto module = tag == Tag::K_import ?
import(dbg) :
plugin(dbg))
177 return ptr<Import>(track, tag, name.dbg(), std::move(module));
181Dbg Parser::parse_id(std::string_view ctxt) {
182 if (
auto id = accept(Tag::M_id))
return id.dbg();
183 syntax_err(
"identifier", ctxt);
184 return {curr_,
driver().sym(
"<error>")};
187Dbg Parser::parse_name(std::string_view ctxt) {
188 if (
auto tok = accept(Tag::M_anx))
return tok.dbg();
189 if (
auto tok = accept(Tag::M_id))
return tok.dbg();
190 syntax_err(
"identifier or annex name", ctxt);
191 return Dbg(curr_,
ast().sym(
"<error>"));
194Ptr<Expr> Parser::parse_type_ascr(std::string_view ctxt) {
195 if (accept(Tag::T_colon))
return parse_expr(ctxt);
196 if (ctxt.empty())
return nullptr;
197 syntax_err(
"':'", ctxt);
198 return ptr<ErrorExpr>(curr_);
206 auto track = tracker();
207 auto lhs = parse_primary_expr(ctxt);
208 return parse_infix_expr(track, std::move(lhs), curr_prec);
214 switch (ahead().tag()) {
215 case Tag::T_extract: {
218 if (
auto tok = accept(Tag::M_id))
219 lhs = ptr<ExtractExpr>(track, std::move(lhs), tok.dbg());
222 lhs = ptr<ExtractExpr>(track, std::move(lhs), std::move(rhs));
230 lhs = ptr<ArrowExpr>(track, std::move(lhs), std::move(rhs));
237 types.emplace_back(std::move(lhs));
240 types.emplace_back(std::move(t));
241 }
while (accept(Tag::T_union));
242 lhs = ptr<UnionExpr>(track, std::move(types));
249 lhs = ptr<InjExpr>(track, std::move(lhs), std::move(rhs));
255 auto rhs = parse_expr(
"explicit argument to an application",
Expr::Prec::App);
256 lhs = ptr<AppExpr>(track,
true, std::move(lhs), std::move(rhs));
261 switch (ahead().tag()) {
263 ast().
warn(ahead().loc(),
"you are passing a declaration expression as argument");
264 ast().
note(lhs->loc(),
"to this expression");
266 "if this was your intention, consider to parenthesize the declaration expression");
267 ast().
note(lhs->loc().anew_finis(),
"otherwise, you are probably missing a ';'");
271 lhs = ptr<AppExpr>(track,
false, std::move(lhs), std::move(rhs));
277 auto decls = parse_decls();
278 lhs = ptr<DeclExpr>(track, std::move(decls), std::move(lhs),
true);
280 bool where = ahead().tag() == Tag::K_where;
281 expect(Tag::K_end,
"end of a where declaration block");
283 ast().
note(lhs->loc().anew_finis(),
284 "did you accidentally end your declaration expression with a ';'?");
294 auto track = tracker();
295 expect(Tag::D_paren_l,
"opening paren for insert arguments");
296 auto tuple = parse_expr(
"the tuple to insert into");
297 expect(Tag::T_comma,
"comma after tuple to insert into");
298 auto index = parse_expr(
"insert index");
299 expect(Tag::T_comma,
"comma after insert index");
300 auto value = parse_expr(
"insert value");
301 expect(Tag::D_paren_r,
"closing paren for insert arguments");
302 return ptr<InsertExpr>(track, std::move(tuple), std::move(index), std::move(value));
306 auto track = tracker();
307 expect(Tag::D_curly_l,
"opening curly bracket for singleton type");
308 auto inhabitant = parse_expr(
"singleton type");
309 expect(Tag::D_curly_r,
"closing curly bracket for singleton type");
310 return ptr<UniqExpr>(track, std::move(inhabitant));
314 auto track = tracker();
315 expect(Tag::K_match,
"opening match for union destruction");
316 auto scrutinee = parse_expr(
"destroyed union element");
317 expect(Tag::K_with,
"match");
319 parse_list(
"match branches", Tag::D_brace_l, [&]() {
320 auto track = tracker();
321 auto ptrn = parse_ptrn(Paren_Style,
"right-hand side of a match-arm",
Expr::Prec::Bot);
322 expect(Tag::T_fat_arrow,
"arm of a match-expression");
323 auto body = parse_expr(
"arm of a match-expression");
324 arms.emplace_back(ptr<MatchExpr::Arm>(track, std::move(ptrn), std::move(body)));
326 return ptr<MatchExpr>(track, std::move(scrutinee), std::move(arms));
329Ptr<Expr> Parser::parse_primary_expr(std::string_view ctxt) {
331 switch (ahead().tag()) {
332 case Tag::C_PRIMARY:
return ptr<PrimaryExpr>(lex());
333 case Tag::C_ID:
return ptr<IdExpr>(lex().dbg());
334 case Tag::C_LIT:
return parse_lit_expr();
335 case Tag::C_DECL:
return parse_decl_expr();
336 case Tag::C_PI:
return parse_pi_expr();
337 case Tag::C_LM:
return parse_lam_expr();
338 case Tag::K_ins:
return parse_insert_expr();
339 case Tag::K_ret:
return parse_ret_expr();
340 case Tag::D_curly_l:
return parse_uniq_expr();
342 case Tag::D_angle_l:
return parse_seq_expr();
343 case Tag::D_brckt_l:
return parse_sigma_expr();
344 case Tag::D_paren_l:
return parse_tuple_expr();
345 case Tag::K_Type:
return parse_type_expr();
346 case Tag::K_match:
return parse_match_expr();
348 if (ctxt.empty())
return nullptr;
349 syntax_err(
"primary expression", ctxt);
352 return ptr<ErrorExpr>(curr_);
356 auto track = tracker();
357 bool is_arr = accept(Tag::D_quote_l) ? true : (eat(Tag::D_angle_l),
false);
359 std::deque<std::pair<Ptr<IdPtrn>,
Ptr<Expr>>> shapes;
363 if (ahead(0).isa(Tag::M_id) && ahead(1).isa(Tag::T_colon)) {
364 dbg = eat(Tag::M_id).dbg();
368 auto expr = parse_expr(is_arr ?
"shape of an array" :
"shape of a pack");
370 shapes.emplace_back(std::move(ptrn), std::move(expr));
371 }
while (accept(Tag::T_comma));
373 expect(Tag::T_semicolon, is_arr ?
"array" :
"pack");
374 auto body = parse_expr(is_arr ?
"body of an array" :
"body of a pack");
375 expect(is_arr ? Tag::D_quote_r : Tag::D_angle_r,
376 is_arr ?
"closing delimiter of an array" :
"closing delimiter of a pack");
378 for (
auto& [ptrn, expr] : shapes | std::ranges::views::reverse)
379 body = ptr<SeqExpr>(track, is_arr, std::move(ptrn), std::move(body));
385 auto track = tracker();
386 auto decls = parse_decls();
387 auto expr = parse_expr(
"final expression of a declaration expression");
388 return ptr<DeclExpr>(track, std::move(decls), std::move(expr),
false);
392 auto track = tracker();
395 return ptr<LitExpr>(track, tok, std::move(type));
399 auto track = tracker();
400 auto ptrn = parse_tuple_ptrn(Brckt_Style);
401 switch (ahead().tag()) {
404 auto alias = ptr<AliasPtrn>(track, std::move(ptrn), parse_name(
"alias pattern"));
405 return parse_pi_expr(std::move(alias));
407 case Tag::C_CURRIED_B:
408 case Tag::T_arrow:
return parse_pi_expr(std::move(ptrn));
409 default:
return ptr<SigmaExpr>(std::move(ptrn));
414 auto track = tracker();
416 parse_list(
"tuple", Tag::D_paren_l, [&]() { elems.emplace_back(parse_expr(
"tuple element")); });
417 return ptr<TupleExpr>(track, std::move(elems));
421 auto track = tracker();
424 return ptr<TypeExpr>(track, std::move(level));
428 auto track = tracker();
429 auto tag = ahead().tag();
430 auto entity =
"dependent function type"s;
432 if (accept(Tag::K_Cn))
433 entity =
"continuation type";
434 else if (accept(Tag::K_Fn))
435 entity =
"returning continuation type";
437 auto domt = tracker();
439 auto ptrn = parse_ptrn(Brckt_Style | Implicit,
"domain of a "s + entity, prec);
440 auto dom = ptr<PiExpr::Dom>(domt, std::move(ptrn));
442 auto codom = tag != Tag::K_Cn
443 ? (expect(Tag::T_arrow, entity), parse_expr(
"codomain of a "s + entity,
Expr::Prec::Arrow))
446 if (tag == Tag::K_Fn) dom->add_ret(
ast(), codom ? std::move(codom) : ptr<HoleExpr>(curr_));
447 return ptr<PiExpr>(track, tag, std::move(dom), std::move(codom));
451 auto track = tracker(ptrn->loc());
452 auto entity =
"dependent function type"s;
453 auto dom = ptr<PiExpr::Dom>(ptrn->loc(), std::move(ptrn));
454 expect(Tag::T_arrow, entity);
456 return ptr<PiExpr>(track, Tag::Nil, std::move(dom), std::move(codom));
459Ptr<Expr> Parser::parse_lam_expr() {
return ptr<LamExpr>(parse_lam_decl()); }
462 auto track = tracker();
464 auto ptrn = parse_ptrn(Paren_Style,
"binding pattern of a ret expression");
465 expect(Tag::T_assign,
"ret expression");
466 auto callee = parse_expr(
"continuation expression of a ret expression");
467 expect(Tag::T_dollar,
"separator of a ret expression");
468 auto arg = parse_expr(
"argument of ret expression");
469 expect(Tag::T_semicolon,
"ret expression");
470 auto body = parse_expr(
"body of a ret expression");
471 return ptr<RetExpr>(track, std::move(ptrn), std::move(callee), std::move(arg), std::move(body));
479 auto track = tracker();
480 auto ptrn = parse_ptrn_(style, ctxt, prec);
481 if (accept(Tag::K_as))
return ptr<AliasPtrn>(track, std::move(ptrn), parse_name(
"alias pattern"));
486 auto track = tracker();
491 if (is_paren_style(style) && ahead().isa(Tag::D_paren_l))
return parse_tuple_ptrn(style);
492 if (is_implicit(style) && ahead().isa(Tag::D_brace_l))
return parse_tuple_ptrn(style);
493 if (ahead().isa(Tag::D_brckt_l))
return parse_tuple_ptrn(Brckt_Style);
495 if (ahead(0).isa(Tag::M_id)) {
496 if (ahead(1).isa(Tag::T_colon)) {
498 auto dbg = eat(Tag::M_id).dbg();
500 auto type = parse_expr(ctxt, prec);
501 return ptr<IdPtrn>(track, dbg, std::move(type));
502 }
else if (is_paren_style(style)) {
505 auto dbg = eat(Tag::M_id).dbg();
506 return ptr<IdPtrn>(track, dbg,
nullptr);
509 auto type = parse_expr(ctxt, prec);
510 return ptr<IdPtrn>(track,
type->loc().anew_begin(), std::move(type));
512 }
else if (is_brket_style(style)) {
514 auto type = parse_expr(ctxt, prec);
515 auto loc =
type->loc().anew_begin();
516 return ptr<IdPtrn>(track, Dbg(loc), std::move(type));
517 }
else if (!ctxt.empty()) {
519 syntax_err(
"pattern", ctxt);
520 return ptr<ErrorPtrn>(curr_);
527 auto track = tracker();
528 auto delim_l = ahead().tag();
531 parse_list(
"tuple pattern", delim_l, [&]() {
532 auto track = tracker();
535 if (ahead(0).isa(Tag::M_id) && ahead(1).isa(Tag::M_id)) {
537 while (
auto tok = accept(Tag::M_id)) dbgs.emplace_back(tok.dbg());
539 if (accept(Tag::T_colon)) {
540 auto dbg = dbgs.back();
541 auto type = parse_expr(
"type of an identifier group within a tuple pattern");
542 auto id = ptr<IdPtrn>(dbg.loc() +
type->loc().finis, dbg, std::move(type));
544 for (
auto dbg : dbgs | std::views::take(dbgs.size() - 1))
545 ptrns.emplace_back(ptr<GrpPtrn>(dbg,
id.
get()));
546 ptrns.emplace_back(std::move(
id));
551 Ptr<Expr> lhs = ptr<IdExpr>(dbgs.front());
552 for (
auto dbg : dbgs | std::views::drop(1)) {
553 auto rhs = ptr<IdExpr>(dbg);
554 lhs = ptr<AppExpr>(track,
false, std::move(lhs), std::move(rhs));
559 ptrn = parse_ptrn(style & Style_Bit,
"element of a tuple pattern");
561 if (is_brket_style(style)) {
563 if (ahead().isa(Tag::T_arrow)) {
564 auto loc = ptrn->loc();
565 auto expr = parse_pi_expr(std::move(ptrn));
566 ptrn = ptr<IdPtrn>(loc, Dbg(loc.anew_begin(), Sym()), std::move(expr));
569 auto addr = expr.get();
570 expr = parse_infix_expr(track, std::move(expr));
571 if (expr.get() != addr) {
572 auto loc = expr->loc();
573 ptrn = ptr<IdPtrn>(loc, Dbg(loc.anew_begin(), Sym()), std::move(expr));
581 ptrns.emplace_back(std::move(ptrn));
584 return ptr<TuplePtrn>(track, delim_l, std::move(ptrns));
595 switch (ahead().tag()) {
596 case Tag::T_semicolon: lex();
break;
597 case Tag::K_axm: decls.emplace_back(parse_axm_decl());
break;
599 case Tag::K_cfun: decls.emplace_back(parse_c_decl());
break;
600 case Tag::K_let: decls.emplace_back(parse_let_decl());
break;
601 case Tag::K_rec: decls.emplace_back(parse_rec_decl(
true));
break;
604 case Tag::K_lam: decls.emplace_back(parse_lam_decl());
break;
605 default:
return decls;
612 auto track = tracker();
616 if (
auto name = expect(Tag::M_anx,
"annex name of an axm"))
619 dbg = Dbg(curr_,
ast().sym(
"<error annex name>"));
621 std::deque<Ptrs<AxmDecl::Alias>> subs;
622 if (ahead().isa(Tag::D_paren_l)) {
623 parse_list(
"tag list of an axm", Tag::D_paren_l, [&]() {
624 auto& aliases = subs.emplace_back();
625 aliases.emplace_back(ptr<AxmDecl::Alias>(parse_id(
"tag of an axm")));
626 while (accept(Tag::T_assign)) aliases.emplace_back(ptr<AxmDecl::Alias>(parse_id(
"alias of an axm tag")));
630 auto type = parse_type_ascr(
"type ascription of an axm");
632 if (ahead(0).isa(Tag::T_comma) && ahead(1).isa(Tag::M_id)) {
634 normalizer = lex().dbg();
636 if (accept(Tag::T_comma)) {
637 if (
auto c = expect(Tag::L_u,
"curry counter for axm")) curry =
c;
638 if (accept(Tag::T_comma)) {
639 if (
auto t = expect(Tag::L_u,
"trip count for axm")) trip =
t;
643 return ptr<AxmDecl>(track, dbg, std::move(subs), std::move(type), normalizer, curry, trip);
647 auto track = tracker();
651 if (
auto anx = accept(Tok::Tag::M_anx)) {
652 auto type = parse_type_ascr();
653 ptrn = ptr<IdPtrn>(track, anx.dbg(), std::move(type));
655 ptrn = parse_ptrn(Paren_Style,
"binding pattern of a let declaration",
Expr::Prec::Bot);
658 expect(Tag::T_assign,
"let");
659 auto type = parse_type_ascr();
660 auto value = parse_expr(
"value of a let declaration");
661 return ptr<LetDecl>(track, std::move(ptrn), std::move(value));
665 auto track = tracker();
666 auto tag = lex().tag();
667 auto id = expect(Tag::M_id,
"C function declaration");
668 auto dom = parse_ptrn(Brckt_Style,
"domain of a C function"s,
Expr::Prec::App);
670 if (tag == Tag::K_cfun) {
671 expect(Tag::T_colon,
"codomain of a C function");
672 codom = parse_expr(
"codomain of a C function");
674 return ptr<CDecl>(track, tag,
id.dbg(), std::move(dom), std::move(codom));
678 auto track = tracker();
679 eat(first ? Tag::K_rec : Tag::K_and);
680 auto dbg = parse_name(
"recursive declaration");
681 auto type = accept(Tag::T_colon) ? parse_expr(
"type of a recursive declaration") : ptr<HoleExpr>(curr_);
682 expect(Tag::T_assign,
"recursive declaration");
683 auto body = parse_expr(
"body of a recursive declaration");
684 auto next = ahead().isa(Tag::K_and) ? parse_and_decl() : nullptr;
685 return ptr<RecDecl>(track, dbg, std::move(type), std::move(body), std::move(next));
689 auto track = tracker();
690 auto tag = lex().tag();
692 bool external = (bool)accept(Tag::K_extern);
698 case Tag::T_lm: decl =
false; entity =
"function expression";
break;
699 case Tag::K_cn: decl =
false; entity =
"continuation expression";
break;
700 case Tag::K_fn: decl =
false; entity =
"returning continuation expression";
break;
701 case Tag::K_lam: decl = true ; entity =
"function declaration";
break;
702 case Tag::K_con: decl = true ; entity =
"continuation declaration";
break;
703 case Tag::K_fun: decl = true ; entity =
"returning continuation declaration";
break;
704 default: fe::unreachable();
708 auto dbg = decl ? parse_name(entity) : Dbg();
711 auto track = tracker();
712 auto ptrn = parse_ptrn(Paren_Style | Implicit,
"domain pattern of a "s + entity, prec);
713 auto filter = accept(Tag::T_at) ? parse_expr(
"filter") : nullptr;
714 doms.emplace_back(ptr<LamDecl::Dom>(track, std::move(ptrn), std::move(filter)));
716 switch (ahead().tag()) {
717 case Tag::C_CURRIED_P:
continue;
723 auto codom = accept(Tag::T_colon) ? parse_expr(
"codomain of a "s + entity,
Expr::Prec::Arrow) : nullptr;
724 if (tag == Tag::K_fn || tag == Tag::K_fun)
725 doms.back()->add_ret(
ast(), codom ? std::move(codom) : ptr<HoleExpr>(curr_));
727 expect(Tag::T_assign,
"body of a "s + entity);
728 auto body = parse_expr(
"body of a "s + entity);
729 auto next = ahead().isa(Tag::K_and) ? parse_and_decl() : nullptr;
731 return ptr<LamDecl>(track, tag, external, dbg, std::move(doms), std::move(codom), std::move(body), std::move(next));
735 switch (ahead(1).tag()) {
736 case Tag::C_LAM:
return lex(), parse_lam_decl();
737 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