syndicate-lang
/
preserves
mirror of https://gitlab.com/preserves/preserves.git
1
0
Fork 1
Code Releases Activity

Better error handling; use domains correctly

This commit is contained in:
Tony Garnock-Jones 2021-06-30 15:50:50 +02:00
parent aea230b056
commit 569563a564
5 changed files with 232 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
implementations/rust/preserves-schema/src/compiler/mod.rs
View File

@ -117,13 +117,15 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> {
let mut lines: Vec<String> = 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();",

40
implementations/rust/preserves-schema/src/compiler/parsers.rs
View File

@ -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<Self, Self::Error> ",
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<Item>,
) {
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);
}
}

2
implementations/rust/preserves-schema/src/compiler/unparsers.rs
View File

@ -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 } => {

295
implementations/rust/preserves-schema/src/gen/schema.rs
View File

@ -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<AtomKind, ()> {if value != &*LIT0 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Boolean)}
fn _parse_atom_kind_boolean(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, _support::ParseError> {
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<AtomKind, ()> {if value != &*LIT1 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Float)}
fn _parse_atom_kind_float(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, _support::ParseError> {
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<AtomKind, ()> {if value != &*LIT2 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Double)}
fn _parse_atom_kind_double(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, _support::ParseError> {
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<AtomKind, ()> {
if value != &*LIT3 { return Err(()); }
fn _parse_atom_kind_signed_integer(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, _support::ParseError> {
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<AtomKind, ()> {if value != &*LIT4 { return Err(()); } let _tmp0 = (); Ok(AtomKind::String)}
fn _parse_atom_kind_string(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, _support::ParseError> {
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<AtomKind, ()> {
if value != &*LIT5 { return Err(()); }
fn _parse_atom_kind_byte_string(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, _support::ParseError> {
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<AtomKind, ()> {if value != &*LIT6 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Symbol)}
fn _parse_atom_kind_symbol(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, _support::ParseError> {
if value != &*LIT6 { return Err(_support::ParseError::ConformanceError); }
let _tmp0 = ();
Ok(AtomKind::Symbol)
}
impl std::convert::TryFrom<preserves::value::IOValue> for AtomKind {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
let value = &value;
if let Ok(r) = _parse_atom_kind_boolean(value) { return Ok(r); }
@ -163,7 +185,7 @@ impl std::convert::TryFrom<preserves::value::IOValue> 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<preserves::value::IOValue> for Binding {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<preserves::value::IOValue> for Bundle {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<CompoundPattern, ()> {
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<CompoundPattern, _support::ParseError> {
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<CompoundPattern, ()> {
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<CompoundPattern, _support::ParseError> {
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<CompoundPattern, ()> {
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<CompoundPattern, _support::ParseError> {
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<CompoundPattern, ()> {
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<CompoundPattern, _support::ParseError> {
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<preserves::value::IOValue> for CompoundPattern {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<Definition, ()> {
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<Definition, _support::ParseError> {
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<Definition, ()> {
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<Definition, _support::ParseError> {
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<Definition, ()> {
fn _parse_definition_pattern(value: &preserves::value::IOValue) -> std::result::Result<Definition, _support::ParseError> {
let _tmp0 = Pattern::try_from(value.clone())?;
Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
}
impl std::convert::TryFrom<preserves::value::IOValue> for Definition {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<preserves::value::IOValue> for Definitions {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<preserves::value::IOValue> for DictionaryEntries {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<EmbeddedTypeName, ()> {
fn _parse_embedded_type_name_ref(value: &preserves::value::IOValue) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
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<EmbeddedTypeName, ()> {
if value != &*LIT15 { return Err(()); }
fn _parse_embedded_type_name_false(value: &preserves::value::IOValue) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
if value != &*LIT15 { return Err(_support::ParseError::ConformanceError); }
let _tmp0 = ();
Ok(EmbeddedTypeName::False)
}
impl std::convert::TryFrom<preserves::value::IOValue> for EmbeddedTypeName {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<preserves::value::IOValue> for ModulePath {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<preserves::value::IOValue> for Modules {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<preserves::value::IOValue> for NamedAlternative {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<NamedPattern, ()> {
fn _parse_named_pattern_named(value: &preserves::value::IOValue) -> std::result::Result<NamedPattern, _support::ParseError> {
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<NamedPattern, ()> {
fn _parse_named_pattern_anonymous(value: &preserves::value::IOValue) -> std::result::Result<NamedPattern, _support::ParseError> {
let _tmp0 = Pattern::try_from(value.clone())?;
Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
}
impl std::convert::TryFrom<preserves::value::IOValue> for NamedPattern {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<NamedSimplePattern, ()> {
fn _parse_named_simple_pattern_named(value: &preserves::value::IOValue) -> std::result::Result<NamedSimplePattern, _support::ParseError> {
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<NamedSimplePattern, ()> {
fn _parse_named_simple_pattern_anonymous(value: &preserves::value::IOValue) -> std::result::Result<NamedSimplePattern, _support::ParseError> {
let _tmp0 = SimplePattern::try_from(value.clone())?;
Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
}
impl std::convert::TryFrom<preserves::value::IOValue> for NamedSimplePattern {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<Pattern, ()> {
fn _parse_pattern_simple_pattern(value: &preserves::value::IOValue) -> std::result::Result<Pattern, _support::ParseError> {
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<Pattern, ()> {
fn _parse_pattern_compound_pattern(value: &preserves::value::IOValue) -> std::result::Result<Pattern, _support::ParseError> {
let _tmp0 = CompoundPattern::try_from(value.clone())?;
Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
}
impl std::convert::TryFrom<preserves::value::IOValue> for Pattern {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<preserves::value::IOValue> for Ref {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<preserves::value::IOValue> for Schema {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
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<SimplePattern, ()> {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)}
fn _parse_simple_pattern_any(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, _support::ParseError> {
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<SimplePattern, ()> {
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<SimplePattern, _support::ParseError> {
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<SimplePattern, ()> {
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<SimplePattern, _support::ParseError> {
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<SimplePattern, ()> {
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<SimplePattern, _support::ParseError> {
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<SimplePattern, ()> {
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<SimplePattern, _support::ParseError> {
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<SimplePattern, ()> {
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<SimplePattern, _support::ParseError> {
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<SimplePattern, ()> {
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<SimplePattern, _support::ParseError> {
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<SimplePattern, ()> {
fn _parse_simple_pattern_ref(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, _support::ParseError> {
let _tmp0 = Ref::try_from(value.clone())?;
Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
}
impl std::convert::TryFrom<preserves::value::IOValue> for SimplePattern {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
let value = &value;
if let Ok(r) = _parse_simple_pattern_any(value) { return Ok(r); }
@ -782,7 +805,7 @@ impl std::convert::TryFrom<preserves::value::IOValue> 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<preserves::value::IOValue> for Version {
type Error = ();
type Error = _support::ParseError;
fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
let value = &value;
if value != &*LIT28 { return Err(()); }
if value != &*LIT28 { return Err(_support::ParseError::ConformanceError); }
let _tmp0 = ();
Ok(Version)
}

45
implementations/rust/preserves-schema/src/support/mod.rs
View File

@ -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<std::io::Error> for ParseError {
fn from(v: std::io::Error) -> Self {
ParseError::IO(v)
}
}
impl From<preserves::error::Error> for ParseError {
fn from(v: preserves::error::Error) -> Self {
ParseError::Preserves(v)
}
}
impl From<ParseError> 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(),
}
}
}