1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
#![allow(dead_code)]
use crate::error::{TypeError, TypeMessage};
use crate::semantics::core::var::AlphaVar;
use crate::semantics::phase::normalize::{normalize_tyexpr_whnf, NzEnv};
use crate::semantics::phase::typecheck::rc;
use crate::semantics::phase::Normalized;
use crate::semantics::phase::{NormalizedExpr, ToExprOptions};
use crate::semantics::tck::typecheck::TyEnv;
use crate::semantics::Value;
use crate::syntax::{ExprKind, Label, Span, V};
pub(crate) type Type = Value;
// An expression with inferred types at every node and resolved variables.
#[derive(Clone)]
pub(crate) struct TyExpr {
kind: Box<TyExprKind>,
ty: Option<Type>,
span: Span,
}
#[derive(Debug, Clone)]
pub(crate) enum TyExprKind {
Var(AlphaVar),
// Forbidden ExprKind variants: Var, Import, Embed
Expr(ExprKind<TyExpr, Normalized>),
}
impl TyExpr {
pub fn new(kind: TyExprKind, ty: Option<Type>, span: Span) -> Self {
TyExpr {
kind: Box::new(kind),
ty,
span,
}
}
pub fn kind(&self) -> &TyExprKind {
&*self.kind
}
pub fn get_type(&self) -> Result<Type, TypeError> {
match &self.ty {
Some(t) => Ok(t.clone()),
None => Err(TypeError::new(TypeMessage::Sort)),
}
}
/// Converts a value back to the corresponding AST expression.
pub fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
tyexpr_to_expr(self, opts, &mut Vec::new())
}
pub fn to_expr_tyenv(&self, env: &TyEnv) -> NormalizedExpr {
let opts = ToExprOptions {
normalize: true,
alpha: false,
};
let env = env.as_nameenv().names();
let mut env = env.iter().collect();
tyexpr_to_expr(self, opts, &mut env)
}
// TODO: temporary hack
pub fn to_value(&self) -> Value {
todo!()
}
pub fn normalize_whnf(&self, env: &NzEnv) -> Value {
normalize_tyexpr_whnf(self, env)
}
pub fn normalize_whnf_noenv(&self) -> Value {
self.normalize_whnf(&NzEnv::new())
}
pub fn normalize_nf(&self, env: &NzEnv) -> Value {
let mut val = self.normalize_whnf(env);
val.normalize_mut();
val
}
pub fn normalize_nf_noenv(&self) -> Value {
self.normalize_nf(&NzEnv::new())
}
}
fn tyexpr_to_expr<'a>(
tyexpr: &'a TyExpr,
opts: ToExprOptions,
ctx: &mut Vec<&'a Label>,
) -> NormalizedExpr {
rc(match tyexpr.kind() {
TyExprKind::Var(v) if opts.alpha => {
ExprKind::Var(V("_".into(), v.idx()))
}
TyExprKind::Var(v) => {
let name = ctx[ctx.len() - 1 - v.idx()];
let idx = ctx
.iter()
.rev()
.take(v.idx())
.filter(|l| **l == name)
.count();
ExprKind::Var(V(name.clone(), idx))
}
TyExprKind::Expr(e) => {
let e = e.map_ref_maybe_binder(|l, tye| {
if let Some(l) = l {
ctx.push(l);
}
let e = tyexpr_to_expr(tye, opts, ctx);
if let Some(_) = l {
ctx.pop();
}
e
});
match e {
ExprKind::Lam(_, t, e) if opts.alpha => {
ExprKind::Lam("_".into(), t, e)
}
ExprKind::Pi(_, t, e) if opts.alpha => {
ExprKind::Pi("_".into(), t, e)
}
e => e,
}
}
})
}
impl std::fmt::Debug for TyExpr {
fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut x = fmt.debug_struct("TyExpr");
x.field("kind", self.kind());
if let Some(ty) = self.ty.as_ref() {
x.field("type", &ty);
} else {
x.field("type", &None::<()>);
}
x.finish()
}
}
|
