Skip to content

Commit c7c4520

Browse files
lazearlazear
committed
type vectors
1 parent 068a73c commit c7c4520

File tree

9 files changed

+196
-90
lines changed

9 files changed

+196
-90
lines changed

‎crates/sml-core/src/alpha.rs

+115-48
Original file line numberDiff line numberDiff line change
@@ -6,22 +6,22 @@ use crate::elaborate::{Context, ElabError, ErrorKind};
66
use crate::types::{Constructor, Type};
77
use crate::{Decl, Expr, ExprKind, Lambda, Pat, PatKind, Row, Rule, SortedRecord};
88
use sml_util::interner::Symbol;
9+
use sml_util::pretty_print::PrettyPrinter;
910
use sml_util::span::Span;
1011
use sml_util::Const;
1112
use std::{cell::Cell, collections::HashMap};
1213

13-
pub struct Entry {
14+
pub struct Entry<'a> {
1415
name: Symbol,
1516
tyvars: Vec<usize>,
16-
// usages:
17+
usages: Vec<Vec<&'a Type<'a>>>,
1718
}
1819

19-
pub struct Monomorphizer {}
20-
2120
pub struct Rename<'a> {
2221
pub decls: Vec<Decl<'a>>,
2322
arena: &'a CoreArena<'a>,
2423
stack: Vec<Namespace>,
24+
cache: HashMap<Symbol, Vec<Vec<&'a Type<'a>>>>,
2525
id: u32,
2626
}
2727

@@ -39,6 +39,7 @@ impl<'a> Rename<'a> {
3939
decls: Vec::default(),
4040
arena,
4141
stack: vec![Namespace::default()],
42+
cache: HashMap::new(),
4243
id: 0,
4344
}
4445
}
@@ -51,6 +52,47 @@ impl<'a> Rename<'a> {
5152
self.stack.pop();
5253
}
5354

55+
fn cache_decl(&mut self, name: Symbol, tyvars: Vec<usize>) {
56+
let entry = Entry {
57+
name,
58+
tyvars,
59+
usages: Vec::new(),
60+
};
61+
self.cache.insert(name, Vec::new());
62+
}
63+
64+
pub fn dump_cache(&self, pp: &mut PrettyPrinter<'_>) {
65+
for (k, entry) in &self.cache {
66+
pp.line().text("CACHE ").print(k);
67+
for usage in entry {
68+
for ty in usage {
69+
pp.text(" ").print(*ty).text(",");
70+
}
71+
}
72+
}
73+
let mut b = String::new();
74+
let _ = pp.write_fmt(&mut b);
75+
println!("{}", b);
76+
}
77+
78+
fn add_usage(&mut self, name: Symbol, usage: Vec<&'a Type<'a>>, pp: &mut PrettyPrinter<'_>) {
79+
// self.cache.entry(name)
80+
// for (k, entry) in &self.cache {
81+
// pp.line().text("CACHE ").print(k);
82+
// for usage in entry {
83+
// pp.text(" ").print(*usage).text(",");
84+
// }
85+
// }
86+
// let mut b = String::new();
87+
// let _ = pp.write_fmt(&mut b);
88+
// println!("{}", b);
89+
// let entry = self
90+
// .cache
91+
// .get_mut(&name)
92+
// .expect(&format!("Invalid usage! {:?}", name));
93+
self.cache.entry(name).or_default().push(usage);
94+
}
95+
5496
#[inline]
5597
pub fn fresh(&mut self) -> Symbol {
5698
let id = self.id;
@@ -102,11 +144,11 @@ impl<'a> Rename<'a> {
102144
}
103145
}
104146

