MimIR 0.1
MimIR is my Intermediate Representation
Loading...
Searching...
No Matches
emit.cpp
Go to the documentation of this file.
1#include "mim/def.h"
2#include "mim/rewrite.h"
3
4#include "mim/ast/ast.h"
5
6using namespace std::literals;
7
8namespace mim::ast {
9
10using Tag = Tok::Tag;
11
12class Emitter {
13public:
15 : ast_(ast) {}
16
17 AST& ast() const { return ast_; }
18 World& world() { return ast().world(); }
19 Driver& driver() { return world().driver(); }
20
21 void register_annex(AnnexInfo* annex, sub_t sub, const Def* def) {
22 if (annex) {
23 const auto& id = annex->id;
24 world().register_annex(id.plugin | (id.tag << 8) | sub, def);
25 }
26 }
27
28 absl::node_hash_map<Sigma*, fe::SymMap<size_t>, GIDHash<const Def*>> sigma2sym2idx;
29
30private:
31 AST& ast_;
32};
33
34/*
35 * Module
36 */
37
38void Module::emit(AST& ast) const {
39 auto emitter = Emitter(ast);
40 emit(emitter);
41}
42
43void Module::emit(Emitter& e) const {
44 auto _ = e.world().push(loc());
45 for (const auto& import : implicit_imports())
46 import->emit(e);
47 for (const auto& import : imports())
48 import->emit(e);
49 for (const auto& decl : decls())
50 decl->emit(e);
51}
52
53void Import::emit(Emitter& e) const { module()->emit(e); }
54
55/*
56 * Ptrn::emit_value
57 */
58
59const Def* ErrorPtrn::emit_value(Emitter&, const Def* def) const { return def; }
60
61const Def* IdPtrn::emit_value(Emitter& e, const Def* def) const {
62 emit_type(e);
63 return def_ = def->set(dbg());
64}
65
66const Def* GrpPtrn::emit_value(Emitter&, const Def* def) const { return def_ = def->set(dbg()); }
67
68const Def* AliasPtrn::emit_value(Emitter& e, const Def* def) const {
69 return def_ = ptrn()->emit_value(e, def)->set(dbg());
70}
71
72const Def* TuplePtrn::emit_value(Emitter& e, const Def* def) const {
73 auto _ = e.world().push(loc());
74 emit_type(e);
75 for (size_t i = 0, n = num_ptrns(); i != n; ++i)
76 ptrn(i)->emit_value(e, def->proj(n, i));
77 return def_ = def;
78}
79
80/*
81 * Ptrn::emit_Type
82 */
83
84const Def* ErrorPtrn::emit_type(Emitter&) const { fe::unreachable(); }
85
86const Def* IdPtrn::emit_type(Emitter& e) const {
87 auto _ = e.world().push(loc());
88 return type() ? type()->emit(e) : e.world().mut_hole_type();
89}
90
91const Def* AliasPtrn::emit_type(Emitter& e) const { return ptrn()->emit_type(e); }
92
93const Def* GrpPtrn::emit_type(Emitter& e) const { return id()->emit_type(e); }
94
95const Def* TuplePtrn::emit_type(Emitter& e) const { return emit_body(e, {}); }
96
97const Def* TuplePtrn::emit_body(Emitter& e, const Def* decl) const {
98 auto _ = e.world().push(loc());
99 auto n = num_ptrns();
100 Sigma* sigma;
101 if (decl) {
102 sigma = decl->as_mut<Sigma>();
103 } else {
104 auto type = e.world().type_infer_univ();
105 sigma = e.world().mut_sigma(type, n);
106 }
107 auto var = sigma->var();
108 auto& sym2idx = e.sigma2sym2idx[sigma];
109
110 for (size_t i = 0; i != n; ++i) {
111 sigma->set(i, ptrn(i)->emit_type(e));
112 ptrn(i)->emit_value(e, var->proj(n, i));
113 if (auto id = ptrn(i)->isa<IdPtrn>()) sym2idx[id->dbg().sym()] = i;
114 }
115
116 if (auto imm = sigma->immutabilize()) return imm;
117 return sigma;
118}
119
120const Def* TuplePtrn::emit_decl(Emitter& e, const Def* type) const {
121 auto _ = e.world().push(loc());
122 type = type ? type : e.world().type_infer_univ();
123 return e.world().mut_sigma(type, num_ptrns());
124}
125
126/*
127 * Expr
128 */
129
130const Def* Expr::emit(Emitter& e) const {
131 auto _ = e.world().push(loc());
132 return emit_(e);
133}
134
135const Def* ErrorExpr::emit_(Emitter&) const { fe::unreachable(); }
136const Def* HoleExpr::emit_(Emitter& e) const { return e.world().mut_hole_type(); }
137
138const Def* IdExpr::emit_(Emitter&) const {
139 assert(decl());
140 return decl()->def();
141}
142
143const Def* TypeExpr::emit_(Emitter& e) const {
144 auto l = level()->emit(e);
145 return e.world().type(l);
146}
147
148const Def* PrimaryExpr ::emit_(Emitter& e) const {
149 // clang-format off
150 switch (tag()) {
151 case Tag::K_Univ: return e.world().univ();
152 case Tag::K_Nat: return e.world().type_nat();
153 case Tag::K_Idx: return e.world().type_idx();
154 case Tag::K_Bool: return e.world().type_bool();
155 case Tag::K_ff: return e.world().lit_ff();
156 case Tag::K_tt: return e.world().lit_tt();
157 case Tag::K_i1: return e.world().lit_i1();
158 case Tag::K_i8: return e.world().lit_i8();
159 case Tag::K_i16: return e.world().lit_i16();
160 case Tag::K_i32: return e.world().lit_i32();
161 case Tag::K_i64: return e.world().lit_i64();
162 case Tag::K_I1: return e.world().type_i1();
163 case Tag::K_I8: return e.world().type_i8();
164 case Tag::K_I16: return e.world().type_i16();
165 case Tag::K_I32: return e.world().type_i32();
166 case Tag::K_I64: return e.world().type_i64();
167 case Tag::T_star: return e.world().type<0>();
168 case Tag::T_box: return e.world().type<1>();
169 default: fe::unreachable();
170 }
171 // clang-format on
172}
173
174const Def* LitExpr::emit_(Emitter& e) const {
175 auto t = type() ? type()->emit(e) : nullptr;
176 // clang-format off
177 switch (tag()) {
178 case Tag::L_f:
179 case Tag::L_s:
180 case Tag::L_u: return t ? e.world().lit(t, tok().lit_u()) : e.world().lit_nat(tok().lit_u());
181 case Tag::L_i: return tok().lit_i();
182 case Tag::L_c: return e.world().lit_i8(tok().lit_c());
183 case Tag::L_str: return e.world().tuple(tok().sym());
184 case Tag::T_bot: return t ? e.world().bot(t) : e.world().type_bot();
185 case Tag::T_top: return t ? e.world().top(t) : e.world().type_top();
186 default: fe::unreachable();
187 }
188 // clang-format on
189}
190
191const Def* DeclExpr::emit_(Emitter& e) const {
192 if (is_where())
193 for (const auto& decl : decls() | std::ranges::views::reverse)
194 decl->emit(e);
195 else
196 for (const auto& decl : decls())
197 decl->emit(e);
198 return expr()->emit(e);
199}
200
201const Def* ArrowExpr::emit_decl(Emitter& e, const Def* type) const {
202 return decl_ = e.world().mut_pi(type, false)->set(loc());
203}
204
205void ArrowExpr::emit_body(Emitter& e, const Def*) const {
206 decl_->set_dom(dom()->emit(e));
207 decl_->set_codom(codom()->emit(e)); // TODO try to immutabilize
208}
209
210const Def* ArrowExpr::emit_(Emitter& e) const {
211 auto d = dom()->emit(e);
212 auto c = codom()->emit(e);
213 return e.world().pi(d, c);
214}
215
216const Def* UnionExpr::emit_(Emitter& e) const {
217 DefVec etypes;
218 for (auto& t : types())
219 etypes.emplace_back(t->emit(e));
220 return e.world().join(etypes);
221}
222
223const Def* InjExpr::emit_(Emitter& e) const {
224 auto v = value()->emit(e);
225 auto t = type()->emit(e);
226 return e.world().inj(t, v);
227}
228
230 auto _ = e.world().push(loc());
231 auto dom_t = ptrn()->emit_type(e);
232 auto pi = e.world().pi(dom_t, e.world().mut_hole_type());
233 auto lam = e.world().mut_lam(pi);
234 ptrn()->emit_value(e, lam->var());
235 return lam->set(true, body()->emit(e));
236}
237
238const Def* MatchExpr::emit_(Emitter& e) const {
239 DefVec res;
240 res.emplace_back(scrutinee()->emit(e));
241 for (const auto& arm : arms())
242 res.emplace_back(arm->emit(e));
243 return e.world().match(res);
244}
245
247 pi_ = decl_ ? decl_ : e.world().mut_pi(e.world().type_infer_univ(), is_implicit());
248 auto dom_t = ptrn()->emit_type(e);
249
250 if (ret()) {
251 auto sigma = e.world().mut_sigma(2)->set(loc());
252 auto var = sigma->var()->set(ret()->loc().anew_begin());
253 sigma->set(0, dom_t);
254 ptrn()->emit_value(e, var->proj(2, 0));
255 auto ret_t = e.world().cn(ret()->emit_type(e));
256 sigma->set(1, ret_t);
257
258 if (auto imm = sigma->immutabilize())
259 dom_t = imm;
260 else
261 dom_t = sigma;
262 pi_->set_dom(dom_t);
263 } else {
264 pi_->set_dom(dom_t);
265 ptrn()->emit_value(e, pi_->var());
266 }
267}
268
269const Def* PiExpr::emit_decl(Emitter& e, const Def* type) const {
270 return dom()->decl_ = e.world().mut_pi(type, dom()->is_implicit())->set(loc());
271}
272
273void PiExpr::emit_body(Emitter& e, const Def*) const { emit(e); }
274
275const Def* PiExpr::emit_(Emitter& e) const {
276 dom()->emit_type(e);
277 auto cod = codom() ? codom()->emit(e) : e.world().type_bot();
278 return dom()->pi_->set_codom(cod);
279}
280
281const Def* LamExpr::emit_decl(Emitter& e, const Def*) const { return lam()->emit_decl(e), lam()->def(); }
282void LamExpr::emit_body(Emitter& e, const Def*) const { lam()->emit_body(e); }
283
284const Def* LamExpr::emit_(Emitter& e) const {
285 auto res = emit_decl(e, {});
286 emit_body(e, {});
287 return res;
288}
289
290const Def* AppExpr::emit_(Emitter& e) const {
291 auto c = callee()->emit(e);
292 auto a = arg()->emit(e);
293 return is_explicit() ? e.world().app(c, a) : e.world().implicit_app(c, a);
294}
295
296const Def* RetExpr::emit_(Emitter& e) const {
297 auto c = callee()->emit(e);
298 if (auto cn = Pi::has_ret_pi(c->type())) {
299 auto con = e.world().mut_lam(cn);
300 auto pair = e.world().tuple({arg()->emit(e), con});
301 auto app = e.world().app(c, pair)->set(c->loc() + arg()->loc());
302 ptrn()->emit_value(e, con->var());
303 con->set(false, body()->emit(e));
304 return app;
305 }
306
307 error(c->loc(), "callee of a ret expression must type as a returning continuation but got '{}' of type '{}'", c,
308 c->type());
309}
310
311const Def* SigmaExpr::emit_decl(Emitter& e, const Def* type) const { return ptrn()->emit_decl(e, type); }
312void SigmaExpr::emit_body(Emitter& e, const Def* decl) const { ptrn()->emit_body(e, decl); }
313const Def* SigmaExpr::emit_(Emitter& e) const { return ptrn()->emit_type(e); }
314
315const Def* TupleExpr::emit_(Emitter& e) const {
316 DefVec elems(num_elems(), [&](size_t i) { return elem(i)->emit(e); });
317 return e.world().tuple(elems);
318}
319
320const Def* SeqExpr::emit_(Emitter& e) const {
321 auto s = arity()->emit_type(e);
322 if (arity()->dbg().is_anon()) { // immutable
323 auto b = body()->emit(e);
324 return is_arr() ? e.world().arr(s, b) : e.world().pack(s, b);
325 }
326
327 auto t = e.world().type_infer_univ();
328 auto a = e.world().mut_arr(t);
329 a->set_arity(s);
330
331 if (is_arr()) {
332 auto var = a->var();
333 arity()->emit_value(e, var);
334 a->set_body(body()->emit(e));
335 if (auto imm = a->immutabilize()) return imm;
336 return a;
337 } else {
338 auto p = e.world().mut_pack(a);
339 auto var = p->var();
340 arity()->emit_value(e, var);
341 auto b = body()->emit(e);
342 a->set_body(b->type());
343 p->set(b);
344 if (auto imm = p->immutabilize()) return imm;
345 return p;
346 }
347}
348
350 auto tup = tuple()->emit(e);
351 if (auto dbg = std::get_if<Dbg>(&index())) {
352 if (auto sigma = tup->type()->isa_mut<Sigma>()) {
353 if (auto i = e.sigma2sym2idx.find(sigma); i != e.sigma2sym2idx.end()) {
354 auto sigma = i->first->as_mut<Sigma>();
355 const auto& sym2idx = i->second;
356 if (auto i = sym2idx.find(dbg->sym()); i != sym2idx.end())
357 return e.world().extract(tup, sigma->num_ops(), i->second);
358 }
359 }
360
361 if (decl()) return e.world().extract(tup, decl()->def());
362 error(dbg->loc(), "cannot resolve index '{}' for extraction", *dbg);
363 }
364
365 auto expr = std::get<Ptr<Expr>>(index()).get();
366 auto i = expr->emit(e);
367 return e.world().extract(tup, i);
368}
369
370const Def* InsertExpr::emit_(Emitter& e) const {
371 auto t = tuple()->emit(e);
372 auto i = index()->emit(e);
373 auto v = value()->emit(e);
374 return e.world().insert(t, i, v);
375}
376
377const Def* UniqExpr::emit_(Emitter& e) const { return e.world().uniq(inhabitant()->emit(e)); }
378
379/*
380 * Decl
381 */
382
383void AxmDecl::emit(Emitter& e) const {
384 mim_type_ = type()->emit(e);
385 auto& id = annex_->id;
386
387 std::tie(id.curry, id.trip) = Axm::infer_curry_and_trip(mim_type_);
388 if (curry_) {
389 if (curry_.lit_u() > id.curry)
390 error(curry_.loc(), "curry counter cannot be greater than {}", id.curry);
391 else
392 id.curry = curry_.lit_u();
393 }
394
395 if (trip_) {
396 if (trip_.lit_u() > id.curry)
397 error(trip_.loc(), "trip counter cannot be greater than curry counter '{}'", (int)id.curry);
398 else
399 id.trip = trip_.lit_u();
400 }
401
402 if (num_subs() == 0) {
403 auto norm = e.driver().normalizer(id.plugin, id.tag, 0);
404 auto axm = e.world().axm(norm, id.curry, id.trip, mim_type_, id.plugin, id.tag, 0)->set(dbg());
405 def_ = axm;
406 e.world().register_annex(id.plugin, id.tag, 0, axm);
407 } else {
408 for (sub_t i = 0, n = num_subs(); i != n; ++i) {
409 sub_t s = i + offset_;
410 auto norm = e.driver().normalizer(id.plugin, id.tag, s);
411 auto name = e.world().sym(dbg().sym().str() + "."s + sub(i).front()->dbg().sym().str());
412 auto axm = e.world().axm(norm, id.curry, id.trip, mim_type_, id.plugin, id.tag, s)->set(name);
413 e.world().register_annex(id.plugin, id.tag, s, axm);
414
415 for (const auto& alias : sub(i))
416 alias->def_ = axm;
417 }
418 }
419}
420
421void LetDecl::emit(Emitter& e) const {
422 auto v = value()->emit(e);
423 def_ = ptrn()->emit_value(e, v);
424 e.register_annex(annex_, sub_, def_);
425}
426
427void RecDecl::emit(Emitter& e) const {
428 for (auto curr = this; curr; curr = curr->next())
429 curr->emit_decl(e);
430 for (auto curr = this; curr; curr = curr->next())
431 curr->emit_body(e);
432}
433
435 auto t = type() ? type()->emit(e) : e.world().type_infer_univ();
436 def_ = body()->emit_decl(e, t);
437 def_->set(dbg());
438}
439
441 body()->emit_body(e, def_);
442 // TODO immutabilize?
443 e.register_annex(annex_, sub_, def_);
444}
445
447 lam_ = e.world().mut_lam(pi_);
448 auto var = lam_->var();
449
450 if (ret()) {
451 ptrn()->emit_value(e, var->proj(2, 0));
452 ret()->emit_value(e, var->proj(2, 1));
453 } else {
454 ptrn()->emit_value(e, var);
455 }
456
457 return lam_;
458}
459
461 auto _ = e.world().push(loc());
462 bool is_cps = tag_ == Tag::K_cn || tag_ == Tag::K_con || tag_ == Tag::K_fn || tag_ == Tag::K_fun;
463
464 // Iterate over all doms: Build a Lam for curr dom, by first building a curried Pi for the remaining doms.
465 for (size_t i = 0, n = num_doms(); i != n; ++i) {
466 for (const auto& dom : doms() | std::ranges::views::drop(i))
467 dom->emit_type(e);
468
469 auto cod = codom() ? codom()->emit(e) : is_cps ? e.world().type_bot() : e.world().mut_hole_type();
470 for (const auto& dom : doms() | std::ranges::views::drop(i) | std::ranges::views::reverse)
471 cod = dom->pi_->set_codom(cod);
472
473 auto cur = dom(i);
474 auto lam = cur->emit_value(e);
475 auto filter = cur->filter() ? cur->filter()->emit(e)
476 : i + 1 == n && is_cps ? e.world().lit_ff()
477 : e.world().lit_tt();
478 lam->set_filter(filter);
479
480 if (i == 0)
481 def_ = lam->set(dbg().sym());
482 else
483 dom(i - 1)->lam_->set_body(lam);
484 }
485}
486
488 auto b = body()->emit(e);
489 doms().back()->lam_->set_body(b);
490
491 // rewrite holes
492 for (size_t i = 0, n = num_doms(); i != n; ++i) {
493 auto rw = VarRewriter(e.world());
494 auto lam = dom(i)->lam_;
495 auto pi = lam->type()->as_mut<Pi>();
496 for (const auto& dom : doms() | std::ranges::views::drop(i)) {
497 if (auto var = pi->has_var()) rw.add(dom->lam_->var()->as<Var>(), var);
498 auto cod = pi->codom();
499 if (!cod || !cod->isa_mut<Pi>()) break;
500 pi = cod->as_mut<Pi>();
501 }
502
503 if (auto cod = pi->codom(); cod && cod->has_dep(Dep::Hole)) pi->set(pi->dom(), rw.rewrite(cod));
504 }
505
506 for (const auto& dom : doms() | std::ranges::views::reverse) {
507 if (auto imm = dom->pi_->immutabilize()) {
508 auto f = dom->lam_->filter();
509 auto b = dom->lam_->body();
510 dom->lam_->unset()->set_type(imm)->as<Lam>()->set(f, b);
511 }
512 }
513
514 if (is_external()) doms().front()->lam_->make_external();
515 e.register_annex(annex_, sub_, def_);
516}
517
518void CDecl::emit(Emitter& e) const {
519 auto dom_t = dom()->emit_type(e);
520 if (tag() == Tag::K_cfun) {
521 auto ret_t = codom()->emit(e);
522 def_ = e.world().mut_fun(dom_t, ret_t)->set(dbg());
523 } else {
524 def_ = e.world().mut_con(dom_t)->set(dbg());
525 }
526}
527
528void RuleDecl::emit(Emitter& e) const {
529 auto _ = e.world().push(loc());
530 auto meta_t = e.world().reform(var()->emit_type(e));
531 auto rule_ = e.world().mut_rule(meta_t);
532 var()->emit_value(e, rule_->var());
533 auto l = lhs()->emit(e);
534 auto r = rhs()->emit(e);
535 auto c = guard()->emit(e);
536 rule_->set(l, r, c);
537 // TODO register rule somewhere
538}
539
540} // namespace mim::ast
static std::pair< u8, u8 > infer_curry_and_trip(const Def *type)
Definition axm.cpp:14
Base class for all Defs.
Definition def.h:251
Def * set(size_t i, const Def *)
Successively set from left to right.
Definition def.cpp:266
T * as_mut() const
Asserts that this is a mutable, casts constness away and performs a static_cast to T.
Definition def.h:491
const Def * var(nat_t a, nat_t i) noexcept
Definition def.h:429
Some "global" variables needed all over the place.
Definition driver.h:17
A function.
Definition lam.h:109
A dependent function type.
Definition lam.h:13
static const Pi * has_ret_pi(const Def *d)
Yields the Pi::ret_pi() of d, if it is in fact a Pi.
Definition lam.h:58
Pi * set(const Def *dom, const Def *codom)
Definition lam.h:75
A dependent tuple type.
Definition tuple.h:20
const Def * immutabilize() final
Tries to make an immutable from a mutable.
Definition def.cpp:198
Sigma * set(size_t i, const Def *def)
Definition tuple.h:32
The World represents the whole program and manages creation of MimIR nodes (Defs).
Definition world.h:36
const Driver & driver() const
Definition world.h:87
const Def * register_annex(flags_t f, const Def *)
Definition world.cpp:78
World & world()
Definition ast.h:61
const Def * emit_value(Emitter &, const Def *) const override
Definition emit.cpp:68
Dbg dbg() const
Definition ast.h:276
const Def * emit_type(Emitter &) const override
Definition emit.cpp:91
const Ptrn * ptrn() const
Definition ast.h:275
const Def * emit_(Emitter &) const override
Definition emit.cpp:290
bool is_explicit() const
Definition ast.h:652
const Expr * arg() const
Definition ast.h:654
const Expr * callee() const
Definition ast.h:653
void emit_body(Emitter &, const Def *decl) const override
Definition emit.cpp:205
const Def * emit_decl(Emitter &, const Def *type) const override
Definition emit.cpp:201
const Def * emit_(Emitter &) const override
Definition emit.cpp:210
void emit(Emitter &) const override
Definition emit.cpp:383
const Expr * type() const
Definition ast.h:890
Tok trip() const
Definition ast.h:893
size_t num_subs() const
Definition ast.h:888
Tok curry() const
Definition ast.h:892
Dbg dbg() const
Definition ast.h:886
const auto & sub(size_t i) const
Definition ast.h:889
Tok::Tag tag() const
Definition ast.h:1022
const Ptrn * dom() const
Definition ast.h:1023
void emit(Emitter &) const override
Definition emit.cpp:518
const Expr * codom() const
Definition ast.h:1024
Dbg dbg() const
Definition ast.h:1021
const Expr * expr() const
Definition ast.h:420
const Def * emit_(Emitter &) const override
Definition emit.cpp:191
const auto & decls() const
Definition ast.h:418
bool is_where() const
Definition ast.h:419
const Def * def_
Definition ast.h:173
const Def * def() const
Definition ast.h:170
AST & ast() const
Definition emit.cpp:17
World & world()
Definition emit.cpp:18
Emitter(AST &ast)
Definition emit.cpp:14
void register_annex(AnnexInfo *annex, sub_t sub, const Def *def)
Definition emit.cpp:21
absl::node_hash_map< Sigma *, fe::SymMap< size_t >, GIDHash< const Def * > > sigma2sym2idx
Definition emit.cpp:28
Driver & driver()
Definition emit.cpp:19
const Def * emit_(Emitter &) const override
Definition emit.cpp:135
const Def * emit_type(Emitter &) const override
Definition emit.cpp:84
const Def * emit_value(Emitter &, const Def *) const override
Definition emit.cpp:59
const Def * emit(Emitter &) const
Definition emit.cpp:130
virtual void emit_body(Emitter &, const Def *) const
Definition ast.h:158
virtual const Def * emit_(Emitter &) const =0
virtual const Def * emit_decl(Emitter &, const Def *) const
Definition ast.h:157
const Decl * decl() const
Definition ast.h:775
const Def * emit_(Emitter &) const override
Definition emit.cpp:349
const auto & index() const
Definition ast.h:774
const Expr * tuple() const
Definition ast.h:773
const Def * emit_type(Emitter &) const override
Definition emit.cpp:93
const Def * emit_value(Emitter &, const Def *) const override
Definition emit.cpp:66
Dbg dbg() const
Definition ast.h:254
const IdPtrn * id() const
Definition ast.h:255
const Def * emit_(Emitter &) const override
Definition emit.cpp:136
const Def * emit_(Emitter &) const override
Definition emit.cpp:138
const Decl * decl() const
Definition ast.h:355
const Def * emit_type(Emitter &) const override
Definition emit.cpp:86
const Def * emit_value(Emitter &, const Def *) const override
Definition emit.cpp:61
Dbg dbg() const
Definition ast.h:224
const Expr * type() const
Definition ast.h:225
void emit(Emitter &) const
Definition emit.cpp:53
const Module * module() const
Definition ast.h:1086
const Def * emit_(Emitter &) const override
Definition emit.cpp:223
const Expr * type() const
Definition ast.h:482
const Expr * value() const
Definition ast.h:481
const Expr * index() const
Definition ast.h:798
const Expr * tuple() const
Definition ast.h:797
const Def * emit_(Emitter &) const override
Definition emit.cpp:370
const Expr * value() const
Definition ast.h:799
Lam * emit_value(Emitter &) const
Definition emit.cpp:446
bool is_external() const
Definition ast.h:990
const Ptrs< Dom > & doms() const
Definition ast.h:991
const Expr * codom() const
Definition ast.h:994
void emit_decl(Emitter &) const override
Definition emit.cpp:460
size_t num_doms() const
Definition ast.h:993
void emit_body(Emitter &) const override
Definition emit.cpp:487
const Dom * dom(size_t i) const
Definition ast.h:992
void emit_body(Emitter &, const Def *decl) const override
Definition emit.cpp:282
const Def * emit_(Emitter &) const override
Definition emit.cpp:284
const LamDecl * lam() const
Definition ast.h:630
const Def * emit_decl(Emitter &, const Def *type) const override
Definition emit.cpp:281
const Expr * value() const
Definition ast.h:843
const Ptrn * ptrn() const
Definition ast.h:842
void emit(Emitter &) const override
Definition emit.cpp:421
Tok tok() const
Definition ast.h:395
const Expr * type() const
Definition ast.h:397
const Def * emit_(Emitter &) const override
Definition emit.cpp:174
Tok::Tag tag() const
Definition ast.h:396
Lam * emit(Emitter &) const
Definition emit.cpp:229
const Expr * body() const
Definition ast.h:507
const Ptrn * ptrn() const
Definition ast.h:506
const Def * emit_(Emitter &) const override
Definition emit.cpp:238
const Expr * scrutinee() const
Definition ast.h:523
const Arm * arm(size_t i) const
Definition ast.h:525
const auto & arms() const
Definition ast.h:524
const auto & decls() const
Definition ast.h:1114
void emit(AST &) const
Definition emit.cpp:38
const auto & implicit_imports() const
Definition ast.h:1112
const auto & imports() const
Definition ast.h:1113
Loc loc() const
Definition ast.h:122
virtual void emit_type(Emitter &) const
Definition emit.cpp:246
const IdPtrn * ret() const
Definition ast.h:579
bool is_implicit() const
Definition ast.h:577
const Ptrn * ptrn() const
Definition ast.h:578
const Def * emit_(Emitter &) const override
Definition emit.cpp:275
const Def * emit_decl(Emitter &, const Def *type) const override
Definition emit.cpp:269
void emit_body(Emitter &, const Def *decl) const override
Definition emit.cpp:273
Tok::Tag tag() const
Definition ast.h:376
virtual const Def * emit_value(Emitter &, const Def *) const =0
virtual const Def * emit_type(Emitter &) const =0
void emit(Emitter &) const override
Definition emit.cpp:427
Dbg dbg() const
Definition ast.h:920
virtual void emit_body(Emitter &) const
Definition emit.cpp:440
virtual void emit_decl(Emitter &) const
Definition emit.cpp:434
const Expr * body() const
Definition ast.h:922
const Expr * type() const
Definition ast.h:921
const Ptrn * ptrn() const
Definition ast.h:677
const Expr * arg() const
Definition ast.h:679
const Def * emit_(Emitter &) const override
Definition emit.cpp:296
const Expr * body() const
Definition ast.h:680
const Expr * callee() const
Definition ast.h:678
const Ptrn * var() const
Definition ast.h:1052
const Expr * guard() const
Definition ast.h:1055
const Expr * rhs() const
Definition ast.h:1054
const Expr * lhs() const
Definition ast.h:1053
void emit(Emitter &) const override
Definition emit.cpp:528
const Expr * body() const
Definition ast.h:748
const IdPtrn * arity() const
Definition ast.h:747
bool is_arr() const
Definition ast.h:746
const Def * emit_(Emitter &) const override
Definition emit.cpp:320
const TuplePtrn * ptrn() const
Definition ast.h:702
const Def * emit_(Emitter &) const override
Definition emit.cpp:313
void emit_body(Emitter &, const Def *decl) const override
Definition emit.cpp:312
const Def * emit_decl(Emitter &, const Def *type) const override
Definition emit.cpp:311
const Lit * lit_i() const
Definition tok.h:167
const Expr * elem(size_t i) const
Definition ast.h:725
const Def * emit_(Emitter &) const override
Definition emit.cpp:315
const auto & elems() const
Definition ast.h:724
size_t num_elems() const
Definition ast.h:726
const Ptrn * ptrn(size_t i) const
Definition ast.h:304
const Def * emit_type(Emitter &) const override
Definition emit.cpp:95
const Def * emit_decl(Emitter &, const Def *type) const
Definition emit.cpp:120
size_t num_ptrns() const
Definition ast.h:305
const Def * emit_value(Emitter &, const Def *) const override
Definition emit.cpp:72
const Def * emit_body(Emitter &, const Def *decl) const
Definition emit.cpp:97
const Def * emit_(Emitter &) const override
Definition emit.cpp:143
const Expr * level() const
Definition ast.h:440
const auto & types() const
Definition ast.h:460
const Def * emit_(Emitter &) const override
Definition emit.cpp:216
const Expr * inhabitant() const
Definition ast.h:819
const Def * emit_(Emitter &) const override
Definition emit.cpp:377
Definition ast.h:14
Tok::Tag Tag
Definition bind.cpp:7
Vector< const Def * > DefVec
Definition def.h:77
u8 sub_t
Definition types.h:48
@ Hole
Definition def.h:127
void error(Loc loc, const char *f, Args &&... args)
Definition dbg.h:125
constexpr decltype(auto) get(Span< T, N > span) noexcept
Definition span.h:115
struct mim::ast::AnnexInfo::@177100250272201136376142224053244231100060214216 id