From 569563a564867f120c035323d8b24fff89bd3419 Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Wed, 30 Jun 2021 15:50:50 +0200 Subject: [PATCH] Better error handling; use domains correctly --- .../rust/preserves-schema/src/compiler/mod.rs | 6 +- .../preserves-schema/src/compiler/parsers.rs | 40 ++- .../src/compiler/unparsers.rs | 2 +- .../rust/preserves-schema/src/gen/schema.rs | 295 ++++++++++-------- .../rust/preserves-schema/src/support/mod.rs | 45 +++ 5 files changed, 232 insertions(+), 156 deletions(-) diff --git a/implementations/rust/preserves-schema/src/compiler/mod.rs b/implementations/rust/preserves-schema/src/compiler/mod.rs index 761f4e8..3431f8d 100644 --- a/implementations/rust/preserves-schema/src/compiler/mod.rs +++ b/implementations/rust/preserves-schema/src/compiler/mod.rs @@ -117,13 +117,15 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> { let mut lines: Vec = Vec::new(); lines.push("#![allow(unused_parens)]".to_owned()); + lines.push("#![allow(unused_imports)]".to_owned()); lines.push("".to_owned()); lines.push("use std::convert::TryFrom;".to_owned()); + lines.push("use preserves::value::Domain;".to_owned()); lines.push("use preserves::value::NestedValue;".to_owned()); - lines.push(format!("use {}::support::*;", &config.support_crate)); + lines.push(format!("use {}::support as _support;", &config.support_crate)); lines.push("".to_owned()); - lines.push("lazy_static! {".to_owned()); + lines.push("_support::lazy_static! {".to_owned()); for (value, name) in m.literals { let bs = preserves::value::PackedWriter::encode(&value.to_io_value()).unwrap(); lines.push(format!(" pub static ref {}: preserves::value::IOValue = /* {:?} */ preserves::value::packed::from_bytes(&vec!{:?}).unwrap();", diff --git a/implementations/rust/preserves-schema/src/compiler/parsers.rs b/implementations/rust/preserves-schema/src/compiler/parsers.rs index 4f05427..6aa63a5 100644 --- a/implementations/rust/preserves-schema/src/compiler/parsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs @@ -27,12 +27,12 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) { let dest = dest.as_ref().map(String::as_str); construct(&ctxt, ctorname, false, &pattern_type(pat), dest, &mut body); item(seq!["fn ", fname.clone(), "(value: &preserves::value::IOValue) -> ", - "std::result::Result<", names::render_constructor(n), ", ()> ", + "std::result::Result<", names::render_constructor(n), ", _support::ParseError> ", block(body)]) }); body.push(item(seq!["if let Ok(r) = ", fname, "(value) { return Ok(r); }"])); } - body.push(item(seq!["Err(())"])); + body.push(item(seq!["Err(_support::ParseError::ConformanceError)"])); } Definition::And { pattern_0, pattern_1, pattern_n } => { let mut ps = vec![&**pattern_0, &**pattern_1]; @@ -51,7 +51,7 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) { item(seq!["impl std::convert::TryFrom", anglebrackets!["preserves::value::IOValue"], " for ", names::render_constructor(n), " ", block![ - seq!["type Error = ();"], + seq!["type Error = _support::ParseError;"], seq!["fn try_from(value: preserves::value::IOValue) -> ", "std::result::Result ", block(body)]]]) @@ -95,8 +95,6 @@ fn store_wrap(is_struct: bool, ty: &TField, expr: &str) -> String { } } -const MAP_ERR_Q: &str = ".map_err(|_| ())?"; - fn simple_pattern_parser( ctxt: &mut FunctionContext, p: &SimplePattern, @@ -107,7 +105,7 @@ fn simple_pattern_parser( let dest = ctxt.gentempname(); match p { SimplePattern::Any => { - push_let(body, item(dest.to_owned()), item(seq!["_Any::from_io_value", parens![src.to_owned()], MAP_ERR_Q])); + push_let(body, item(dest.to_owned()), item(seq!["_Any::from_io_value", parens![src.to_owned()], "?"])); dest }, SimplePattern::Atom { atom_kind: k } => { @@ -120,16 +118,19 @@ fn simple_pattern_parser( AtomKind::ByteString => "to_bytestring", AtomKind::Symbol => "to_symbol", }; - push_let(body, item(dest.to_owned()), item(seq![src.to_owned(), ".value().", converter, "()", MAP_ERR_Q])); + push_let(body, item(dest.to_owned()), item(seq![src.to_owned(), ".value().", converter, "()?"])); dest }, SimplePattern::Embedded { .. } => { - push_let(body, item(dest.to_owned()), item(seq![src.to_owned(), ".value().to_embedded()", MAP_ERR_Q])); + push_let(body, item(dest.to_owned()), item(seq![ + "_Ptr::from_preserves", + parens![seq![src.to_owned(), ".value().to_embedded()?", ".clone()"]], + "?"])); dest }, SimplePattern::Lit { value } => { body.push(item(seq!["if ", src.to_owned(), " != ", ctxt.m.define_literal(value), - " { return Err(()); }"])); + " { return Err(_support::ParseError::ConformanceError); }"])); push_let(body, item(dest.to_owned()), item("()")); dest }, @@ -154,7 +155,7 @@ fn simple_pattern_parser( store_wrap(true, &field_type(pattern), &item_dest), ");"])); push_let_mut(body, item(dest.to_owned()), item("preserves::value::Set::new()")); body.push(item(seq!["for ", tmp.to_owned(), - " in ", src.to_owned(), ".value().to_set()", MAP_ERR_Q, + " in ", src.to_owned(), ".value().to_set()?", " ", block(inner)])); dest }, @@ -170,7 +171,7 @@ fn simple_pattern_parser( store_wrap(true, &field_type(value), &value_dest), ");"])); push_let_mut(body, item(dest.to_owned()), item("preserves::value::Map::new()")); body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")", - " in ", src.to_owned(), ".value().to_dictionary()", MAP_ERR_Q, + " in ", src.to_owned(), ".value().to_dictionary()?", " ", block(inner)])); dest }, @@ -196,7 +197,7 @@ fn sequenceify( let tmp = ctxt.gentempname(); push_let(body, item(tmp.to_owned()), - item(seq![src.to_owned(), ".value().to_sequence()", MAP_ERR_Q])); + item(seq![src.to_owned(), ".value().to_sequence()?"])); (tmp, 0) } } @@ -210,8 +211,13 @@ fn fixed_sequence_parser( body: &mut Vec, ) { let mut i = base; - body.push(item(seq!["if ", src.to_owned(), ".len() - ", base.to_string(), " < ", - ps.len().to_string(), " { return Err(()); }"])); + let required_count = ps.len(); + if required_count > 0 { + body.push(item(seq!["if ", src.to_owned(), ".len()", + if base > 0 { seq![" - ", base.to_string()] } else { seq![] }, + " < ", required_count.to_string(), + " { return Err(_support::ParseError::ConformanceError); }"])); + } for p in ps { named_pattern_parser(ctxt, p, &format!("(&{}[{}])", src, i), None, body); i += 1; @@ -252,7 +258,7 @@ fn pattern_parser( match &**c { CompoundPattern::Rec { label, fields } => { let rtmp = ctxt.gentempname(); - push_let(body, item(rtmp.to_owned()), item(seq![src.to_owned(), ".value().to_record(None)", MAP_ERR_Q])); + push_let(body, item(rtmp.to_owned()), item(seq![src.to_owned(), ".value().to_record(None)?"])); named_pattern_parser(ctxt, &**label, &format!("{}.label()", rtmp), None, body); named_pattern_parser(ctxt, &**fields, &format!("{}.fields()", rtmp), Some(0), body); }, @@ -267,12 +273,12 @@ fn pattern_parser( }, CompoundPattern::Dict { entries } => { let dtmp = ctxt.gentempname(); - push_let(body, item(dtmp.to_owned()), item(seq![src.to_owned(), ".value().to_dictionary()", MAP_ERR_Q])); + push_let(body, item(dtmp.to_owned()), item(seq![src.to_owned(), ".value().to_dictionary()?"])); for (key_lit, value_pat) in entries.0.iter() { let vtmp = ctxt.gentempname(); push_let(body, item(vtmp.to_owned()), item(seq![ dtmp.to_owned(), ".get", parens![ctxt.m.define_literal(key_lit)], - ".ok_or(())?"])); + ".ok_or(_support::ParseError::ConformanceError)?"])); named_pattern_parser(ctxt, &promote(value_pat), &vtmp, None, body); } } diff --git a/implementations/rust/preserves-schema/src/compiler/unparsers.rs b/implementations/rust/preserves-schema/src/compiler/unparsers.rs index 78deade..9a7326f 100644 --- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs @@ -133,7 +133,7 @@ fn simple_pattern_unparser( } } SimplePattern::Embedded { .. } => - item(seq!["preserves::value::Value::Domain(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]), + item(seq!["preserves::value::Value::Domain(", src.as_ref().unwrap().to_owned(), ".as_preserves()).wrap()"]), SimplePattern::Lit { value } => item(seq![parens![ctxt.m.define_literal(value)], ".clone()"]), SimplePattern::Seqof { pattern } => { diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs index 973be38..66dda6a 100644 --- a/implementations/rust/preserves-schema/src/gen/schema.rs +++ b/implementations/rust/preserves-schema/src/gen/schema.rs @@ -1,10 +1,12 @@ #![allow(unused_parens)] +#![allow(unused_imports)] use std::convert::TryFrom; +use preserves::value::Domain; use preserves::value::NestedValue; -use crate::support::*; +use crate::support as _support; -lazy_static! { +_support::lazy_static! { pub static ref LIT15: preserves::value::IOValue = /* #f */ preserves::value::packed::from_bytes(&vec![128]).unwrap(); pub static ref LIT28: preserves::value::IOValue = /* 1 */ preserves::value::packed::from_bytes(&vec![145]).unwrap(); pub static ref LIT0: preserves::value::IOValue = /* Boolean */ preserves::value::packed::from_bytes(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).unwrap(); @@ -130,30 +132,50 @@ pub enum SimplePattern { #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub struct Version; -fn _parse_atom_kind_boolean(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT0 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Boolean)} +fn _parse_atom_kind_boolean(value: &preserves::value::IOValue) -> std::result::Result { + if value != &*LIT0 { return Err(_support::ParseError::ConformanceError); } + let _tmp0 = (); + Ok(AtomKind::Boolean) +} -fn _parse_atom_kind_float(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT1 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Float)} +fn _parse_atom_kind_float(value: &preserves::value::IOValue) -> std::result::Result { + if value != &*LIT1 { return Err(_support::ParseError::ConformanceError); } + let _tmp0 = (); + Ok(AtomKind::Float) +} -fn _parse_atom_kind_double(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT2 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Double)} +fn _parse_atom_kind_double(value: &preserves::value::IOValue) -> std::result::Result { + if value != &*LIT2 { return Err(_support::ParseError::ConformanceError); } + let _tmp0 = (); + Ok(AtomKind::Double) +} -fn _parse_atom_kind_signed_integer(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT3 { return Err(()); } +fn _parse_atom_kind_signed_integer(value: &preserves::value::IOValue) -> std::result::Result { + if value != &*LIT3 { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(AtomKind::SignedInteger) } -fn _parse_atom_kind_string(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT4 { return Err(()); } let _tmp0 = (); Ok(AtomKind::String)} +fn _parse_atom_kind_string(value: &preserves::value::IOValue) -> std::result::Result { + if value != &*LIT4 { return Err(_support::ParseError::ConformanceError); } + let _tmp0 = (); + Ok(AtomKind::String) +} -fn _parse_atom_kind_byte_string(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT5 { return Err(()); } +fn _parse_atom_kind_byte_string(value: &preserves::value::IOValue) -> std::result::Result { + if value != &*LIT5 { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(AtomKind::ByteString) } -fn _parse_atom_kind_symbol(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT6 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Symbol)} +fn _parse_atom_kind_symbol(value: &preserves::value::IOValue) -> std::result::Result { + if value != &*LIT6 { return Err(_support::ParseError::ConformanceError); } + let _tmp0 = (); + Ok(AtomKind::Symbol) +} impl std::convert::TryFrom for AtomKind { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; if let Ok(r) = _parse_atom_kind_boolean(value) { return Ok(r); } @@ -163,7 +185,7 @@ impl std::convert::TryFrom for AtomKind { if let Ok(r) = _parse_atom_kind_string(value) { return Ok(r); } if let Ok(r) = _parse_atom_kind_byte_string(value) { return Ok(r); } if let Ok(r) = _parse_atom_kind_symbol(value) { return Ok(r); } - Err(()) + Err(_support::ParseError::ConformanceError) } } @@ -182,14 +204,14 @@ impl std::convert::From<&AtomKind> for preserves::value::IOValue { } impl std::convert::TryFrom for Binding { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT7 { return Err(()); } + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT7 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 2 { return Err(()); } - let _tmp2 = (&_tmp0.fields()[0]).value().to_symbol().map_err(|_| ())?; + if _tmp0.fields().len() < 2 { return Err(_support::ParseError::ConformanceError); } + let _tmp2 = (&_tmp0.fields()[0]).value().to_symbol()?; let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]).clone())?; Ok(Binding {name: _tmp2.clone(), pattern: _tmp3}) } @@ -208,13 +230,13 @@ impl std::convert::From<&Binding> for preserves::value::IOValue { } impl std::convert::TryFrom for Bundle { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT8 { return Err(()); } + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT8 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = Modules::try_from((&_tmp0.fields()[0]).clone())?; Ok(Bundle {modules: _tmp2}) } @@ -231,57 +253,57 @@ impl std::convert::From<&Bundle> for preserves::value::IOValue { } } -fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT9 { return Err(()); } +fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT9 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 2 { return Err(()); } + if _tmp0.fields().len() < 2 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = NamedPattern::try_from((&_tmp0.fields()[0]).clone())?; let _tmp3 = NamedPattern::try_from((&_tmp0.fields()[1]).clone())?; Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)}) } -fn _parse_compound_pattern_tuple(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT10 { return Err(()); } +fn _parse_compound_pattern_tuple(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT10 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?; + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } + let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence()?; let mut _tmp2 = std::vec::Vec::new(); for _tmp4 in &_tmp3[0..] {let _tmp5 = NamedPattern::try_from(_tmp4.clone())?; _tmp2.push(_tmp5);} Ok(CompoundPattern::Tuple {patterns: _tmp2}) } -fn _parse_compound_pattern_tuple_prefix(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT11 { return Err(()); } +fn _parse_compound_pattern_tuple_prefix(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT11 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 2 { return Err(()); } - let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?; + if _tmp0.fields().len() < 2 { return Err(_support::ParseError::ConformanceError); } + let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence()?; let mut _tmp2 = std::vec::Vec::new(); for _tmp4 in &_tmp3[0..] {let _tmp5 = NamedPattern::try_from(_tmp4.clone())?; _tmp2.push(_tmp5);} let _tmp6 = NamedSimplePattern::try_from((&_tmp0.fields()[1]).clone())?; Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)}) } -fn _parse_compound_pattern_dict(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT12 { return Err(()); } +fn _parse_compound_pattern_dict(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT12 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = DictionaryEntries::try_from((&_tmp0.fields()[0]).clone())?; Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)}) } impl std::convert::TryFrom for CompoundPattern { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; if let Ok(r) = _parse_compound_pattern_rec(value) { return Ok(r); } if let Ok(r) = _parse_compound_pattern_tuple(value) { return Ok(r); } if let Ok(r) = _parse_compound_pattern_tuple_prefix(value) { return Ok(r); } if let Ok(r) = _parse_compound_pattern_dict(value) { return Ok(r); } - Err(()) + Err(_support::ParseError::ConformanceError) } } @@ -326,13 +348,13 @@ impl std::convert::From<&CompoundPattern> for preserves::value::IOValue { } } -fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT13 { return Err(()); } +fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT13 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?; - if _tmp2.len() - 0 < 2 { return Err(()); } + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } + let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?; + if _tmp2.len() < 2 { return Err(_support::ParseError::ConformanceError); } let _tmp3 = NamedAlternative::try_from((&_tmp2[0]).clone())?; let _tmp4 = NamedAlternative::try_from((&_tmp2[1]).clone())?; let mut _tmp5 = std::vec::Vec::new(); @@ -344,13 +366,13 @@ fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Resul }) } -fn _parse_definition_and(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT14 { return Err(()); } +fn _parse_definition_and(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT14 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?; - if _tmp2.len() - 0 < 2 { return Err(()); } + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } + let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?; + if _tmp2.len() < 2 { return Err(_support::ParseError::ConformanceError); } let _tmp3 = NamedPattern::try_from((&_tmp2[0]).clone())?; let _tmp4 = NamedPattern::try_from((&_tmp2[1]).clone())?; let mut _tmp5 = std::vec::Vec::new(); @@ -362,19 +384,19 @@ fn _parse_definition_and(value: &preserves::value::IOValue) -> std::result::Resu }) } -fn _parse_definition_pattern(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_definition_pattern(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = Pattern::try_from(value.clone())?; Ok(Definition::Pattern(std::boxed::Box::new(_tmp0))) } impl std::convert::TryFrom for Definition { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; if let Ok(r) = _parse_definition_or(value) { return Ok(r); } if let Ok(r) = _parse_definition_and(value) { return Ok(r); } if let Ok(r) = _parse_definition_pattern(value) { return Ok(r); } - Err(()) + Err(_support::ParseError::ConformanceError) } } @@ -413,12 +435,12 @@ impl std::convert::From<&Definition> for preserves::value::IOValue { } impl std::convert::TryFrom for Definitions { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; let mut _tmp0 = preserves::value::Map::new(); - for (_tmp1, _tmp2) in value.value().to_dictionary().map_err(|_| ())? { - let _tmp3 = _tmp1.value().to_symbol().map_err(|_| ())?; + for (_tmp1, _tmp2) in value.value().to_dictionary()? { + let _tmp3 = _tmp1.value().to_symbol()?; let _tmp4 = Definition::try_from(_tmp2.clone())?; _tmp0.insert(_tmp3.clone(), _tmp4); } @@ -437,12 +459,12 @@ impl std::convert::From<&Definitions> for preserves::value::IOValue { } impl std::convert::TryFrom for DictionaryEntries { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; let mut _tmp0 = preserves::value::Map::new(); - for (_tmp1, _tmp2) in value.value().to_dictionary().map_err(|_| ())? { - let _tmp3 = _Any::from_io_value(_tmp1).map_err(|_| ())?; + for (_tmp1, _tmp2) in value.value().to_dictionary()? { + let _tmp3 = _Any::from_io_value(_tmp1)?; let _tmp4 = NamedSimplePattern::try_from(_tmp2.clone())?; _tmp0.insert(_tmp3.clone(), _tmp4); } @@ -457,24 +479,24 @@ impl std::convert::From<&DictionaryEntries> for preserves::value::IOValue { } } -fn _parse_embedded_type_name_ref(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_embedded_type_name_ref(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = Ref::try_from(value.clone())?; Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0))) } -fn _parse_embedded_type_name_false(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT15 { return Err(()); } +fn _parse_embedded_type_name_false(value: &preserves::value::IOValue) -> std::result::Result { + if value != &*LIT15 { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(EmbeddedTypeName::False) } impl std::convert::TryFrom for EmbeddedTypeName { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; if let Ok(r) = _parse_embedded_type_name_ref(value) { return Ok(r); } if let Ok(r) = _parse_embedded_type_name_false(value) { return Ok(r); } - Err(()) + Err(_support::ParseError::ConformanceError) } } @@ -488,15 +510,12 @@ impl std::convert::From<&EmbeddedTypeName> for preserves::value::IOValue { } impl std::convert::TryFrom for ModulePath { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; - let _tmp1 = value.value().to_sequence().map_err(|_| ())?; + let _tmp1 = value.value().to_sequence()?; let mut _tmp0 = std::vec::Vec::new(); - for _tmp2 in &_tmp1[0..] { - let _tmp3 = _tmp2.value().to_symbol().map_err(|_| ())?; - _tmp0.push(_tmp3.clone()); - } + for _tmp2 in &_tmp1[0..] {let _tmp3 = _tmp2.value().to_symbol()?; _tmp0.push(_tmp3.clone());} Ok(ModulePath(_tmp0)) } } @@ -513,11 +532,11 @@ impl std::convert::From<&ModulePath> for preserves::value::IOValue { } impl std::convert::TryFrom for Modules { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; let mut _tmp0 = preserves::value::Map::new(); - for (_tmp1, _tmp2) in value.value().to_dictionary().map_err(|_| ())? { + for (_tmp1, _tmp2) in value.value().to_dictionary()? { let _tmp3 = ModulePath::try_from(_tmp1.clone())?; let _tmp4 = Schema::try_from(_tmp2.clone())?; _tmp0.insert(_tmp3, _tmp4); @@ -534,12 +553,12 @@ impl std::convert::From<&Modules> for preserves::value::IOValue { } impl std::convert::TryFrom for NamedAlternative { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; - let _tmp0 = value.value().to_sequence().map_err(|_| ())?; - if _tmp0.len() - 0 < 2 { return Err(()); } - let _tmp1 = (&_tmp0[0]).value().to_string().map_err(|_| ())?; + let _tmp0 = value.value().to_sequence()?; + if _tmp0.len() < 2 { return Err(_support::ParseError::ConformanceError); } + let _tmp1 = (&_tmp0[0]).value().to_string()?; let _tmp2 = Pattern::try_from((&_tmp0[1]).clone())?; Ok(NamedAlternative {variant_label: _tmp1.clone(), pattern: _tmp2}) } @@ -557,23 +576,23 @@ impl std::convert::From<&NamedAlternative> for preserves::value::IOValue { } } -fn _parse_named_pattern_named(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_named_pattern_named(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = Binding::try_from(value.clone())?; Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0))) } -fn _parse_named_pattern_anonymous(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_named_pattern_anonymous(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = Pattern::try_from(value.clone())?; Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0))) } impl std::convert::TryFrom for NamedPattern { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; if let Ok(r) = _parse_named_pattern_named(value) { return Ok(r); } if let Ok(r) = _parse_named_pattern_anonymous(value) { return Ok(r); } - Err(()) + Err(_support::ParseError::ConformanceError) } } @@ -586,23 +605,23 @@ impl std::convert::From<&NamedPattern> for preserves::value::IOValue { } } -fn _parse_named_simple_pattern_named(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_named_simple_pattern_named(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = Binding::try_from(value.clone())?; Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0))) } -fn _parse_named_simple_pattern_anonymous(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_named_simple_pattern_anonymous(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = SimplePattern::try_from(value.clone())?; Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0))) } impl std::convert::TryFrom for NamedSimplePattern { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; if let Ok(r) = _parse_named_simple_pattern_named(value) { return Ok(r); } if let Ok(r) = _parse_named_simple_pattern_anonymous(value) { return Ok(r); } - Err(()) + Err(_support::ParseError::ConformanceError) } } @@ -615,23 +634,23 @@ impl std::convert::From<&NamedSimplePattern> for preserves::value::IOValue { } } -fn _parse_pattern_simple_pattern(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_pattern_simple_pattern(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = SimplePattern::try_from(value.clone())?; Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0))) } -fn _parse_pattern_compound_pattern(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_pattern_compound_pattern(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = CompoundPattern::try_from(value.clone())?; Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0))) } impl std::convert::TryFrom for Pattern { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; if let Ok(r) = _parse_pattern_simple_pattern(value) { return Ok(r); } if let Ok(r) = _parse_pattern_compound_pattern(value) { return Ok(r); } - Err(()) + Err(_support::ParseError::ConformanceError) } } @@ -645,15 +664,15 @@ impl std::convert::From<&Pattern> for preserves::value::IOValue { } impl std::convert::TryFrom for Ref { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT16 { return Err(()); } + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT16 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 2 { return Err(()); } + if _tmp0.fields().len() < 2 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = ModulePath::try_from((&_tmp0.fields()[0]).clone())?; - let _tmp3 = (&_tmp0.fields()[1]).value().to_symbol().map_err(|_| ())?; + let _tmp3 = (&_tmp0.fields()[1]).value().to_symbol()?; Ok(Ref {module: _tmp2, name: _tmp3.clone()}) } } @@ -671,19 +690,19 @@ impl std::convert::From<&Ref> for preserves::value::IOValue { } impl std::convert::TryFrom for Schema { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT17 { return Err(()); } + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT17 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp2 = (&_tmp0.fields()[0]).value().to_dictionary().map_err(|_| ())?; - let _tmp3 = _tmp2.get(&*LIT18).ok_or(())?; + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } + let _tmp2 = (&_tmp0.fields()[0]).value().to_dictionary()?; + let _tmp3 = _tmp2.get(&*LIT18).ok_or(_support::ParseError::ConformanceError)?; let _tmp4 = Definitions::try_from(_tmp3.clone())?; - let _tmp5 = _tmp2.get(&*LIT19).ok_or(())?; + let _tmp5 = _tmp2.get(&*LIT19).ok_or(_support::ParseError::ConformanceError)?; let _tmp6 = EmbeddedTypeName::try_from(_tmp5.clone())?; - let _tmp7 = _tmp2.get(&*LIT20).ok_or(())?; + let _tmp7 = _tmp2.get(&*LIT20).ok_or(_support::ParseError::ConformanceError)?; let _tmp8 = Version::try_from(_tmp7.clone())?; Ok(Schema {definitions: _tmp4, embedded_type: _tmp6, version: _tmp8}) } @@ -708,70 +727,74 @@ impl std::convert::From<&Schema> for preserves::value::IOValue { } } -fn _parse_simple_pattern_any(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)} +fn _parse_simple_pattern_any(value: &preserves::value::IOValue) -> std::result::Result { + if value != &*LIT21 { return Err(_support::ParseError::ConformanceError); } + let _tmp0 = (); + Ok(SimplePattern::Any) +} -fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT22 { return Err(()); } +fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT22 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = AtomKind::try_from((&_tmp0.fields()[0]).clone())?; Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)}) } -fn _parse_simple_pattern_embedded(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT23 { return Err(()); } +fn _parse_simple_pattern_embedded(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT23 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)}) } -fn _parse_simple_pattern_lit(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT24 { return Err(()); } +fn _parse_simple_pattern_lit(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT24 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp2 = _Any::from_io_value((&_tmp0.fields()[0])).map_err(|_| ())?; + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } + let _tmp2 = _Any::from_io_value((&_tmp0.fields()[0]))?; Ok(SimplePattern::Lit {value: _tmp2.clone()}) } -fn _parse_simple_pattern_seqof(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT25 { return Err(()); } +fn _parse_simple_pattern_seqof(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT25 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)}) } -fn _parse_simple_pattern_setof(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT26 { return Err(()); } +fn _parse_simple_pattern_setof(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT26 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 1 { return Err(()); } + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)}) } -fn _parse_simple_pattern_dictof(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = value.value().to_record(None).map_err(|_| ())?; - if _tmp0.label() != &*LIT27 { return Err(()); } +fn _parse_simple_pattern_dictof(value: &preserves::value::IOValue) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*LIT27 { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); - if _tmp0.fields().len() - 0 < 2 { return Err(()); } + if _tmp0.fields().len() < 2 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]).clone())?; Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)}) } -fn _parse_simple_pattern_ref(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_simple_pattern_ref(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = Ref::try_from(value.clone())?; Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0))) } impl std::convert::TryFrom for SimplePattern { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; if let Ok(r) = _parse_simple_pattern_any(value) { return Ok(r); } @@ -782,7 +805,7 @@ impl std::convert::TryFrom for SimplePattern { if let Ok(r) = _parse_simple_pattern_setof(value) { return Ok(r); } if let Ok(r) = _parse_simple_pattern_dictof(value) { return Ok(r); } if let Ok(r) = _parse_simple_pattern_ref(value) { return Ok(r); } - Err(()) + Err(_support::ParseError::ConformanceError) } } @@ -827,10 +850,10 @@ impl std::convert::From<&SimplePattern> for preserves::value::IOValue { } impl std::convert::TryFrom for Version { - type Error = (); + type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; - if value != &*LIT28 { return Err(()); } + if value != &*LIT28 { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(Version) } diff --git a/implementations/rust/preserves-schema/src/support/mod.rs b/implementations/rust/preserves-schema/src/support/mod.rs index c1e2423..1083abb 100644 --- a/implementations/rust/preserves-schema/src/support/mod.rs +++ b/implementations/rust/preserves-schema/src/support/mod.rs @@ -1,2 +1,47 @@ +use std::convert::From; + pub use lazy_static::lazy_static; +#[derive(Debug)] +pub enum ParseError { + ConformanceError, + IO(std::io::Error), + Preserves(preserves::error::Error), +} + +const INPUT_NOT_CONFORMANT: &str = "Input not conformant with Schema"; + +impl std::fmt::Display for ParseError { + fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { + match self { + ParseError::ConformanceError => write!(f, "{}", INPUT_NOT_CONFORMANT), + ParseError::IO(e) => e.fmt(f), + ParseError::Preserves(e) => e.fmt(f), + } + } +} + +impl std::error::Error for ParseError {} + +impl From for ParseError { + fn from(v: std::io::Error) -> Self { + ParseError::IO(v) + } +} + +impl From for ParseError { + fn from(v: preserves::error::Error) -> Self { + ParseError::Preserves(v) + } +} + +impl From for std::io::Error { + fn from(v: ParseError) -> Self { + match v { + ParseError::ConformanceError => + std::io::Error::new(std::io::ErrorKind::InvalidData, INPUT_NOT_CONFORMANT), + ParseError::IO(e) => e, + ParseError::Preserves(e) => e.into(), + } + } +}