MimIR 0.1
MimIR is my Intermediate Representation
Loading...
Searching...
No Matches
parser.cpp
Go to the documentation of this file.
1#include "mim/ast/parser.h"
2
3#include <filesystem>
4#include <fstream>
5#include <ranges>
6
7#include "mim/driver.h"
8
9// clang-format off
10#define C_PRIMARY \
11 K_Univ: \
12 case Tag::K_Nat: \
13 case Tag::K_Idx: \
14 case Tag::K_Bool: \
15 case Tag::K_ff: \
16 case Tag::K_tt: \
17 case Tag::K_i1: \
18 case Tag::K_i8: \
19 case Tag::K_i16: \
20 case Tag::K_i32: \
21 case Tag::K_i64: \
22 case Tag::K_I1: \
23 case Tag::K_I8: \
24 case Tag::K_I16: \
25 case Tag::K_I32: \
26 case Tag::K_I64: \
27 case Tag::T_star: \
28 case Tag::T_box
29
30#define C_ID \
31 M_anx: \
32 case Tag::M_id
33
34#define C_LIT \
35 T_bot: \
36 case Tag::T_top: \
37 case Tag::L_str: \
38 case Tag::L_c: \
39 case Tag::L_s: \
40 case Tag::L_u: \
41 case Tag::L_f: \
42 case Tag::L_i
43
44#define C_LAM \
45 K_lam: \
46 case Tag::K_con: \
47 case Tag::K_fun
48
49#define C_DECL \
50 K_axm: \
51 case Tag::K_let: \
52 case Tag::K_rec: \
53 case Tag::K_ccon: \
54 case Tag::K_cfun: \
55 case Tag::C_LAM
56
57#define C_PI \
58 D_brace_l: \
59 case Tag::K_Cn: \
60 case Tag::K_Fn
61
62#define C_LM \
63 T_lm: \
64 case Tag::K_cn: \
65 case Tag::K_fn
66
67#define C_EXPR \
68 C_PRIMARY: \
69 case Tag::C_ID: \
70 case Tag::C_LIT: \
71 case Tag::C_DECL: \
72 case Tag::C_PI: \
73 case Tag::C_LM: \
74 case Tag::K_Type: /*TypeExpr*/ \
75 case Tag::K_ins: /*InsertExpr*/ \
76 case Tag::K_ret: /*RetExpr*/ \
77 case Tag::D_angle_l: /*PackExpr*/ \
78 case Tag::D_brckt_l: /*SigmaExpr*/ \
79 case Tag::D_curly_l: /*UniqExpr*/ \
80 case Tag::D_paren_l: /*TupleExpr*/ \
81 case Tag::D_quote_l /*ArrExpr*/
82
83#define C_CURRIED_B \
84 D_brace_l: \
85 case Tag::D_brckt_l: \
86 case Tag::D_quote_l
87
88#define C_CURRIED_P \
89 D_brace_l: \
90 case Tag::D_brckt_l: \
91 case Tag::D_paren_l
92// clang-format on
93
94using namespace std::string_literals;
95
96namespace mim::ast {
97
98using Tag = Tok::Tag;
99
100/*
101 * entry points
102 */
103
104Ptr<Module> Parser::parse_module() {
105 auto track = tracker();
106 Ptrs<Import> imports;
107 while (true) {
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));
110 } else {
111 break;
112 }
113 }
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 ';'?");
119 return mod;
120}
121
122Ptr<Module> Parser::import(Dbg dbg, std::ostream* md) {
123 auto name = dbg.sym();
124 auto filename = fs::path(name.view());
125 driver().VLOG("import: {}", name);
126
127 if (!filename.has_extension()) filename.replace_extension("mim"); // TODO error cases
128
129 fs::path rel_path;
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;
136 }
137
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);
141 }
142 return {};
143}
144
145Ptr<Module> Parser::import(std::istream& is, Loc loc, const fs::path* path, std::ostream* md) {
146 driver().VLOG("reading: {}", path ? path->string() : "<unknown file>"s);
147 if (!is) {
148 ast().error(loc, "cannot read file {}", *path);
149 return {};
150 }
151
152 auto state = std::tuple(curr_, ahead_, lexer_);
153 auto lexer = Lexer(ast(), is, path, md);
154 lexer_ = &lexer;
155 init(path);
156 auto mod = parse_module();
157 std::tie(curr_, ahead_, lexer_) = state;
158 return mod;
159}
160
162 // if (!driver().is_loaded(dbg.sym()) && (!driver().flags().bootstrap || driver().world().name() != dbg.sym()))
163 if (!driver().is_loaded(dbg.sym()) && !driver().flags().bootstrap) driver().load(dbg.sym());
164 return import(dbg);
165}
166
167/*
168 * misc
169 */
170
171Ptr<Import> Parser::parse_import_or_plugin() {
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));
179 return {};
180}
181
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>")};
186}
187
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>"));
193}
194
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_);
200}
201
202/*
203 * exprs
204 */
205
206Ptr<Expr> Parser::parse_expr(std::string_view ctxt, Expr::Prec curr_prec) {
207 auto track = tracker();
208 auto lhs = parse_primary_expr(ctxt);
209 return parse_infix_expr(track, std::move(lhs), curr_prec);
210}
211
212Ptr<Expr> Parser::parse_infix_expr(Tracker track, Ptr<Expr>&& lhs, Expr::Prec curr_prec) {
213 while (true) {
214 // If operator in ahead has less left precedence: reduce (break).
215 switch (ahead().tag()) {
216 case Tag::T_extract: {
217 if (curr_prec >= Expr::Prec::Extract) return lhs;
218 lex();
219 if (auto tok = accept(Tag::M_id))
220 lhs = ptr<ExtractExpr>(track, std::move(lhs), tok.dbg());
221 else {
222 auto rhs = parse_expr("right-hand side of an extract", Expr::Prec::Extract);
223 lhs = ptr<ExtractExpr>(track, std::move(lhs), std::move(rhs));
224 }
225 continue;
226 }
227 case Tag::T_arrow: {
228 if (curr_prec > Expr::Prec::Arrow) return lhs; // ">" - Arrow is rassoc
229 lex();
230 auto rhs = parse_expr("right-hand side of a function type", Expr::Prec::Arrow);
231 lhs = ptr<ArrowExpr>(track, std::move(lhs), std::move(rhs));
232 continue;
233 }
234 case Tag::T_union: {
235 if (curr_prec >= Expr::Prec::Union) return lhs;
236 lex();
237 Ptrs<Expr> types;
238 types.emplace_back(std::move(lhs));
239 do {
240 auto t = parse_expr("right-hand side of a union type", Expr::Prec::Union);
241 types.emplace_back(std::move(t));
242 } while (accept(Tag::T_union));
243 lhs = ptr<UnionExpr>(track, std::move(types));
244 continue;
245 }
246 case Tag::K_inj: {
247 if (curr_prec > Expr::Prec::Inj) return lhs;
248 lex();
249 auto rhs = parse_expr("type a value is injected in", Expr::Prec::Inj);
250 lhs = ptr<InjExpr>(track, std::move(lhs), std::move(rhs));
251 continue;
252 }
253 case Tag::T_at: {
254 if (curr_prec >= Expr::Prec::App) return lhs;
255 lex();
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));
258 continue;
259 }
260 case Tag::C_EXPR: {
261 if (curr_prec >= Expr::Prec::App) return lhs;
262 switch (ahead().tag()) {
263 case Tag::C_DECL:
264 ast().warn(ahead().loc(), "you are passing a declaration expression as argument");
265 ast().note(lhs->loc(), "to this expression");
266 ast().note(ahead().loc(),
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 ';'");
269 default: break;
270 }
271 auto rhs = parse_expr("argument to an application", Expr::Prec::App);
272 lhs = ptr<AppExpr>(track, false, std::move(lhs), std::move(rhs));
273 continue;
274 }
275 case Tag::K_where: {
276 if (curr_prec >= Expr::Prec::Where) return lhs;
277 lex();
278 auto decls = parse_decls();
279 lhs = ptr<DeclExpr>(track, std::move(decls), std::move(lhs), true);
280
281 bool where = ahead().tag() == Tag::K_where;
282 expect(Tag::K_end, "end of a where declaration block");
283 if (where)
284 ast().note(lhs->loc().anew_finis(),
285 "did you accidentally end your declaration expression with a ';'?");
286 return lhs;
287 }
288 default: return lhs;
289 }
290 }
291}
292
293Ptr<Expr> Parser::parse_insert_expr() {
294 eat(Tag::K_ins);
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));
304}
305
306Ptr<Expr> Parser::parse_uniq_expr() {
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));
312}
313
314Ptr<Expr> Parser::parse_match_expr() {
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)));
326 });
327 return ptr<MatchExpr>(track, std::move(scrutinee), std::move(arms));
328}
329
330Ptr<Expr> Parser::parse_primary_expr(std::string_view ctxt) {
331 // clang-format off
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();
342 case Tag::D_quote_l:
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();
348 default:
349 if (ctxt.empty()) return nullptr;
350 syntax_err("primary expression", ctxt);
351 }
352 // clang-format on
353 return ptr<ErrorExpr>(curr_);
354}
355
356Ptr<Expr> Parser::parse_seq_expr() {
357 auto track = tracker();
358 bool is_arr = accept(Tag::D_quote_l) ? true : (eat(Tag::D_angle_l), false);
359
360 std::deque<std::pair<Ptr<IdPtrn>, Ptr<Expr>>> shapes;
361
362 do {
363 Dbg dbg;
364 if (ahead(0).isa(Tag::M_id) && ahead(1).isa(Tag::T_colon)) {
365 dbg = eat(Tag::M_id).dbg();
366 eat(Tag::T_colon);
367 }
368
369 auto expr = parse_expr(is_arr ? "shape of an array" : "shape of a pack");
370 auto ptrn = IdPtrn::make_id(ast(), dbg, std::move(expr));
371 shapes.emplace_back(std::move(ptrn), std::move(expr));
372 } while (accept(Tag::T_comma));
373
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");
378
379 for (auto& [ptrn, expr] : shapes | std::ranges::views::reverse)
380 body = ptr<SeqExpr>(track, is_arr, std::move(ptrn), std::move(body));
381
382 return body;
383}
384
385Ptr<Expr> Parser::parse_decl_expr() {
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);
390}
391
392Ptr<Expr> Parser::parse_lit_expr() {
393 auto track = tracker();
394 auto tok = lex();
395 auto type = accept(Tag::T_colon) ? parse_expr("literal", Expr::Prec::Lit) : nullptr;
396 return ptr<LitExpr>(track, tok, std::move(type));
397}
398
399Ptr<Expr> Parser::parse_sigma_expr() {
400 auto track = tracker();
401 auto ptrn = parse_tuple_ptrn(Brckt_Style);
402 switch (ahead().tag()) {
403 case Tag::K_as: {
404 lex();
405 auto alias = ptr<AliasPtrn>(track, std::move(ptrn), parse_name("alias pattern"));
406 return parse_pi_expr(std::move(alias));
407 }
408 case Tag::C_CURRIED_B:
409 case Tag::T_arrow: return parse_pi_expr(std::move(ptrn)); // TODO precedences for patterns
410 default: return ptr<SigmaExpr>(std::move(ptrn));
411 }
412}
413
414Ptr<Expr> Parser::parse_tuple_expr() {
415 auto track = tracker();
416 Ptrs<Expr> elems;
417 parse_list("tuple", Tag::D_paren_l, [&]() { elems.emplace_back(parse_expr("tuple element")); });
418 return ptr<TupleExpr>(track, std::move(elems));
419}
420
421Ptr<Expr> Parser::parse_type_expr() {
422 auto track = tracker();
423 eat(Tag::K_Type);
424 auto level = parse_expr("type level", Expr::Prec::App);
425 return ptr<TypeExpr>(track, std::move(level));
426}
427
428Ptr<Expr> Parser::parse_pi_expr() {
429 auto track = tracker();
430 auto tag = ahead().tag();
431 auto entity = "dependent function type"s;
432
433 if (accept(Tag::K_Cn))
434 entity = "continuation type";
435 else if (accept(Tag::K_Fn))
436 entity = "returning continuation type";
437
438 auto domt = tracker();
439 auto prec = tag == Tag::K_Cn ? Expr::Prec::Bot : Expr::Prec::Pi;
440 auto ptrn = parse_ptrn(Brckt_Style | Implicit, "domain of a "s + entity, prec);
441 auto dom = ptr<PiExpr::Dom>(domt, std::move(ptrn));
442
443 auto codom = tag != Tag::K_Cn
444 ? (expect(Tag::T_arrow, entity), parse_expr("codomain of a "s + entity, Expr::Prec::Arrow))
445 : nullptr;
446
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));
449}
450
451Ptr<Expr> Parser::parse_pi_expr(Ptr<Ptrn>&& ptrn) {
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);
456 auto codom = parse_expr("codomain of a "s + entity, Expr::Prec::Arrow);
457 return ptr<PiExpr>(track, Tag::Nil, std::move(dom), std::move(codom));
458}
459
460Ptr<Expr> Parser::parse_lam_expr() { return ptr<LamExpr>(parse_lam_decl()); }
461
462Ptr<Expr> Parser::parse_ret_expr() {
463 auto track = tracker();
464 eat(Tag::K_ret);
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));
473}
474
475/*
476 * ptrns
477 */
478
479Ptr<Ptrn> Parser::parse_ptrn(int style, std::string_view ctxt, Expr::Prec prec) {
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"));
483 return ptrn;
484}
485
486Ptr<Ptrn> Parser::parse_ptrn_(int style, std::string_view ctxt, Expr::Prec prec) {
487 auto track = tracker();
488
489 // p -> (p, ..., p)
490 // p -> {b, ..., b} b -> {b, ..., b}
491 // p -> [b, ..., b] b -> [b, ..., b]
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);
495
496 if (ahead(0).isa(Tag::M_id)) {
497 if (ahead(1).isa(Tag::T_colon)) {
498 // p -> s: e b -> s: e
499 auto dbg = eat(Tag::M_id).dbg();
500 eat(Tag::T_colon);
501 auto type = parse_expr(ctxt, prec);
502 return ptr<IdPtrn>(track, dbg, std::move(type));
503 } else if (is_paren_style(style)) {
504 // p -> s
505 // p -> `s
506 auto dbg = eat(Tag::M_id).dbg();
507 return ptr<IdPtrn>(track, dbg, nullptr);
508 } else {
509 // b -> e where e == id
510 auto type = parse_expr(ctxt, prec);
511 return ptr<IdPtrn>(track, type->loc().anew_begin(), std::move(type));
512 }
513 } else if (is_brket_style(style)) {
514 // b -> e where e != id
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()) {
519 // p -> ↯
520 syntax_err("pattern", ctxt);
521 return ptr<ErrorPtrn>(curr_);
522 }
523
524 return nullptr;
525}
526
527Ptr<TuplePtrn> Parser::parse_tuple_ptrn(int style) {
528 auto track = tracker();
529 auto delim_l = ahead().tag();
530
531 Ptrs<Ptrn> ptrns;
532 parse_list("tuple pattern", delim_l, [&]() {
533 auto track = tracker();
534 Ptr<Ptrn> ptrn;
535
536 if (ahead(0).isa(Tag::M_id) && ahead(1).isa(Tag::M_id)) {
537 Dbgs dbgs;
538 while (auto tok = accept(Tag::M_id)) dbgs.emplace_back(tok.dbg());
539
540 if (accept(Tag::T_colon)) { // identifier group: x y x: T
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));
544
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));
548 return;
549 }
550
551 // "x y z" is a curried app and maybe the prefix of a longer type expression
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));
556 }
557 auto expr = parse_infix_expr(track, std::move(lhs), Expr::Prec::App);
558 ptrn = IdPtrn::make_type(ast(), std::move(expr));
559 } else {
560 ptrn = parse_ptrn(style & Style_Bit, "element of a tuple pattern");
561
562 if (is_brket_style(style)) {
563 // [..., [Nat, Nat] -> Nat, ...] ==> [..., _: [Nat, Nat] -> Nat, ...]
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));
568 } else if (auto expr = Ptrn::to_expr(ast(), std::move(ptrn))) {
569 // If we are able to parse more stuff, we got an expr instead of a binder
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));
575 } else {
576 if (!ptrn) ptrn = Ptrn::to_ptrn(std::move(expr));
577 }
578 }
579 }
580 }
581
582 ptrns.emplace_back(std::move(ptrn));
583 });
584
585 return ptr<TuplePtrn>(track, delim_l, std::move(ptrns));
586}
587
588/*
589 * decls
590 */
591
592Ptrs<ValDecl> Parser::parse_decls() {
593 Ptrs<ValDecl> decls;
594 while (true) {
595 // clang-format off
596 switch (ahead().tag()) {
597 case Tag::T_semicolon: lex(); break; // eat up stray semicolons
598 case Tag::K_axm: decls.emplace_back(parse_axm_decl()); break;
599 case Tag::K_ccon:
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;
603 case Tag::K_con:
604 case Tag::K_fun:
605 case Tag::K_lam: decls.emplace_back(parse_lam_decl()); break;
606 default: return decls;
607 }
608 // clang-format on
609 }
610}
611
612Ptr<ValDecl> Parser::parse_axm_decl() {
613 auto track = tracker();
614 eat(Tag::K_axm);
615 Dbg dbg, normalizer;
616 Tok curry, trip;
617 if (auto name = expect(Tag::M_anx, "annex name of an axm"))
618 dbg = name.dbg();
619 else
620 dbg = Dbg(curr_, ast().sym("<error annex name>"));
621
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")));
628 });
629 }
630
631 auto type = parse_type_ascr("type ascription of an axm");
632
633 if (ahead(0).isa(Tag::T_comma) && ahead(1).isa(Tag::M_id)) {
634 lex();
635 normalizer = lex().dbg();
636 }
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;
641 }
642 }
643
644 return ptr<AxmDecl>(track, dbg, std::move(subs), std::move(type), normalizer, curry, trip);
645}
646
647Ptr<ValDecl> Parser::parse_let_decl() {
648 auto track = tracker();
649 eat(Tag::K_let);
650
651 Ptr<Ptrn> ptrn;
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));
655 } else {
656 ptrn = parse_ptrn(Paren_Style, "binding pattern of a let declaration", Expr::Prec::Bot);
657 }
658
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));
663}
664
665Ptr<ValDecl> Parser::parse_c_decl() {
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);
670 Ptr<Expr> codom;
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");
674 }
675 return ptr<CDecl>(track, tag, id.dbg(), std::move(dom), std::move(codom));
676}
677
678Ptr<RecDecl> Parser::parse_rec_decl(bool first) {
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));
687}
688
689Ptr<LamDecl> Parser::parse_lam_decl() {
690 auto track = tracker();
691 auto tag = lex().tag();
692 auto prec = tag == Tag::K_cn || tag == Tag::K_con ? Expr::Prec::Bot : Expr::Prec::Pi;
693 bool external = (bool)accept(Tag::K_extern);
694
695 bool decl;
696 std::string entity;
697 // clang-format off
698 switch (tag) {
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();
706 }
707 // clang-format on
708
709 auto dbg = decl ? parse_name(entity) : Dbg();
711 while (true) {
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)));
716
717 switch (ahead().tag()) {
718 case Tag::C_CURRIED_P: continue;
719 default: break;
720 }
721 break;
722 }
723
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_));
727
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;
731
732 return ptr<LamDecl>(track, tag, external, dbg, std::move(doms), std::move(codom), std::move(body), std::move(next));
733}
734
735Ptr<RecDecl> Parser::parse_and_decl() {
736 switch (ahead(1).tag()) {
737 case Tag::C_LAM: return lex(), parse_lam_decl();
738 default: return parse_rec_decl(false);
739 }
740}
741
742} // namespace mim::ast
void load(Sym name)
Definition driver.cpp:53
Error & note(Loc loc, const char *fmt, Args &&... args) const
Definition ast.h:86
Error & error()
Definition ast.h:63
Error & warn(Loc loc, const char *fmt, Args &&... args) const
Definition ast.h:85
static Ptr< IdPtrn > make_type(AST &ast, Ptr< Expr > &&type)
Definition ast.h:226
static Ptr< IdPtrn > make_id(AST &ast, Dbg dbg, Ptr< Expr > &&type)
Definition ast.h:230
Ptr< Module > import(std::string_view sv)
Definition parser.h:39
AST & ast()
Definition parser.h:37
Driver & driver()
Definition parser.h:38
Ptr< Module > plugin(Dbg)
Definition parser.cpp:161
static Ptr< Ptrn > to_ptrn(Ptr< Expr > &&)
Definition ast.cpp:177
static Ptr< Expr > to_expr(AST &, Ptr< Ptrn > &&)
Definition ast.cpp:167
Definition ast.h:14
std::deque< Dbg > Dbgs
Definition ast.h:23
fe::Arena::Ptr< const T > Ptr
Definition ast.h:21
std::deque< Ptr< T > > Ptrs
Definition ast.h:22
constexpr decltype(auto) get(Span< T, N > span) noexcept
Definition span.h:107