105-
pub fn visit_decl(&mut self, decl: &Decl<'a>) -> Decl<'a> {
147+
pub fn visit_decl(&mut self, decl: &Decl<'a>, pp: &mut PrettyPrinter<'_>) -> Decl<'a> {
106148
match decl {
107149
Decl::Val(vars, Rule { pat, expr }) => {
108-
let pat = self.visit_pat(&pat);
109-
let expr = self.visit_expr(&expr);
150+
let pat = self.visit_pat(&pat, pp);
151+
let expr = self.visit_expr(&expr, pp);
110152

111153
Decl::Val(vars.clone(), Rule { pat, expr })
112154
}
@@ -117,8 +159,8 @@ impl<'a> Rename<'a> {
117159
let sym = self.register_val(*sym);
118160
self.enter();
119161
lam.arg = self.register_val(lam.arg);
120-
lam.ty = self.visit_type(lam.ty);
121-
lam.body = self.visit_expr(&lam.body);
162+
lam.ty = self.visit_type(lam.ty, pp);
163+
lam.body = self.visit_expr(&lam.body, pp);
122164
self.leave();
123165
(sym, lam)
124166
})
@@ -128,7 +170,7 @@ impl<'a> Rename<'a> {
128170
}
129171
Decl::Datatype(dts) => {
130172
for dt in dts {
131-
self.register_type(dt.tycon.name);
173+
let name = self.register_type(dt.tycon.name);
132174
}
133175

134176
Decl::Datatype(
@@ -155,32 +197,33 @@ impl<'a> Rename<'a> {
155197
let mut con = *con;
156198
con.name = self.register_val(con.name);
157199
// con.tycon should be EXN
158-
let ty = ty.map(|ty| self.visit_type(ty));
200+
let ty = ty.map(|ty| self.visit_type(ty, pp));
159201
Decl::Exn(con, ty)
160202
}
161203
}
162204
}
163205

164-
fn visit_type(&mut self, ty: &'a Type<'a>) -> &'a Type<'a> {
206+
fn visit_type(&mut self, ty: &'a Type<'a>, pp: &mut PrettyPrinter<'_>) -> &'a Type<'a> {
165207
match ty {
166208
Type::Var(tyvar) => match tyvar.ty() {
167-
Some(ty) => self.visit_type(ty),
209+
Some(ty) => self.visit_type(ty, pp),
168210
None => {
169211
// emit warning for unused type variable
170-
self.arena.types.unit()
212+
// self.arena.types.unit()
213+
ty
171214
}
172215
},
173216
Type::Record(fields) => {
174217
let args = SortedRecord::new_unchecked(
175218
fields
176219
.iter()
177-
.map(|row| row.fmap(|ty| self.visit_type(ty)))
220+
.map(|row| row.fmap(|ty| self.visit_type(ty, pp)))
178221
.collect(),
179222
);
180223
self.arena.types.alloc(Type::Record(args))
181224
}
182225
Type::Flex(flex) => match flex.ty() {
183-
Some(ty) => self.visit_type(ty),
226+
Some(ty) => self.visit_type(ty, pp),
184227
None => {
185228
// emit warning for unused type variable
186229
self.arena.types.unit()
@@ -190,18 +233,20 @@ impl<'a> Rename<'a> {
190233
con.name = self.swap_type(con.name).expect("BUG: Type::Con");
191234
self.arena.types.alloc(Type::Con(
192235
con,
193-
args.iter().map(|ty| self.visit_type(ty)).collect(),
236+
args.iter().map(|ty| self.visit_type(ty, pp)).collect(),
194237
))
195238
}
196239
}
197240
}
198241

199-
fn visit_pat(&mut self, pat: &Pat<'a>) -> Pat<'a> {
242+
fn visit_pat(&mut self, pat: &Pat<'a>, pp: &mut PrettyPrinter<'_>) -> Pat<'a> {
243+
let ty = self.visit_type(pat.ty, pp);
244+
200245
let kind = match pat.kind {
201246
PatKind::App(mut con, Some(pat)) => {
202247
con.name = self.swap_value(con.name).expect("BUG: PatKind::Con");
203248
con.tycon = self.swap_type(con.tycon).expect("BUG: PatKind::Con");
204-
PatKind::App(con, Some(self.visit_pat(pat)))
249+
PatKind::App(con, Some(self.visit_pat(pat, pp)))
205250
}
206251
PatKind::App(mut con, None) => {
207252
con.name = self.swap_value(con.name).expect("BUG: PatKind::Con");
@@ -212,37 +257,39 @@ impl<'a> Rename<'a> {
212257
PatKind::Record(fields) => PatKind::Record(SortedRecord::new_unchecked(
213258
fields
214259
.iter()
215-
.map(|row| row.fmap(|pat| self.visit_pat(pat)))
260+
.map(|row| row.fmap(|pat| self.visit_pat(pat, pp)))
216261
.collect(),
217262
)),
218263
PatKind::Var(sym) => PatKind::Var(self.register_val(*sym)),
219264
PatKind::Wild => PatKind::Var(self.fresh()),
220265
};
221-
Pat::new(
222-
self.arena.pats.alloc(kind),
223-
self.visit_type(pat.ty),
224-
pat.span,
225-
)
266+
Pat::new(self.arena.pats.alloc(kind), ty, pat.span)
226267
}
227268

228-
fn visit_expr(&mut self, expr: &Expr<'a>) -> Expr<'a> {
269+
fn visit_expr(&mut self, expr: &Expr<'a>, pp: &mut PrettyPrinter<'_>) -> Expr<'a> {
270+
pp.text("visiting ").print(expr);
271+
let mut b = String::new();
272+
let _ = pp.write_fmt(&mut b);
273+
println!("{}", b);
274+
275+
let ty = self.visit_type(expr.ty, pp);
229276
let kind = match expr.kind {
230277
ExprKind::App(e1, e2) => {
231-
let e1 = self.visit_expr(e1);
232-
let e2 = self.visit_expr(e2);
278+
let e1 = self.visit_expr(e1, pp);
279+
let e2 = self.visit_expr(e2, pp);
233280
ExprKind::App(e1, e2)
234281
}
235282
ExprKind::Case(casee, rules) => {
236283
let (var, ty) = casee;
237284
let var = self.swap_value(*var).expect("BUG: ExprKind::Case");
238-
let ty = self.visit_type(ty);
285+
let ty = self.visit_type(ty, pp);
239286

240287
let rules = rules
241288
.iter()
242289
.map(|rule| {
243290
self.enter();
244-
let pat = self.visit_pat(&rule.pat);
245-
let expr = self.visit_expr(&rule.expr);
291+
let pat = self.visit_pat(&rule.pat, pp);
292+
let expr = self.visit_expr(&rule.expr, pp);
246293
self.leave();
247294
Rule { pat, expr }
248295
})
@@ -253,50 +300,70 @@ impl<'a> Rename<'a> {
253300
ExprKind::Con(mut con, tys) => {
254301
con.name = self.swap_value(con.name).expect("BUG: ExprKind::Con");
255302
con.tycon = self.swap_type(con.tycon).expect("BUG: ExprKind::Con");
256-
ExprKind::Con(con, tys.iter().map(|ty| self.visit_type(ty)).collect())
303+
let tys = tys
304+
.iter()
305+
.map(|ty| self.visit_type(ty, pp))
306+
.collect::<Vec<_>>();
307+
self.add_usage(con.name, tys.clone(), pp);
308+
ExprKind::Con(con, tys)
257309
}
258310
ExprKind::Const(c) => ExprKind::Const(*c),
259311
ExprKind::Handle(tryy, sym, handler) => {
260-
let tryy = self.visit_expr(tryy);
312+
let tryy = self.visit_expr(tryy, pp);
261313
let sym = self.swap_value(*sym).expect("BUG: ExprKind::Handle");
262-
let handler = self.visit_expr(handler);
314+
let handler = self.visit_expr(handler, pp);
263315
ExprKind::Handle(tryy, sym, handler)
264316
}
265317
ExprKind::Lambda(lam) => {
266318
let mut lam = *lam;
267319
self.enter();
268320
lam.arg = self.register_val(lam.arg);
269-
lam.ty = self.visit_type(lam.ty);
270-
lam.body = self.visit_expr(&lam.body);
321+
lam.ty = self.visit_type(lam.ty, pp);
322+
lam.body = self.visit_expr(&lam.body, pp);
271323
self.leave();
272324
ExprKind::Lambda(lam)
273325
}
274326
ExprKind::Let(decls, body) => {
275327
self.enter();
276-
let decls = decls.iter().map(|d| self.visit_decl(d)).collect();
277-
let body = self.visit_expr(body);
328+
let decls = decls.iter().map(|d| self.visit_decl(d, pp)).collect();
329+
let body = self.visit_expr(body, pp);
278330
self.leave();
279331
ExprKind::Let(decls, body)
280332
}
281333
ExprKind::List(exprs) => {
282-
ExprKind::List(exprs.iter().map(|e| self.visit_expr(e)).collect())
334+
ExprKind::List(exprs.iter().map(|e| self.visit_expr(e, pp)).collect())
283335
}
284336
ExprKind::Primitive(sym) => ExprKind::Primitive(*sym),
285-
ExprKind::Raise(e) => ExprKind::Raise(self.visit_expr(e)),
337+
ExprKind::Raise(e) => ExprKind::Raise(self.visit_expr(e, pp)),
286338
ExprKind::Record(rows) => ExprKind::Record(
287339
rows.iter()
288-
.map(|row| row.fmap(|ex| self.visit_expr(ex)))
340+
.map(|row| row.fmap(|ex| self.visit_expr(ex, pp)))
289341
.collect(),
290342
),
291343
ExprKind::Seq(exprs) => {
292-
ExprKind::Seq(exprs.iter().map(|e| self.visit_expr(e)).collect())
344+
ExprKind::Seq(exprs.iter().map(|e| self.visit_expr(e, pp)).collect())
345+
}
346+
ExprKind::Var(s, tys) => {
347+
let name = self.swap_value(*s).expect("BUG");
348+
let tys = tys
349+
.iter()
350+
.map(|ty| self.visit_type(ty, pp))
351+
.collect::<Vec<_>>();
352+
self.add_usage(name, tys.clone(), pp);
353+
pp.line().text("VAR ").print(&name).print(ty);
354+
ExprKind::Var(name, tys)
355+
// if vars.is_empty() {
356+
// ExprKind::Var(name, Vec::new())
357+
// } else {
358+
// let usage = vars
359+
// .iter()
360+
// .map(|ty| self.visit_type(ty, pp))
361+
// .collect::<Vec<_>>();
362+
// self.add_usage(name, usage.clone(), pp);
363+
// ExprKind::Var(name, usage)
364+
// }
293365
}
294-
ExprKind::Var(s) => ExprKind::Var(self.swap_value(*s).expect("BUG")),
295366
};
296-
Expr::new(
297-
self.arena.exprs.alloc(kind),
298-
self.visit_type(expr.ty),
299-
expr.span,
300-
)
367+
Expr::new(self.arena.exprs.alloc(kind), ty, expr.span)
301368
}
302369
}

0 commit comments

Comments
 (0)