summaryrefslogtreecommitdiff
path: root/dhall/src/semantics
diff options
context:
space:
mode:
Diffstat (limited to 'dhall/src/semantics')
-rw-r--r--dhall/src/semantics/builtins.rs28
-rw-r--r--dhall/src/semantics/nze/nir.rs46
-rw-r--r--dhall/src/semantics/nze/normalize.rs182
-rw-r--r--dhall/src/semantics/resolve/resolve.rs21
-rw-r--r--dhall/src/semantics/tck/typecheck.rs35
5 files changed, 171 insertions, 141 deletions
diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 6007a92..45be448 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -5,8 +5,8 @@ use crate::syntax::map::DupTreeMap;
use crate::syntax::Const::Type;
use crate::syntax::{
BinOp, Builtin, Const, Expr, ExprKind, InterpolatedText,
- InterpolatedTextContents, Label, NaiveDouble, NumKind, Span, UnspannedExpr,
- V,
+ InterpolatedTextContents, Label, NaiveDouble, NumKind, OpKind, Span,
+ UnspannedExpr, V,
};
use std::collections::HashMap;
use std::convert::TryInto;
@@ -34,10 +34,10 @@ impl BuiltinClosure {
HirKind::Expr(self.args.iter().fold(
ExprKind::Builtin(self.b),
|acc, v| {
- ExprKind::App(
+ ExprKind::Op(OpKind::App(
Hir::new(HirKind::Expr(acc), Span::Artificial),
v.to_hir(venv),
- )
+ ))
},
))
}
@@ -59,16 +59,16 @@ macro_rules! make_type {
rc(ExprKind::Var(V(stringify!($var).into(), 0)))
};
(Optional $ty:ident) => {
- rc(ExprKind::App(
+ rc(ExprKind::Op(OpKind::App(
rc(ExprKind::Builtin(Builtin::Optional)),
make_type!($ty)
- ))
+ )))
};
(List $($rest:tt)*) => {
- rc(ExprKind::App(
+ rc(ExprKind::Op(OpKind::App(
rc(ExprKind::Builtin(Builtin::List)),
make_type!($($rest)*)
- ))
+ )))
};
({ $($label:ident : $ty:ident),* }) => {{
let mut kts = DupTreeMap::new();
@@ -214,10 +214,10 @@ macro_rules! make_closure {
};
(List $($ty:tt)*) => {{
let ty = make_closure!($($ty)*);
- rc(ExprKind::App(
+ rc(ExprKind::Op(OpKind::App(
rc(ExprKind::Builtin(Builtin::List)),
ty
- ))
+ )))
}};
(Some($($v:tt)*)) => {
rc(ExprKind::SomeLit(
@@ -225,20 +225,20 @@ macro_rules! make_closure {
))
};
(1 + $($v:tt)*) => {
- rc(ExprKind::BinOp(
+ rc(ExprKind::Op(OpKind::BinOp(
BinOp::NaturalPlus,
make_closure!($($v)*),
rc(ExprKind::Num(NumKind::Natural(1)))
- ))
+ )))
};
([ $($head:tt)* ] # $($tail:tt)*) => {{
let head = make_closure!($($head)*);
let tail = make_closure!($($tail)*);
- rc(ExprKind::BinOp(
+ rc(ExprKind::Op(OpKind::BinOp(
BinOp::ListAppend,
rc(ExprKind::NEListLit(vec![head])),
tail,
- ))
+ )))
}};
}
diff --git a/dhall/src/semantics/nze/nir.rs b/dhall/src/semantics/nze/nir.rs
index e0d227e..73c3f30 100644
--- a/dhall/src/semantics/nze/nir.rs
+++ b/dhall/src/semantics/nze/nir.rs
@@ -8,7 +8,7 @@ use crate::semantics::{
};
use crate::syntax::{
BinOp, Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Label,
- NumKind, Span,
+ NumKind, OpKind, Span,
};
use crate::ToExprOptions;
@@ -190,24 +190,24 @@ impl Nir {
NirKind::Const(c) => ExprKind::Const(*c),
NirKind::BuiltinType(b) => ExprKind::Builtin(*b),
NirKind::Num(l) => ExprKind::Num(l.clone()),
- NirKind::OptionalType(t) => ExprKind::App(
+ NirKind::OptionalType(t) => ExprKind::Op(OpKind::App(
Nir::from_builtin(Builtin::Optional).to_hir(venv),
t.to_hir(venv),
- ),
- NirKind::EmptyOptionalLit(n) => ExprKind::App(
+ )),
+ NirKind::EmptyOptionalLit(n) => ExprKind::Op(OpKind::App(
Nir::from_builtin(Builtin::OptionalNone).to_hir(venv),
n.to_hir(venv),
- ),
+ )),
NirKind::NEOptionalLit(n) => ExprKind::SomeLit(n.to_hir(venv)),
- NirKind::ListType(t) => ExprKind::App(
+ NirKind::ListType(t) => ExprKind::Op(OpKind::App(
Nir::from_builtin(Builtin::List).to_hir(venv),
t.to_hir(venv),
- ),
+ )),
NirKind::EmptyListLit(n) => ExprKind::EmptyListLit(Hir::new(
- HirKind::Expr(ExprKind::App(
+ HirKind::Expr(ExprKind::Op(OpKind::App(
Nir::from_builtin(Builtin::List).to_hir(venv),
n.to_hir(venv),
- )),
+ ))),
Span::Artificial,
)),
NirKind::NEListLit(elts) => ExprKind::NEListLit(
@@ -229,31 +229,33 @@ impl Nir {
.collect(),
),
NirKind::UnionType(kts) => map_uniontype(kts),
- NirKind::UnionConstructor(l, kts) => ExprKind::Field(
- Hir::new(
- HirKind::Expr(map_uniontype(kts)),
- Span::Artificial,
- ),
- l.clone(),
- ),
- NirKind::UnionLit(l, v, kts) => ExprKind::App(
+ NirKind::UnionConstructor(l, kts) => {
+ ExprKind::Op(OpKind::Field(
+ Hir::new(
+ HirKind::Expr(map_uniontype(kts)),
+ Span::Artificial,
+ ),
+ l.clone(),
+ ))
+ }
+ NirKind::UnionLit(l, v, kts) => ExprKind::Op(OpKind::App(
Hir::new(
- HirKind::Expr(ExprKind::Field(
+ HirKind::Expr(ExprKind::Op(OpKind::Field(
Hir::new(
HirKind::Expr(map_uniontype(kts)),
Span::Artificial,
),
l.clone(),
- )),
+ ))),
Span::Artificial,
),
v.to_hir(venv),
- ),
- NirKind::Equivalence(x, y) => ExprKind::BinOp(
+ )),
+ NirKind::Equivalence(x, y) => ExprKind::Op(OpKind::BinOp(
BinOp::Equivalence,
x.to_hir(venv),
y.to_hir(venv),
- ),
+ )),
NirKind::PartialExpr(e) => e.map_ref(|v| v.to_hir(venv)),
}),
};
diff --git a/dhall/src/semantics/nze/normalize.rs b/dhall/src/semantics/nze/normalize.rs
index 570e106..ebf4ae1 100644
--- a/dhall/src/semantics/nze/normalize.rs
+++ b/dhall/src/semantics/nze/normalize.rs
@@ -3,7 +3,9 @@ use std::collections::HashMap;
use crate::semantics::NzEnv;
use crate::semantics::{Binder, Closure, Hir, HirKind, Nir, NirKind, TextLit};
-use crate::syntax::{BinOp, ExprKind, InterpolatedTextContents, NumKind};
+use crate::syntax::{
+ BinOp, ExprKind, InterpolatedTextContents, NumKind, OpKind,
+};
pub fn apply_any(f: Nir, a: Nir) -> NirKind {
match f.kind() {
@@ -12,7 +14,7 @@ pub fn apply_any(f: Nir, a: Nir) -> NirKind {
NirKind::UnionConstructor(l, kts) => {
NirKind::UnionLit(l.clone(), a, kts.clone())
}
- _ => NirKind::PartialExpr(ExprKind::App(f, a)),
+ _ => NirKind::PartialExpr(ExprKind::Op(OpKind::App(f, a))),
}
}
@@ -173,11 +175,11 @@ fn apply_binop<'a>(o: BinOp, x: &'a Nir, y: &'a Nir) -> Option<Ret<'a>> {
}
(RecursiveRecordMerge, RecordLit(kvs1), RecordLit(kvs2)) => {
let kvs = merge_maps(kvs1, kvs2, |_, v1, v2| {
- Nir::from_partial_expr(ExprKind::BinOp(
+ Nir::from_partial_expr(ExprKind::Op(OpKind::BinOp(
RecursiveRecordMerge,
v1.clone(),
v2.clone(),
- ))
+ )))
});
Ret::NirKind(RecordLit(kvs))
}
@@ -188,11 +190,11 @@ fn apply_binop<'a>(o: BinOp, x: &'a Nir, y: &'a Nir) -> Option<Ret<'a>> {
kts_y,
// If the Label exists for both records, then we hit the recursive case.
|_, l: &Nir, r: &Nir| {
- Nir::from_partial_expr(ExprKind::BinOp(
+ Nir::from_partial_expr(ExprKind::Op(OpKind::BinOp(
RecursiveRecordTypeMerge,
l.clone(),
r.clone(),
- ))
+ )))
},
);
Ret::NirKind(RecordType(kts))
@@ -216,7 +218,7 @@ pub fn normalize_one_layer(expr: ExprKind<Nir>, env: &NzEnv) -> NirKind {
use NumKind::Bool;
let ret = match expr {
- ExprKind::Import(..) | ExprKind::Completion(..) => {
+ ExprKind::Import(..) | ExprKind::Op(OpKind::Completion(..)) => {
unreachable!("This case should have been handled in resolution")
}
ExprKind::Var(..)
@@ -230,7 +232,7 @@ pub fn normalize_one_layer(expr: ExprKind<Nir>, env: &NzEnv) -> NirKind {
ExprKind::Const(c) => Ret::Nir(Nir::from_const(c)),
ExprKind::Builtin(b) => Ret::Nir(Nir::from_builtin_env(b, env)),
ExprKind::Assert(_) => Ret::Expr(expr),
- ExprKind::App(v, a) => Ret::Nir(v.app(a)),
+ ExprKind::Op(OpKind::App(v, a)) => Ret::Nir(v.app(a)),
ExprKind::Num(l) => Ret::NirKind(Num(l)),
ExprKind::SomeLit(e) => Ret::NirKind(NEOptionalLit(e)),
ExprKind::EmptyListLit(t) => {
@@ -261,7 +263,7 @@ pub fn normalize_one_layer(expr: ExprKind<Nir>, env: &NzEnv) -> NirKind {
Ret::NirKind(NirKind::TextLit(tlit))
}
}
- ExprKind::BoolIf(ref b, ref e1, ref e2) => {
+ ExprKind::Op(OpKind::BoolIf(ref b, ref e1, ref e2)) => {
match b.kind() {
Num(Bool(true)) => Ret::NirRef(e1),
Num(Bool(false)) => Ret::NirRef(e2),
@@ -275,12 +277,14 @@ pub fn normalize_one_layer(expr: ExprKind<Nir>, env: &NzEnv) -> NirKind {
}
}
}
- ExprKind::BinOp(o, ref x, ref y) => match apply_binop(o, x, y) {
- Some(ret) => ret,
- None => Ret::Expr(expr),
- },
+ ExprKind::Op(OpKind::BinOp(o, ref x, ref y)) => {
+ match apply_binop(o, x, y) {
+ Some(ret) => ret,
+ None => Ret::Expr(expr),
+ }
+ }
- ExprKind::Field(ref v, ref field) => match v.kind() {
+ ExprKind::Op(OpKind::Field(ref v, ref field)) => match v.kind() {
RecordLit(kvs) => match kvs.get(field) {
Some(r) => Ret::Nir(r.clone()),
None => Ret::Expr(expr),
@@ -288,53 +292,65 @@ pub fn normalize_one_layer(expr: ExprKind<Nir>, env: &NzEnv) -> NirKind {
UnionType(kts) => {
Ret::NirKind(UnionConstructor(field.clone(), kts.clone()))
}
- PartialExpr(ExprKind::Projection(x, _)) => {
+ PartialExpr(ExprKind::Op(OpKind::Projection(x, _))) => {
return normalize_one_layer(
- ExprKind::Field(x.clone(), field.clone()),
+ ExprKind::Op(OpKind::Field(x.clone(), field.clone())),
env,
)
}
- PartialExpr(ExprKind::BinOp(
+ PartialExpr(ExprKind::Op(OpKind::BinOp(
BinOp::RightBiasedRecordMerge,
x,
y,
- )) => match (x.kind(), y.kind()) {
+ ))) => match (x.kind(), y.kind()) {
(_, RecordLit(kvs)) => match kvs.get(field) {
Some(r) => Ret::Nir(r.clone()),
None => {
return normalize_one_layer(
- ExprKind::Field(x.clone(), field.clone()),
+ ExprKind::Op(OpKind::Field(
+ x.clone(),
+ field.clone(),
+ )),
env,
)
}
},
(RecordLit(kvs), _) => match kvs.get(field) {
- Some(r) => Ret::Expr(ExprKind::Field(
- Nir::from_kind(PartialExpr(ExprKind::BinOp(
- BinOp::RightBiasedRecordMerge,
- Nir::from_kind(RecordLit(
- Some((field.clone(), r.clone()))
- .into_iter()
- .collect(),
- )),
- y.clone(),
+ Some(r) => Ret::Expr(ExprKind::Op(OpKind::Field(
+ Nir::from_kind(PartialExpr(ExprKind::Op(
+ OpKind::BinOp(
+ BinOp::RightBiasedRecordMerge,
+ Nir::from_kind(RecordLit(
+ Some((field.clone(), r.clone()))
+ .into_iter()
+ .collect(),
+ )),
+ y.clone(),
+ ),
))),
field.clone(),
- )),
+ ))),
None => {
return normalize_one_layer(
- ExprKind::Field(y.clone(), field.clone()),
+ ExprKind::Op(OpKind::Field(
+ y.clone(),
+ field.clone(),
+ )),
env,
)
}
},
_ => Ret::Expr(expr),
},
- PartialExpr(ExprKind::BinOp(BinOp::RecursiveRecordMerge, x, y)) => {
- match (x.kind(), y.kind()) {
- (RecordLit(kvs), _) => match kvs.get(field) {
- Some(r) => Ret::Expr(ExprKind::Field(
- Nir::from_kind(PartialExpr(ExprKind::BinOp(
+ PartialExpr(ExprKind::Op(OpKind::BinOp(
+ BinOp::RecursiveRecordMerge,
+ x,
+ y,
+ ))) => match (x.kind(), y.kind()) {
+ (RecordLit(kvs), _) => match kvs.get(field) {
+ Some(r) => Ret::Expr(ExprKind::Op(OpKind::Field(
+ Nir::from_kind(PartialExpr(ExprKind::Op(
+ OpKind::BinOp(
BinOp::RecursiveRecordMerge,
Nir::from_kind(RecordLit(
Some((field.clone(), r.clone()))
@@ -342,19 +358,24 @@ pub fn normalize_one_layer(expr: ExprKind<Nir>, env: &NzEnv) -> NirKind {
.collect(),
)),
y.clone(),
- ))),
- field.clone(),
- )),
- None => {
- return normalize_one_layer(
- ExprKind::Field(y.clone(), field.clone()),
- env,
- )
- }
- },
- (_, RecordLit(kvs)) => match kvs.get(field) {
- Some(r) => Ret::Expr(ExprKind::Field(
- Nir::from_kind(PartialExpr(ExprKind::BinOp(
+ ),
+ ))),
+ field.clone(),
+ ))),
+ None => {
+ return normalize_one_layer(
+ ExprKind::Op(OpKind::Field(
+ y.clone(),
+ field.clone(),
+ )),
+ env,
+ )
+ }
+ },
+ (_, RecordLit(kvs)) => match kvs.get(field) {
+ Some(r) => Ret::Expr(ExprKind::Op(OpKind::Field(
+ Nir::from_kind(PartialExpr(ExprKind::Op(
+ OpKind::BinOp(
BinOp::RecursiveRecordMerge,
x.clone(),
Nir::from_kind(RecordLit(
@@ -362,52 +383,57 @@ pub fn normalize_one_layer(expr: ExprKind<Nir>, env: &NzEnv) -> NirKind {
.into_iter()
.collect(),
)),
- ))),
- field.clone(),
- )),
- None => {
- return normalize_one_layer(
- ExprKind::Field(x.clone(), field.clone()),
- env,
- )
- }
- },
- _ => Ret::Expr(expr),
- }
- }
+ ),
+ ))),
+ field.clone(),
+ ))),
+ None => {
+ return normalize_one_layer(
+ ExprKind::Op(OpKind::Field(
+ x.clone(),
+ field.clone(),
+ )),
+ env,
+ )
+ }
+ },
+ _ => Ret::Expr(expr),
+ },
_ => Ret::Expr(expr),
},
- ExprKind::Projection(_, ref ls) if ls.is_empty() => {
+ ExprKind::Op(OpKind::Projection(_, ref ls)) if ls.is_empty() => {
Ret::NirKind(RecordLit(HashMap::new()))
}
- ExprKind::Projection(ref v, ref ls) => match v.kind() {
+ ExprKind::Op(OpKind::Projection(ref v, ref ls)) => match v.kind() {
RecordLit(kvs) => Ret::NirKind(RecordLit(
ls.iter()
.filter_map(|l| kvs.get(l).map(|x| (l.clone(), x.clone())))
.collect(),
)),
- PartialExpr(ExprKind::Projection(v2, _)) => {
+ PartialExpr(ExprKind::Op(OpKind::Projection(v2, _))) => {
return normalize_one_layer(
- ExprKind::Projection(v2.clone(), ls.clone()),
+ ExprKind::Op(OpKind::Projection(v2.clone(), ls.clone())),
env,
)
}
_ => Ret::Expr(expr),
},
- ExprKind::ProjectionByExpr(ref v, ref t) => match t.kind() {
- RecordType(kts) => {
- return normalize_one_layer(
- ExprKind::Projection(
- v.clone(),
- kts.keys().cloned().collect(),
- ),
- env,
- )
+ ExprKind::Op(OpKind::ProjectionByExpr(ref v, ref t)) => {
+ match t.kind() {
+ RecordType(kts) => {
+ return normalize_one_layer(
+ ExprKind::Op(OpKind::Projection(
+ v.clone(),
+ kts.keys().cloned().collect(),
+ )),
+ env,
+ )
+ }
+ _ => Ret::Expr(expr),
}
- _ => Ret::Expr(expr),
- },
+ }
- ExprKind::Merge(ref handlers, ref variant, _) => {
+ ExprKind::Op(OpKind::Merge(ref handlers, ref variant, _)) => {
match handlers.kind() {
RecordLit(kvs) => match variant.kind() {
UnionConstructor(l, _) => match kvs.get(l) {
@@ -431,7 +457,7 @@ pub fn normalize_one_layer(expr: ExprKind<Nir>, env: &NzEnv) -> NirKind {
_ => Ret::Expr(expr),
}
}
- ExprKind::ToMap(ref v, ref annot) => match v.kind() {
+ ExprKind::Op(OpKind::ToMap(ref v, ref annot)) => match v.kind() {
RecordLit(kvs) if kvs.is_empty() => {
match annot.as_ref().map(|v| v.kind()) {
Some(NirKind::ListType(t)) => {
diff --git a/dhall/src/semantics/resolve/resolve.rs b/dhall/src/semantics/resolve/resolve.rs
index 6e50fa6..3e0022f 100644
--- a/dhall/src/semantics/resolve/resolve.rs
+++ b/dhall/src/semantics/resolve/resolve.rs
@@ -11,7 +11,7 @@ use crate::syntax;
use crate::syntax::map::DupTreeMap;
use crate::syntax::{
BinOp, Builtin, Expr, ExprKind, FilePath, FilePrefix, Hash, ImportMode,
- ImportTarget, Span, UnspannedExpr, URL,
+ ImportTarget, OpKind, Span, UnspannedExpr, URL,
};
use crate::{Parsed, Resolved};
@@ -179,12 +179,13 @@ impl ImportLocation {
};
let asloc_ty = make_aslocation_uniontype();
- let expr = mkexpr(ExprKind::Field(asloc_ty, field_name.into()));
+ let expr =
+ mkexpr(ExprKind::Op(OpKind::Field(asloc_ty, field_name.into())));
match arg {
- Some(arg) => mkexpr(ExprKind::App(
+ Some(arg) => mkexpr(ExprKind::Op(OpKind::App(
expr,
mkexpr(ExprKind::TextLit(arg.into())),
- )),
+ ))),
None => expr,
}
}
@@ -261,21 +262,21 @@ fn resolve_one_import(
/// Desugar the first level of the expression.
fn desugar(expr: &Expr) -> Cow<'_, Expr> {
match expr.kind() {
- ExprKind::Completion(ty, compl) => {
+ ExprKind::Op(OpKind::Completion(ty, compl)) => {
let ty_field_default = Expr::new(
- ExprKind::Field(ty.clone(), "default".into()),
+ ExprKind::Op(OpKind::Field(ty.clone(), "default".into())),
expr.span(),
);
let merged = Expr::new(
- ExprKind::BinOp(
+ ExprKind::Op(OpKind::BinOp(
BinOp::RightBiasedRecordMerge,
ty_field_default,
compl.clone(),
- ),
+ )),
expr.span(),
);
let ty_field_type = Expr::new(
- ExprKind::Field(ty.clone(), "Type".into()),
+ ExprKind::Op(OpKind::Field(ty.clone(), "Type".into())),
expr.span(),
);
Cow::Owned(Expr::new(
@@ -304,7 +305,7 @@ fn traverse_resolve_expr(
.format(),
)?,
},
- ExprKind::BinOp(BinOp::ImportAlt, l, r) => {
+ ExprKind::Op(OpKind::BinOp(BinOp::ImportAlt, l, r)) => {
match traverse_resolve_expr(name_env, l, f) {
Ok(l) => l,
Err(_) => {
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index c3334b5..8f3fcb2 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -9,7 +9,8 @@ use crate::semantics::{
Type,
};
use crate::syntax::{
- BinOp, Builtin, Const, ExprKind, InterpolatedTextContents, NumKind, Span,
+ BinOp, Builtin, Const, ExprKind, InterpolatedTextContents, NumKind, OpKind,
+ Span,
};
fn check_rectymerge(
@@ -75,7 +76,7 @@ fn type_one_layer(
let span_err = |msg: &str| mk_span_err(span.clone(), msg);
let ty = match &ekind {
- ExprKind::Import(..) | ExprKind::Completion(..) => {
+ ExprKind::Import(..) | ExprKind::Op(OpKind::Completion(..)) => {
unreachable!("This case should have been handled in resolution")
}
ExprKind::Var(..)
@@ -222,7 +223,7 @@ fn type_one_layer(
Type::from_const(k)
}
- ExprKind::Field(scrut, x) => {
+ ExprKind::Op(OpKind::Field(scrut, x)) => {
match scrut.ty().kind() {
NirKind::RecordType(kts) => match kts.get(&x) {
Some(val) => Type::new_infer_universe(env, val.clone())?,
@@ -261,7 +262,7 @@ fn type_one_layer(
}
t
}
- ExprKind::App(f, arg) => {
+ ExprKind::Op(OpKind::App(f, arg)) => {
match f.ty().kind() {
// TODO: store Type in closure
NirKind::PiClosure { annot, closure, .. } => {
@@ -309,7 +310,7 @@ fn type_one_layer(
),
}
}
- ExprKind::BoolIf(x, y, z) => {
+ ExprKind::Op(OpKind::BoolIf(x, y, z)) => {
if *x.ty().kind() != NirKind::from_builtin(Builtin::Bool) {
return span_err("InvalidPredicate");
}
@@ -322,7 +323,7 @@ fn type_one_layer(
y.ty().clone()
}
- ExprKind::BinOp(BinOp::RightBiasedRecordMerge, x, y) => {
+ ExprKind::Op(OpKind::BinOp(BinOp::RightBiasedRecordMerge, x, y)) => {
let x_type = x.ty();
let y_type = y.ty();
@@ -344,22 +345,22 @@ fn type_one_layer(
let u = max(x.ty().ty(), y.ty().ty());
Nir::from_kind(NirKind::RecordType(kts)).to_type(u)
}
- ExprKind::BinOp(BinOp::RecursiveRecordMerge, x, y) => {
+ ExprKind::Op(OpKind::BinOp(BinOp::RecursiveRecordMerge, x, y)) => {
check_rectymerge(&span, env, x.ty().to_nir(), y.ty().to_nir())?;
let hir = Hir::new(
- HirKind::Expr(ExprKind::BinOp(
+ HirKind::Expr(ExprKind::Op(OpKind::BinOp(
BinOp::RecursiveRecordTypeMerge,
x.ty().to_hir(env.as_varenv()),
y.ty().to_hir(env.as_varenv()),
- )),
+ ))),
span.clone(),
);
let x_u = x.ty().ty();
let y_u = y.ty().ty();
Type::new(hir.eval(env), max(x_u, y_u))
}
- ExprKind::BinOp(BinOp::RecursiveRecordTypeMerge, x, y) => {
+ ExprKind::Op(OpKind::BinOp(BinOp::RecursiveRecordTypeMerge, x, y)) => {
check_rectymerge(&span, env, x.eval(env), y.eval(env))?;
// A RecordType's type is always a const
@@ -367,7 +368,7 @@ fn type_one_layer(
let yk = y.ty().as_const().unwrap();
Type::from_const(max(xk, yk))
}
- ExprKind::BinOp(BinOp::ListAppend, l, r) => {
+ ExprKind::Op(OpKind::BinOp(BinOp::ListAppend, l, r)) => {
match l.ty().kind() {
NirKind::ListType(..) => {}
_ => return span_err("BinOpTypeMismatch"),
@@ -379,7 +380,7 @@ fn type_one_layer(
l.ty().clone()
}
- ExprKind::BinOp(BinOp::Equivalence, l, r) => {
+ ExprKind::Op(OpKind::BinOp(BinOp::Equivalence, l, r)) => {
if l.ty() != r.ty() {
return span_err("EquivalenceTypeMismatch");
}
@@ -389,7 +390,7 @@ fn type_one_layer(
Type::from_const(Const::Type)
}
- ExprKind::BinOp(o, l, r) => {
+ ExprKind::Op(OpKind::BinOp(o, l, r)) => {
let t = Type::from_builtin(match o {
BinOp::BoolAnd
| BinOp::BoolOr
@@ -415,7 +416,7 @@ fn type_one_layer(
t
}
- ExprKind::Merge(record, union, type_annot) => {
+ ExprKind::Op(OpKind::Merge(record, union, type_annot)) => {
let record_type = record.ty();
let handlers = match record_type.kind() {
NirKind::RecordType(kts) => kts,
@@ -554,7 +555,7 @@ fn type_one_layer(
(None, None) => return span_err("MergeEmptyNeedsAnnotation"),
}
}
- ExprKind::ToMap(record, annot) => {
+ ExprKind::Op(OpKind::ToMap(record, annot)) => {
if record.ty().ty().as_const() != Some(Const::Type) {
return span_err("`toMap` only accepts records of type `Type`");
}
@@ -624,7 +625,7 @@ fn type_one_layer(
output_type
}
}
- ExprKind::Projection(record, labels) => {
+ ExprKind::Op(OpKind::Projection(record, labels)) => {
let record_type = record.ty();
let kts = match record_type.kind() {
NirKind::RecordType(kts) => kts,
@@ -652,7 +653,7 @@ fn type_one_layer(
Nir::from_kind(NirKind::RecordType(new_kts)),
)?
}
- ExprKind::ProjectionByExpr(record, selection) => {
+ ExprKind::Op(OpKind::ProjectionByExpr(record, selection)) => {
let record_type = record.ty();
let rec_kts = match record_type.kind() {
NirKind::RecordType(kts) => kts,