From cc03ada4e713f145f2eb1bbf0f131a4c5746cf74 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Sat, 3 Aug 2019 22:55:51 +0200 Subject: Inline headers --- dhall/src/phase/binary.rs | 29 ++++++++++++++--------------- dhall/src/phase/resolve.rs | 6 ++++++ dhall/src/phase/typecheck.rs | 1 + 3 files changed, 21 insertions(+), 15 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index 1812131..874b4fb 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -216,18 +216,19 @@ fn cbor_value_to_dhall( }; let headers = match rest.next() { Some(Null) => None, - Some(x) => { - match cbor_value_to_dhall(&x)?.as_ref() { - Embed(import) => Some(Box::new( - import.location_hashed.clone(), - )), - _ => Err(DecodeError::WrongFormatError( - "import/remote/headers".to_owned(), - ))?, - } - } + // TODO + // Some(x) => { + // match cbor_value_to_dhall(&x)?.as_ref() { + // Embed(import) => Some(Box::new( + // import.location_hashed.clone(), + // )), + // _ => Err(DecodeError::WrongFormatError( + // "import/remote/headers".to_owned(), + // ))?, + // } + // } _ => Err(DecodeError::WrongFormatError( - "import/remote/headers".to_owned(), + "import/remote/headers is unimplemented".to_owned(), ))?, }; let authority = match rest.next() { @@ -378,7 +379,6 @@ enum Serialize<'a> { CBOR(cbor::Value), RecordMap(&'a DupTreeMap), UnionMap(&'a DupTreeMap>), - Import(&'a Import), } macro_rules! count { @@ -566,10 +566,10 @@ where match &url.headers { None => ser_seq.serialize_element(&Null)?, Some(location_hashed) => ser_seq.serialize_element( - &self::Serialize::Import(&Import { + &self::Serialize::Expr(&SubExpr::from_expr_no_note(ExprF::Embed(Import { mode: ImportMode::Code, location_hashed: location_hashed.as_ref().clone(), - }), + }))), )?, }; ser_seq.serialize_element(&url.authority)?; @@ -617,7 +617,6 @@ impl<'a> serde::ser::Serialize for Serialize<'a> { (cbor::Value::String(k.into()), v) })) } - Serialize::Import(import) => serialize_import(ser, import), } } } diff --git a/dhall/src/phase/resolve.rs b/dhall/src/phase/resolve.rs index c4d7e5f..8c561a3 100644 --- a/dhall/src/phase/resolve.rs +++ b/dhall/src/phase/resolve.rs @@ -122,12 +122,18 @@ mod spec_tests { // import_success!(success_alternativeEnvNatural, "alternativeEnvNatural"); // import_success!(success_alternativeEnvSimple, "alternativeEnvSimple"); + // import_success!(success_alternativeHashMismatch, "alternativeHashMismatch"); // import_success!(success_alternativeNatural, "alternativeNatural"); + // import_success!(success_alternativeParseError, "alternativeParseError"); // import_success!(success_asText, "asText"); + // import_success!(success_customHeaders, "customHeaders"); import_success!(success_fieldOrder, "fieldOrder"); + // import_success!(success_headerForwarding, "headerForwarding"); + // import_success!(success_noHeaderForwarding, "noHeaderForwarding"); // import_failure!(failure_alternativeEnv, "alternativeEnv"); // import_failure!(failure_alternativeEnvMissing, "alternativeEnvMissing"); // import_failure!(failure_cycle, "cycle"); + // import_failure!(failure_hashMismatch, "hashMismatch"); // import_failure!(failure_missing, "missing"); // import_failure!(failure_referentiallyInsane, "referentiallyInsane"); } diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index a3f676c..efdc2bb 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -1167,6 +1167,7 @@ mod spec_tests { // tc_failure!(tc_failure_importBoundary, "importBoundary"); tc_failure!(tc_failure_mixedUnions, "mixedUnions"); tc_failure!(tc_failure_preferMixedRecords, "preferMixedRecords"); + // tc_failure!(tc_failure_customHeadersUsingBoundVariable, "customHeadersUsingBoundVariable"); tc_failure!(tc_failure_unit_FunctionApplicationArgumentNotMatch, "unit/FunctionApplicationArgumentNotMatch"); tc_failure!(tc_failure_unit_FunctionApplicationIsNotFunction, "unit/FunctionApplicationIsNotFunction"); tc_failure!(tc_failure_unit_FunctionArgumentTypeNotAType, "unit/FunctionArgumentTypeNotAType"); -- cgit v1.3.1 From 711164a7a24ab832006b72cac162e78cf434861a Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Sun, 4 Aug 2019 11:11:37 +0200 Subject: Remove old-style optional literals --- dhall-lang | 2 +- dhall/src/phase/binary.rs | 16 ++++++++------ dhall/src/phase/normalize.rs | 10 +++------ dhall/src/phase/typecheck.rs | 27 ++++-------------------- dhall_generated_parser/src/dhall.pest.visibility | 2 -- dhall_syntax/src/core/expr.rs | 4 ---- dhall_syntax/src/core/visitor.rs | 4 ---- dhall_syntax/src/parser.rs | 18 +++------------- dhall_syntax/src/printer.rs | 8 ------- tests_buffer | 3 +++ 10 files changed, 23 insertions(+), 71 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index b1f9815..b199229 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit b1f98152c404b661233db9a834d8e31ab2704479 +Subproject commit b1992297d702c67d2e1b1597af5c533af2934300 diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index 874b4fb..dcf60bb 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -115,18 +115,22 @@ fn cbor_value_to_dhall( .collect::, _>>()?; NEListLit(rest) } - [U64(5), t] => { - let t = cbor_value_to_dhall(&t)?; - OldOptionalLit(None, t) - } [U64(5), Null, x] => { let x = cbor_value_to_dhall(&x)?; SomeLit(x) } + // Old-style optional literals + [U64(5), t] => { + let t = cbor_value_to_dhall(&t)?; + App(rc(ExprF::Builtin(Builtin::OptionalNone)), t) + } [U64(5), t, x] => { let x = cbor_value_to_dhall(&x)?; let t = cbor_value_to_dhall(&t)?; - OldOptionalLit(Some(x), t) + Annot( + rc(SomeLit(x)), + rc(App(rc(ExprF::Builtin(Builtin::Optional)), t)), + ) } [U64(6), x, y] => { let x = cbor_value_to_dhall(&x)?; @@ -460,8 +464,6 @@ where ) } Annot(x, y) => ser_seq!(ser; tag(26), expr(x), expr(y)), - OldOptionalLit(None, t) => ser_seq!(ser; tag(5), expr(t)), - OldOptionalLit(Some(x), t) => ser_seq!(ser; tag(5), expr(t), expr(x)), SomeLit(x) => ser_seq!(ser; tag(5), null(), expr(x)), EmptyListLit(x) => ser_seq!(ser; tag(4), expr(x)), NEListLit(xs) => ser.collect_seq( diff --git a/dhall/src/phase/normalize.rs b/dhall/src/phase/normalize.rs index 35d32cb..f3684d1 100644 --- a/dhall/src/phase/normalize.rs +++ b/dhall/src/phase/normalize.rs @@ -611,9 +611,9 @@ fn apply_binop<'a>(o: BinOp, x: &'a Thunk, y: &'a Thunk) -> Option> { pub fn normalize_one_layer(expr: ExprF) -> Value { use Value::{ - BoolLit, DoubleLit, EmptyListLit, EmptyOptionalLit, IntegerLit, Lam, - NEListLit, NEOptionalLit, NaturalLit, Pi, RecordLit, RecordType, - TextLit, UnionConstructor, UnionLit, UnionType, + BoolLit, DoubleLit, EmptyListLit, IntegerLit, Lam, NEListLit, + NEOptionalLit, NaturalLit, Pi, RecordLit, RecordType, TextLit, + UnionConstructor, UnionLit, UnionType, }; let ret = match expr { @@ -639,10 +639,6 @@ pub fn normalize_one_layer(expr: ExprF) -> Value { ExprF::NaturalLit(n) => Ret::Value(NaturalLit(n)), ExprF::IntegerLit(n) => Ret::Value(IntegerLit(n)), ExprF::DoubleLit(n) => Ret::Value(DoubleLit(n)), - ExprF::OldOptionalLit(None, t) => { - Ret::Value(EmptyOptionalLit(TypeThunk::from_thunk(t))) - } - ExprF::OldOptionalLit(Some(e), _) => Ret::Value(NEOptionalLit(e)), ExprF::SomeLit(e) => Ret::Value(NEOptionalLit(e)), ExprF::EmptyListLit(t) => { Ret::Value(EmptyListLit(TypeThunk::from_thunk(t))) diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index efdc2bb..8551503 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -329,9 +329,7 @@ fn type_with( ctx: &TypecheckContext, e: SubExpr, ) -> Result { - use dhall_syntax::ExprF::{ - Annot, App, Embed, Lam, Let, OldOptionalLit, Pi, SomeLit, Var, - }; + use dhall_syntax::ExprF::{Annot, Embed, Lam, Let, Pi, Var}; use Ret::*; Ok(match e.as_ref() { @@ -364,18 +362,6 @@ fn type_with( let v = type_with(ctx, v)?; return type_with(&ctx.insert_value(x, v.clone())?, e.clone()); } - OldOptionalLit(None, t) => { - let none = SubExpr::from_builtin(Builtin::OptionalNone); - let e = e.rewrap(App(none, t.clone())); - return type_with(ctx, e); - } - OldOptionalLit(Some(x), t) => { - let optional = SubExpr::from_builtin(Builtin::Optional); - let x = x.rewrap(SomeLit(x.clone())); - let t = t.rewrap(App(optional, t.clone())); - let e = e.rewrap(Annot(x, t)); - return type_with(ctx, e); - } Embed(p) => p.clone().into_typed(), Var(var) => match ctx.lookup(&var) { Some(typed) => typed, @@ -423,12 +409,9 @@ fn type_last_layer( let mkerr = |msg: TypeMessage| TypeError::new(ctx, msg); match e { - Lam(_, _, _) - | Pi(_, _, _) - | Let(_, _, _, _) - | OldOptionalLit(_, _) - | Embed(_) - | Var(_) => unreachable!(), + Lam(_, _, _) | Pi(_, _, _) | Let(_, _, _, _) | Embed(_) | Var(_) => { + unreachable!() + } App(f, a) => { let tf = f.get_type()?; let (x, tx, tb) = match &tf.to_value() { @@ -1296,8 +1279,6 @@ mod spec_tests { ti_success!(ti_success_unit_NaturalShow, "unit/NaturalShow"); ti_success!(ti_success_unit_NaturalToInteger, "unit/NaturalToInteger"); ti_success!(ti_success_unit_None, "unit/None"); - ti_success!(ti_success_unit_OldOptionalNone, "unit/OldOptionalNone"); - ti_success!(ti_success_unit_OldOptionalTrue, "unit/OldOptionalTrue"); ti_success!(ti_success_unit_OperatorAnd, "unit/OperatorAnd"); ti_success!(ti_success_unit_OperatorAndNormalizeArguments, "unit/OperatorAndNormalizeArguments"); ti_success!(ti_success_unit_OperatorEqual, "unit/OperatorEqual"); diff --git a/dhall_generated_parser/src/dhall.pest.visibility b/dhall_generated_parser/src/dhall.pest.visibility index 60de54d..0c48656 100644 --- a/dhall_generated_parser/src/dhall.pest.visibility +++ b/dhall_generated_parser/src/dhall.pest.visibility @@ -134,8 +134,6 @@ import expression annotated_expression let_binding -empty_collection -non_empty_optional # operator_expression import_alt_expression or_expression diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs index da9465d..df2dc97 100644 --- a/dhall_syntax/src/core/expr.rs +++ b/dhall_syntax/src/core/expr.rs @@ -194,10 +194,6 @@ pub enum ExprF { EmptyListLit(SubExpr), /// `[x, y, z]` NEListLit(Vec), - /// Deprecated Optional literal form - /// `[] : Optional a` - /// `[x] : Optional a` - OldOptionalLit(Option, SubExpr), /// `Some e` SomeLit(SubExpr), /// `{ k1 : t1, k2 : t1 }` diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs index 99a9c11..1745fdb 100644 --- a/dhall_syntax/src/core/visitor.rs +++ b/dhall_syntax/src/core/visitor.rs @@ -137,10 +137,6 @@ where ), EmptyListLit(t) => EmptyListLit(v.visit_subexpr(t)?), NEListLit(es) => NEListLit(vec(es, |e| v.visit_subexpr(e))?), - OldOptionalLit(x, t) => OldOptionalLit( - opt(x, |e| v.visit_subexpr(e))?, - v.visit_subexpr(t)?, - ), SomeLit(e) => SomeLit(v.visit_subexpr(e)?), RecordType(kts) => RecordType(dupmap(kts, v)?), RecordLit(kvs) => RecordLit(dupmap(kvs, v)?), diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index 9d9a374..db1699b 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -724,6 +724,9 @@ make_parser! { [merge(()), expression(x), expression(y), expression(z)] => { spanned(span, Merge(x, y, Some(z))) }, + [List(()), expression(x)] => { + spanned(span, EmptyListLit(x)) + }, [expression(e)] => e, )); @@ -738,21 +741,6 @@ make_parser! { token_rule!(List<()>); token_rule!(Optional<()>); - rule!(empty_collection as expression; span; children!( - [List(_), expression(t)] => { - spanned(span, EmptyListLit(t)) - }, - [Optional(_), expression(t)] => { - spanned(span, OldOptionalLit(None, t)) - }, - )); - - rule!(non_empty_optional as expression; span; children!( - [expression(x), Optional(_), expression(t)] => { - spanned(span, OldOptionalLit(Some(x), t)) - } - )); - rule!(import_alt_expression as expression; children!( [expression(e)] => e, [expression(first), expression(rest)..] => { diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs index dbed55d..b585a5b 100644 --- a/dhall_syntax/src/printer.rs +++ b/dhall_syntax/src/printer.rs @@ -32,12 +32,6 @@ impl Display for ExprF { NEListLit(es) => { fmt_list("[", ", ", "]", es, f, Display::fmt)?; } - OldOptionalLit(None, t) => { - write!(f, "[] : Optional {}", t)?; - } - OldOptionalLit(Some(x), t) => { - write!(f, "[{}] : Optional {}", x, t)?; - } SomeLit(e) => { write!(f, "Some {}", e)?; } @@ -154,7 +148,6 @@ impl Expr { | Let(_, _, _, _) | EmptyListLit(_) | NEListLit(_) - | OldOptionalLit(_, _) | SomeLit(_) | Merge(_, _, _) | Annot(_, _) @@ -190,7 +183,6 @@ impl Expr { b.phase(PrintPhase::BinOp(op)), ), EmptyListLit(t) => EmptyListLit(t.phase(Import)), - OldOptionalLit(x, t) => OldOptionalLit(x, t.phase(Import)), SomeLit(e) => SomeLit(e.phase(Import)), ExprF::App(f, a) => ExprF::App(f.phase(Import), a.phase(Import)), Field(a, b) => Field(a.phase(Primitive), b), diff --git a/tests_buffer b/tests_buffer index 1ea9a1c..deb245d 100644 --- a/tests_buffer +++ b/tests_buffer @@ -86,6 +86,8 @@ success/ failure/ ProjectionByExpressionNeedsParens r.{ x: T } +binary decoding: +decode old-style optional literals ? import: success/ @@ -104,6 +106,7 @@ variables across import boundaries typecheck: something that involves destructuring a recordtype after merge +failure on old-style optional literal success/ MergeEmptyAlternative merge { x = 1 } < x >.x MergeTrickyShadowing let _ = Bool in merge {_ = \(x: _) -> x} (<_: Bool>._ True) -- cgit v1.3.1 From 5f872a7a5de12898fce32c057818ac2efb90e3fb Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Sun, 4 Aug 2019 11:15:18 +0200 Subject: Update dhall-lang submodule --- dhall-lang | 2 +- dhall/src/phase/resolve.rs | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index b199229..0396b67 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit b1992297d702c67d2e1b1597af5c533af2934300 +Subproject commit 0396b67639a6deaff480844e71b576db998717d3 diff --git a/dhall/src/phase/resolve.rs b/dhall/src/phase/resolve.rs index 8c561a3..f1329aa 100644 --- a/dhall/src/phase/resolve.rs +++ b/dhall/src/phase/resolve.rs @@ -128,6 +128,8 @@ mod spec_tests { // import_success!(success_asText, "asText"); // import_success!(success_customHeaders, "customHeaders"); import_success!(success_fieldOrder, "fieldOrder"); + // note: this one needs special setup with env variables + // import_success!(success_hashFromCache, "hashFromCache"); // import_success!(success_headerForwarding, "headerForwarding"); // import_success!(success_noHeaderForwarding, "noHeaderForwarding"); // import_failure!(failure_alternativeEnv, "alternativeEnv"); -- cgit v1.3.1 From 278cd9be7d93bc1eeecde05c964da5b097668016 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Sun, 4 Aug 2019 11:15:28 +0200 Subject: rustfmt --- dhall/src/phase/binary.rs | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index dcf60bb..443af7e 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -232,7 +232,8 @@ fn cbor_value_to_dhall( // } // } _ => Err(DecodeError::WrongFormatError( - "import/remote/headers is unimplemented".to_owned(), + "import/remote/headers is unimplemented" + .to_owned(), ))?, }; let authority = match rest.next() { @@ -567,12 +568,14 @@ where ImportLocation::Remote(url) => { match &url.headers { None => ser_seq.serialize_element(&Null)?, - Some(location_hashed) => ser_seq.serialize_element( - &self::Serialize::Expr(&SubExpr::from_expr_no_note(ExprF::Embed(Import { - mode: ImportMode::Code, - location_hashed: location_hashed.as_ref().clone(), - }))), - )?, + Some(location_hashed) => { + ser_seq.serialize_element(&self::Serialize::Expr( + &SubExpr::from_expr_no_note(ExprF::Embed(Import { + mode: ImportMode::Code, + location_hashed: location_hashed.as_ref().clone(), + })), + ))? + } }; ser_seq.serialize_element(&url.authority)?; for p in &url.path { -- cgit v1.3.1 From 696efe66336a268054c475fab9fe6505bdfc7b60 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Sun, 4 Aug 2019 13:00:56 +0200 Subject: Add some new tests and implement import alternatives --- dhall/src/error/mod.rs | 2 +- dhall/src/phase/resolve.rs | 4 ++-- dhall/src/phase/typecheck.rs | 2 +- dhall_syntax/src/core/expr.rs | 39 +++++++++++++++++++++++++++++++++++++++ dhall_syntax/src/core/visitor.rs | 25 +++++++++++++++++++++++++ 5 files changed, 68 insertions(+), 4 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs index aed6ccd..a0ee30a 100644 --- a/dhall/src/error/mod.rs +++ b/dhall/src/error/mod.rs @@ -86,7 +86,7 @@ pub(crate) enum TypeMessage { RecordTypeMergeRequiresRecordType(Type), RecordTypeMismatch(Type, Type, Type, Type), UnionTypeDuplicateField, - Unimplemented, + // Unimplemented, } impl TypeError { diff --git a/dhall/src/phase/resolve.rs b/dhall/src/phase/resolve.rs index f1329aa..0609694 100644 --- a/dhall/src/phase/resolve.rs +++ b/dhall/src/phase/resolve.rs @@ -86,7 +86,7 @@ fn do_resolve_expr( } } }; - let expr = expr.traverse_embed(resolve)?; + let expr = expr.traverse_resolve(resolve)?; Ok(Resolved(expr)) } @@ -100,7 +100,7 @@ pub fn skip_resolve_expr( let resolve = |import: &Import| -> Result { Err(ImportError::UnexpectedImport(import.clone())) }; - let expr = expr.traverse_embed(resolve)?; + let expr = expr.traverse_resolve(resolve)?; Ok(Resolved(expr)) } diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index 8551503..753d25e 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -823,7 +823,7 @@ fn type_last_layer( RightBiasedRecordMerge => unreachable!(), RecursiveRecordMerge => unreachable!(), RecursiveRecordTypeMerge => unreachable!(), - _ => return Err(mkerr(Unimplemented)), + ImportAlt => unreachable!("There should remain no import alternatives in a resolved expression"), })?; ensure_equal!( diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs index df2dc97..e33859b 100644 --- a/dhall_syntax/src/core/expr.rs +++ b/dhall_syntax/src/core/expr.rs @@ -307,6 +307,35 @@ impl Expr { { trivial_result(self.traverse_embed(|x| Ok(map_embed(x)))) } + + pub fn traverse_resolve( + &self, + visit_embed: impl FnMut(&E) -> Result, + ) -> Result, Err> + where + N: Clone, + { + self.traverse_resolve_with_visitor(&mut visitor::ResolveVisitor( + visit_embed, + )) + } + + pub(crate) fn traverse_resolve_with_visitor( + &self, + visitor: &mut visitor::ResolveVisitor, + ) -> Result, Err> + where + N: Clone, + F1: FnMut(&E) -> Result, + { + match self { + ExprF::BinOp(BinOp::ImportAlt, l, r) => l + .as_ref() + .traverse_resolve_with_visitor(visitor) + .or(r.as_ref().traverse_resolve_with_visitor(visitor)), + _ => self.visit(visitor), + } + } } impl Expr { @@ -383,6 +412,16 @@ impl SubExpr { )), } } + + pub fn traverse_resolve( + &self, + visit_embed: impl FnMut(&E) -> Result, + ) -> Result, Err> + where + N: Clone, + { + Ok(self.rewrap(self.as_ref().traverse_resolve(visit_embed)?)) + } } impl SubExpr { diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs index 1745fdb..b02544f 100644 --- a/dhall_syntax/src/core/visitor.rs +++ b/dhall_syntax/src/core/visitor.rs @@ -358,6 +358,31 @@ where } } +pub struct ResolveVisitor(pub F1); + +impl<'a, 'b, N, E, E2, Err, F1> + ExprFFallibleVisitor<'a, SubExpr, SubExpr, E, E2> + for &'b mut ResolveVisitor +where + N: Clone + 'a, + F1: FnMut(&E) -> Result, +{ + type Error = Err; + + fn visit_subexpr( + &mut self, + subexpr: &'a SubExpr, + ) -> Result, Self::Error> { + Ok(subexpr.rewrap( + subexpr + .as_ref() + .traverse_resolve_with_visitor(&mut **self)?, + )) + } + fn visit_embed(self, embed: &'a E) -> Result { + (self.0)(embed) + } +} pub struct NoteAbsurdVisitor; impl<'a, 'b, N, E> -- cgit v1.3.1 From 2551e6f91110bfe385fa65dd63e576df637c26fa Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Mon, 5 Aug 2019 18:18:45 +0200 Subject: Add some tests --- dhall-lang | 2 +- dhall/build.rs | 20 ++++++++++++++++++-- dhall/src/phase/normalize.rs | 10 ++++++++++ tests_buffer | 3 +++ 4 files changed, 32 insertions(+), 3 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index dbf4ebc..e01c734 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit dbf4ebcfabf499e87c27e75bec108d91929ccc31 +Subproject commit e01c734e612daac327b06845e45c34552d65d9e1 diff --git a/dhall/build.rs b/dhall/build.rs index 5a99def..7e320c5 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -90,6 +90,10 @@ fn main() -> std::io::Result<()> { // TODO: Inline headers are not implemented || path == "success/unit/import/parenthesizeUsing" || path == "success/unit/import/inlineUsing" + // TODO: projection by expression + || path == "success/recordProjectionByExpression" + || path == "success/unit/recordProjectionByExpression" + || path == "success/unit/recordProjectionByExpressionEmpty" }, )?; @@ -105,6 +109,10 @@ fn main() -> std::io::Result<()> { || path == "success/largeExpression" // TODO: Inline headers are not implemented || path == "success/unit/import/inlineUsing" + // TODO: projection by expression + || path == "success/recordProjectionByExpression" + || path == "success/unit/recordProjectionByExpression" + || path == "success/unit/recordProjectionByExpressionEmpty" }, )?; @@ -124,8 +132,11 @@ fn main() -> std::io::Result<()> { // See https://github.com/pyfisch/cbor/issues/109 || path == "success/double" // TODO: Inline headers are not implemented - || path == "success/unit/import/parenthesizeUsing" || path == "success/unit/import/inlineUsing" + // TODO: projection by expression + || path == "success/recordProjectionByExpression" + || path == "success/unit/recordProjectionByExpression" + || path == "success/unit/recordProjectionByExpressionEmpty" }, )?; @@ -139,9 +150,14 @@ fn main() -> std::io::Result<()> { path == "success/simple/integerToDouble" // Too slow || path == "success/remoteSystems" - // TODO: selection by expression + // TODO: projection by expression || path == "success/unit/RecordProjectionTypeEmpty" || path == "success/unit/RecordProjectionTypeNonEmpty" + || path == "success/unit/RecordProjectionTypeNormalizeProjection" + // TODO: fix Double/show + || path == "success/prelude/JSON/number/1" + // the test is wrong + || path == "success/prelude/JSON/Type/0" }, )?; diff --git a/dhall/src/phase/normalize.rs b/dhall/src/phase/normalize.rs index f3684d1..d5bdc9e 100644 --- a/dhall/src/phase/normalize.rs +++ b/dhall/src/phase/normalize.rs @@ -72,6 +72,16 @@ pub fn apply_builtin(b: Builtin, args: Vec) -> Value { (TextShow, [v, r..]) => match &*v.as_value() { TextLit(elts) => { match elts.as_slice() { + // Empty string literal. + [] => { + // Printing InterpolatedText takes care of all the escaping + let txt: InterpolatedText = std::iter::empty().collect(); + let s = txt.to_string(); + Ok(( + r, + TextLit(vec![InterpolatedTextContents::Text(s)]), + )) + } // If there are no interpolations (invariants ensure that when there are no // interpolations, there is a single Text item) in the literal. [InterpolatedTextContents::Text(s)] => { diff --git a/tests_buffer b/tests_buffer index deb245d..5234562 100644 --- a/tests_buffer +++ b/tests_buffer @@ -98,6 +98,8 @@ failure/ normalization: variables across import boundaries +Text/show "" +Double/show -1.5e-10 TextLitNested1 "${""}${x}" TextLitNested2 "${"${x}"}" TextLitNested3 "${"${""}"}${x}" @@ -106,6 +108,7 @@ variables across import boundaries typecheck: something that involves destructuring a recordtype after merge +add some of the more complicated Prelude tests back, like List/enumerate failure on old-style optional literal success/ MergeEmptyAlternative merge { x = 1 } < x >.x -- cgit v1.3.1 From 482be29e0f03e10c2469ef80bdd6ac7593207dc5 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 6 Aug 2019 20:38:06 +0200 Subject: RFC3986 URLs --- dhall-lang | 2 +- dhall/build.rs | 20 ++++++++++++++++++-- dhall/src/phase/binary.rs | 8 +++++++- dhall_generated_parser/build.rs | 6 ++++++ dhall_generated_parser/src/dhall.pest.visibility | 1 + dhall_syntax/src/core/import.rs | 1 + dhall_syntax/src/parser.rs | 7 +++++++ dhall_syntax/src/printer.rs | 1 + tests_buffer | 1 + 9 files changed, 43 insertions(+), 4 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index e01c734..2c0f238 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit e01c734e612daac327b06845e45c34552d65d9e1 +Subproject commit 2c0f2389e11597131b8ce021344322e5ed3a9131 diff --git a/dhall/build.rs b/dhall/build.rs index 7e320c5..cdbd560 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -94,6 +94,12 @@ fn main() -> std::io::Result<()> { || path == "success/recordProjectionByExpression" || path == "success/unit/recordProjectionByExpression" || path == "success/unit/recordProjectionByExpressionEmpty" + // TODO: RFC3986 URLs + || path == "success/unit/import/urls/emptyPath0" + || path == "success/unit/import/urls/emptyPath1" + || path == "success/unit/import/urls/emptyPathSegment" + // Test is broken + || path == "success/unit/import/asLocation" }, )?; @@ -113,6 +119,12 @@ fn main() -> std::io::Result<()> { || path == "success/recordProjectionByExpression" || path == "success/unit/recordProjectionByExpression" || path == "success/unit/recordProjectionByExpressionEmpty" + // TODO: RFC3986 URLs + || path == "success/unit/import/urls/emptyPath0" + || path == "success/unit/import/urls/emptyPath1" + || path == "success/unit/import/urls/emptyPathSegment" + // Test is broken + || path == "success/unit/import/asLocation" }, )?; @@ -137,6 +149,12 @@ fn main() -> std::io::Result<()> { || path == "success/recordProjectionByExpression" || path == "success/unit/recordProjectionByExpression" || path == "success/unit/recordProjectionByExpressionEmpty" + // TODO: RFC3986 URLs + || path == "success/unit/import/urls/emptyPath0" + || path == "success/unit/import/urls/emptyPath1" + || path == "success/unit/import/urls/emptyPathSegment" + // Test is broken + || path == "success/unit/import/asLocation" }, )?; @@ -156,8 +174,6 @@ fn main() -> std::io::Result<()> { || path == "success/unit/RecordProjectionTypeNormalizeProjection" // TODO: fix Double/show || path == "success/prelude/JSON/number/1" - // the test is wrong - || path == "success/prelude/JSON/Type/0" }, )?; diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index 443af7e..bab3fd8 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -195,8 +195,13 @@ fn cbor_value_to_dhall( } [U64(24), hash, U64(mode), U64(scheme), rest..] => { let mode = match mode { + 0 => ImportMode::Code, 1 => ImportMode::RawText, - _ => ImportMode::Code, + 2 => ImportMode::Location, + _ => Err(DecodeError::WrongFormatError(format!( + "import/mode/unknown_mode: {:?}", + mode + )))?, }; let hash = match hash { Null => None, @@ -545,6 +550,7 @@ where let mode = match import.mode { ImportMode::Code => 0, ImportMode::RawText => 1, + ImportMode::Location => 2, }; ser_seq.serialize_element(&U64(mode))?; diff --git a/dhall_generated_parser/build.rs b/dhall_generated_parser/build.rs index 744cb3d..2c1a8f5 100644 --- a/dhall_generated_parser/build.rs +++ b/dhall_generated_parser/build.rs @@ -27,6 +27,7 @@ fn main() -> std::io::Result<()> { } } rules.remove("http"); + rules.remove("url_path"); rules.remove("simple_label"); rules.remove("nonreserved_label"); @@ -53,6 +54,11 @@ fn main() -> std::io::Result<()> { ~ (import_hashed | ^\"(\" ~ whsp ~ import_hashed ~ whsp ~ ^\")\"))? }}" )?; + // TODO: this is a cheat; properly support RFC3986 URLs instead + writeln!( + &mut file, + "url_path = _{{ path }}" + )?; writeln!( &mut file, "nonreserved_label = _{{ diff --git a/dhall_generated_parser/src/dhall.pest.visibility b/dhall_generated_parser/src/dhall.pest.visibility index 2b7c477..97d3a69 100644 --- a/dhall_generated_parser/src/dhall.pest.visibility +++ b/dhall_generated_parser/src/dhall.pest.visibility @@ -48,6 +48,7 @@ builtin Optional Text List +Location # Bool # True # False diff --git a/dhall_syntax/src/core/import.rs b/dhall_syntax/src/core/import.rs index 306460b..d41eae2 100644 --- a/dhall_syntax/src/core/import.rs +++ b/dhall_syntax/src/core/import.rs @@ -41,6 +41,7 @@ pub enum Scheme { pub enum ImportMode { Code, RawText, + Location, } #[derive(Debug, Clone, PartialEq, Eq, Hash)] diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index 2450c76..2c0cee9 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -697,6 +697,7 @@ make_parser! { )); token_rule!(Text<()>); + token_rule!(Location<()>); rule!(import as expression; span; children!( [import_hashed(location_hashed)] => { @@ -711,6 +712,12 @@ make_parser! { location_hashed })) }, + [import_hashed(location_hashed), Location(_)] => { + spanned(span, Embed(Import { + mode: ImportMode::Location, + location_hashed + })) + }, )); token_rule!(lambda<()>); diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs index b585a5b..2b2bbcc 100644 --- a/dhall_syntax/src/printer.rs +++ b/dhall_syntax/src/printer.rs @@ -435,6 +435,7 @@ impl Display for Import { match self.mode { Code => {} RawText => write!(f, " as Text")?, + Location => write!(f, " as Location")?, } Ok(()) } diff --git a/tests_buffer b/tests_buffer index 5234562..ca578e4 100644 --- a/tests_buffer +++ b/tests_buffer @@ -6,6 +6,7 @@ remove `double` remove imports/parenthesizeUsing remove multilet selection by expression unit tests +split aslocation test into actual unit tests success/ imports/ Missing missing -- cgit v1.3.1 From 054121b427b5344b41a0fb230b69d81ea0b5cd0a Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 6 Aug 2019 20:52:25 +0200 Subject: Change some tests --- dhall-lang | 2 +- dhall/build.rs | 28 +++++++++++++--------------- dhall/src/phase/typecheck.rs | 5 +++++ 3 files changed, 19 insertions(+), 16 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index 2c0f238..65aa743 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit 2c0f2389e11597131b8ce021344322e5ed3a9131 +Subproject commit 65aa7435040141dd30d5983695b7ebdb4224b280 diff --git a/dhall/build.rs b/dhall/build.rs index cdbd560..db66e3c 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -92,14 +92,14 @@ fn main() -> std::io::Result<()> { || path == "success/unit/import/inlineUsing" // TODO: projection by expression || path == "success/recordProjectionByExpression" - || path == "success/unit/recordProjectionByExpression" - || path == "success/unit/recordProjectionByExpressionEmpty" + || path == "success/RecordProjectionByType" + || path == "success/unit/RecordProjectionByType" + || path == "success/unit/RecordProjectionByTypeEmpty" + || path == "success/unit/RecordProjectFields" // TODO: RFC3986 URLs || path == "success/unit/import/urls/emptyPath0" || path == "success/unit/import/urls/emptyPath1" || path == "success/unit/import/urls/emptyPathSegment" - // Test is broken - || path == "success/unit/import/asLocation" }, )?; @@ -117,14 +117,13 @@ fn main() -> std::io::Result<()> { || path == "success/unit/import/inlineUsing" // TODO: projection by expression || path == "success/recordProjectionByExpression" - || path == "success/unit/recordProjectionByExpression" - || path == "success/unit/recordProjectionByExpressionEmpty" + || path == "success/RecordProjectionByType" + || path == "success/unit/RecordProjectionByType" + || path == "success/unit/RecordProjectionByTypeEmpty" // TODO: RFC3986 URLs || path == "success/unit/import/urls/emptyPath0" || path == "success/unit/import/urls/emptyPath1" || path == "success/unit/import/urls/emptyPathSegment" - // Test is broken - || path == "success/unit/import/asLocation" }, )?; @@ -147,14 +146,13 @@ fn main() -> std::io::Result<()> { || path == "success/unit/import/inlineUsing" // TODO: projection by expression || path == "success/recordProjectionByExpression" - || path == "success/unit/recordProjectionByExpression" - || path == "success/unit/recordProjectionByExpressionEmpty" + || path == "success/RecordProjectionByType" + || path == "success/unit/RecordProjectionByType" + || path == "success/unit/RecordProjectionByTypeEmpty" // TODO: RFC3986 URLs || path == "success/unit/import/urls/emptyPath0" || path == "success/unit/import/urls/emptyPath1" || path == "success/unit/import/urls/emptyPathSegment" - // Test is broken - || path == "success/unit/import/asLocation" }, )?; @@ -169,9 +167,9 @@ fn main() -> std::io::Result<()> { // Too slow || path == "success/remoteSystems" // TODO: projection by expression - || path == "success/unit/RecordProjectionTypeEmpty" - || path == "success/unit/RecordProjectionTypeNonEmpty" - || path == "success/unit/RecordProjectionTypeNormalizeProjection" + || path == "success/unit/RecordProjectionByTypeEmpty" + || path == "success/unit/RecordProjectionByTypeNonEmpty" + || path == "success/unit/RecordProjectionByTypeNormalizeProjection" // TODO: fix Double/show || path == "success/prelude/JSON/number/1" }, diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index 753d25e..bd09b35 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -1195,6 +1195,8 @@ mod spec_tests { tc_failure!(tc_failure_unit_RecordProjectionEmpty, "unit/RecordProjectionEmpty"); tc_failure!(tc_failure_unit_RecordProjectionNotPresent, "unit/RecordProjectionNotPresent"); tc_failure!(tc_failure_unit_RecordProjectionNotRecord, "unit/RecordProjectionNotRecord"); + // tc_failure!(tc_failure_unit_RecordProjectionByTypeFieldTypeMismatch, "unit/RecordProjectionByTypeFieldTypeMismatch"); + // tc_failure!(tc_failure_unit_RecordProjectionByTypeNotPresent, "unit/RecordProjectionByTypeNotPresent"); tc_failure!(tc_failure_unit_RecordSelectionEmpty, "unit/RecordSelectionEmpty"); tc_failure!(tc_failure_unit_RecordSelectionNotPresent, "unit/RecordSelectionNotPresent"); tc_failure!(tc_failure_unit_RecordSelectionNotRecord, "unit/RecordSelectionNotRecord"); @@ -1220,6 +1222,7 @@ mod spec_tests { tc_failure!(tc_failure_unit_TextLiteralInterpolateNotText, "unit/TextLiteralInterpolateNotText"); tc_failure!(tc_failure_unit_TypeAnnotationWrong, "unit/TypeAnnotationWrong"); tc_failure!(tc_failure_unit_UnionConstructorFieldNotPresent, "unit/UnionConstructorFieldNotPresent"); + tc_failure!(tc_failure_unit_UnionDeprecatedConstructorsKeyword, "unit/UnionDeprecatedConstructorsKeyword"); tc_failure!(tc_failure_unit_UnionTypeMixedKinds, "unit/UnionTypeMixedKinds"); tc_failure!(tc_failure_unit_UnionTypeMixedKinds2, "unit/UnionTypeMixedKinds2"); tc_failure!(tc_failure_unit_UnionTypeMixedKinds3, "unit/UnionTypeMixedKinds3"); @@ -1310,6 +1313,8 @@ mod spec_tests { ti_success!(ti_success_unit_RecordProjectionKind, "unit/RecordProjectionKind"); ti_success!(ti_success_unit_RecordProjectionType, "unit/RecordProjectionType"); ti_success!(ti_success_unit_RecordProjectionValue, "unit/RecordProjectionValue"); + // ti_success!(ti_success_unit_RecordProjectionByTypeEmpty, "unit/RecordProjectionByTypeEmpty"); + // ti_success!(ti_success_unit_RecordProjectionByTypeJudgmentalEquality, "unit/RecordProjectionByTypeJudgmentalEquality"); ti_success!(ti_success_unit_RecordSelectionKind, "unit/RecordSelectionKind"); ti_success!(ti_success_unit_RecordSelectionType, "unit/RecordSelectionType"); ti_success!(ti_success_unit_RecordSelectionValue, "unit/RecordSelectionValue"); -- cgit v1.3.1 From f20970a24db223f171eac2a3752f840dbf45d72b Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 6 Aug 2019 21:15:20 +0200 Subject: Auto-generate typechecking tests list --- dhall/build.rs | 36 +++- dhall/src/phase/typecheck.rs | 395 ------------------------------------------- 2 files changed, 33 insertions(+), 398 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall/build.rs b/dhall/build.rs index 2fa63c6..c78f8f9 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -87,7 +87,7 @@ fn main() -> std::io::Result<()> { |path| { // Too slow in debug mode path == "success/largeExpression" - // TODO: Inline headers are not implemented + // TODO: Inline headers || path == "success/unit/import/parenthesizeUsing" || path == "success/unit/import/inlineUsing" // TODO: projection by expression @@ -114,7 +114,7 @@ fn main() -> std::io::Result<()> { path.starts_with("failure/") // Too slow in debug mode || path == "success/largeExpression" - // TODO: Inline headers are not implemented + // TODO: Inline headers || path == "success/unit/import/inlineUsing" // TODO: projection by expression || path == "success/recordProjectionByExpression" @@ -143,7 +143,7 @@ fn main() -> std::io::Result<()> { || path == "success/multilet" // See https://github.com/pyfisch/cbor/issues/109 || path == "success/double" - // TODO: Inline headers are not implemented + // TODO: Inline headers || path == "success/unit/import/inlineUsing" // TODO: projection by expression || path == "success/recordProjectionByExpression" @@ -184,5 +184,35 @@ fn main() -> std::io::Result<()> { |_| false, )?; + make_test_module( + &mut file, + "typecheck", + &tests_dir.join("typecheck/"), + "Typecheck", + |path| { + false + || path == "failure/importBoundary" + // TODO: Inline headers + || path == "failure/customHeadersUsingBoundVariable" + // TODO: projection by expression + || path == "failure/unit/RecordProjectionByTypeFieldTypeMismatch" + || path == "failure/unit/RecordProjectionByTypeNotPresent" + }, + )?; + + make_test_module( + &mut file, + "type_inference", + &tests_dir.join("type-inference/"), + "TypeInference", + |path| { + false + // TODO: projection by expression + || path == "success/unit/RecordProjectionByType" + || path == "success/unit/RecordProjectionByTypeEmpty" + || path == "success/unit/RecordProjectionByTypeJudgmentalEquality" + }, + )?; + Ok(()) } diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index bd09b35..fc6c1da 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -968,398 +968,3 @@ pub fn typecheck_with(e: Resolved, ty: &Type) -> Result { pub fn skip_typecheck(e: Resolved) -> Typed { Typed::from_thunk_untyped(Thunk::new(NormalizationContext::new(), e.0)) } - -#[cfg(test)] -mod spec_tests { - #![rustfmt::skip] - - macro_rules! tc_success { - ($name:ident, $path:expr) => { - make_spec_test!(Typecheck, Success, $name, &("success/".to_owned() + $path)); - }; - } - macro_rules! tc_failure { - ($name:ident, $path:expr) => { - make_spec_test!(Typecheck, Failure, $name, &("failure/".to_owned() + $path)); - }; - } - - macro_rules! ti_success { - ($name:ident, $path:expr) => { - make_spec_test!(TypeInference, Success, $name, &("success/".to_owned() + $path)); - }; - } - // macro_rules! ti_failure { - // ($name:ident, $path:expr) => { - // make_spec_test!(TypeInference, Failure, $name, &("failure/".to_owned() + $path)); - // }; - // } - - // tc_success!(tc_success_accessEncodedType, "accessEncodedType"); - // tc_success!(tc_success_accessType, "accessType"); - tc_success!(tc_success_prelude_Bool_and_0, "prelude/Bool/and/0"); - tc_success!(tc_success_prelude_Bool_and_1, "prelude/Bool/and/1"); - tc_success!(tc_success_prelude_Bool_build_0, "prelude/Bool/build/0"); - tc_success!(tc_success_prelude_Bool_build_1, "prelude/Bool/build/1"); - tc_success!(tc_success_prelude_Bool_even_0, "prelude/Bool/even/0"); - tc_success!(tc_success_prelude_Bool_even_1, "prelude/Bool/even/1"); - tc_success!(tc_success_prelude_Bool_even_2, "prelude/Bool/even/2"); - tc_success!(tc_success_prelude_Bool_even_3, "prelude/Bool/even/3"); - tc_success!(tc_success_prelude_Bool_fold_0, "prelude/Bool/fold/0"); - tc_success!(tc_success_prelude_Bool_fold_1, "prelude/Bool/fold/1"); - tc_success!(tc_success_prelude_Bool_not_0, "prelude/Bool/not/0"); - tc_success!(tc_success_prelude_Bool_not_1, "prelude/Bool/not/1"); - tc_success!(tc_success_prelude_Bool_odd_0, "prelude/Bool/odd/0"); - tc_success!(tc_success_prelude_Bool_odd_1, "prelude/Bool/odd/1"); - tc_success!(tc_success_prelude_Bool_odd_2, "prelude/Bool/odd/2"); - tc_success!(tc_success_prelude_Bool_odd_3, "prelude/Bool/odd/3"); - tc_success!(tc_success_prelude_Bool_or_0, "prelude/Bool/or/0"); - tc_success!(tc_success_prelude_Bool_or_1, "prelude/Bool/or/1"); - tc_success!(tc_success_prelude_Bool_show_0, "prelude/Bool/show/0"); - tc_success!(tc_success_prelude_Bool_show_1, "prelude/Bool/show/1"); - tc_success!(tc_success_prelude_Double_show_0, "prelude/Double/show/0"); - tc_success!(tc_success_prelude_Double_show_1, "prelude/Double/show/1"); - tc_success!(tc_success_prelude_Integer_show_0, "prelude/Integer/show/0"); - tc_success!(tc_success_prelude_Integer_show_1, "prelude/Integer/show/1"); - tc_success!(tc_success_prelude_Integer_toDouble_0, "prelude/Integer/toDouble/0"); - tc_success!(tc_success_prelude_Integer_toDouble_1, "prelude/Integer/toDouble/1"); - tc_success!(tc_success_prelude_List_all_0, "prelude/List/all/0"); - tc_success!(tc_success_prelude_List_all_1, "prelude/List/all/1"); - tc_success!(tc_success_prelude_List_any_0, "prelude/List/any/0"); - tc_success!(tc_success_prelude_List_any_1, "prelude/List/any/1"); - tc_success!(tc_success_prelude_List_build_0, "prelude/List/build/0"); - tc_success!(tc_success_prelude_List_build_1, "prelude/List/build/1"); - tc_success!(tc_success_prelude_List_concat_0, "prelude/List/concat/0"); - tc_success!(tc_success_prelude_List_concat_1, "prelude/List/concat/1"); - tc_success!(tc_success_prelude_List_concatMap_0, "prelude/List/concatMap/0"); - tc_success!(tc_success_prelude_List_concatMap_1, "prelude/List/concatMap/1"); - tc_success!(tc_success_prelude_List_filter_0, "prelude/List/filter/0"); - tc_success!(tc_success_prelude_List_filter_1, "prelude/List/filter/1"); - tc_success!(tc_success_prelude_List_fold_0, "prelude/List/fold/0"); - tc_success!(tc_success_prelude_List_fold_1, "prelude/List/fold/1"); - tc_success!(tc_success_prelude_List_fold_2, "prelude/List/fold/2"); - tc_success!(tc_success_prelude_List_generate_0, "prelude/List/generate/0"); - tc_success!(tc_success_prelude_List_generate_1, "prelude/List/generate/1"); - tc_success!(tc_success_prelude_List_head_0, "prelude/List/head/0"); - tc_success!(tc_success_prelude_List_head_1, "prelude/List/head/1"); - tc_success!(tc_success_prelude_List_indexed_0, "prelude/List/indexed/0"); - tc_success!(tc_success_prelude_List_indexed_1, "prelude/List/indexed/1"); - tc_success!(tc_success_prelude_List_iterate_0, "prelude/List/iterate/0"); - tc_success!(tc_success_prelude_List_iterate_1, "prelude/List/iterate/1"); - tc_success!(tc_success_prelude_List_last_0, "prelude/List/last/0"); - tc_success!(tc_success_prelude_List_last_1, "prelude/List/last/1"); - tc_success!(tc_success_prelude_List_length_0, "prelude/List/length/0"); - tc_success!(tc_success_prelude_List_length_1, "prelude/List/length/1"); - tc_success!(tc_success_prelude_List_map_0, "prelude/List/map/0"); - tc_success!(tc_success_prelude_List_map_1, "prelude/List/map/1"); - tc_success!(tc_success_prelude_List_null_0, "prelude/List/null/0"); - tc_success!(tc_success_prelude_List_null_1, "prelude/List/null/1"); - tc_success!(tc_success_prelude_List_replicate_0, "prelude/List/replicate/0"); - tc_success!(tc_success_prelude_List_replicate_1, "prelude/List/replicate/1"); - tc_success!(tc_success_prelude_List_reverse_0, "prelude/List/reverse/0"); - tc_success!(tc_success_prelude_List_reverse_1, "prelude/List/reverse/1"); - tc_success!(tc_success_prelude_List_shifted_0, "prelude/List/shifted/0"); - tc_success!(tc_success_prelude_List_shifted_1, "prelude/List/shifted/1"); - tc_success!(tc_success_prelude_List_unzip_0, "prelude/List/unzip/0"); - tc_success!(tc_success_prelude_List_unzip_1, "prelude/List/unzip/1"); - tc_success!(tc_success_prelude_Monoid_00, "prelude/Monoid/00"); - tc_success!(tc_success_prelude_Monoid_01, "prelude/Monoid/01"); - tc_success!(tc_success_prelude_Monoid_02, "prelude/Monoid/02"); - tc_success!(tc_success_prelude_Monoid_03, "prelude/Monoid/03"); - tc_success!(tc_success_prelude_Monoid_04, "prelude/Monoid/04"); - tc_success!(tc_success_prelude_Monoid_05, "prelude/Monoid/05"); - tc_success!(tc_success_prelude_Monoid_06, "prelude/Monoid/06"); - tc_success!(tc_success_prelude_Monoid_07, "prelude/Monoid/07"); - tc_success!(tc_success_prelude_Monoid_08, "prelude/Monoid/08"); - tc_success!(tc_success_prelude_Monoid_09, "prelude/Monoid/09"); - tc_success!(tc_success_prelude_Monoid_10, "prelude/Monoid/10"); - tc_success!(tc_success_prelude_Natural_build_0, "prelude/Natural/build/0"); - tc_success!(tc_success_prelude_Natural_build_1, "prelude/Natural/build/1"); - tc_success!(tc_success_prelude_Natural_enumerate_0, "prelude/Natural/enumerate/0"); - tc_success!(tc_success_prelude_Natural_enumerate_1, "prelude/Natural/enumerate/1"); - tc_success!(tc_success_prelude_Natural_even_0, "prelude/Natural/even/0"); - tc_success!(tc_success_prelude_Natural_even_1, "prelude/Natural/even/1"); - tc_success!(tc_success_prelude_Natural_fold_0, "prelude/Natural/fold/0"); - tc_success!(tc_success_prelude_Natural_fold_1, "prelude/Natural/fold/1"); - tc_success!(tc_success_prelude_Natural_fold_2, "prelude/Natural/fold/2"); - tc_success!(tc_success_prelude_Natural_isZero_0, "prelude/Natural/isZero/0"); - tc_success!(tc_success_prelude_Natural_isZero_1, "prelude/Natural/isZero/1"); - tc_success!(tc_success_prelude_Natural_odd_0, "prelude/Natural/odd/0"); - tc_success!(tc_success_prelude_Natural_odd_1, "prelude/Natural/odd/1"); - tc_success!(tc_success_prelude_Natural_product_0, "prelude/Natural/product/0"); - tc_success!(tc_success_prelude_Natural_product_1, "prelude/Natural/product/1"); - tc_success!(tc_success_prelude_Natural_show_0, "prelude/Natural/show/0"); - tc_success!(tc_success_prelude_Natural_show_1, "prelude/Natural/show/1"); - tc_success!(tc_success_prelude_Natural_sum_0, "prelude/Natural/sum/0"); - tc_success!(tc_success_prelude_Natural_sum_1, "prelude/Natural/sum/1"); - tc_success!(tc_success_prelude_Natural_toDouble_0, "prelude/Natural/toDouble/0"); - tc_success!(tc_success_prelude_Natural_toDouble_1, "prelude/Natural/toDouble/1"); - tc_success!(tc_success_prelude_Natural_toInteger_0, "prelude/Natural/toInteger/0"); - tc_success!(tc_success_prelude_Natural_toInteger_1, "prelude/Natural/toInteger/1"); - tc_success!(tc_success_prelude_Optional_all_0, "prelude/Optional/all/0"); - tc_success!(tc_success_prelude_Optional_all_1, "prelude/Optional/all/1"); - tc_success!(tc_success_prelude_Optional_any_0, "prelude/Optional/any/0"); - tc_success!(tc_success_prelude_Optional_any_1, "prelude/Optional/any/1"); - tc_success!(tc_success_prelude_Optional_build_0, "prelude/Optional/build/0"); - tc_success!(tc_success_prelude_Optional_build_1, "prelude/Optional/build/1"); - tc_success!(tc_success_prelude_Optional_concat_0, "prelude/Optional/concat/0"); - tc_success!(tc_success_prelude_Optional_concat_1, "prelude/Optional/concat/1"); - tc_success!(tc_success_prelude_Optional_concat_2, "prelude/Optional/concat/2"); - tc_success!(tc_success_prelude_Optional_filter_0, "prelude/Optional/filter/0"); - tc_success!(tc_success_prelude_Optional_filter_1, "prelude/Optional/filter/1"); - tc_success!(tc_success_prelude_Optional_fold_0, "prelude/Optional/fold/0"); - tc_success!(tc_success_prelude_Optional_fold_1, "prelude/Optional/fold/1"); - tc_success!(tc_success_prelude_Optional_head_0, "prelude/Optional/head/0"); - tc_success!(tc_success_prelude_Optional_head_1, "prelude/Optional/head/1"); - tc_success!(tc_success_prelude_Optional_head_2, "prelude/Optional/head/2"); - tc_success!(tc_success_prelude_Optional_last_0, "prelude/Optional/last/0"); - tc_success!(tc_success_prelude_Optional_last_1, "prelude/Optional/last/1"); - tc_success!(tc_success_prelude_Optional_last_2, "prelude/Optional/last/2"); - tc_success!(tc_success_prelude_Optional_length_0, "prelude/Optional/length/0"); - tc_success!(tc_success_prelude_Optional_length_1, "prelude/Optional/length/1"); - tc_success!(tc_success_prelude_Optional_map_0, "prelude/Optional/map/0"); - tc_success!(tc_success_prelude_Optional_map_1, "prelude/Optional/map/1"); - tc_success!(tc_success_prelude_Optional_null_0, "prelude/Optional/null/0"); - tc_success!(tc_success_prelude_Optional_null_1, "prelude/Optional/null/1"); - tc_success!(tc_success_prelude_Optional_toList_0, "prelude/Optional/toList/0"); - tc_success!(tc_success_prelude_Optional_toList_1, "prelude/Optional/toList/1"); - tc_success!(tc_success_prelude_Optional_unzip_0, "prelude/Optional/unzip/0"); - tc_success!(tc_success_prelude_Optional_unzip_1, "prelude/Optional/unzip/1"); - tc_success!(tc_success_prelude_Text_concat_0, "prelude/Text/concat/0"); - tc_success!(tc_success_prelude_Text_concat_1, "prelude/Text/concat/1"); - tc_success!(tc_success_prelude_Text_concatMap_0, "prelude/Text/concatMap/0"); - tc_success!(tc_success_prelude_Text_concatMap_1, "prelude/Text/concatMap/1"); - // tc_success!(tc_success_prelude_Text_concatMapSep_0, "prelude/Text/concatMapSep/0"); - // tc_success!(tc_success_prelude_Text_concatMapSep_1, "prelude/Text/concatMapSep/1"); - // tc_success!(tc_success_prelude_Text_concatSep_0, "prelude/Text/concatSep/0"); - // tc_success!(tc_success_prelude_Text_concatSep_1, "prelude/Text/concatSep/1"); - tc_success!(tc_success_recordOfRecordOfTypes, "recordOfRecordOfTypes"); - tc_success!(tc_success_recordOfTypes, "recordOfTypes"); - // tc_success!(tc_success_simple_access_0, "simple/access/0"); - // tc_success!(tc_success_simple_access_1, "simple/access/1"); - // tc_success!(tc_success_simple_anonymousFunctionsInTypes, "simple/anonymousFunctionsInTypes"); - // tc_success!(tc_success_simple_fieldsAreTypes, "simple/fieldsAreTypes"); - // tc_success!(tc_success_simple_kindParameter, "simple/kindParameter"); - tc_success!(tc_success_simple_mergeEquivalence, "simple/mergeEquivalence"); - // tc_success!(tc_success_simple_mixedFieldAccess, "simple/mixedFieldAccess"); - tc_success!(tc_success_simple_unionsOfTypes, "simple/unionsOfTypes"); - - tc_failure!(tc_failure_combineMixedRecords, "combineMixedRecords"); - tc_failure!(tc_failure_duplicateFields, "duplicateFields"); - tc_failure!(tc_failure_hurkensParadox, "hurkensParadox"); - // tc_failure!(tc_failure_importBoundary, "importBoundary"); - tc_failure!(tc_failure_mixedUnions, "mixedUnions"); - tc_failure!(tc_failure_preferMixedRecords, "preferMixedRecords"); - // tc_failure!(tc_failure_customHeadersUsingBoundVariable, "customHeadersUsingBoundVariable"); - tc_failure!(tc_failure_unit_FunctionApplicationArgumentNotMatch, "unit/FunctionApplicationArgumentNotMatch"); - tc_failure!(tc_failure_unit_FunctionApplicationIsNotFunction, "unit/FunctionApplicationIsNotFunction"); - tc_failure!(tc_failure_unit_FunctionArgumentTypeNotAType, "unit/FunctionArgumentTypeNotAType"); - tc_failure!(tc_failure_unit_FunctionDependentType, "unit/FunctionDependentType"); - tc_failure!(tc_failure_unit_FunctionDependentType2, "unit/FunctionDependentType2"); - tc_failure!(tc_failure_unit_FunctionTypeArgumentTypeNotAType, "unit/FunctionTypeArgumentTypeNotAType"); - tc_failure!(tc_failure_unit_FunctionTypeKindSort, "unit/FunctionTypeKindSort"); - tc_failure!(tc_failure_unit_FunctionTypeTypeKind, "unit/FunctionTypeTypeKind"); - tc_failure!(tc_failure_unit_FunctionTypeTypeSort, "unit/FunctionTypeTypeSort"); - tc_failure!(tc_failure_unit_IfBranchesNotMatch, "unit/IfBranchesNotMatch"); - tc_failure!(tc_failure_unit_IfBranchesNotType, "unit/IfBranchesNotType"); - tc_failure!(tc_failure_unit_IfNotBool, "unit/IfNotBool"); - tc_failure!(tc_failure_unit_LetWithWrongAnnotation, "unit/LetWithWrongAnnotation"); - tc_failure!(tc_failure_unit_ListLiteralEmptyNotType, "unit/ListLiteralEmptyNotType"); - tc_failure!(tc_failure_unit_ListLiteralNotType, "unit/ListLiteralNotType"); - tc_failure!(tc_failure_unit_ListLiteralTypesNotMatch, "unit/ListLiteralTypesNotMatch"); - tc_failure!(tc_failure_unit_MergeAlternativeHasNoHandler, "unit/MergeAlternativeHasNoHandler"); - tc_failure!(tc_failure_unit_MergeAnnotationNotType, "unit/MergeAnnotationNotType"); - tc_failure!(tc_failure_unit_MergeEmptyWithoutAnnotation, "unit/MergeEmptyWithoutAnnotation"); - tc_failure!(tc_failure_unit_MergeHandlerNotFunction, "unit/MergeHandlerNotFunction"); - tc_failure!(tc_failure_unit_MergeHandlerNotInUnion, "unit/MergeHandlerNotInUnion"); - tc_failure!(tc_failure_unit_MergeHandlerNotMatchAlternativeType, "unit/MergeHandlerNotMatchAlternativeType"); - tc_failure!(tc_failure_unit_MergeHandlersWithDifferentType, "unit/MergeHandlersWithDifferentType"); - tc_failure!(tc_failure_unit_MergeLhsNotRecord, "unit/MergeLhsNotRecord"); - tc_failure!(tc_failure_unit_MergeRhsNotUnion, "unit/MergeRhsNotUnion"); - tc_failure!(tc_failure_unit_MergeWithWrongAnnotation, "unit/MergeWithWrongAnnotation"); - tc_failure!(tc_failure_unit_OperatorAndNotBool, "unit/OperatorAndNotBool"); - tc_failure!(tc_failure_unit_OperatorEqualNotBool, "unit/OperatorEqualNotBool"); - tc_failure!(tc_failure_unit_OperatorListConcatenateLhsNotList, "unit/OperatorListConcatenateLhsNotList"); - tc_failure!(tc_failure_unit_OperatorListConcatenateListsNotMatch, "unit/OperatorListConcatenateListsNotMatch"); - tc_failure!(tc_failure_unit_OperatorListConcatenateNotListsButMatch, "unit/OperatorListConcatenateNotListsButMatch"); - tc_failure!(tc_failure_unit_OperatorListConcatenateRhsNotList, "unit/OperatorListConcatenateRhsNotList"); - tc_failure!(tc_failure_unit_OperatorNotEqualNotBool, "unit/OperatorNotEqualNotBool"); - tc_failure!(tc_failure_unit_OperatorOrNotBool, "unit/OperatorOrNotBool"); - tc_failure!(tc_failure_unit_OperatorPlusNotNatural, "unit/OperatorPlusNotNatural"); - tc_failure!(tc_failure_unit_OperatorTextConcatenateLhsNotText, "unit/OperatorTextConcatenateLhsNotText"); - tc_failure!(tc_failure_unit_OperatorTextConcatenateRhsNotText, "unit/OperatorTextConcatenateRhsNotText"); - tc_failure!(tc_failure_unit_OperatorTimesNotNatural, "unit/OperatorTimesNotNatural"); - tc_failure!(tc_failure_unit_RecordMixedKinds, "unit/RecordMixedKinds"); - tc_failure!(tc_failure_unit_RecordMixedKinds2, "unit/RecordMixedKinds2"); - tc_failure!(tc_failure_unit_RecordMixedKinds3, "unit/RecordMixedKinds3"); - tc_failure!(tc_failure_unit_RecordProjectionEmpty, "unit/RecordProjectionEmpty"); - tc_failure!(tc_failure_unit_RecordProjectionNotPresent, "unit/RecordProjectionNotPresent"); - tc_failure!(tc_failure_unit_RecordProjectionNotRecord, "unit/RecordProjectionNotRecord"); - // tc_failure!(tc_failure_unit_RecordProjectionByTypeFieldTypeMismatch, "unit/RecordProjectionByTypeFieldTypeMismatch"); - // tc_failure!(tc_failure_unit_RecordProjectionByTypeNotPresent, "unit/RecordProjectionByTypeNotPresent"); - tc_failure!(tc_failure_unit_RecordSelectionEmpty, "unit/RecordSelectionEmpty"); - tc_failure!(tc_failure_unit_RecordSelectionNotPresent, "unit/RecordSelectionNotPresent"); - tc_failure!(tc_failure_unit_RecordSelectionNotRecord, "unit/RecordSelectionNotRecord"); - tc_failure!(tc_failure_unit_RecordSelectionTypeNotUnionType, "unit/RecordSelectionTypeNotUnionType"); - tc_failure!(tc_failure_unit_RecordTypeMixedKinds, "unit/RecordTypeMixedKinds"); - tc_failure!(tc_failure_unit_RecordTypeMixedKinds2, "unit/RecordTypeMixedKinds2"); - tc_failure!(tc_failure_unit_RecordTypeMixedKinds3, "unit/RecordTypeMixedKinds3"); - tc_failure!(tc_failure_unit_RecordTypeValueMember, "unit/RecordTypeValueMember"); - tc_failure!(tc_failure_unit_RecursiveRecordMergeLhsNotRecord, "unit/RecursiveRecordMergeLhsNotRecord"); - tc_failure!(tc_failure_unit_RecursiveRecordMergeMixedKinds, "unit/RecursiveRecordMergeMixedKinds"); - tc_failure!(tc_failure_unit_RecursiveRecordMergeOverlapping, "unit/RecursiveRecordMergeOverlapping"); - tc_failure!(tc_failure_unit_RecursiveRecordMergeRhsNotRecord, "unit/RecursiveRecordMergeRhsNotRecord"); - tc_failure!(tc_failure_unit_RecursiveRecordTypeMergeLhsNotRecordType, "unit/RecursiveRecordTypeMergeLhsNotRecordType"); - tc_failure!(tc_failure_unit_RecursiveRecordTypeMergeOverlapping, "unit/RecursiveRecordTypeMergeOverlapping"); - tc_failure!(tc_failure_unit_RecursiveRecordTypeMergeRhsNotRecordType, "unit/RecursiveRecordTypeMergeRhsNotRecordType"); - tc_failure!(tc_failure_unit_RightBiasedRecordMergeLhsNotRecord, "unit/RightBiasedRecordMergeLhsNotRecord"); - tc_failure!(tc_failure_unit_RightBiasedRecordMergeMixedKinds, "unit/RightBiasedRecordMergeMixedKinds"); - tc_failure!(tc_failure_unit_RightBiasedRecordMergeMixedKinds2, "unit/RightBiasedRecordMergeMixedKinds2"); - tc_failure!(tc_failure_unit_RightBiasedRecordMergeMixedKinds3, "unit/RightBiasedRecordMergeMixedKinds3"); - tc_failure!(tc_failure_unit_RightBiasedRecordMergeRhsNotRecord, "unit/RightBiasedRecordMergeRhsNotRecord"); - tc_failure!(tc_failure_unit_SomeNotType, "unit/SomeNotType"); - tc_failure!(tc_failure_unit_Sort, "unit/Sort"); - tc_failure!(tc_failure_unit_TextLiteralInterpolateNotText, "unit/TextLiteralInterpolateNotText"); - tc_failure!(tc_failure_unit_TypeAnnotationWrong, "unit/TypeAnnotationWrong"); - tc_failure!(tc_failure_unit_UnionConstructorFieldNotPresent, "unit/UnionConstructorFieldNotPresent"); - tc_failure!(tc_failure_unit_UnionDeprecatedConstructorsKeyword, "unit/UnionDeprecatedConstructorsKeyword"); - tc_failure!(tc_failure_unit_UnionTypeMixedKinds, "unit/UnionTypeMixedKinds"); - tc_failure!(tc_failure_unit_UnionTypeMixedKinds2, "unit/UnionTypeMixedKinds2"); - tc_failure!(tc_failure_unit_UnionTypeMixedKinds3, "unit/UnionTypeMixedKinds3"); - tc_failure!(tc_failure_unit_UnionTypeNotType, "unit/UnionTypeNotType"); - tc_failure!(tc_failure_unit_VariableFree, "unit/VariableFree"); - - ti_success!(ti_success_simple_alternativesAreTypes, "simple/alternativesAreTypes"); - ti_success!(ti_success_simple_kindParameter, "simple/kindParameter"); - ti_success!(ti_success_unit_Bool, "unit/Bool"); - ti_success!(ti_success_unit_Double, "unit/Double"); - ti_success!(ti_success_unit_DoubleLiteral, "unit/DoubleLiteral"); - ti_success!(ti_success_unit_DoubleShow, "unit/DoubleShow"); - ti_success!(ti_success_unit_False, "unit/False"); - ti_success!(ti_success_unit_Function, "unit/Function"); - ti_success!(ti_success_unit_FunctionApplication, "unit/FunctionApplication"); - ti_success!(ti_success_unit_FunctionNamedArg, "unit/FunctionNamedArg"); - ti_success!(ti_success_unit_FunctionTypeKindKind, "unit/FunctionTypeKindKind"); - ti_success!(ti_success_unit_FunctionTypeKindTerm, "unit/FunctionTypeKindTerm"); - ti_success!(ti_success_unit_FunctionTypeKindType, "unit/FunctionTypeKindType"); - ti_success!(ti_success_unit_FunctionTypeTermTerm, "unit/FunctionTypeTermTerm"); - ti_success!(ti_success_unit_FunctionTypeTypeTerm, "unit/FunctionTypeTypeTerm"); - ti_success!(ti_success_unit_FunctionTypeTypeType, "unit/FunctionTypeTypeType"); - ti_success!(ti_success_unit_FunctionTypeUsingArgument, "unit/FunctionTypeUsingArgument"); - ti_success!(ti_success_unit_If, "unit/If"); - ti_success!(ti_success_unit_IfNormalizeArguments, "unit/IfNormalizeArguments"); - ti_success!(ti_success_unit_Integer, "unit/Integer"); - ti_success!(ti_success_unit_IntegerLiteral, "unit/IntegerLiteral"); - ti_success!(ti_success_unit_IntegerShow, "unit/IntegerShow"); - ti_success!(ti_success_unit_IntegerToDouble, "unit/IntegerToDouble"); - ti_success!(ti_success_unit_Kind, "unit/Kind"); - ti_success!(ti_success_unit_Let, "unit/Let"); - ti_success!(ti_success_unit_LetNestedTypeSynonym, "unit/LetNestedTypeSynonym"); - ti_success!(ti_success_unit_LetTypeSynonym, "unit/LetTypeSynonym"); - ti_success!(ti_success_unit_LetWithAnnotation, "unit/LetWithAnnotation"); - ti_success!(ti_success_unit_List, "unit/List"); - ti_success!(ti_success_unit_ListBuild, "unit/ListBuild"); - ti_success!(ti_success_unit_ListFold, "unit/ListFold"); - ti_success!(ti_success_unit_ListHead, "unit/ListHead"); - ti_success!(ti_success_unit_ListIndexed, "unit/ListIndexed"); - ti_success!(ti_success_unit_ListLast, "unit/ListLast"); - ti_success!(ti_success_unit_ListLength, "unit/ListLength"); - ti_success!(ti_success_unit_ListLiteralEmpty, "unit/ListLiteralEmpty"); - ti_success!(ti_success_unit_ListLiteralNormalizeArguments, "unit/ListLiteralNormalizeArguments"); - ti_success!(ti_success_unit_ListLiteralOne, "unit/ListLiteralOne"); - ti_success!(ti_success_unit_ListReverse, "unit/ListReverse"); - ti_success!(ti_success_unit_MergeEmptyUnion, "unit/MergeEmptyUnion"); - ti_success!(ti_success_unit_MergeOne, "unit/MergeOne"); - ti_success!(ti_success_unit_MergeOneEmpty, "unit/MergeOneEmpty"); - ti_success!(ti_success_unit_MergeOneWithAnnotation, "unit/MergeOneWithAnnotation"); - ti_success!(ti_success_unit_Natural, "unit/Natural"); - ti_success!(ti_success_unit_NaturalBuild, "unit/NaturalBuild"); - ti_success!(ti_success_unit_NaturalEven, "unit/NaturalEven"); - ti_success!(ti_success_unit_NaturalFold, "unit/NaturalFold"); - ti_success!(ti_success_unit_NaturalIsZero, "unit/NaturalIsZero"); - ti_success!(ti_success_unit_NaturalLiteral, "unit/NaturalLiteral"); - ti_success!(ti_success_unit_NaturalOdd, "unit/NaturalOdd"); - ti_success!(ti_success_unit_NaturalShow, "unit/NaturalShow"); - ti_success!(ti_success_unit_NaturalToInteger, "unit/NaturalToInteger"); - ti_success!(ti_success_unit_None, "unit/None"); - ti_success!(ti_success_unit_OperatorAnd, "unit/OperatorAnd"); - ti_success!(ti_success_unit_OperatorAndNormalizeArguments, "unit/OperatorAndNormalizeArguments"); - ti_success!(ti_success_unit_OperatorEqual, "unit/OperatorEqual"); - ti_success!(ti_success_unit_OperatorEqualNormalizeArguments, "unit/OperatorEqualNormalizeArguments"); - ti_success!(ti_success_unit_OperatorListConcatenate, "unit/OperatorListConcatenate"); - ti_success!(ti_success_unit_OperatorListConcatenateNormalizeArguments, "unit/OperatorListConcatenateNormalizeArguments"); - ti_success!(ti_success_unit_OperatorNotEqual, "unit/OperatorNotEqual"); - ti_success!(ti_success_unit_OperatorNotEqualNormalizeArguments, "unit/OperatorNotEqualNormalizeArguments"); - ti_success!(ti_success_unit_OperatorOr, "unit/OperatorOr"); - ti_success!(ti_success_unit_OperatorOrNormalizeArguments, "unit/OperatorOrNormalizeArguments"); - ti_success!(ti_success_unit_OperatorPlus, "unit/OperatorPlus"); - ti_success!(ti_success_unit_OperatorPlusNormalizeArguments, "unit/OperatorPlusNormalizeArguments"); - ti_success!(ti_success_unit_OperatorTextConcatenate, "unit/OperatorTextConcatenate"); - ti_success!(ti_success_unit_OperatorTextConcatenateNormalizeArguments, "unit/OperatorTextConcatenateNormalizeArguments"); - ti_success!(ti_success_unit_OperatorTimes, "unit/OperatorTimes"); - ti_success!(ti_success_unit_OperatorTimesNormalizeArguments, "unit/OperatorTimesNormalizeArguments"); - ti_success!(ti_success_unit_Optional, "unit/Optional"); - ti_success!(ti_success_unit_OptionalBuild, "unit/OptionalBuild"); - ti_success!(ti_success_unit_OptionalFold, "unit/OptionalFold"); - ti_success!(ti_success_unit_RecordEmpty, "unit/RecordEmpty"); - ti_success!(ti_success_unit_RecordNestedKind, "unit/RecordNestedKind"); - ti_success!(ti_success_unit_RecordNestedKindLike, "unit/RecordNestedKindLike"); - ti_success!(ti_success_unit_RecordNestedType, "unit/RecordNestedType"); - ti_success!(ti_success_unit_RecordNestedTypeLike, "unit/RecordNestedTypeLike"); - ti_success!(ti_success_unit_RecordOneKind, "unit/RecordOneKind"); - ti_success!(ti_success_unit_RecordOneType, "unit/RecordOneType"); - ti_success!(ti_success_unit_RecordOneValue, "unit/RecordOneValue"); - ti_success!(ti_success_unit_RecordProjectionEmpty, "unit/RecordProjectionEmpty"); - ti_success!(ti_success_unit_RecordProjectionKind, "unit/RecordProjectionKind"); - ti_success!(ti_success_unit_RecordProjectionType, "unit/RecordProjectionType"); - ti_success!(ti_success_unit_RecordProjectionValue, "unit/RecordProjectionValue"); - // ti_success!(ti_success_unit_RecordProjectionByTypeEmpty, "unit/RecordProjectionByTypeEmpty"); - // ti_success!(ti_success_unit_RecordProjectionByTypeJudgmentalEquality, "unit/RecordProjectionByTypeJudgmentalEquality"); - ti_success!(ti_success_unit_RecordSelectionKind, "unit/RecordSelectionKind"); - ti_success!(ti_success_unit_RecordSelectionType, "unit/RecordSelectionType"); - ti_success!(ti_success_unit_RecordSelectionValue, "unit/RecordSelectionValue"); - ti_success!(ti_success_unit_RecordType, "unit/RecordType"); - ti_success!(ti_success_unit_RecordTypeEmpty, "unit/RecordTypeEmpty"); - ti_success!(ti_success_unit_RecordTypeKind, "unit/RecordTypeKind"); - ti_success!(ti_success_unit_RecordTypeKindLike, "unit/RecordTypeKindLike"); - ti_success!(ti_success_unit_RecordTypeNestedKind, "unit/RecordTypeNestedKind"); - ti_success!(ti_success_unit_RecordTypeNestedKindLike, "unit/RecordTypeNestedKindLike"); - ti_success!(ti_success_unit_RecordTypeType, "unit/RecordTypeType"); - ti_success!(ti_success_unit_RecursiveRecordMergeLhsEmpty, "unit/RecursiveRecordMergeLhsEmpty"); - ti_success!(ti_success_unit_RecursiveRecordMergeRecursively, "unit/RecursiveRecordMergeRecursively"); - ti_success!(ti_success_unit_RecursiveRecordMergeRecursivelyKinds, "unit/RecursiveRecordMergeRecursivelyKinds"); - ti_success!(ti_success_unit_RecursiveRecordMergeRecursivelyTypes, "unit/RecursiveRecordMergeRecursivelyTypes"); - ti_success!(ti_success_unit_RecursiveRecordMergeRhsEmpty, "unit/RecursiveRecordMergeRhsEmpty"); - ti_success!(ti_success_unit_RecursiveRecordMergeTwo, "unit/RecursiveRecordMergeTwo"); - ti_success!(ti_success_unit_RecursiveRecordMergeTwoKinds, "unit/RecursiveRecordMergeTwoKinds"); - ti_success!(ti_success_unit_RecursiveRecordMergeTwoTypes, "unit/RecursiveRecordMergeTwoTypes"); - ti_success!(ti_success_unit_RecursiveRecordTypeMergeRecursively, "unit/RecursiveRecordTypeMergeRecursively"); - ti_success!(ti_success_unit_RecursiveRecordTypeMergeRecursivelyKinds, "unit/RecursiveRecordTypeMergeRecursivelyKinds"); - ti_success!(ti_success_unit_RecursiveRecordTypeMergeRecursivelyTypes, "unit/RecursiveRecordTypeMergeRecursivelyTypes"); - ti_success!(ti_success_unit_RecursiveRecordTypeMergeRhsEmpty, "unit/RecursiveRecordTypeMergeRhsEmpty"); - ti_success!(ti_success_unit_RecursiveRecordTypeMergeTwo, "unit/RecursiveRecordTypeMergeTwo"); - ti_success!(ti_success_unit_RecursiveRecordTypeMergeTwoKinds, "unit/RecursiveRecordTypeMergeTwoKinds"); - ti_success!(ti_success_unit_RecursiveRecordTypeMergeTwoTypes, "unit/RecursiveRecordTypeMergeTwoTypes"); - ti_success!(ti_success_unit_RightBiasedRecordMergeRhsEmpty, "unit/RightBiasedRecordMergeRhsEmpty"); - ti_success!(ti_success_unit_RightBiasedRecordMergeTwo, "unit/RightBiasedRecordMergeTwo"); - ti_success!(ti_success_unit_RightBiasedRecordMergeTwoDifferent, "unit/RightBiasedRecordMergeTwoDifferent"); - ti_success!(ti_success_unit_RightBiasedRecordMergeTwoKinds, "unit/RightBiasedRecordMergeTwoKinds"); - ti_success!(ti_success_unit_RightBiasedRecordMergeTwoTypes, "unit/RightBiasedRecordMergeTwoTypes"); - ti_success!(ti_success_unit_SomeTrue, "unit/SomeTrue"); - ti_success!(ti_success_unit_Text, "unit/Text"); - ti_success!(ti_success_unit_TextLiteral, "unit/TextLiteral"); - ti_success!(ti_success_unit_TextLiteralNormalizeArguments, "unit/TextLiteralNormalizeArguments"); - ti_success!(ti_success_unit_TextLiteralWithInterpolation, "unit/TextLiteralWithInterpolation"); - ti_success!(ti_success_unit_TextShow, "unit/TextShow"); - ti_success!(ti_success_unit_True, "unit/True"); - ti_success!(ti_success_unit_Type, "unit/Type"); - ti_success!(ti_success_unit_TypeAnnotation, "unit/TypeAnnotation"); - ti_success!(ti_success_unit_TypeAnnotationSort, "unit/TypeAnnotationSort"); - ti_success!(ti_success_unit_UnionConstructorEmptyField, "unit/UnionConstructorEmptyField"); - ti_success!(ti_success_unit_UnionConstructorField, "unit/UnionConstructorField"); - ti_success!(ti_success_unit_UnionLiteralOne, "unit/UnionLiteralOne"); - ti_success!(ti_success_unit_UnionTypeEmpty, "unit/UnionTypeEmpty"); - ti_success!(ti_success_unit_UnionTypeKind, "unit/UnionTypeKind"); - ti_success!(ti_success_unit_UnionTypeOne, "unit/UnionTypeOne"); - ti_success!(ti_success_unit_UnionTypeType, "unit/UnionTypeType"); -} -- cgit v1.3.1 From 749834cb5e166665476f2fbc83fdfec794d90cec Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 6 Aug 2019 21:29:44 +0200 Subject: rustfmt --- dhall/src/phase/normalize.rs | 3 ++- dhall_generated_parser/build.rs | 5 +---- 2 files changed, 3 insertions(+), 5 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall/src/phase/normalize.rs b/dhall/src/phase/normalize.rs index d5bdc9e..4bc0f04 100644 --- a/dhall/src/phase/normalize.rs +++ b/dhall/src/phase/normalize.rs @@ -75,7 +75,8 @@ pub fn apply_builtin(b: Builtin, args: Vec) -> Value { // Empty string literal. [] => { // Printing InterpolatedText takes care of all the escaping - let txt: InterpolatedText = std::iter::empty().collect(); + let txt: InterpolatedText = + std::iter::empty().collect(); let s = txt.to_string(); Ok(( r, diff --git a/dhall_generated_parser/build.rs b/dhall_generated_parser/build.rs index 2c1a8f5..5275097 100644 --- a/dhall_generated_parser/build.rs +++ b/dhall_generated_parser/build.rs @@ -55,10 +55,7 @@ fn main() -> std::io::Result<()> { }}" )?; // TODO: this is a cheat; properly support RFC3986 URLs instead - writeln!( - &mut file, - "url_path = _{{ path }}" - )?; + writeln!(&mut file, "url_path = _{{ path }}")?; writeln!( &mut file, "nonreserved_label = _{{ -- cgit v1.3.1 From 705433487da3cd3b4517fcf74b0497c76dbb4080 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 6 Aug 2019 22:36:43 +0200 Subject: Prepare for https://github.com/dhall-lang/dhall-lang/pull/630 --- dhall/src/core/value.rs | 8 +++-- dhall/src/phase/binary.rs | 11 +++++-- dhall/src/phase/normalize.rs | 22 ++++++++++--- dhall/src/phase/typecheck.rs | 75 +++++++++++++++++++++++--------------------- dhall_syntax/src/parser.rs | 3 +- dhall_syntax/src/printer.rs | 3 +- 6 files changed, 74 insertions(+), 48 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall/src/core/value.rs b/dhall/src/core/value.rs index bc8fa34..f47f1b2 100644 --- a/dhall/src/core/value.rs +++ b/dhall/src/core/value.rs @@ -47,6 +47,7 @@ pub enum Value { DoubleLit(NaiveDouble), EmptyOptionalLit(TypeThunk), NEOptionalLit(Thunk), + // EmptyListLit(t) means `[] : List t` EmptyListLit(TypeThunk), NEListLit(Vec), RecordLit(HashMap), @@ -128,9 +129,10 @@ impl Value { Value::NEOptionalLit(n) => { rc(ExprF::SomeLit(n.normalize_to_expr_maybe_alpha(alpha))) } - Value::EmptyListLit(n) => { - rc(ExprF::EmptyListLit(n.normalize_to_expr_maybe_alpha(alpha))) - } + Value::EmptyListLit(n) => rc(ExprF::EmptyListLit(rc(ExprF::App( + rc(ExprF::Builtin(Builtin::List)), + n.normalize_to_expr_maybe_alpha(alpha), + )))), Value::NEListLit(elts) => rc(ExprF::NEListLit( elts.iter() .map(|n| n.normalize_to_expr_maybe_alpha(alpha)) diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index bab3fd8..66b235f 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -106,7 +106,7 @@ fn cbor_value_to_dhall( } [U64(4), t] => { let t = cbor_value_to_dhall(&t)?; - EmptyListLit(t) + EmptyListLit(rc(App(rc(ExprF::Builtin(Builtin::List)), t))) } [U64(4), Null, rest..] => { let rest = rest @@ -413,6 +413,7 @@ where S: serde::ser::Serializer, { use cbor::Value::{String, I64, U64}; + use dhall_syntax::Builtin; use dhall_syntax::ExprF::*; use std::iter::once; @@ -471,7 +472,13 @@ where } Annot(x, y) => ser_seq!(ser; tag(26), expr(x), expr(y)), SomeLit(x) => ser_seq!(ser; tag(5), null(), expr(x)), - EmptyListLit(x) => ser_seq!(ser; tag(4), expr(x)), + EmptyListLit(x) => match x.as_ref() { + App(f, a) => match f.as_ref() { + ExprF::Builtin(Builtin::List) => ser_seq!(ser; tag(4), expr(a)), + _ => unreachable!(), + }, + _ => unreachable!(), + }, NEListLit(xs) => ser.collect_seq( once(tag(4)).chain(once(null())).chain(xs.iter().map(expr)), ), diff --git a/dhall/src/phase/normalize.rs b/dhall/src/phase/normalize.rs index 4bc0f04..2e9f258 100644 --- a/dhall/src/phase/normalize.rs +++ b/dhall/src/phase/normalize.rs @@ -622,9 +622,9 @@ fn apply_binop<'a>(o: BinOp, x: &'a Thunk, y: &'a Thunk) -> Option> { pub fn normalize_one_layer(expr: ExprF) -> Value { use Value::{ - BoolLit, DoubleLit, EmptyListLit, IntegerLit, Lam, NEListLit, - NEOptionalLit, NaturalLit, Pi, RecordLit, RecordType, TextLit, - UnionConstructor, UnionLit, UnionType, + AppliedBuiltin, BoolLit, DoubleLit, EmptyListLit, IntegerLit, Lam, + NEListLit, NEOptionalLit, NaturalLit, Pi, RecordLit, RecordType, + TextLit, UnionConstructor, UnionLit, UnionType, }; let ret = match expr { @@ -651,8 +651,20 @@ pub fn normalize_one_layer(expr: ExprF) -> Value { ExprF::IntegerLit(n) => Ret::Value(IntegerLit(n)), ExprF::DoubleLit(n) => Ret::Value(DoubleLit(n)), ExprF::SomeLit(e) => Ret::Value(NEOptionalLit(e)), - ExprF::EmptyListLit(t) => { - Ret::Value(EmptyListLit(TypeThunk::from_thunk(t))) + ExprF::EmptyListLit(ref t) => { + // Check if the type is of the form `List x` + let t_borrow = t.as_value(); + match &*t_borrow { + AppliedBuiltin(Builtin::List, args) if args.len() == 1 => { + Ret::Value(EmptyListLit(TypeThunk::from_thunk( + args[0].clone(), + ))) + } + _ => { + drop(t_borrow); + Ret::Expr(expr) + } + } } ExprF::NEListLit(elts) => { Ret::Value(NEListLit(elts.into_iter().collect())) diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index fc6c1da..35bf3a9 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -164,37 +164,6 @@ fn tck_union_type( )) } -fn tck_list_type(ctx: &TypecheckContext, t: Type) -> Result { - use crate::error::TypeMessage::*; - ensure_simple_type!( - t, - TypeError::new(ctx, InvalidListType(t.to_normalized())), - ); - Ok(Typed::from_thunk_and_type( - Value::from_builtin(Builtin::List) - .app(t.to_value()) - .into_thunk(), - Type::from_const(Const::Type), - )) -} - -fn tck_optional_type( - ctx: &TypecheckContext, - t: Type, -) -> Result { - use crate::error::TypeMessage::*; - ensure_simple_type!( - t, - TypeError::new(ctx, InvalidOptionalType(t.to_normalized())), - ); - Ok(Typed::from_thunk_and_type( - Value::from_builtin(Builtin::Optional) - .app(t.to_value()) - .into_thunk(), - Type::from_const(Const::Type), - )) -} - fn function_check(a: Const, b: Const) -> Result { use dhall_syntax::Const::*; match (a, b) { @@ -460,7 +429,17 @@ fn type_last_layer( } EmptyListLit(t) => { let t = t.to_type(); - Ok(RetTypeOnly(tck_list_type(ctx, t)?.to_type())) + match &t.to_value() { + Value::AppliedBuiltin(dhall_syntax::Builtin::List, args) + if args.len() == 1 => {} + _ => { + return Err(TypeError::new( + ctx, + InvalidListType(t.to_normalized()), + )) + } + } + Ok(RetTypeOnly(t)) } NEListLit(xs) => { let mut iter = xs.iter().enumerate(); @@ -476,12 +455,38 @@ fn type_last_layer( )) ); } - let t = x.get_type()?.into_owned(); - Ok(RetTypeOnly(tck_list_type(ctx, t)?.to_type())) + let t = x.get_type()?; + ensure_simple_type!( + t, + TypeError::new(ctx, InvalidListType(t.to_normalized())), + ); + + Ok(RetTypeOnly( + Typed::from_thunk_and_type( + Value::from_builtin(dhall_syntax::Builtin::List) + .app(t.to_value()) + .into_thunk(), + Type::from_const(dhall_syntax::Const::Type), + ) + .to_type(), + )) } SomeLit(x) => { let t = x.get_type()?.into_owned(); - Ok(RetTypeOnly(tck_optional_type(ctx, t)?.to_type())) + ensure_simple_type!( + t, + TypeError::new(ctx, InvalidOptionalType(t.to_normalized())), + ); + + Ok(RetTypeOnly( + Typed::from_thunk_and_type( + Value::from_builtin(dhall_syntax::Builtin::Optional) + .app(t.to_value()) + .into_thunk(), + Type::from_const(dhall_syntax::Const::Type), + ) + .to_type(), + )) } RecordType(kts) => Ok(RetWhole(tck_record_type( ctx, diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index 8355ebf..0832af3 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -752,7 +752,8 @@ make_parser! { spanned(span, Merge(x, y, Some(z))) }, [List(()), expression(x)] => { - spanned(span, EmptyListLit(x)) + let list = unspanned(Builtin(crate::Builtin::List)); + spanned(span, EmptyListLit(unspanned(App(list, x)))) }, [expression(e)] => e, )); diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs index 2b2bbcc..52d3d81 100644 --- a/dhall_syntax/src/printer.rs +++ b/dhall_syntax/src/printer.rs @@ -27,7 +27,7 @@ impl Display for ExprF { write!(f, " = {} in {}", c, d)?; } EmptyListLit(t) => { - write!(f, "[] : List {}", t)?; + write!(f, "[] : {}", t)?; } NEListLit(es) => { fmt_list("[", ", ", "]", es, f, Display::fmt)?; @@ -182,7 +182,6 @@ impl Expr { a.phase(PrintPhase::BinOp(op)), b.phase(PrintPhase::BinOp(op)), ), - EmptyListLit(t) => EmptyListLit(t.phase(Import)), SomeLit(e) => SomeLit(e.phase(Import)), ExprF::App(f, a) => ExprF::App(f.phase(Import), a.phase(Import)), Field(a, b) => Field(a.phase(Primitive), b), -- cgit v1.3.1 From f7b0c6b9c52f65624dc765fb9eaa7d0d94eeae76 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 6 Aug 2019 23:03:01 +0200 Subject: Generalize empty list annotations --- dhall-lang | 2 +- dhall/build.rs | 2 ++ dhall/src/phase/binary.rs | 8 ++++++-- dhall_generated_parser/build.rs | 22 ++++++++++++++++++++++ dhall_syntax/src/core/expr.rs | 2 +- dhall_syntax/src/parser.rs | 10 ++++++---- 6 files changed, 38 insertions(+), 8 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index 1b587f8..4d68c57 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit 1b587f866a16ce4ae198d5ff51848a4ffc0f4cdc +Subproject commit 4d68c5708cfc5c3f5ff7e5a6c4df25c5fdfd96f4 diff --git a/dhall/build.rs b/dhall/build.rs index 2d75cbf..07da3f5 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -103,6 +103,8 @@ fn main() -> std::io::Result<()> { || path == "success/unit/import/urls/potPourri" // TODO: toMap || path == "success/toMap" + // Not a failure anymore + || path == "failure/unit/ListLitEmptyPrecedence" }, )?; diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index 66b235f..f88eee2 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -341,6 +341,10 @@ fn cbor_value_to_dhall( let y = cbor_value_to_dhall(&y)?; Annot(x, y) } + [U64(27), x] => { + let x = cbor_value_to_dhall(&x)?; + EmptyListLit(x) + } _ => Err(DecodeError::WrongFormatError(format!("{:?}", data)))?, }, _ => Err(DecodeError::WrongFormatError(format!("{:?}", data)))?, @@ -475,9 +479,9 @@ where EmptyListLit(x) => match x.as_ref() { App(f, a) => match f.as_ref() { ExprF::Builtin(Builtin::List) => ser_seq!(ser; tag(4), expr(a)), - _ => unreachable!(), + _ => ser_seq!(ser; tag(27), expr(x)), }, - _ => unreachable!(), + _ => ser_seq!(ser; tag(27), expr(x)), }, NEListLit(xs) => ser.collect_seq( once(tag(4)).chain(once(null())).chain(xs.iter().map(expr)), diff --git a/dhall_generated_parser/build.rs b/dhall_generated_parser/build.rs index 1edce9e..7eba52c 100644 --- a/dhall_generated_parser/build.rs +++ b/dhall_generated_parser/build.rs @@ -31,6 +31,7 @@ fn main() -> std::io::Result<()> { rules.remove("simple_label"); rules.remove("nonreserved_label"); rules.remove("first_application_expression"); + rules.remove("expression"); let mut file = File::create(pest_path)?; writeln!(&mut file, "// AUTO-GENERATED FILE. See build.rs.")?; @@ -65,6 +66,27 @@ fn main() -> std::io::Result<()> { | import_expression }}" )?; + // TODO: hack; we'll need to upstream a change to the grammar + writeln!( + &mut file, + r#"expression = {{ + lambda ~ whsp ~ ^"(" ~ whsp ~ nonreserved_label ~ whsp ~ ^":" ~ whsp1 ~ expression ~ whsp ~ ^")" ~ whsp ~ arrow ~ whsp ~ expression + | if_ ~ whsp1 ~ expression ~ whsp ~ then ~ whsp1 ~ expression ~ whsp ~ else_ ~ whsp1 ~ expression + | let_binding+ ~ in_ ~ whsp1 ~ expression + | forall ~ whsp ~ ^"(" ~ whsp ~ nonreserved_label ~ whsp ~ ^":" ~ whsp1 ~ expression ~ whsp ~ ^")" ~ whsp ~ arrow ~ whsp ~ expression + | operator_expression ~ whsp ~ arrow ~ whsp ~ expression + | merge ~ whsp1 ~ import_expression ~ whsp1 ~ import_expression ~ whsp ~ ^":" ~ whsp1 ~ application_expression + | empty_list_literal + | toMap ~ whsp1 ~ import_expression ~ whsp ~ ^":" ~ whsp1 ~ application_expression + | annotated_expression + }}"# + )?; + writeln!( + &mut file, + r#"empty_list_literal = {{ + ^"[" ~ whsp ~ ^"]" ~ whsp ~ ^":" ~ whsp1 ~ application_expression + }}"# + )?; // TODO: this is a cheat; properly support RFC3986 URLs instead writeln!(&mut file, "url_path = _{{ path }}")?; writeln!( diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs index e33859b..14dc165 100644 --- a/dhall_syntax/src/core/expr.rs +++ b/dhall_syntax/src/core/expr.rs @@ -190,7 +190,7 @@ pub enum ExprF { DoubleLit(Double), /// `"Some ${interpolated} text"` TextLit(InterpolatedText), - /// `[] : List t` + /// `[] : t` EmptyListLit(SubExpr), /// `[x, y, z]` NEListLit(Vec), diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index 0832af3..8a84b00 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -727,6 +727,12 @@ make_parser! { token_rule!(if_<()>); token_rule!(in_<()>); + rule!(empty_list_literal as expression; span; children!( + [expression(e)] => { + spanned(span, EmptyListLit(e)) + }, + )); + rule!(expression as expression; span; children!( [lambda(()), label(l), expression(typ), arrow(()), expression(body)] => { @@ -751,10 +757,6 @@ make_parser! { [merge(()), expression(x), expression(y), expression(z)] => { spanned(span, Merge(x, y, Some(z))) }, - [List(()), expression(x)] => { - let list = unspanned(Builtin(crate::Builtin::List)); - spanned(span, EmptyListLit(unspanned(App(list, x)))) - }, [expression(e)] => e, )); -- cgit v1.3.1 From 98e7751fb8deb22685b6991367404515c35f502f Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Wed, 7 Aug 2019 16:28:48 +0200 Subject: Various parsing tweaks --- dhall-lang | 2 +- dhall/build.rs | 4 ---- dhall/src/phase/binary.rs | 6 +++--- dhall_generated_parser/build.rs | 11 ----------- 4 files changed, 4 insertions(+), 19 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index 599f83b..f4ee1fb 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit 599f83b9d5ed24f4357455aecc794f572234a69a +Subproject commit f4ee1fb8f8165c6d68d5f7f4da609483839271db diff --git a/dhall/build.rs b/dhall/build.rs index 07da3f5..d3f63ad 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -100,11 +100,8 @@ fn main() -> std::io::Result<()> { || path == "success/unit/import/urls/emptyPath0" || path == "success/unit/import/urls/emptyPath1" || path == "success/unit/import/urls/emptyPathSegment" - || path == "success/unit/import/urls/potPourri" // TODO: toMap || path == "success/toMap" - // Not a failure anymore - || path == "failure/unit/ListLitEmptyPrecedence" }, )?; @@ -160,7 +157,6 @@ fn main() -> std::io::Result<()> { || path == "success/unit/import/urls/emptyPath0" || path == "success/unit/import/urls/emptyPath1" || path == "success/unit/import/urls/emptyPathSegment" - || path == "success/unit/import/urls/potPourri" // TODO: toMap || path == "success/toMap" }, diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index f88eee2..e44b1e2 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -341,7 +341,7 @@ fn cbor_value_to_dhall( let y = cbor_value_to_dhall(&y)?; Annot(x, y) } - [U64(27), x] => { + [U64(28), x] => { let x = cbor_value_to_dhall(&x)?; EmptyListLit(x) } @@ -479,9 +479,9 @@ where EmptyListLit(x) => match x.as_ref() { App(f, a) => match f.as_ref() { ExprF::Builtin(Builtin::List) => ser_seq!(ser; tag(4), expr(a)), - _ => ser_seq!(ser; tag(27), expr(x)), + _ => ser_seq!(ser; tag(28), expr(x)), }, - _ => ser_seq!(ser; tag(27), expr(x)), + _ => ser_seq!(ser; tag(28), expr(x)), }, NEListLit(xs) => ser.collect_seq( once(tag(4)).chain(once(null())).chain(xs.iter().map(expr)), diff --git a/dhall_generated_parser/build.rs b/dhall_generated_parser/build.rs index 7eba52c..74210bf 100644 --- a/dhall_generated_parser/build.rs +++ b/dhall_generated_parser/build.rs @@ -30,7 +30,6 @@ fn main() -> std::io::Result<()> { rules.remove("url_path"); rules.remove("simple_label"); rules.remove("nonreserved_label"); - rules.remove("first_application_expression"); rules.remove("expression"); let mut file = File::create(pest_path)?; @@ -56,16 +55,6 @@ fn main() -> std::io::Result<()> { ~ (import_hashed | ^\"(\" ~ whsp ~ import_hashed ~ whsp ~ ^\")\"))? }}" )?; - // TODO: hack while waiting to catch up on commit e7fdf9d of the spec - writeln!( - &mut file, - "first_application_expression = {{ - merge ~ whsp1 ~ import_expression ~ whsp1 ~ import_expression - | Some_ ~ whsp1 ~ import_expression - | toMap ~ whsp1 ~ import_expression - | import_expression - }}" - )?; // TODO: hack; we'll need to upstream a change to the grammar writeln!( &mut file, -- cgit v1.3.1 From d248762095908246951b6aa6c211587c6e333c0e Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Wed, 7 Aug 2019 21:05:01 +0200 Subject: Remove union literals from the language --- dhall-lang | 2 +- dhall/src/core/value.rs | 15 ++----- dhall/src/phase/binary.rs | 12 ++---- dhall/src/phase/normalize.rs | 7 ---- dhall/src/phase/typecheck.rs | 9 ----- dhall_generated_parser/src/dhall.pest.visibility | 6 +-- dhall_syntax/src/core/expr.rs | 2 - dhall_syntax/src/core/visitor.rs | 3 -- dhall_syntax/src/parser.rs | 51 ++---------------------- dhall_syntax/src/printer.rs | 10 ----- 10 files changed, 12 insertions(+), 105 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index 95cfb88..f692f70 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit 95cfb88db2f79b3c4bf61c76d9e9869d149cdefd +Subproject commit f692f70bafa0322da5d9c4b535b2d323a9c5ac61 diff --git a/dhall/src/core/value.rs b/dhall/src/core/value.rs index f47f1b2..d7b9149 100644 --- a/dhall/src/core/value.rs +++ b/dhall/src/core/value.rs @@ -178,19 +178,10 @@ impl Value { .collect(); rc(ExprF::Field(rc(ExprF::UnionType(kts)), l.clone())) } - Value::UnionLit(l, v, kts) => rc(ExprF::UnionLit( - l.clone(), + Value::UnionLit(l, v, kts) => rc(ExprF::App( + Value::UnionConstructor(l.clone(), kts.clone()) + .normalize_to_expr_maybe_alpha(alpha), v.normalize_to_expr_maybe_alpha(alpha), - kts.iter() - .map(|(k, v)| { - ( - k.clone(), - v.as_ref().map(|v| { - v.normalize_to_expr_maybe_alpha(alpha) - }), - ) - }) - .collect(), )), Value::TextLit(elts) => { use InterpolatedTextContents::{Expr, Text}; diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index e44b1e2..bfe217f 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -160,12 +160,9 @@ fn cbor_value_to_dhall( let map = cbor_map_to_dhall_opt_map(map)?; UnionType(map) } - [U64(12), String(l), x, Object(map)] => { - let map = cbor_map_to_dhall_opt_map(map)?; - let x = cbor_value_to_dhall(&x)?; - let l = Label::from(l.as_str()); - UnionLit(l, x, map) - } + [U64(12), ..] => Err(DecodeError::WrongFormatError( + "Union literals are not supported anymore".to_owned(), + ))?, [U64(14), x, y, z] => { let x = cbor_value_to_dhall(&x)?; let y = cbor_value_to_dhall(&y)?; @@ -496,9 +493,6 @@ where RecordType(map) => ser_seq!(ser; tag(7), RecordMap(map)), RecordLit(map) => ser_seq!(ser; tag(8), RecordMap(map)), UnionType(map) => ser_seq!(ser; tag(11), UnionMap(map)), - UnionLit(l, x, map) => { - ser_seq!(ser; tag(12), label(l), expr(x), UnionMap(map)) - } Field(x, l) => ser_seq!(ser; tag(9), expr(x), label(l)), BinOp(op, x, y) => { use dhall_syntax::BinOp::*; diff --git a/dhall/src/phase/normalize.rs b/dhall/src/phase/normalize.rs index 2e9f258..3e45240 100644 --- a/dhall/src/phase/normalize.rs +++ b/dhall/src/phase/normalize.rs @@ -677,13 +677,6 @@ pub fn normalize_one_layer(expr: ExprF) -> Value { .map(|(k, t)| (k, TypeThunk::from_thunk(t))) .collect(), )), - ExprF::UnionLit(l, x, kts) => Ret::Value(UnionLit( - l, - x, - kts.into_iter() - .map(|(k, t)| (k, t.map(|t| TypeThunk::from_thunk(t)))) - .collect(), - )), ExprF::UnionType(kts) => Ret::Value(UnionType( kts.into_iter() .map(|(k, t)| (k, t.map(|t| TypeThunk::from_thunk(t)))) diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index 35bf3a9..4b3a03f 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -505,15 +505,6 @@ fn type_last_layer( )? .into_type(), )), - UnionLit(x, v, kvs) => { - use std::iter::once; - let kts = kvs - .iter() - .map(|(x, v)| Ok((x.clone(), v.as_ref().map(|v| v.to_type())))); - let t = v.get_type()?.into_owned(); - let kts = kts.chain(once(Ok((x.clone(), Some(t))))); - Ok(RetTypeOnly(tck_union_type(ctx, kts)?.to_type())) - } Field(r, x) => { match &r.get_type()?.to_value() { Value::RecordType(kts) => match kts.get(&x) { diff --git a/dhall_generated_parser/src/dhall.pest.visibility b/dhall_generated_parser/src/dhall.pest.visibility index 33018ae..dd54578 100644 --- a/dhall_generated_parser/src/dhall.pest.visibility +++ b/dhall_generated_parser/src/dhall.pest.visibility @@ -169,11 +169,9 @@ non_empty_record_type record_type_entry non_empty_record_literal record_literal_entry -union_type_or_literal +union_type empty_union_type -non_empty_union_type_or_literal -union_literal_variant_value +# non_empty_union_type union_type_entry -union_type_or_literal_variant_type non_empty_list_literal # complete_expression diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs index 668ab45..aab4b6a 100644 --- a/dhall_syntax/src/core/expr.rs +++ b/dhall_syntax/src/core/expr.rs @@ -202,8 +202,6 @@ pub enum ExprF { RecordLit(DupTreeMap), /// `< k1 : t1, k2 >` UnionType(DupTreeMap>), - /// `< k1 = t1, k2 : t2, k3 >` - UnionLit(Label, SubExpr, DupTreeMap>), /// `merge x y : t` Merge(SubExpr, SubExpr, Option), /// `e.x` diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs index b02544f..68ad956 100644 --- a/dhall_syntax/src/core/visitor.rs +++ b/dhall_syntax/src/core/visitor.rs @@ -141,9 +141,6 @@ where RecordType(kts) => RecordType(dupmap(kts, v)?), RecordLit(kvs) => RecordLit(dupmap(kvs, v)?), UnionType(kts) => UnionType(optdupmap(kts, v)?), - UnionLit(k, x, kts) => { - UnionLit(k.clone(), v.visit_subexpr(x)?, optdupmap(kts, v)?) - } Merge(x, y, t) => Merge( v.visit_subexpr(x)?, v.visit_subexpr(y)?, diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index 8336c74..a7f419a 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -976,67 +976,22 @@ make_parser! { [label(name), expression(expr)] => (name, expr) )); - rule!(union_type_or_literal as expression; span; children!( + rule!(union_type as expression; span; children!( [empty_union_type(_)] => { spanned(span, UnionType(Default::default())) }, - [non_empty_union_type_or_literal((Some((l, e)), entries))] => { - spanned(span, UnionLit(l, e, entries)) - }, - [non_empty_union_type_or_literal((None, entries))] => { - spanned(span, UnionType(entries)) + [union_type_entry(entries)..] => { + spanned(span, UnionType(entries.collect())) }, )); token_rule!(empty_union_type<()>); - rule!(non_empty_union_type_or_literal - <(Option<(Label, ParsedSubExpr)>, - DupTreeMap>)>; - children!( - [label(l), union_literal_variant_value((e, entries))] => { - (Some((l, e)), entries) - }, - [label(l), union_type_or_literal_variant_type((e, rest))] => { - let (x, mut entries) = rest; - entries.insert(l, e); - (x, entries) - }, - )); - - rule!(union_literal_variant_value - <(ParsedSubExpr, DupTreeMap>)>; - children!( - [expression(e), union_type_entry(entries)..] => { - (e, entries.collect()) - }, - )); - rule!(union_type_entry<(Label, Option)>; children!( [label(name), expression(expr)] => (name, Some(expr)), [label(name)] => (name, None), )); - // TODO: unary union variants - rule!(union_type_or_literal_variant_type - <(Option, - (Option<(Label, ParsedSubExpr)>, - DupTreeMap>))>; - children!( - [expression(e), non_empty_union_type_or_literal(rest)] => { - (Some(e), rest) - }, - [expression(e)] => { - (Some(e), (None, Default::default())) - }, - [non_empty_union_type_or_literal(rest)] => { - (None, rest) - }, - [] => { - (None, (None, Default::default())) - }, - )); - rule!(non_empty_list_literal as expression; span; children!( [expression(items)..] => spanned( diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs index 52d3d81..db688bd 100644 --- a/dhall_syntax/src/printer.rs +++ b/dhall_syntax/src/printer.rs @@ -85,16 +85,6 @@ impl Display for ExprF { } Ok(()) })?, - UnionLit(a, b, c) => { - write!(f, "< {} = {}", a, b)?; - for (k, v) in c { - write!(f, " | {}", k)?; - if let Some(v) = v { - write!(f, ": {}", v)?; - } - } - f.write_str(" >")? - } Embed(a) => a.fmt(f)?, } Ok(()) -- cgit v1.3.1 From 51c4f79fe092191d670ffa2f9098693079dbc1be Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Wed, 7 Aug 2019 21:18:11 +0200 Subject: Add truncated Natural subtraction --- dhall-lang | 2 +- dhall/src/phase/normalize.rs | 10 ++++++++++ dhall/src/phase/typecheck.rs | 1 + dhall_generated_parser/src/dhall.pest.visibility | 1 + dhall_syntax/src/core/expr.rs | 1 + dhall_syntax/src/parser.rs | 1 + dhall_syntax/src/printer.rs | 1 + 7 files changed, 16 insertions(+), 1 deletion(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index f692f70..c7082d9 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit f692f70bafa0322da5d9c4b535b2d323a9c5ac61 +Subproject commit c7082d910d956bcedfdc51daae989659a2db67bd diff --git a/dhall/src/phase/normalize.rs b/dhall/src/phase/normalize.rs index 3e45240..395cf28 100644 --- a/dhall/src/phase/normalize.rs +++ b/dhall/src/phase/normalize.rs @@ -47,6 +47,16 @@ pub fn apply_builtin(b: Builtin, args: Vec) -> Value { )), _ => Err(()), }, + (NaturalSubtract, [a, b, r..]) => { + match (&*a.as_value(), &*b.as_value()) { + (NaturalLit(a), NaturalLit(b)) => { + Ok((r, NaturalLit(if b > a { b - a } else { 0 }))) + } + (NaturalLit(0), b) => Ok((r, b.clone())), + (_, NaturalLit(0)) => Ok((r, NaturalLit(0))), + _ => Err(()), + } + } (IntegerShow, [n, r..]) => match &*n.as_value() { IntegerLit(n) => { let s = if *n < 0 { diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index 4b3a03f..2e4642c 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -212,6 +212,7 @@ fn type_of_builtin(b: Builtin) -> Expr { ), NaturalToInteger => dhall::expr!(Natural -> Integer), NaturalShow => dhall::expr!(Natural -> Text), + NaturalSubtract => dhall::expr!(Natural -> Natural -> Natural), IntegerToDouble => dhall::expr!(Integer -> Double), IntegerShow => dhall::expr!(Integer -> Text), diff --git a/dhall_generated_parser/src/dhall.pest.visibility b/dhall_generated_parser/src/dhall.pest.visibility index dd54578..de6dc8d 100644 --- a/dhall_generated_parser/src/dhall.pest.visibility +++ b/dhall_generated_parser/src/dhall.pest.visibility @@ -71,6 +71,7 @@ Location # Natural_show # Integer_toDouble # Integer_show +# Natural_subtract # Double_show # List_build # List_fold diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs index aab4b6a..b293357 100644 --- a/dhall_syntax/src/core/expr.rs +++ b/dhall_syntax/src/core/expr.rs @@ -119,6 +119,7 @@ pub enum Builtin { NaturalOdd, NaturalToInteger, NaturalShow, + NaturalSubtract, IntegerToDouble, IntegerShow, DoubleShow, diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index a7f419a..72dfcdd 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -80,6 +80,7 @@ impl crate::Builtin { "Natural/odd" => Some(NaturalOdd), "Natural/toInteger" => Some(NaturalToInteger), "Natural/show" => Some(NaturalShow), + "Natural/subtract" => Some(NaturalSubtract), "Integer/toDouble" => Some(IntegerToDouble), "Integer/show" => Some(IntegerShow), "Double/show" => Some(DoubleShow), diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs index db688bd..1d6c113 100644 --- a/dhall_syntax/src/printer.rs +++ b/dhall_syntax/src/printer.rs @@ -449,6 +449,7 @@ impl Display for Builtin { NaturalOdd => "Natural/odd", NaturalToInteger => "Natural/toInteger", NaturalShow => "Natural/show", + NaturalSubtract => "Natural/subtract", IntegerToDouble => "Integer/toDouble", IntegerShow => "Integer/show", DoubleShow => "Double/show", -- cgit v1.3.1 From 6654d441e5741013a8618907773ac54101e3fdf2 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Wed, 7 Aug 2019 21:38:01 +0200 Subject: Add binary-decode tests --- dhall/build.rs | 23 +++++++++++++++++++++-- dhall/src/phase/binary.rs | 21 +++++++++++++++++++++ dhall/src/tests.rs | 33 ++++++++++++++++++++++++++++++++- 3 files changed, 74 insertions(+), 3 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall/build.rs b/dhall/build.rs index d3f63ad..1da06ca 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -15,11 +15,15 @@ fn dhall_files_in_dir<'a>( .filter_map(move |path| { let path = path.path(); let path = path.strip_prefix(dir).unwrap(); - if path.extension() != Some(&OsString::from("dhall")) { + let ext = path.extension(); + if ext != Some(&OsString::from("dhall")) + && ext != Some(&OsString::from("dhallb")) + { return None; } + let ext = ext.unwrap(); let path = path.to_string_lossy(); - let path = &path[..path.len() - 6]; + let path = &path[..path.len() - 1 - ext.len()]; let path = if take_a_suffix { if &path[path.len() - 1..] != "A" { return None; @@ -162,6 +166,21 @@ fn main() -> std::io::Result<()> { }, )?; + make_test_module( + &mut file, + "binary_decoding", + &tests_dir.join("binary-decode/"), + "BinaryDecoding", + |path| { + false + // TODO: projection by expression + || path == "success/unit/RecordProjectFields" + || path == "success/unit/recordProjectionByExpression" + // TODO: test is wrong + || path == "success/unit/BuiltinNaturalSubtract" + }, + )?; + make_test_module( &mut file, "beta_normalize", diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index bfe217f..cab3c8e 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -48,10 +48,21 @@ fn cbor_value_to_dhall( Bool(b) => BoolLit(*b), Array(vec) => match vec.as_slice() { [String(l), U64(n)] => { + if l.as_str() == "_" { + Err(DecodeError::WrongFormatError( + "`_` variable was encoded incorrectly".to_owned(), + ))? + } let l = Label::from(l.as_str()); Var(V(l, *n as usize)) } [U64(0), f, args..] => { + if args.is_empty() { + Err(DecodeError::WrongFormatError( + "Function application must have at least one argument" + .to_owned(), + ))? + } let mut f = cbor_value_to_dhall(&f)?; for a in args { let a = cbor_value_to_dhall(&a)?; @@ -65,6 +76,11 @@ fn cbor_value_to_dhall( Lam(Label::from("_"), x, y) } [U64(1), String(l), x, y] => { + if l.as_str() == "_" { + Err(DecodeError::WrongFormatError( + "`_` variable was encoded incorrectly".to_owned(), + ))? + } let x = cbor_value_to_dhall(&x)?; let y = cbor_value_to_dhall(&y)?; let l = Label::from(l.as_str()); @@ -76,6 +92,11 @@ fn cbor_value_to_dhall( Pi(Label::from("_"), x, y) } [U64(2), String(l), x, y] => { + if l.as_str() == "_" { + Err(DecodeError::WrongFormatError( + "`_` variable was encoded incorrectly".to_owned(), + ))? + } let x = cbor_value_to_dhall(&x)?; let y = cbor_value_to_dhall(&y)?; let l = Label::from(l.as_str()); diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs index 8b32fb4..da48d15 100644 --- a/dhall/src/tests.rs +++ b/dhall/src/tests.rs @@ -45,6 +45,7 @@ pub enum Feature { Parser, Printer, BinaryEncoding, + BinaryDecoding, Import, Normalization, AlphaNormalization, @@ -84,6 +85,7 @@ pub fn run_test( Parser => "parser/", Printer => "parser/", BinaryEncoding => "parser/", + BinaryDecoding => "binary-decode/", Import => "import/", Normalization => "normalization/", AlphaNormalization => "alpha-normalization/", @@ -94,6 +96,24 @@ pub fn run_test( "../dhall-lang/tests/".to_owned() + feature_prefix + base_path; match status { Success => { + match feature { + BinaryDecoding => { + let expr_file_path = base_path.clone() + "A.dhallb"; + let expr_file_path = PathBuf::from(&expr_file_path); + let mut expr_data = Vec::new(); + { + File::open(&expr_file_path)? + .read_to_end(&mut expr_data)?; + } + let expr = Parsed::parse_binary(&expr_data)?; + let expected_file_path = base_path + "B.dhall"; + let expected = parse_file_str(&expected_file_path)?; + assert_eq_pretty!(expr, expected); + + return Ok(()); + } + _ => {} + } let expr_file_path = base_path.clone() + "A.dhall"; let expr = parse_file_str(&expr_file_path)?; @@ -164,7 +184,9 @@ pub fn run_test( .normalize(); match feature { - Parser | Printer | BinaryEncoding => unreachable!(), + Parser | Printer | BinaryEncoding | BinaryDecoding => { + unreachable!() + } Import => { let expr = expr.skip_typecheck().normalize(); assert_eq_display!(expr, expected); @@ -201,6 +223,15 @@ pub fn run_test( } } Printer | BinaryEncoding => unreachable!(), + BinaryDecoding => { + let expr_file_path = file_path + "b"; + let mut expr_data = Vec::new(); + { + File::open(&PathBuf::from(&expr_file_path))? + .read_to_end(&mut expr_data)?; + } + Parsed::parse_binary(&expr_data).unwrap_err(); + } Import => { parse_file_str(&file_path)?.resolve().unwrap_err(); } -- cgit v1.3.1 From a01cf8ad53a3839d13aa99a589ba0f2aa796d511 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Wed, 7 Aug 2019 21:57:51 +0200 Subject: Remove an annoying redundancy in the test harness --- dhall/build.rs | 65 +++++++++++++++++++++------------------------- dhall/src/phase/resolve.rs | 4 +-- dhall/src/tests.rs | 14 +--------- 3 files changed, 33 insertions(+), 50 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall/build.rs b/dhall/build.rs index 1da06ca..3d4611e 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -41,29 +41,37 @@ fn dhall_files_in_dir<'a>( fn make_test_module( w: &mut impl Write, // Where to output the generated code mod_name: &str, // Name of the module, used in the output of `cargo test` - dir: &Path, // Directory containing the tests files + subdir: &str, // Directory containing the tests files feature: &str, // Relevant variant of `dhall::tests::Feature` mut exclude: impl FnMut(&str) -> bool, // Given a file name, whether to exclude it ) -> std::io::Result<()> { + let all_tests_dir = Path::new("../dhall-lang/tests/"); + let tests_dir = all_tests_dir.join(subdir); writeln!(w, "mod {} {{", mod_name)?; - for (name, path) in dhall_files_in_dir(&dir.join("success/"), true) { + for (name, path) in dhall_files_in_dir(&tests_dir.join("success/"), true) { if exclude(&("success/".to_owned() + &path)) { continue; } writeln!( w, - r#"make_spec_test!({}, Success, success_{}, "success/{}");"#, - feature, name, path + r#"make_spec_test!({}, Success, success_{}, "{}/success/{}");"#, + feature, + name, + tests_dir.to_string_lossy(), + path )?; } - for (name, path) in dhall_files_in_dir(&dir.join("failure/"), false) { + for (name, path) in dhall_files_in_dir(&tests_dir.join("failure/"), false) { if exclude(&("failure/".to_owned() + &path)) { continue; } writeln!( w, - r#"make_spec_test!({}, Failure, failure_{}, "failure/{}");"#, - feature, name, path + r#"make_spec_test!({}, Failure, failure_{}, "{}/failure/{}");"#, + feature, + name, + tests_dir.to_string_lossy(), + path )?; } writeln!(w, "}}")?; @@ -71,26 +79,20 @@ fn make_test_module( } fn main() -> std::io::Result<()> { - // Tries to detect when the submodule gets updated; doesn't really work. + // Tries to detect when the submodule gets updated. // To force regeneration of the test list, just `touch dhall-lang/.git` println!("cargo:rerun-if-changed=../dhall-lang/.git"); println!( "cargo:rerun-if-changed=../.git/modules/dhall-lang/refs/heads/master" ); let out_dir = env::var("OUT_DIR").unwrap(); - let tests_dir = Path::new("../dhall-lang/tests/"); let parser_tests_path = Path::new(&out_dir).join("spec_tests.rs"); let mut file = File::create(parser_tests_path)?; - make_test_module( - &mut file, - "parse", - &tests_dir.join("parser/"), - "Parser", - |path| { - // Too slow in debug mode - path == "success/largeExpression" + make_test_module(&mut file, "parse", "parser/", "Parser", |path| { + // Too slow in debug mode + path == "success/largeExpression" // TODO: Inline headers || path == "success/unit/import/parenthesizeUsing" || path == "success/unit/import/inlineUsing" @@ -106,17 +108,11 @@ fn main() -> std::io::Result<()> { || path == "success/unit/import/urls/emptyPathSegment" // TODO: toMap || path == "success/toMap" - }, - )?; + })?; - make_test_module( - &mut file, - "printer", - &tests_dir.join("parser/"), - "Printer", - |path| { - // Failure tests are only for the parser - path.starts_with("failure/") + make_test_module(&mut file, "printer", "parser/", "Printer", |path| { + // Failure tests are only for the parser + path.starts_with("failure/") // Too slow in debug mode || path == "success/largeExpression" // TODO: Inline headers @@ -132,13 +128,12 @@ fn main() -> std::io::Result<()> { || path == "success/unit/import/urls/emptyPathSegment" // TODO: toMap || path == "success/toMap" - }, - )?; + })?; make_test_module( &mut file, "binary_encoding", - &tests_dir.join("parser/"), + "parser/", "BinaryEncoding", |path| { // Failure tests are only for the parser @@ -169,7 +164,7 @@ fn main() -> std::io::Result<()> { make_test_module( &mut file, "binary_decoding", - &tests_dir.join("binary-decode/"), + "binary-decode/", "BinaryDecoding", |path| { false @@ -184,7 +179,7 @@ fn main() -> std::io::Result<()> { make_test_module( &mut file, "beta_normalize", - &tests_dir.join("normalization/"), + "normalization/", "Normalization", |path| { // We don't support bignums @@ -207,7 +202,7 @@ fn main() -> std::io::Result<()> { make_test_module( &mut file, "alpha_normalize", - &tests_dir.join("alpha-normalization/"), + "alpha-normalization/", "AlphaNormalization", |_| false, )?; @@ -215,7 +210,7 @@ fn main() -> std::io::Result<()> { make_test_module( &mut file, "typecheck", - &tests_dir.join("typecheck/"), + "typecheck/", "Typecheck", |path| { false @@ -239,7 +234,7 @@ fn main() -> std::io::Result<()> { make_test_module( &mut file, "type_inference", - &tests_dir.join("type-inference/"), + "type-inference/", "TypeInference", |path| { false diff --git a/dhall/src/phase/resolve.rs b/dhall/src/phase/resolve.rs index 0609694..0b29513 100644 --- a/dhall/src/phase/resolve.rs +++ b/dhall/src/phase/resolve.rs @@ -110,13 +110,13 @@ mod spec_tests { macro_rules! import_success { ($name:ident, $path:expr) => { - make_spec_test!(Import, Success, $name, &("success/".to_owned() + $path)); + make_spec_test!(Import, Success, $name, &("../dhall-lang/tests/import/success/".to_owned() + $path)); }; } // macro_rules! import_failure { // ($name:ident, $path:expr) => { - // make_spec_test!(Import, Failure, $name, &("failure/".to_owned() + $path)); + // make_spec_test!(Import, Failure, $name, &("../dhall-lang/tests/import/failure/".to_owned() + $path)); // }; // } diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs index da48d15..9784eec 100644 --- a/dhall/src/tests.rs +++ b/dhall/src/tests.rs @@ -81,19 +81,7 @@ pub fn run_test( ) -> Result<()> { use self::Feature::*; use self::Status::*; - let feature_prefix = match feature { - Parser => "parser/", - Printer => "parser/", - BinaryEncoding => "parser/", - BinaryDecoding => "binary-decode/", - Import => "import/", - Normalization => "normalization/", - AlphaNormalization => "alpha-normalization/", - Typecheck => "typecheck/", - TypeInference => "type-inference/", - }; - let base_path = - "../dhall-lang/tests/".to_owned() + feature_prefix + base_path; + let base_path = base_path.to_owned(); match status { Success => { match feature { -- cgit v1.3.1 From c2cb7d38dfec05b6337aa5dcd0dc3068e73c9a58 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Wed, 7 Aug 2019 22:25:35 +0200 Subject: Flatten nested let bindings --- dhall-lang | 2 +- dhall/build.rs | 3 +++ dhall/src/phase/binary.rs | 46 ++++++++++++++++++++++++++++++++++++++++------ 3 files changed, 44 insertions(+), 7 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index ebda6c1..95dd430 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit ebda6c150056f4e7a801ee11f611be86ce694e8a +Subproject commit 95dd43037ce516907b0919a6cf2e8a9089b67f73 diff --git a/dhall/build.rs b/dhall/build.rs index 983fcad..29e86e3 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -173,6 +173,9 @@ fn main() -> std::io::Result<()> { || path == "success/unit/recordProjectionByExpression" // TODO: test is wrong || path == "success/unit/BuiltinNaturalSubtract" + // TODO: toMap + || path == "success/unit/ToMap" + || path == "success/unit/ToMapAnnotated" }, )?; diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index cab3c8e..5e7eb40 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -477,12 +477,23 @@ where ser_seq!(ser; tag(2), expr(x), expr(y)) } Pi(l, x, y) => ser_seq!(ser; tag(2), label(l), expr(x), expr(y)), - // TODO: multilet - Let(l, None, x, y) => { - ser_seq!(ser; tag(25), label(l), null(), expr(x), expr(y)) - } - Let(l, Some(t), x, y) => { - ser_seq!(ser; tag(25), label(l), expr(t), expr(x), expr(y)) + Let(_, _, _, _) => { + let (bound_e, bindings) = collect_nested_lets(e); + let count = 1 + 3 * bindings.len() + 1; + + use serde::ser::SerializeSeq; + let mut ser_seq = ser.serialize_seq(Some(count))?; + ser_seq.serialize_element(&tag(25))?; + for (l, t, v) in bindings { + ser_seq.serialize_element(&label(l))?; + match t { + Some(t) => ser_seq.serialize_element(&expr(t))?, + None => ser_seq.serialize_element(&null())?, + } + ser_seq.serialize_element(&expr(v))?; + } + ser_seq.serialize_element(&expr(bound_e))?; + ser_seq.end() } App(_, _) => { let (f, args) = collect_nested_applications(e); @@ -677,3 +688,26 @@ fn collect_nested_applications<'a, N, E>( let e = go(e, &mut vec); (e, vec) } + +type LetBinding<'a, N, E> = + (&'a Label, &'a Option>, &'a SubExpr); + +fn collect_nested_lets<'a, N, E>( + e: &'a SubExpr, +) -> (&'a SubExpr, Vec>) { + fn go<'a, N, E>( + e: &'a SubExpr, + vec: &mut Vec>, + ) -> &'a SubExpr { + match e.as_ref() { + ExprF::Let(l, t, v, e) => { + vec.push((l, t, v)); + go(e, vec) + } + _ => e, + } + } + let mut vec = vec![]; + let e = go(e, &mut vec); + (e, vec) +} -- cgit v1.3.1 From e81ab9a553bf82f20fa0b0344926258176a21dac Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Wed, 7 Aug 2019 22:28:36 +0200 Subject: Update dhall-lang submodule --- dhall-lang | 2 +- dhall/build.rs | 1 + dhall/src/phase/resolve.rs | 3 +++ 3 files changed, 5 insertions(+), 1 deletion(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index 95dd430..9f259cd 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit 95dd43037ce516907b0919a6cf2e8a9089b67f73 +Subproject commit 9f259cd68870b912fbf2f2a08cd63dc3ccba9dc3 diff --git a/dhall/build.rs b/dhall/build.rs index 29e86e3..b6df3d0 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -259,6 +259,7 @@ fn main() -> std::io::Result<()> { || path == "success/unit/RecordProjectionByTypeJudgmentalEquality" // TODO: toMap || path == "success/unit/ToMap" + || path == "success/unit/ToMapAnnotated" }, )?; diff --git a/dhall/src/phase/resolve.rs b/dhall/src/phase/resolve.rs index 0b29513..abcee7e 100644 --- a/dhall/src/phase/resolve.rs +++ b/dhall/src/phase/resolve.rs @@ -125,12 +125,15 @@ mod spec_tests { // import_success!(success_alternativeHashMismatch, "alternativeHashMismatch"); // import_success!(success_alternativeNatural, "alternativeNatural"); // import_success!(success_alternativeParseError, "alternativeParseError"); + // import_success!(success_alternativeTypeError, "alternativeTypeError"); + // import_success!(success_asLocation, "asLocation"); // import_success!(success_asText, "asText"); // import_success!(success_customHeaders, "customHeaders"); import_success!(success_fieldOrder, "fieldOrder"); // note: this one needs special setup with env variables // import_success!(success_hashFromCache, "hashFromCache"); // import_success!(success_headerForwarding, "headerForwarding"); + // import_success!(success_nestedHash, "nestedHash"); // import_success!(success_noHeaderForwarding, "noHeaderForwarding"); // import_failure!(failure_alternativeEnv, "alternativeEnv"); // import_failure!(failure_alternativeEnvMissing, "alternativeEnvMissing"); -- cgit v1.3.1 From 071ba528cd8c6a222be345ddec7560bb45cca6be Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Thu, 8 Aug 2019 19:33:07 +0200 Subject: Add support for dependent types --- dhall-lang | 2 +- dhall/build.rs | 5 +- dhall/src/core/thunk.rs | 4 ++ dhall/src/core/value.rs | 19 +++++++- dhall/src/error/mod.rs | 6 ++- dhall/src/phase/binary.rs | 7 +++ dhall/src/phase/normalize.rs | 12 +++-- dhall/src/phase/typecheck.rs | 60 ++++++++++++++++-------- dhall/src/tests.rs | 1 + dhall_generated_parser/build.rs | 1 + dhall_generated_parser/src/dhall.pest.visibility | 3 ++ dhall_syntax/src/core/expr.rs | 6 ++- dhall_syntax/src/core/visitor.rs | 1 + dhall_syntax/src/parser.rs | 12 +++++ dhall_syntax/src/printer.rs | 4 ++ 15 files changed, 114 insertions(+), 29 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index 9f259cd..bf9783f 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit 9f259cd68870b912fbf2f2a08cd63dc3ccba9dc3 +Subproject commit bf9783fc4298d5d54897af1631d677b05dd19db5 diff --git a/dhall/build.rs b/dhall/build.rs index b6df3d0..c05df0d 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -199,7 +199,7 @@ fn main() -> std::io::Result<()> { || path == "success/unit/EmptyToMap" || path == "success/unit/ToMap" || path == "success/unit/ToMapWithType" - // Normalize field selection further by inspecting the argument + // TODO: Normalize field selection further by inspecting the argument || path == "success/simplifications/rightBiasedMergeWithinRecordProjectionWithinFieldSelection0" || path == "success/simplifications/rightBiasedMergeWithinRecordProjectionWithinFieldSelection1" || path == "success/simplifications/rightBiasedMergeWithinRecursiveRecordMergeWithinFieldselection" @@ -229,7 +229,10 @@ fn main() -> std::io::Result<()> { "Typecheck", |path| { false + // TODO: Enable imports in typecheck tests || path == "failure/importBoundary" + // Too slow + || path == "success/prelude" // TODO: Inline headers || path == "failure/customHeadersUsingBoundVariable" // TODO: projection by expression diff --git a/dhall/src/core/thunk.rs b/dhall/src/core/thunk.rs index 5c569e1..5bc25f2 100644 --- a/dhall/src/core/thunk.rs +++ b/dhall/src/core/thunk.rs @@ -221,6 +221,10 @@ impl TypeThunk { self.0.to_type() } + pub fn to_typed(&self) -> Typed { + self.0.clone() + } + pub fn normalize_to_expr_maybe_alpha(&self, alpha: bool) -> OutputSubExpr { self.normalize_nf().normalize_to_expr_maybe_alpha(alpha) } diff --git a/dhall/src/core/value.rs b/dhall/src/core/value.rs index d7b9149..26568b5 100644 --- a/dhall/src/core/value.rs +++ b/dhall/src/core/value.rs @@ -47,7 +47,7 @@ pub enum Value { DoubleLit(NaiveDouble), EmptyOptionalLit(TypeThunk), NEOptionalLit(Thunk), - // EmptyListLit(t) means `[] : List t` + // EmptyListLit(t) means `[] : List t`, not `[] : t` EmptyListLit(TypeThunk), NEListLit(Vec), RecordLit(HashMap), @@ -58,6 +58,7 @@ pub enum Value { // Invariant: this must not contain interpolations that are themselves TextLits, and // contiguous text values must be merged. TextLit(Vec>), + Equivalence(TypeThunk, TypeThunk), // Invariant: this must not contain a value captured by one of the variants above. PartialExpr(ExprF), } @@ -196,6 +197,11 @@ impl Value { .collect(), )) } + Value::Equivalence(x, y) => rc(ExprF::BinOp( + dhall_syntax::BinOp::Equivalence, + x.normalize_to_expr_maybe_alpha(alpha), + y.normalize_to_expr_maybe_alpha(alpha), + )), Value::PartialExpr(e) => { rc(e.map_ref_simple(|v| v.normalize_to_expr_maybe_alpha(alpha))) } @@ -282,6 +288,10 @@ impl Value { } } } + Value::Equivalence(x, y) => { + x.normalize_mut(); + y.normalize_mut(); + } Value::PartialExpr(e) => { // TODO: need map_mut_simple e.map_ref_simple(|v| { @@ -418,6 +428,9 @@ impl Shift for Value { }) .collect::>()?, ), + Value::Equivalence(x, y) => { + Value::Equivalence(x.shift(delta, var)?, y.shift(delta, var)?) + } Value::PartialExpr(e) => Value::PartialExpr( e.traverse_ref_with_special_handling_of_binders( |v| Ok(v.shift(delta, var)?), @@ -533,6 +546,10 @@ impl Subst for Value { }) .collect(), ), + Value::Equivalence(x, y) => Value::Equivalence( + x.subst_shift(var, val), + y.subst_shift(var, val), + ), } } } diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs index a0ee30a..3c00017 100644 --- a/dhall/src/error/mod.rs +++ b/dhall/src/error/mod.rs @@ -68,7 +68,6 @@ pub(crate) enum TypeMessage { MissingRecordField(Label, Typed), MissingUnionField(Label, Normalized), BinOpTypeMismatch(BinOp, Typed), - NoDependentTypes(Normalized, Normalized), InvalidTextInterpolation(Typed), Merge1ArgMustBeRecord(Typed), Merge2ArgMustBeUnion(Typed), @@ -86,7 +85,10 @@ pub(crate) enum TypeMessage { RecordTypeMergeRequiresRecordType(Type), RecordTypeMismatch(Type, Type, Type, Type), UnionTypeDuplicateField, - // Unimplemented, + EquivalenceArgumentMustBeTerm(bool, Typed), + EquivalenceTypeMismatch(Typed, Typed), + AssertMismatch(Typed, Typed), + AssertMustTakeEquivalence, } impl TypeError { diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index 5e7eb40..719b1c7 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -119,6 +119,7 @@ fn cbor_value_to_dhall( 9 => RightBiasedRecordMerge, 10 => RecursiveRecordTypeMerge, 11 => ImportAlt, + 12 => Equivalence, _ => { Err(DecodeError::WrongFormatError("binop".to_owned()))? } @@ -211,6 +212,10 @@ fn cbor_value_to_dhall( .collect::>()?, ))) } + [U64(19), t] => { + let t = cbor_value_to_dhall(&t)?; + Assert(t) + } [U64(24), hash, U64(mode), U64(scheme), rest..] => { let mode = match mode { 0 => ImportMode::Code, @@ -504,6 +509,7 @@ where ) } Annot(x, y) => ser_seq!(ser; tag(26), expr(x), expr(y)), + Assert(x) => ser_seq!(ser; tag(19), expr(x)), SomeLit(x) => ser_seq!(ser; tag(5), null(), expr(x)), EmptyListLit(x) => match x.as_ref() { App(f, a) => match f.as_ref() { @@ -541,6 +547,7 @@ where RightBiasedRecordMerge => 9, RecursiveRecordTypeMerge => 10, ImportAlt => 11, + Equivalence => 12, }; ser_seq!(ser; tag(3), U64(op), expr(x), expr(y)) } diff --git a/dhall/src/phase/normalize.rs b/dhall/src/phase/normalize.rs index 395cf28..ecad063 100644 --- a/dhall/src/phase/normalize.rs +++ b/dhall/src/phase/normalize.rs @@ -508,9 +508,9 @@ where fn apply_binop<'a>(o: BinOp, x: &'a Thunk, y: &'a Thunk) -> Option> { use BinOp::{ - BoolAnd, BoolEQ, BoolNE, BoolOr, ListAppend, NaturalPlus, NaturalTimes, - RecursiveRecordMerge, RecursiveRecordTypeMerge, RightBiasedRecordMerge, - TextAppend, + BoolAnd, BoolEQ, BoolNE, BoolOr, Equivalence, ListAppend, NaturalPlus, + NaturalTimes, RecursiveRecordMerge, RecursiveRecordTypeMerge, + RightBiasedRecordMerge, TextAppend, }; use Value::{ BoolLit, EmptyListLit, NEListLit, NaturalLit, RecordLit, RecordType, @@ -626,6 +626,11 @@ fn apply_binop<'a>(o: BinOp, x: &'a Thunk, y: &'a Thunk) -> Option> { Ret::Value(RecordType(kvs)) } + (Equivalence, _, _) => Ret::Value(Value::Equivalence( + TypeThunk::from_thunk(x.clone()), + TypeThunk::from_thunk(y.clone()), + )), + _ => return None, }) } @@ -641,6 +646,7 @@ pub fn normalize_one_layer(expr: ExprF) -> Value { ExprF::Embed(_) => unreachable!(), ExprF::Var(_) => unreachable!(), ExprF::Annot(x, _) => Ret::Thunk(x), + ExprF::Assert(_) => Ret::Expr(expr), ExprF::Lam(x, t, e) => { Ret::Value(Lam(x.into(), TypeThunk::from_thunk(t), e)) } diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index 2e4642c..297a096 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -60,18 +60,7 @@ fn tck_pi_type( } }; - let k = match function_check(ka, kb) { - Ok(k) => k, - Err(()) => { - return Err(TypeError::new( - ctx, - NoDependentTypes( - tx.to_normalized(), - te.get_type()?.to_normalized(), - ), - )) - } - }; + let k = function_check(ka, kb); Ok(Typed::from_thunk_and_type( Value::Pi(x.into(), TypeThunk::from_type(tx), TypeThunk::from_type(te)) @@ -164,14 +153,13 @@ fn tck_union_type( )) } -fn function_check(a: Const, b: Const) -> Result { - use dhall_syntax::Const::*; - match (a, b) { - (_, Type) => Ok(Type), - (Kind, Kind) => Ok(Kind), - (Sort, Sort) => Ok(Sort), - (Sort, Kind) => Ok(Sort), - _ => Err(()), +fn function_check(a: Const, b: Const) -> Const { + use dhall_syntax::Const::Type; + use std::cmp::max; + if b == Type { + Type + } else { + max(a, b) } } @@ -403,6 +391,19 @@ fn type_last_layer( ); Ok(RetTypeOnly(x.get_type()?.into_owned())) } + Assert(t) => { + match t.to_value() { + Value::Equivalence(x, y) if x == y => {} + Value::Equivalence(x, y) => { + return Err(mkerr(AssertMismatch( + x.to_typed(), + y.to_typed(), + ))) + } + _ => return Err(mkerr(AssertMustTakeEquivalence)), + } + Ok(RetTypeOnly(t.to_type())) + } BoolIf(x, y, z) => { ensure_equal!( x.get_type()?, @@ -807,6 +808,24 @@ fn type_last_layer( Ok(RetTypeOnly(l.get_type()?.into_owned())) } + BinOp(Equivalence, l, r) => { + ensure_simple_type!( + l.get_type()?, + mkerr(EquivalenceArgumentMustBeTerm(true, l.clone())), + ); + ensure_simple_type!( + r.get_type()?, + mkerr(EquivalenceArgumentMustBeTerm(false, r.clone())), + ); + + ensure_equal!( + l.get_type()?, + r.get_type()?, + mkerr(EquivalenceTypeMismatch(r.clone(), l.clone())) + ); + + Ok(RetTypeOnly(Type::from_const(dhall_syntax::Const::Type))) + } BinOp(o, l, r) => { let t = builtin_to_type(match o { BoolAnd => Bool, @@ -821,6 +840,7 @@ fn type_last_layer( RecursiveRecordMerge => unreachable!(), RecursiveRecordTypeMerge => unreachable!(), ImportAlt => unreachable!("There should remain no import alternatives in a resolved expression"), + Equivalence => unreachable!(), })?; ensure_equal!( diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs index 9784eec..15bc97a 100644 --- a/dhall/src/tests.rs +++ b/dhall/src/tests.rs @@ -107,6 +107,7 @@ pub fn run_test( match feature { Parser => { + // This exercices both parsing and binary decoding // Compare parse/decoded let expected_file_path = base_path + "B.dhallb"; let expected_file_path = PathBuf::from(&expected_file_path); diff --git a/dhall_generated_parser/build.rs b/dhall_generated_parser/build.rs index 74210bf..48605b6 100644 --- a/dhall_generated_parser/build.rs +++ b/dhall_generated_parser/build.rs @@ -67,6 +67,7 @@ fn main() -> std::io::Result<()> { | merge ~ whsp1 ~ import_expression ~ whsp1 ~ import_expression ~ whsp ~ ^":" ~ whsp1 ~ application_expression | empty_list_literal | toMap ~ whsp1 ~ import_expression ~ whsp ~ ^":" ~ whsp1 ~ application_expression + | assert ~ whsp ~ ^":" ~ whsp1 ~ expression | annotated_expression }}"# )?; diff --git a/dhall_generated_parser/src/dhall.pest.visibility b/dhall_generated_parser/src/dhall.pest.visibility index de6dc8d..44a52c1 100644 --- a/dhall_generated_parser/src/dhall.pest.visibility +++ b/dhall_generated_parser/src/dhall.pest.visibility @@ -46,6 +46,7 @@ missing NaN Some_ toMap +assert # keyword builtin Optional @@ -85,6 +86,7 @@ Location # Text_show # combine # combine_types +# equivalent # prefer lambda forall @@ -154,6 +156,7 @@ combine_types_expression times_expression equal_expression not_equal_expression +equivalent_expression application_expression first_application_expression # import_expression diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs index b293357..6522cb1 100644 --- a/dhall_syntax/src/core/expr.rs +++ b/dhall_syntax/src/core/expr.rs @@ -44,7 +44,7 @@ impl From for f64 { } /// Constants for a pure type system -#[derive(Debug, Copy, Clone, PartialEq, Eq)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)] pub enum Const { Type, Kind, @@ -99,6 +99,8 @@ pub enum BinOp { BoolEQ, /// `x != y` BoolNE, + /// x === y + Equivalence, } /// Built-ins @@ -175,6 +177,8 @@ pub enum ExprF { Let(Label, Option, SubExpr, SubExpr), /// `x : t` Annot(SubExpr, SubExpr), + /// `assert : t` + Assert(SubExpr), /// Built-in values Builtin(Builtin), // Binary operations diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs index 68ad956..18f76d9 100644 --- a/dhall_syntax/src/core/visitor.rs +++ b/dhall_syntax/src/core/visitor.rs @@ -148,6 +148,7 @@ where ), Field(e, l) => Field(v.visit_subexpr(e)?, l.clone()), Projection(e, ls) => Projection(v.visit_subexpr(e)?, ls.clone()), + Assert(e) => Assert(v.visit_subexpr(e)?), Embed(a) => return v.visit_embed_squash(a), }) } diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index 72dfcdd..9ae6dc8 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -311,6 +311,7 @@ fn can_be_shortcutted(rule: Rule) -> bool { | times_expression | equal_expression | not_equal_expression + | equivalent_expression | application_expression | first_application_expression | selector_expression @@ -744,6 +745,7 @@ make_parser! { token_rule!(forall<()>); token_rule!(arrow<()>); token_rule!(merge<()>); + token_rule!(assert<()>); token_rule!(if_<()>); token_rule!(in_<()>); @@ -777,6 +779,9 @@ make_parser! { [merge(()), expression(x), expression(y), expression(z)] => { spanned(span, Merge(x, y, Some(z))) }, + [assert(()), expression(x)] => { + spanned(span, Assert(x)) + }, [expression(e)] => e, )); @@ -875,6 +880,13 @@ make_parser! { rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e))) }, )); + rule!(equivalent_expression as expression; children!( + [expression(e)] => e, + [expression(first), expression(rest)..] => { + let o = crate::BinOp::Equivalence; + rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e))) + }, + )); rule!(annotated_expression as expression; span; children!( [expression(e)] => e, diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs index 1d6c113..70b224e 100644 --- a/dhall_syntax/src/printer.rs +++ b/dhall_syntax/src/printer.rs @@ -44,6 +44,9 @@ impl Display for ExprF { Annot(a, b) => { write!(f, "{} : {}", a, b)?; } + Assert(a) => { + write!(f, "assert : {}", a)?; + } ExprF::BinOp(op, a, b) => { write!(f, "{} {} {}", a, op, b)?; } @@ -286,6 +289,7 @@ impl Display for BinOp { ImportAlt => "?", RightBiasedRecordMerge => "⫽", ListAppend => "#", + Equivalence => "≡", }) } } -- cgit v1.3.1 From 4d94c3bbf955c5c32cee0651820484c4e4b6cd90 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Thu, 8 Aug 2019 19:45:52 +0200 Subject: Update dhall-lang submodule --- dhall-lang | 2 +- dhall/build.rs | 3 +++ dhall/src/phase/normalize.rs | 1 + 3 files changed, 5 insertions(+), 1 deletion(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index bf9783f..9729d89 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit bf9783fc4298d5d54897af1631d677b05dd19db5 +Subproject commit 9729d8939a6c79adf9a26dd20978fba6ec39bbec diff --git a/dhall/build.rs b/dhall/build.rs index c05df0d..bcb5d1c 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -208,9 +208,12 @@ fn main() -> std::io::Result<()> { || path == "success/unit/RecursiveRecordMergeWithinFieldSelection0" || path == "success/unit/RecursiveRecordMergeWithinFieldSelection1" || path == "success/unit/RecursiveRecordMergeWithinFieldSelection2" + || path == "success/unit/RecursiveRecordMergeWithinFieldSelection3" || path == "success/unit/RightBiasedMergeWithinFieldSelection0" || path == "success/unit/RightBiasedMergeWithinFieldSelection1" || path == "success/unit/RightBiasedMergeWithinFieldSelection2" + || path == "success/unit/RightBiasedMergeWithinFieldSelection3" + || path == "success/unit/RightBiasedMergeEquivalentArguments" }, )?; diff --git a/dhall/src/phase/normalize.rs b/dhall/src/phase/normalize.rs index ecad063..405677a 100644 --- a/dhall/src/phase/normalize.rs +++ b/dhall/src/phase/normalize.rs @@ -54,6 +54,7 @@ pub fn apply_builtin(b: Builtin, args: Vec) -> Value { } (NaturalLit(0), b) => Ok((r, b.clone())), (_, NaturalLit(0)) => Ok((r, NaturalLit(0))), + _ if a == b => Ok((r, NaturalLit(0))), _ => Err(()), } } -- cgit v1.3.1 From 80c8d87db595c91293af75d710464ac5379c7e28 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Sat, 10 Aug 2019 22:48:21 +0200 Subject: Update dhall-lang submodule --- dhall-lang | 2 +- dhall/build.rs | 13 +++++++++---- dhall/src/phase/binary.rs | 13 +++++++++++++ tests_buffer | 3 ++- 4 files changed, 25 insertions(+), 6 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall-lang b/dhall-lang index 9729d89..fb1c41d 160000 --- a/dhall-lang +++ b/dhall-lang @@ -1 +1 @@ -Subproject commit 9729d8939a6c79adf9a26dd20978fba6ec39bbec +Subproject commit fb1c41ddec1d35dadd89a70780698e1a73e179bd diff --git a/dhall/build.rs b/dhall/build.rs index bcb5d1c..8b23dd9 100644 --- a/dhall/build.rs +++ b/dhall/build.rs @@ -94,8 +94,12 @@ fn main() -> std::io::Result<()> { // Too slow in debug mode path == "success/largeExpression" // TODO: Inline headers - || path == "success/unit/import/parenthesizeUsing" || path == "success/unit/import/inlineUsing" + || path == "success/unit/import/Headers" + || path == "success/unit/import/HeadersDoubleHash" + || path == "success/unit/import/HeadersDoubleHashPrecedence" + || path == "success/unit/import/HeadersHashPrecedence" + || path == "success/unit/import/HeadersInteriorHash" // TODO: projection by expression || path == "success/recordProjectionByExpression" || path == "success/RecordProjectionByType" @@ -117,6 +121,7 @@ fn main() -> std::io::Result<()> { || path == "success/largeExpression" // TODO: Inline headers || path == "success/unit/import/inlineUsing" + || path == "success/unit/import/Headers" // TODO: projection by expression || path == "success/recordProjectionByExpression" || path == "success/RecordProjectionByType" @@ -140,13 +145,13 @@ fn main() -> std::io::Result<()> { path.starts_with("failure/") // Too slow in debug mode || path == "success/largeExpression" - // Too much of a pain to implement; shouldn't make a difference - // since lets disappear on normalization. - || path == "success/multilet" // See https://github.com/pyfisch/cbor/issues/109 || path == "success/double" + || path == "success/unit/DoubleLitExponentNoDot" + || path == "success/unit/DoubleLitSecretelyInt" // TODO: Inline headers || path == "success/unit/import/inlineUsing" + || path == "success/unit/import/Headers" // TODO: projection by expression || path == "success/recordProjectionByExpression" || path == "success/RecordProjectionByType" diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index 719b1c7..f4a9cc1 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -178,6 +178,19 @@ fn cbor_value_to_dhall( let l = Label::from(l.as_str()); Field(x, l) } + [U64(10), x, rest..] => { + let x = cbor_value_to_dhall(&x)?; + let labels = rest + .iter() + .map(|s| match s { + String(s) => Ok(Label::from(s.as_str())), + _ => Err(DecodeError::WrongFormatError( + "projection".to_owned(), + )), + }) + .collect::>()?; + Projection(x, labels) + } [U64(11), Object(map)] => { let map = cbor_map_to_dhall_opt_map(map)?; UnionType(map) diff --git a/tests_buffer b/tests_buffer index 4f8a375..c6366ba 100644 --- a/tests_buffer +++ b/tests_buffer @@ -7,6 +7,8 @@ success/ operators/ PrecedenceAll1 a ? b || c + d ++ e # f && g ∧ h ⫽ i ⩓ j * k == l != m n.o PrecedenceAll2 a b != c == d * e ⩓ f ⫽ g ∧ h && i # j ++ k + l || m ? n + LetNoAnnot let x = y in e + LetAnnot let x: T = y in e failure/ AssertNoAnnotation assert @@ -23,7 +25,6 @@ failure/ normalization: variables across import boundaries Text/show "" - Double/show -1.5e-10 TextLitNested1 "${""}${x}" TextLitNested2 "${"${x}"}" TextLitNested3 "${"${""}"}${x}" -- cgit v1.3.1 From d3f54e5536cc4d2ba46b6e4e88b7218da1b797ee Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Thu, 8 Aug 2019 23:09:37 +0200 Subject: Remove dhall::expr!() macro It's a lot of hassle for not a lot of benefit --- dhall/src/api/mod.rs | 4 - dhall/src/core/thunk.rs | 4 - dhall/src/core/value.rs | 50 ++++++++- dhall/src/phase/mod.rs | 3 - dhall/src/phase/typecheck.rs | 107 +++++++++++++++----- dhall/tests/traits.rs | 30 ++---- dhall_proc_macros/src/lib.rs | 11 -- dhall_proc_macros/src/quote.rs | 223 ----------------------------------------- 8 files changed, 137 insertions(+), 295 deletions(-) delete mode 100644 dhall_proc_macros/src/quote.rs (limited to 'dhall/src/phase') diff --git a/dhall/src/api/mod.rs b/dhall/src/api/mod.rs index 233d7cf..188b6c0 100644 --- a/dhall/src/api/mod.rs +++ b/dhall/src/api/mod.rs @@ -66,10 +66,6 @@ mod typ { )) } #[doc(hidden)] - pub fn from_normalized_expr(e: NormalizedSubExpr) -> Self { - Type(Typed::from_normalized_expr_untyped(e)) - } - #[doc(hidden)] pub fn make_record_type( kts: impl Iterator, ) -> Self { diff --git a/dhall/src/core/thunk.rs b/dhall/src/core/thunk.rs index 5bc25f2..f41579c 100644 --- a/dhall/src/core/thunk.rs +++ b/dhall/src/core/thunk.rs @@ -111,10 +111,6 @@ impl Thunk { ThunkInternal::Value(WHNF, v).into_thunk() } - pub fn from_normalized_expr(e: OutputSubExpr) -> Thunk { - Thunk::new(NormalizationContext::new(), e.absurd()) - } - pub fn from_partial_expr(e: ExprF) -> Thunk { ThunkInternal::PartialExpr(e).into_thunk() } diff --git a/dhall/src/core/value.rs b/dhall/src/core/value.rs index 26568b5..0b68bf6 100644 --- a/dhall/src/core/value.rs +++ b/dhall/src/core/value.rs @@ -1,6 +1,5 @@ use std::collections::HashMap; -use dhall_proc_macros as dhall; use dhall_syntax::{ rc, Builtin, Const, ExprF, Integer, InterpolatedTextContents, Label, NaiveDouble, Natural, X, @@ -75,6 +74,47 @@ impl Value { /// Convert the value to a fully normalized syntactic expression. Also alpha-normalize /// if alpha is `true` pub fn normalize_to_expr_maybe_alpha(&self, alpha: bool) -> OutputSubExpr { + // Ad-hoc macro to help construct the unapplied closures + macro_rules! make_expr { + (Natural) => { rc(ExprF::Builtin(Builtin::Natural)) }; + (var($var:ident)) => { + rc(ExprF::Var(dhall_syntax::V(stringify!($var).into(), 0))) + }; + ($var:ident) => { $var }; + (List $($rest:tt)*) => { + rc(ExprF::App( + rc(ExprF::Builtin(Builtin::List)), + make_expr!($($rest)*) + )) + }; + (Some $($rest:tt)*) => { + rc(ExprF::SomeLit( + make_expr!($($rest)*) + )) + }; + (1 + $($rest:tt)*) => { + rc(ExprF::BinOp( + dhall_syntax::BinOp::NaturalPlus, + rc(ExprF::NaturalLit(1)), + make_expr!($($rest)*) + )) + }; + ([ $($head:tt)* ] # $($tail:tt)*) => { + rc(ExprF::BinOp( + dhall_syntax::BinOp::ListAppend, + rc(ExprF::NEListLit(vec![make_expr!($($head)*)])), + make_expr!($($tail)*) + )) + }; + (λ($var:ident : $($ty:tt)*) -> $($rest:tt)*) => { + rc(ExprF::Pi( + stringify!($var).into(), + make_expr!($($ty)*), + make_expr!($($rest)*) + )) + }; + } + match self { Value::Lam(x, t, e) => rc(ExprF::Lam( x.to_label_maybe_alpha(alpha), @@ -93,24 +133,24 @@ impl Value { } Value::OptionalSomeClosure(n) => { let a = n.normalize_to_expr_maybe_alpha(alpha); - dhall::subexpr!(λ(x: a) -> Some x) + make_expr!(λ(x: a) -> Some var(x)) } Value::ListConsClosure(a, None) => { // Avoid accidental capture of the new `x` variable let a1 = a.under_binder(Label::from("x")); let a1 = a1.normalize_to_expr_maybe_alpha(alpha); let a = a.normalize_to_expr_maybe_alpha(alpha); - dhall::subexpr!(λ(x : a) -> λ(xs : List a1) -> [ x ] # xs) + make_expr!(λ(x : a) -> λ(xs : List a1) -> [ var(x) ] # var(xs)) } Value::ListConsClosure(n, Some(v)) => { // Avoid accidental capture of the new `xs` variable let v = v.under_binder(Label::from("xs")); let v = v.normalize_to_expr_maybe_alpha(alpha); let a = n.normalize_to_expr_maybe_alpha(alpha); - dhall::subexpr!(λ(xs : List a) -> [ v ] # xs) + make_expr!(λ(xs : List a) -> [ v ] # var(xs)) } Value::NaturalSuccClosure => { - dhall::subexpr!(λ(x : Natural) -> x + 1) + make_expr!(λ(x : Natural) -> 1 + var(x)) } Value::Pi(x, t, e) => rc(ExprF::Pi( x.to_label_maybe_alpha(alpha), diff --git a/dhall/src/phase/mod.rs b/dhall/src/phase/mod.rs index 681b7fe..ccedff2 100644 --- a/dhall/src/phase/mod.rs +++ b/dhall/src/phase/mod.rs @@ -127,9 +127,6 @@ impl Typed { pub fn from_value_untyped(v: Value) -> Self { Typed::from_thunk_untyped(Thunk::from_value(v)) } - pub fn from_normalized_expr_untyped(e: NormalizedSubExpr) -> Self { - Typed::from_thunk_untyped(Thunk::from_normalized_expr(e)) - } // TODO: Avoid cloning if possible pub fn to_value(&self) -> Value { diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index 297a096..8f5ca8b 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -1,6 +1,5 @@ use std::collections::HashMap; -use dhall_proc_macros as dhall; use dhall_syntax::{ rc, Builtin, Const, Expr, ExprF, InterpolatedTextContents, Label, Span, SubExpr, X, @@ -173,41 +172,97 @@ pub fn type_of_const(c: Const) -> Result { } } +// Ad-hoc macro to help construct the types of builtins +macro_rules! make_type { + (Type) => { ExprF::Const(Const::Type) }; + (Bool) => { ExprF::Builtin(Builtin::Bool) }; + (Natural) => { ExprF::Builtin(Builtin::Natural) }; + (Integer) => { ExprF::Builtin(Builtin::Integer) }; + (Double) => { ExprF::Builtin(Builtin::Double) }; + (Text) => { ExprF::Builtin(Builtin::Text) }; + ($var:ident) => { + ExprF::Var(dhall_syntax::V(stringify!($var).into(), 0)) + }; + (Optional $ty:ident) => { + ExprF::App( + rc(ExprF::Builtin(Builtin::Optional)), + rc(make_type!($ty)) + ) + }; + (List $($rest:tt)*) => { + ExprF::App( + rc(ExprF::Builtin(Builtin::List)), + rc(make_type!($($rest)*)) + ) + }; + ({ $($label:ident : $ty:ident),* }) => {{ + let mut kts = dhall_syntax::map::DupTreeMap::new(); + $( + kts.insert( + Label::from(stringify!($label)), + rc(make_type!($ty)), + ); + )* + ExprF::RecordType(kts) + }}; + ($ty:ident -> $($rest:tt)*) => { + ExprF::Pi( + "_".into(), + rc(make_type!($ty)), + rc(make_type!($($rest)*)) + ) + }; + (($($arg:tt)*) -> $($rest:tt)*) => { + ExprF::Pi( + "_".into(), + rc(make_type!($($arg)*)), + rc(make_type!($($rest)*)) + ) + }; + (forall ($var:ident : $($ty:tt)*) -> $($rest:tt)*) => { + ExprF::Pi( + stringify!($var).into(), + rc(make_type!($($ty)*)), + rc(make_type!($($rest)*)) + ) + }; +} + fn type_of_builtin(b: Builtin) -> Expr { use dhall_syntax::Builtin::*; match b { - Bool | Natural | Integer | Double | Text => dhall::expr!(Type), - List | Optional => dhall::expr!( + Bool | Natural | Integer | Double | Text => make_type!(Type), + List | Optional => make_type!( Type -> Type ), - NaturalFold => dhall::expr!( + NaturalFold => make_type!( Natural -> forall (natural: Type) -> forall (succ: natural -> natural) -> forall (zero: natural) -> natural ), - NaturalBuild => dhall::expr!( + NaturalBuild => make_type!( (forall (natural: Type) -> forall (succ: natural -> natural) -> forall (zero: natural) -> natural) -> Natural ), - NaturalIsZero | NaturalEven | NaturalOdd => dhall::expr!( + NaturalIsZero | NaturalEven | NaturalOdd => make_type!( Natural -> Bool ), - NaturalToInteger => dhall::expr!(Natural -> Integer), - NaturalShow => dhall::expr!(Natural -> Text), - NaturalSubtract => dhall::expr!(Natural -> Natural -> Natural), + NaturalToInteger => make_type!(Natural -> Integer), + NaturalShow => make_type!(Natural -> Text), + NaturalSubtract => make_type!(Natural -> Natural -> Natural), - IntegerToDouble => dhall::expr!(Integer -> Double), - IntegerShow => dhall::expr!(Integer -> Text), - DoubleShow => dhall::expr!(Double -> Text), - TextShow => dhall::expr!(Text -> Text), + IntegerToDouble => make_type!(Integer -> Double), + IntegerShow => make_type!(Integer -> Text), + DoubleShow => make_type!(Double -> Text), + TextShow => make_type!(Text -> Text), - ListBuild => dhall::expr!( + ListBuild => make_type!( forall (a: Type) -> (forall (list: Type) -> forall (cons: a -> list -> list) -> @@ -215,28 +270,28 @@ fn type_of_builtin(b: Builtin) -> Expr { list) -> List a ), - ListFold => dhall::expr!( + ListFold => make_type!( forall (a: Type) -> - List a -> + (List a) -> forall (list: Type) -> forall (cons: a -> list -> list) -> forall (nil: list) -> list ), - ListLength => dhall::expr!(forall (a: Type) -> List a -> Natural), + ListLength => make_type!(forall (a: Type) -> (List a) -> Natural), ListHead | ListLast => { - dhall::expr!(forall (a: Type) -> List a -> Optional a) + make_type!(forall (a: Type) -> (List a) -> Optional a) } - ListIndexed => dhall::expr!( + ListIndexed => make_type!( forall (a: Type) -> - List a -> + (List a) -> List { index: Natural, value: a } ), - ListReverse => dhall::expr!( - forall (a: Type) -> List a -> List a + ListReverse => make_type!( + forall (a: Type) -> (List a) -> List a ), - OptionalBuild => dhall::expr!( + OptionalBuild => make_type!( forall (a: Type) -> (forall (optional: Type) -> forall (just: a -> optional) -> @@ -244,15 +299,15 @@ fn type_of_builtin(b: Builtin) -> Expr { optional) -> Optional a ), - OptionalFold => dhall::expr!( + OptionalFold => make_type!( forall (a: Type) -> - Optional a -> + (Optional a) -> forall (optional: Type) -> forall (just: a -> optional) -> forall (nothing: optional) -> optional ), - OptionalNone => dhall::expr!( + OptionalNone => make_type!( forall (a: Type) -> Optional a ), } diff --git a/dhall/tests/traits.rs b/dhall/tests/traits.rs index 75eaf75..0f75553 100644 --- a/dhall/tests/traits.rs +++ b/dhall/tests/traits.rs @@ -1,23 +1,18 @@ #![feature(proc_macro_hygiene)] -use dhall::de::{StaticType, Type}; -use dhall_proc_macros::subexpr; -use dhall_syntax::{SubExpr, X}; +use dhall::de::{from_str, StaticType, Type}; #[test] fn test_static_type() { - fn mktype(x: SubExpr) -> Type { - Type::from_normalized_expr(x) + fn parse(s: &str) -> Type { + from_str(s, None).unwrap() } - assert_eq!(bool::static_type(), mktype(subexpr!(Bool))); - assert_eq!(String::static_type(), mktype(subexpr!(Text))); - assert_eq!( - >::static_type(), - mktype(subexpr!(Optional Bool)) - ); + assert_eq!(bool::static_type(), parse("Bool")); + assert_eq!(String::static_type(), parse("Text")); + assert_eq!(>::static_type(), parse("Optional Bool")); assert_eq!( <(bool, Vec)>::static_type(), - mktype(subexpr!({ _1: Bool, _2: List Text })) + parse("{ _1: Bool, _2: List Text }") ); #[derive(dhall::de::StaticType)] @@ -28,7 +23,7 @@ fn test_static_type() { } assert_eq!( ::static_type(), - mktype(subexpr!({ field1: Bool, field2: Optional Bool })) + parse("{ field1: Bool, field2: Optional Bool }") ); #[derive(StaticType)] @@ -52,7 +47,7 @@ fn test_static_type() { struct D(); assert_eq!( >::static_type(), - mktype(subexpr!({ _1: {}, _2: Optional Text })) + parse("{ _1: {}, _2: Optional Text }") ); #[derive(StaticType)] @@ -61,10 +56,7 @@ fn test_static_type() { A(T), B(String), }; - assert_eq!( - >::static_type(), - mktype(subexpr!(< A: Bool | B: Text >)) - ); + assert_eq!(>::static_type(), parse("< A: Bool | B: Text >")); #[derive(StaticType)] #[allow(dead_code)] @@ -72,5 +64,5 @@ fn test_static_type() { A, B(bool), }; - assert_eq!(F::static_type(), mktype(subexpr!(< A | B: Bool >))); + assert_eq!(F::static_type(), parse("< A | B: Bool >")); } diff --git a/dhall_proc_macros/src/lib.rs b/dhall_proc_macros/src/lib.rs index e4aa8b5..5304429 100644 --- a/dhall_proc_macros/src/lib.rs +++ b/dhall_proc_macros/src/lib.rs @@ -6,20 +6,9 @@ extern crate proc_macro; mod derive; -mod quote; use proc_macro::TokenStream; -#[proc_macro] -pub fn expr(input: TokenStream) -> TokenStream { - quote::expr(input) -} - -#[proc_macro] -pub fn subexpr(input: TokenStream) -> TokenStream { - quote::subexpr(input) -} - #[proc_macro_derive(StaticType)] pub fn derive_static_type(input: TokenStream) -> TokenStream { derive::derive_static_type(input) diff --git a/dhall_proc_macros/src/quote.rs b/dhall_proc_macros/src/quote.rs deleted file mode 100644 index 3dbfba9..0000000 --- a/dhall_proc_macros/src/quote.rs +++ /dev/null @@ -1,223 +0,0 @@ -extern crate proc_macro; -use dhall_syntax::context::Context; -use dhall_syntax::*; -use proc_macro2::TokenStream; -use quote::quote; - -pub fn expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream { - let input_str = input.to_string(); - let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap(); - let no_import = - |_: &Import| -> X { panic!("Don't use import in dhall::expr!()") }; - let expr = expr.map_embed(no_import); - let output = quote_expr(expr.as_ref(), &Context::new()); - output.into() -} - -pub fn subexpr(input: proc_macro::TokenStream) -> proc_macro::TokenStream { - let input_str = input.to_string(); - let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap(); - let no_import = - |_: &Import| -> X { panic!("Don't use import in dhall::subexpr!()") }; - let expr = expr.map_embed(no_import); - let output = quote_subexpr(&expr, &Context::new()); - output.into() -} - -// Returns an expression of type ExprF, where T is the -// type of the subexpressions after interpolation. -pub fn quote_exprf(expr: ExprF) -> TokenStream -where - TS: quote::ToTokens + std::fmt::Debug, -{ - use dhall_syntax::ExprF::*; - match expr { - Var(_) => unreachable!(), - Pi(x, t, b) => { - let x = quote_label(&x); - quote! { dhall_syntax::ExprF::Pi(#x, #t, #b) } - } - Lam(x, t, b) => { - let x = quote_label(&x); - quote! { dhall_syntax::ExprF::Lam(#x, #t, #b) } - } - App(f, a) => { - quote! { dhall_syntax::ExprF::App(#f, #a) } - } - Annot(x, t) => { - quote! { dhall_syntax::ExprF::Annot(#x, #t) } - } - Const(c) => { - let c = quote_const(c); - quote! { dhall_syntax::ExprF::Const(#c) } - } - Builtin(b) => { - let b = quote_builtin(b); - quote! { dhall_syntax::ExprF::Builtin(#b) } - } - BinOp(o, a, b) => { - let o = quote_binop(o); - quote! { dhall_syntax::ExprF::BinOp(#o, #a, #b) } - } - NaturalLit(n) => { - quote! { dhall_syntax::ExprF::NaturalLit(#n) } - } - BoolLit(b) => { - quote! { dhall_syntax::ExprF::BoolLit(#b) } - } - SomeLit(x) => { - quote! { dhall_syntax::ExprF::SomeLit(#x) } - } - EmptyListLit(t) => { - quote! { dhall_syntax::ExprF::EmptyListLit(#t) } - } - NEListLit(es) => { - let es = quote_vec(es); - quote! { dhall_syntax::ExprF::NEListLit(#es) } - } - RecordType(m) => { - let m = quote_map(m); - quote! { dhall_syntax::ExprF::RecordType(#m) } - } - RecordLit(m) => { - let m = quote_map(m); - quote! { dhall_syntax::ExprF::RecordLit(#m) } - } - UnionType(m) => { - let m = quote_opt_map(m); - quote! { dhall_syntax::ExprF::UnionType(#m) } - } - e => unimplemented!("{:?}", e), - } -} - -// Returns an expression of type SubExpr<_, _>. Expects interpolated variables -// to be of type SubExpr<_, _>. -fn quote_subexpr( - expr: &SubExpr, - ctx: &Context, -) -> TokenStream { - use dhall_syntax::ExprF::*; - match expr.as_ref().map_ref_with_special_handling_of_binders( - |e| quote_subexpr(e, ctx), - |l, e| quote_subexpr(e, &ctx.insert(l.clone(), ())), - |_| unreachable!(), - ) { - Var(V(ref s, n)) => { - match ctx.lookup(s, n) { - // Non-free variable; interpolates as itself - Some(()) => { - let s: String = s.into(); - let var = quote! { dhall_syntax::V(#s.into(), #n) }; - rc(quote! { dhall_syntax::ExprF::Var(#var) }) - } - // Free variable; interpolates as a rust variable - None => { - let s: String = s.into(); - // TODO: insert appropriate shifts ? - let v: TokenStream = s.parse().unwrap(); - quote! { { - let x: dhall_syntax::SubExpr<_, _> = #v.clone(); - x - } } - } - } - } - e => rc(quote_exprf(e)), - } -} - -// Returns an expression of type Expr<_, _>. Expects interpolated variables -// to be of type SubExpr<_, _>. -fn quote_expr(expr: &Expr, ctx: &Context) -> TokenStream { - use dhall_syntax::ExprF::*; - match expr.map_ref_with_special_handling_of_binders( - |e| quote_subexpr(e, ctx), - |l, e| quote_subexpr(e, &ctx.insert(l.clone(), ())), - |_| unreachable!(), - ) { - Var(V(ref s, n)) => { - match ctx.lookup(s, n) { - // Non-free variable; interpolates as itself - Some(()) => { - let s: String = s.into(); - let var = quote! { dhall_syntax::V(#s.into(), #n) }; - quote! { dhall_syntax::ExprF::Var(#var) } - } - // Free variable; interpolates as a rust variable - None => { - let s: String = s.into(); - // TODO: insert appropriate shifts ? - let v: TokenStream = s.parse().unwrap(); - quote! { { - let x: dhall_syntax::SubExpr<_, _> = #v.clone(); - x.unroll() - } } - } - } - } - e => quote_exprf(e), - } -} - -fn quote_builtin(b: Builtin) -> TokenStream { - format!("::dhall_syntax::Builtin::{:?}", b).parse().unwrap() -} - -fn quote_const(c: Const) -> TokenStream { - format!("::dhall_syntax::Const::{:?}", c).parse().unwrap() -} - -fn quote_binop(b: BinOp) -> TokenStream { - format!("::dhall_syntax::BinOp::{:?}", b).parse().unwrap() -} - -fn quote_label(l: &Label) -> TokenStream { - let l = String::from(l); - quote! { dhall_syntax::Label::from(#l) } -} - -fn rc(x: TokenStream) -> TokenStream { - quote! { ::dhall_syntax::rc(#x) } -} - -fn quote_opt(x: Option) -> TokenStream -where - TS: quote::ToTokens + std::fmt::Debug, -{ - match x { - Some(x) => quote!(Some(#x)), - None => quote!(None), - } -} - -fn quote_vec(e: Vec) -> TokenStream -where - TS: quote::ToTokens + std::fmt::Debug, -{ - quote! { vec![ #(#e),* ] } -} - -fn quote_map(m: impl IntoIterator) -> TokenStream -where - TS: quote::ToTokens + std::fmt::Debug, -{ - let entries = m.into_iter().map(|(k, v)| { - let k = quote_label(&k); - quote!(m.insert(#k, #v);) - }); - quote! { { - let mut m = ::dhall_syntax::map::DupTreeMap::new(); - #( #entries )* - m - } } -} - -fn quote_opt_map( - m: impl IntoIterator)>, -) -> TokenStream -where - TS: quote::ToTokens + std::fmt::Debug, -{ - quote_map(m.into_iter().map(|(k, v)| (k, quote_opt(v)))) -} -- cgit v1.3.1 From 2c036f20f9c36a6afb602c6b6c15bc8a81412a6b Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Mon, 12 Aug 2019 22:42:09 +0200 Subject: Remove ensure_... macros in typecheck They weren't worth it --- dhall/src/phase/typecheck.rs | 204 +++++++++++++++++++------------------------ 1 file changed, 89 insertions(+), 115 deletions(-) (limited to 'dhall/src/phase') diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index 8f5ca8b..299997a 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -12,24 +12,6 @@ use crate::core::var::{Shift, Subst}; use crate::error::{TypeError, TypeMessage}; use crate::phase::{Normalized, Resolved, Type, Typed}; -macro_rules! ensure_equal { - ($x:expr, $y:expr, $err:expr $(,)*) => { - if $x.to_value() != $y.to_value() { - return Err($err); - } - }; -} - -// Ensure the provided type has type `Type` -macro_rules! ensure_simple_type { - ($x:expr, $err:expr $(,)*) => {{ - match $x.get_type()?.as_const() { - Some(dhall_syntax::Const::Type) => {} - _ => return Err($err), - } - }}; -} - fn tck_pi_type( ctx: &TypecheckContext, x: Label, @@ -417,6 +399,7 @@ fn type_last_layer( use crate::error::TypeMessage::*; use dhall_syntax::BinOp::*; use dhall_syntax::Builtin::*; + use dhall_syntax::Const::Type; use dhall_syntax::ExprF::*; use Ret::*; let mkerr = |msg: TypeMessage| TypeError::new(ctx, msg); @@ -431,19 +414,21 @@ fn type_last_layer( Value::Pi(x, tx, tb) => (x.clone(), tx.to_type(), tb.to_type()), _ => return Err(mkerr(NotAFunction(f.clone()))), }; - ensure_equal!(a.get_type()?, &tx, { - mkerr(TypeMismatch(f.clone(), tx.to_normalized(), a.clone())) - }); + if a.get_type()?.as_ref() != &tx { + return Err(mkerr(TypeMismatch( + f.clone(), + tx.to_normalized(), + a.clone(), + ))); + } Ok(RetTypeOnly(tb.subst_shift(&x.into(), &a))) } Annot(x, t) => { let t = t.to_type(); - ensure_equal!( - &t, - x.get_type()?, - mkerr(AnnotMismatch(x.clone(), t.to_normalized())) - ); + if &t != x.get_type()?.as_ref() { + return Err(mkerr(AnnotMismatch(x.clone(), t.to_normalized()))); + } Ok(RetTypeOnly(x.get_type()?.into_owned())) } Assert(t) => { @@ -460,27 +445,21 @@ fn type_last_layer( Ok(RetTypeOnly(t.to_type())) } BoolIf(x, y, z) => { - ensure_equal!( - x.get_type()?, - &builtin_to_type(Bool)?, - mkerr(InvalidPredicate(x.clone())), - ); + if x.get_type()?.as_ref() != &builtin_to_type(Bool)? { + return Err(mkerr(InvalidPredicate(x.clone()))); + } - ensure_simple_type!( - y.get_type()?, - mkerr(IfBranchMustBeTerm(true, y.clone())), - ); + if y.get_type()?.get_type()?.as_const() != Some(Type) { + return Err(mkerr(IfBranchMustBeTerm(true, y.clone()))); + } - ensure_simple_type!( - z.get_type()?, - mkerr(IfBranchMustBeTerm(false, z.clone())), - ); + if z.get_type()?.get_type()?.as_const() != Some(Type) { + return Err(mkerr(IfBranchMustBeTerm(false, z.clone()))); + } - ensure_equal!( - y.get_type()?, - z.get_type()?, - mkerr(IfBranchMismatch(y.clone(), z.clone())) - ); + if y.get_type()? != z.get_type()? { + return Err(mkerr(IfBranchMismatch(y.clone(), z.clone()))); + } Ok(RetTypeOnly(y.get_type()?.into_owned())) } @@ -502,45 +481,47 @@ fn type_last_layer( let mut iter = xs.iter().enumerate(); let (_, x) = iter.next().unwrap(); for (i, y) in iter { - ensure_equal!( - x.get_type()?, - y.get_type()?, - mkerr(InvalidListElement( + if x.get_type()? != y.get_type()? { + return Err(mkerr(InvalidListElement( i, x.get_type()?.to_normalized(), - y.clone() - )) - ); + y.clone(), + ))); + } } let t = x.get_type()?; - ensure_simple_type!( - t, - TypeError::new(ctx, InvalidListType(t.to_normalized())), - ); + if t.get_type()?.as_const() != Some(Type) { + return Err(TypeError::new( + ctx, + InvalidListType(t.to_normalized()), + )); + } Ok(RetTypeOnly( Typed::from_thunk_and_type( Value::from_builtin(dhall_syntax::Builtin::List) .app(t.to_value()) .into_thunk(), - Type::from_const(dhall_syntax::Const::Type), + Typed::from_const(Type), ) .to_type(), )) } SomeLit(x) => { let t = x.get_type()?.into_owned(); - ensure_simple_type!( - t, - TypeError::new(ctx, InvalidOptionalType(t.to_normalized())), - ); + if t.get_type()?.as_const() != Some(Type) { + return Err(TypeError::new( + ctx, + InvalidOptionalType(t.to_normalized()), + )); + } Ok(RetTypeOnly( Typed::from_thunk_and_type( Value::from_builtin(dhall_syntax::Builtin::Optional) .app(t.to_value()) .into_thunk(), - Type::from_const(dhall_syntax::Const::Type), + Typed::from_const(Type).into_type(), ) .to_type(), )) @@ -625,11 +606,9 @@ fn type_last_layer( for contents in interpolated.iter() { use InterpolatedTextContents::Expr; if let Expr(x) = contents { - ensure_equal!( - x.get_type()?, - &text_type, - mkerr(InvalidTextInterpolation(x.clone())), - ); + if x.get_type()?.as_ref() != &text_type { + return Err(mkerr(InvalidTextInterpolation(x.clone()))); + } } } Ok(RetTypeOnly(text_type)) @@ -645,11 +624,9 @@ fn type_last_layer( // Check the equality of kinds. // This is to disallow expression such as: // "{ x = Text } // { y = 1 }" - ensure_equal!( - l_kind, - r_kind, - mkerr(RecordMismatch(l.clone(), r.clone())), - ); + if l_kind != r_kind { + return Err(mkerr(RecordMismatch(l.clone(), r.clone()))); + } // Extract the LHS record type let kts_x = match l_type.to_value() { @@ -729,11 +706,9 @@ fn type_last_layer( // Check the equality of kinds. // This is to disallow expression such as: // "{ x = Text } // { y = 1 }" - ensure_equal!( - l_kind, - r_kind, - mkerr(RecordMismatch(l.clone(), r.clone())), - ); + if l_kind != r_kind { + return Err(mkerr(RecordMismatch(l.clone(), r.clone()))); + } // Extract the LHS record type let kts_x = match l_type.to_value() { @@ -855,31 +830,34 @@ fn type_last_layer( _ => return Err(mkerr(BinOpTypeMismatch(*o, l.clone()))), } - ensure_equal!( - l.get_type()?, - r.get_type()?, - mkerr(BinOpTypeMismatch(*o, r.clone())) - ); + if l.get_type()? != r.get_type()? { + return Err(mkerr(BinOpTypeMismatch(*o, r.clone()))); + } Ok(RetTypeOnly(l.get_type()?.into_owned())) } BinOp(Equivalence, l, r) => { - ensure_simple_type!( - l.get_type()?, - mkerr(EquivalenceArgumentMustBeTerm(true, l.clone())), - ); - ensure_simple_type!( - r.get_type()?, - mkerr(EquivalenceArgumentMustBeTerm(false, r.clone())), - ); + if l.get_type()?.get_type()?.as_const() != Some(Type) { + return Err(mkerr(EquivalenceArgumentMustBeTerm( + true, + l.clone(), + ))); + } + if r.get_type()?.get_type()?.as_const() != Some(Type) { + return Err(mkerr(EquivalenceArgumentMustBeTerm( + false, + r.clone(), + ))); + } - ensure_equal!( - l.get_type()?, - r.get_type()?, - mkerr(EquivalenceTypeMismatch(r.clone(), l.clone())) - ); + if l.get_type()? != r.get_type()? { + return Err(mkerr(EquivalenceTypeMismatch( + r.clone(), + l.clone(), + ))); + } - Ok(RetTypeOnly(Type::from_const(dhall_syntax::Const::Type))) + Ok(RetTypeOnly(Typed::from_const(Type).into_type())) } BinOp(o, l, r) => { let t = builtin_to_type(match o { @@ -898,17 +876,13 @@ fn type_last_layer( Equivalence => unreachable!(), })?; - ensure_equal!( - l.get_type()?, - &t, - mkerr(BinOpTypeMismatch(*o, l.clone())) - ); + if l.get_type()?.as_ref() != &t { + return Err(mkerr(BinOpTypeMismatch(*o, l.clone()))); + } - ensure_equal!( - r.get_type()?, - &t, - mkerr(BinOpTypeMismatch(*o, r.clone())) - ); + if r.get_type()?.as_ref() != &t { + return Err(mkerr(BinOpTypeMismatch(*o, r.clone()))); + } Ok(RetTypeOnly(t)) } @@ -937,13 +911,13 @@ fn type_last_layer( _ => return Err(mkerr(NotAFunction(handler_type))), }; - ensure_equal!(&variant_type, &tx, { - mkerr(TypeMismatch( + if &variant_type != &tx { + return Err(mkerr(TypeMismatch( handler_type, tx.to_normalized(), variant_type, - )) - }); + ))); + } // Extract `tb` from under the `x` binder. Fails is `x` was free in `tb`. match tb.over_binder(x) { @@ -966,11 +940,9 @@ fn type_last_layer( match &inferred_type { None => inferred_type = Some(handler_return_type), Some(t) => { - ensure_equal!( - t, - &handler_return_type, - mkerr(MergeHandlerTypeMismatch) - ); + if t != &handler_return_type { + return Err(mkerr(MergeHandlerTypeMismatch)); + } } } } @@ -983,7 +955,9 @@ fn type_last_layer( match (inferred_type, type_annot) { (Some(ref t1), Some(t2)) => { let t2 = t2.to_type(); - ensure_equal!(t1, &t2, mkerr(MergeAnnotMismatch)); + if t1 != &t2 { + return Err(mkerr(MergeAnnotMismatch)); + } Ok(RetTypeOnly(t2)) } (Some(t), None) => Ok(RetTypeOnly(t)), -- cgit v1.3.1