From eafc22fb1c749c5638e0d24b5db65fb5b29c6a7f Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Thu, 12 Aug 2021 15:23:37 -0400 Subject: [PATCH] Compiler plugins (hardcoded to begin with) --- .../preserves-schema/src/compiler/context.rs | 12 +- .../rust/preserves-schema/src/compiler/mod.rs | 36 +- .../preserves-schema/src/compiler/parsers.rs | 14 +- .../preserves-schema/src/compiler/readers.rs | 10 + .../preserves-schema/src/compiler/types.rs | 12 + .../src/compiler/unparsers.rs | 14 +- .../rust/preserves-schema/src/gen/schema.rs | 1038 ++++++++--------- 7 files changed, 600 insertions(+), 536 deletions(-) diff --git a/implementations/rust/preserves-schema/src/compiler/context.rs b/implementations/rust/preserves-schema/src/compiler/context.rs index 7101ebf..874a917 100644 --- a/implementations/rust/preserves-schema/src/compiler/context.rs +++ b/implementations/rust/preserves-schema/src/compiler/context.rs @@ -28,7 +28,7 @@ pub struct ModuleContext<'m> { pub literals: Map<_Any, String>, pub typedefs: Vec, pub functiondefs: Vec, - pub mode: ModuleContextMode, + pub mode: Option, } pub struct FunctionContext<'a, 'm> { @@ -62,7 +62,7 @@ impl<'m> ModuleContext<'m> { literals: Map::new(), typedefs: Vec::new(), functiondefs: Vec::new(), - mode: ModuleContextMode::TargetIOValue, + mode: None, } } @@ -105,15 +105,19 @@ impl<'m> ModuleContext<'m> { } } + pub fn mode(&self) -> ModuleContextMode { + self.mode.expect("defined ModuleContextMode") + } + pub fn target(&self) -> &'static str { - match self.mode { + match self.mode() { ModuleContextMode::TargetIOValue => "preserves::value::IOValue", ModuleContextMode::TargetAny => "_Any", } } pub fn target_prefix(&self) -> &'static str { - match self.mode { + match self.mode() { ModuleContextMode::TargetIOValue => "_io_", ModuleContextMode::TargetAny => "_any_", } diff --git a/implementations/rust/preserves-schema/src/compiler/mod.rs b/implementations/rust/preserves-schema/src/compiler/mod.rs index 8c5cc8b..74fa0bf 100644 --- a/implementations/rust/preserves-schema/src/compiler/mod.rs +++ b/implementations/rust/preserves-schema/src/compiler/mod.rs @@ -28,6 +28,15 @@ use std::path::PathBuf; pub type ModulePath = Vec; +pub trait Plugin { + fn generate( + &mut self, + module_ctxt: &mut context::ModuleContext, + definition_name: &str, + definition: &Definition, + ); +} + #[derive(Debug)] pub struct CompilerConfig { pub bundle: Map, @@ -135,16 +144,24 @@ pub fn compile(config: &CompilerConfig) -> io::Result<()> { let modes = modes; // rebind as non-mutable + let mut plugins: Vec> = vec![ + Box::new(types::TypePlugin), + Box::new(readers::ReaderPlugin), + Box::new(parsers::ParserPlugin), + Box::new(unparsers::UnparserPlugin), + ]; + for (n, d) in &v.definitions.0 { - m.define_type(item(types::render_definition_type(&m, n, &types::definition_type(d)))); - m.define_type(item(seq!["impl preserves::value::Domain for ", - names::render_constructor(n), " {}"])); - for mode in &modes { - m.mode = *mode; - parsers::gen_definition_parser(&mut m, n, d); - unparsers::gen_definition_unparser(&mut m, n, d); + for plugin in plugins.iter_mut() { + plugin.generate(&mut m, n, d); } - readers::gen_definition_reader(&mut m, n, d); + for mode in &modes { + m.mode = Some(*mode); + for plugin in plugins.iter_mut() { + plugin.generate(&mut m, n, d); + } + } + m.mode = None; } //--------------------------------------------------------------------------- @@ -162,7 +179,7 @@ pub fn compile(config: &CompilerConfig) -> io::Result<()> { lines.push("".to_owned()); for mode in &modes { - m.mode = *mode; + m.mode = Some(*mode); lines.push(format!("mod {} {{", m.target_prefix())); lines.push(" use super::_Any;".to_owned()); lines.push(format!(" use {}::support as _support;", &config.support_crate)); @@ -180,6 +197,7 @@ pub fn compile(config: &CompilerConfig) -> io::Result<()> { lines.push("}".to_owned()); lines.push("".to_owned()); } + m.mode = None; for i in m.typedefs { lines.push(Formatter::to_string(i)); diff --git a/implementations/rust/preserves-schema/src/compiler/parsers.rs b/implementations/rust/preserves-schema/src/compiler/parsers.rs index 3f68bd1..81fa283 100644 --- a/implementations/rust/preserves-schema/src/compiler/parsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs @@ -7,6 +7,16 @@ use super::context::{ModuleContextMode, ModuleContext, FunctionContext}; use super::names; use super::types::*; +pub struct ParserPlugin; + +impl compiler::Plugin for ParserPlugin { + fn generate(&mut self, module_ctxt: &mut ModuleContext, definition_name: &str, definition: &Definition) { + if module_ctxt.mode.is_some() { + gen_definition_parser(module_ctxt, definition_name, definition) + } + } +} + pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) { m.define_function( n, @@ -107,7 +117,7 @@ fn simple_pattern_parser( let dest = ctxt.gentempname(); match p { SimplePattern::Any => { - match ctxt.m.mode { + match ctxt.m.mode() { ModuleContextMode::TargetIOValue => ctxt.define_atom(body, &dest, item(seq!["_support::decode_embedded", parens![src.to_owned()], "?"])), ModuleContextMode::TargetAny => @@ -129,7 +139,7 @@ fn simple_pattern_parser( dest }, SimplePattern::Embedded { .. } => { - match ctxt.m.mode { + match ctxt.m.mode() { ModuleContextMode::TargetIOValue => ctxt.define_atom(body, &dest, item(seq![ "std::sync::Arc::new(_Dom::try_from", diff --git a/implementations/rust/preserves-schema/src/compiler/readers.rs b/implementations/rust/preserves-schema/src/compiler/readers.rs index 1605110..51f4db9 100644 --- a/implementations/rust/preserves-schema/src/compiler/readers.rs +++ b/implementations/rust/preserves-schema/src/compiler/readers.rs @@ -14,6 +14,16 @@ use super::context::{ModuleContext, FunctionContext}; use super::names; use super::types::*; +pub struct ReaderPlugin; + +impl compiler::Plugin for ReaderPlugin { + fn generate(&mut self, module_ctxt: &mut ModuleContext, definition_name: &str, definition: &Definition) { + if module_ctxt.mode.is_none() { + gen_definition_reader(module_ctxt, definition_name, definition) + } + } +} + #[derive(Clone)] struct BoundaryTracker { tracker_name: String, diff --git a/implementations/rust/preserves-schema/src/compiler/types.rs b/implementations/rust/preserves-schema/src/compiler/types.rs index 85e1aff..309230a 100644 --- a/implementations/rust/preserves-schema/src/compiler/types.rs +++ b/implementations/rust/preserves-schema/src/compiler/types.rs @@ -31,6 +31,18 @@ pub enum TField { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)] pub struct TRecord(pub Vec<(String, TField)>); +pub struct TypePlugin; + +impl compiler::Plugin for TypePlugin { + fn generate(&mut self, m: &mut ModuleContext, n: &str, d: &Definition) { + if m.mode.is_none() { + m.define_type(item(render_definition_type(m, n, &definition_type(d)))); + m.define_type(item(seq![ + "impl preserves::value::Domain for ", names::render_constructor(n), " {}"])); + } + } +} + pub fn definition_type(d: &Definition) -> TDefinition { match d { Definition::Or { pattern_0, pattern_1, pattern_n } => diff --git a/implementations/rust/preserves-schema/src/compiler/unparsers.rs b/implementations/rust/preserves-schema/src/compiler/unparsers.rs index 2fab59a..b4a23b8 100644 --- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs @@ -10,6 +10,16 @@ use super::context::{ModuleContextMode, ModuleContext, FunctionContext}; use super::names; use super::types::*; +pub struct UnparserPlugin; + +impl compiler::Plugin for UnparserPlugin { + fn generate(&mut self, module_ctxt: &mut ModuleContext, definition_name: &str, definition: &Definition) { + if module_ctxt.mode.is_some() { + gen_definition_unparser(module_ctxt, definition_name, definition) + } + } +} + type ValueSource = Option; #[derive(Clone)] @@ -121,7 +131,7 @@ fn simple_pattern_unparser( let src = &vc.src; match p { SimplePattern::Any => { - match ctxt.m.mode { + match ctxt.m.mode() { ModuleContextMode::TargetIOValue => item(seq!["_support::encode_embedded", parens![src.as_ref().unwrap().to_owned()]]), ModuleContextMode::TargetAny => @@ -139,7 +149,7 @@ fn simple_pattern_unparser( } } SimplePattern::Embedded { .. } => { - match ctxt.m.mode { + match ctxt.m.mode() { ModuleContextMode::TargetIOValue => item(seq!["preserves::value::Value::Embedded(preserves::value::IOValue::from(&**", src.as_ref().unwrap().to_owned(), ")).wrap()"]), ModuleContextMode::TargetAny => diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs index a4fc2b7..452b2b3 100644 --- a/implementations/rust/preserves-schema/src/gen/schema.rs +++ b/implementations/rust/preserves-schema/src/gen/schema.rs @@ -173,76 +173,6 @@ pub struct Version; impl preserves::value::Domain for Version {} -fn _any_parse_atom_kind_boolean(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_0_BOOLEAN { return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean")); } - let _tmp0 = (); - Ok(AtomKind::Boolean) -} - -fn _any_parse_atom_kind_float(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_1_FLOAT { return Err(_support::ParseError::conformance_error("schema.AtomKind::Float")); } - let _tmp0 = (); - Ok(AtomKind::Float) -} - -fn _any_parse_atom_kind_double(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_2_DOUBLE { return Err(_support::ParseError::conformance_error("schema.AtomKind::Double")); } - let _tmp0 = (); - Ok(AtomKind::Double) -} - -fn _any_parse_atom_kind_signed_integer(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_3_SIGNED_INTEGER { return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger")); } - let _tmp0 = (); - Ok(AtomKind::SignedInteger) -} - -fn _any_parse_atom_kind_string(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_4_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::String")); } - let _tmp0 = (); - Ok(AtomKind::String) -} - -fn _any_parse_atom_kind_byte_string(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_5_BYTE_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString")); } - let _tmp0 = (); - Ok(AtomKind::ByteString) -} - -fn _any_parse_atom_kind_symbol(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_6_SYMBOL { return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol")); } - let _tmp0 = (); - Ok(AtomKind::Symbol) -} - -impl std::convert::TryFrom<&_Any> for AtomKind { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_atom_kind_boolean(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_float(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_double(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_signed_integer(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_string(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_byte_string(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_symbol(value) { return Ok(r); } - Err(_support::ParseError::conformance_error("schema.AtomKind")) - } -} - -impl std::convert::From<&AtomKind> for _Any { - fn from(value: &AtomKind) -> Self { - match value { - AtomKind::Boolean => (&*_any_::LIT_0_BOOLEAN).clone(), - AtomKind::Float => (&*_any_::LIT_1_FLOAT).clone(), - AtomKind::Double => (&*_any_::LIT_2_DOUBLE).clone(), - AtomKind::SignedInteger => (&*_any_::LIT_3_SIGNED_INTEGER).clone(), - AtomKind::String => (&*_any_::LIT_4_STRING).clone(), - AtomKind::ByteString => (&*_any_::LIT_5_BYTE_STRING).clone(), - AtomKind::Symbol => (&*_any_::LIT_6_SYMBOL).clone(), - } - } -} - fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { @@ -341,27 +271,72 @@ impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, } } -impl std::convert::TryFrom<&_Any> for Binding { +fn _any_parse_atom_kind_boolean(value: &_Any) -> std::result::Result { + if value != &*_any_::LIT_0_BOOLEAN { return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean")); } + let _tmp0 = (); + Ok(AtomKind::Boolean) +} + +fn _any_parse_atom_kind_float(value: &_Any) -> std::result::Result { + if value != &*_any_::LIT_1_FLOAT { return Err(_support::ParseError::conformance_error("schema.AtomKind::Float")); } + let _tmp0 = (); + Ok(AtomKind::Float) +} + +fn _any_parse_atom_kind_double(value: &_Any) -> std::result::Result { + if value != &*_any_::LIT_2_DOUBLE { return Err(_support::ParseError::conformance_error("schema.AtomKind::Double")); } + let _tmp0 = (); + Ok(AtomKind::Double) +} + +fn _any_parse_atom_kind_signed_integer(value: &_Any) -> std::result::Result { + if value != &*_any_::LIT_3_SIGNED_INTEGER { return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger")); } + let _tmp0 = (); + Ok(AtomKind::SignedInteger) +} + +fn _any_parse_atom_kind_string(value: &_Any) -> std::result::Result { + if value != &*_any_::LIT_4_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::String")); } + let _tmp0 = (); + Ok(AtomKind::String) +} + +fn _any_parse_atom_kind_byte_string(value: &_Any) -> std::result::Result { + if value != &*_any_::LIT_5_BYTE_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString")); } + let _tmp0 = (); + Ok(AtomKind::ByteString) +} + +fn _any_parse_atom_kind_symbol(value: &_Any) -> std::result::Result { + if value != &*_any_::LIT_6_SYMBOL { return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol")); } + let _tmp0 = (); + Ok(AtomKind::Symbol) +} + +impl std::convert::TryFrom<&_Any> for AtomKind { type Error = _support::ParseError; fn try_from(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_7_NAMED { return Err(_support::ParseError::conformance_error("schema.Binding")); } - let _tmp1 = (); - if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.Binding")); } - let _tmp2 = (&_tmp0.fields()[0]).value().to_symbol()?; - let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]))?; - Ok(Binding {name: _tmp2.clone(), pattern: _tmp3}) + if let Ok(r) = _any_parse_atom_kind_boolean(value) { return Ok(r); } + if let Ok(r) = _any_parse_atom_kind_float(value) { return Ok(r); } + if let Ok(r) = _any_parse_atom_kind_double(value) { return Ok(r); } + if let Ok(r) = _any_parse_atom_kind_signed_integer(value) { return Ok(r); } + if let Ok(r) = _any_parse_atom_kind_string(value) { return Ok(r); } + if let Ok(r) = _any_parse_atom_kind_byte_string(value) { return Ok(r); } + if let Ok(r) = _any_parse_atom_kind_symbol(value) { return Ok(r); } + Err(_support::ParseError::conformance_error("schema.AtomKind")) } } -impl std::convert::From<&Binding> for _Any { - fn from(value: &Binding) -> Self { - let Binding {name: _tmp0, pattern: _tmp1} = value; - { - let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_7_NAMED).clone()]); - _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp0).wrap()); - _tmp2.fields_vec_mut().push(_Any::from(_tmp1)); - _tmp2.finish().wrap() +impl std::convert::From<&AtomKind> for _Any { + fn from(value: &AtomKind) -> Self { + match value { + AtomKind::Boolean => (&*_any_::LIT_0_BOOLEAN).clone(), + AtomKind::Float => (&*_any_::LIT_1_FLOAT).clone(), + AtomKind::Double => (&*_any_::LIT_2_DOUBLE).clone(), + AtomKind::SignedInteger => (&*_any_::LIT_3_SIGNED_INTEGER).clone(), + AtomKind::String => (&*_any_::LIT_4_STRING).clone(), + AtomKind::ByteString => (&*_any_::LIT_5_BYTE_STRING).clone(), + AtomKind::Symbol => (&*_any_::LIT_6_SYMBOL).clone(), } } } @@ -391,25 +366,27 @@ impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, } } -impl std::convert::TryFrom<&_Any> for Bundle { +impl std::convert::TryFrom<&_Any> for Binding { type Error = _support::ParseError; fn try_from(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_8_BUNDLE { return Err(_support::ParseError::conformance_error("schema.Bundle")); } + if _tmp0.label() != &*_any_::LIT_7_NAMED { return Err(_support::ParseError::conformance_error("schema.Binding")); } let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Bundle")); } - let _tmp2 = Modules::try_from((&_tmp0.fields()[0]))?; - Ok(Bundle {modules: _tmp2}) + if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.Binding")); } + let _tmp2 = (&_tmp0.fields()[0]).value().to_symbol()?; + let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]))?; + Ok(Binding {name: _tmp2.clone(), pattern: _tmp3}) } } -impl std::convert::From<&Bundle> for _Any { - fn from(value: &Bundle) -> Self { - let Bundle {modules: _tmp0} = value; +impl std::convert::From<&Binding> for _Any { + fn from(value: &Binding) -> Self { + let Binding {name: _tmp0, pattern: _tmp1} = value; { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_8_BUNDLE).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0)); - _tmp1.finish().wrap() + let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_7_NAMED).clone()]); + _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp0).wrap()); + _tmp2.fields_vec_mut().push(_Any::from(_tmp1)); + _tmp2.finish().wrap() } } } @@ -436,96 +413,25 @@ impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, } } -fn _any_parse_compound_pattern_rec(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_9_REC { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); } - let _tmp1 = (); - if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); } - let _tmp2 = NamedPattern::try_from((&_tmp0.fields()[0]))?; - let _tmp3 = NamedPattern::try_from((&_tmp0.fields()[1]))?; - Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)}) -} - -fn _any_parse_compound_pattern_tuple(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_10_TUPLE { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple")); } - let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple")); } - 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)?; _tmp2.push(_tmp5);} - Ok(CompoundPattern::Tuple {patterns: _tmp2}) -} - -fn _any_parse_compound_pattern_tuple_prefix(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_11_TUPLE_PREFIX { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix")); } - let _tmp1 = (); - if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix")); } - 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)?; _tmp2.push(_tmp5);} - let _tmp6 = NamedSimplePattern::try_from((&_tmp0.fields()[1]))?; - Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)}) -} - -fn _any_parse_compound_pattern_dict(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_12_DICT { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); } - let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); } - let _tmp2 = DictionaryEntries::try_from((&_tmp0.fields()[0]))?; - Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)}) -} - -impl std::convert::TryFrom<&_Any> for CompoundPattern { +impl std::convert::TryFrom<&_Any> for Bundle { type Error = _support::ParseError; fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_compound_pattern_rec(value) { return Ok(r); } - if let Ok(r) = _any_parse_compound_pattern_tuple(value) { return Ok(r); } - if let Ok(r) = _any_parse_compound_pattern_tuple_prefix(value) { return Ok(r); } - if let Ok(r) = _any_parse_compound_pattern_dict(value) { return Ok(r); } - Err(_support::ParseError::conformance_error("schema.CompoundPattern")) + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_8_BUNDLE { return Err(_support::ParseError::conformance_error("schema.Bundle")); } + let _tmp1 = (); + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Bundle")); } + let _tmp2 = Modules::try_from((&_tmp0.fields()[0]))?; + Ok(Bundle {modules: _tmp2}) } } -impl std::convert::From<&CompoundPattern> for _Any { - fn from(value: &CompoundPattern) -> Self { - match value { - CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => { - let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_9_REC).clone()]); - _tmp2.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); - _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); - _tmp2.finish().wrap() - }, - CompoundPattern::Tuple {patterns: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_10_TUPLE).clone()]); - _tmp1.fields_vec_mut().push( - { - let mut _tmp2 = std::vec::Vec::new(); - for _tmp3 in _tmp0 {_tmp2.push(_Any::from(_tmp3));} - preserves::value::Value::Sequence(_tmp2).wrap() - } - ); - _tmp1.finish().wrap() - }, - CompoundPattern::TuplePrefix {fixed: _tmp0, variable: _tmp1} => { - let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_11_TUPLE_PREFIX).clone()]); - _tmp2.fields_vec_mut().push( - { - let mut _tmp3 = std::vec::Vec::new(); - for _tmp4 in _tmp0 {_tmp3.push(_Any::from(_tmp4));} - preserves::value::Value::Sequence(_tmp3).wrap() - } - ); - _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); - _tmp2.finish().wrap() - }, - CompoundPattern::Dict {entries: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_12_DICT).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); - _tmp1.finish().wrap() - }, +impl std::convert::From<&Bundle> for _Any { + fn from(value: &Bundle) -> Self { + let Bundle {modules: _tmp0} = value; + { + let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_8_BUNDLE).clone()]); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0)); + _tmp1.finish().wrap() } } } @@ -643,87 +549,96 @@ impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, } } -fn _any_parse_definition_or(value: &_Any) -> std::result::Result { +fn _any_parse_compound_pattern_rec(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_13_OR { return Err(_support::ParseError::conformance_error("schema.Definition::or")); } + if _tmp0.label() != &*_any_::LIT_9_REC { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); } let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Definition::or")); } - let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?; - if _tmp2.len() < 2 { return Err(_support::ParseError::conformance_error("schema.Definition::or")); } - let _tmp3 = NamedAlternative::try_from((&_tmp2[0]))?; - let _tmp4 = NamedAlternative::try_from((&_tmp2[1]))?; - let mut _tmp5 = std::vec::Vec::new(); - for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedAlternative::try_from(_tmp6)?; _tmp5.push(_tmp7);} - Ok(Definition::Or { - pattern_0: std::boxed::Box::new(_tmp3), - pattern_1: std::boxed::Box::new(_tmp4), - pattern_n: _tmp5 - }) + if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); } + let _tmp2 = NamedPattern::try_from((&_tmp0.fields()[0]))?; + let _tmp3 = NamedPattern::try_from((&_tmp0.fields()[1]))?; + Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)}) } -fn _any_parse_definition_and(value: &_Any) -> std::result::Result { +fn _any_parse_compound_pattern_tuple(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_14_AND { return Err(_support::ParseError::conformance_error("schema.Definition::and")); } + if _tmp0.label() != &*_any_::LIT_10_TUPLE { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple")); } let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Definition::and")); } - let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?; - if _tmp2.len() < 2 { return Err(_support::ParseError::conformance_error("schema.Definition::and")); } - let _tmp3 = NamedPattern::try_from((&_tmp2[0]))?; - let _tmp4 = NamedPattern::try_from((&_tmp2[1]))?; - let mut _tmp5 = std::vec::Vec::new(); - for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedPattern::try_from(_tmp6)?; _tmp5.push(_tmp7);} - Ok(Definition::And { - pattern_0: std::boxed::Box::new(_tmp3), - pattern_1: std::boxed::Box::new(_tmp4), - pattern_n: _tmp5 - }) + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple")); } + 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)?; _tmp2.push(_tmp5);} + Ok(CompoundPattern::Tuple {patterns: _tmp2}) } -fn _any_parse_definition_pattern(value: &_Any) -> std::result::Result { - let _tmp0 = Pattern::try_from(value)?; - Ok(Definition::Pattern(std::boxed::Box::new(_tmp0))) +fn _any_parse_compound_pattern_tuple_prefix(value: &_Any) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_11_TUPLE_PREFIX { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix")); } + let _tmp1 = (); + if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix")); } + 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)?; _tmp2.push(_tmp5);} + let _tmp6 = NamedSimplePattern::try_from((&_tmp0.fields()[1]))?; + Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)}) } -impl std::convert::TryFrom<&_Any> for Definition { +fn _any_parse_compound_pattern_dict(value: &_Any) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_12_DICT { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); } + let _tmp1 = (); + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); } + let _tmp2 = DictionaryEntries::try_from((&_tmp0.fields()[0]))?; + Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)}) +} + +impl std::convert::TryFrom<&_Any> for CompoundPattern { type Error = _support::ParseError; fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_definition_or(value) { return Ok(r); } - if let Ok(r) = _any_parse_definition_and(value) { return Ok(r); } - if let Ok(r) = _any_parse_definition_pattern(value) { return Ok(r); } - Err(_support::ParseError::conformance_error("schema.Definition")) + if let Ok(r) = _any_parse_compound_pattern_rec(value) { return Ok(r); } + if let Ok(r) = _any_parse_compound_pattern_tuple(value) { return Ok(r); } + if let Ok(r) = _any_parse_compound_pattern_tuple_prefix(value) { return Ok(r); } + if let Ok(r) = _any_parse_compound_pattern_dict(value) { return Ok(r); } + Err(_support::ParseError::conformance_error("schema.CompoundPattern")) } } -impl std::convert::From<&Definition> for _Any { - fn from(value: &Definition) -> Self { +impl std::convert::From<&CompoundPattern> for _Any { + fn from(value: &CompoundPattern) -> Self { match value { - Definition::Or {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => { - let mut _tmp3 = preserves::value::Record(vec![(&*_any_::LIT_13_OR).clone()]); - _tmp3.fields_vec_mut().push( + CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => { + let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_9_REC).clone()]); + _tmp2.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); + _tmp2.finish().wrap() + }, + CompoundPattern::Tuple {patterns: _tmp0} => { + let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_10_TUPLE).clone()]); + _tmp1.fields_vec_mut().push( { - let mut _tmp4 = std::vec::Vec::new(); - _tmp4.push(_Any::from(_tmp0.as_ref())); - _tmp4.push(_Any::from(_tmp1.as_ref())); - for _tmp5 in _tmp2 {_tmp4.push(_Any::from(_tmp5));} - preserves::value::Value::Sequence(_tmp4).wrap() + let mut _tmp2 = std::vec::Vec::new(); + for _tmp3 in _tmp0 {_tmp2.push(_Any::from(_tmp3));} + preserves::value::Value::Sequence(_tmp2).wrap() } ); - _tmp3.finish().wrap() + _tmp1.finish().wrap() }, - Definition::And {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => { - let mut _tmp3 = preserves::value::Record(vec![(&*_any_::LIT_14_AND).clone()]); - _tmp3.fields_vec_mut().push( + CompoundPattern::TuplePrefix {fixed: _tmp0, variable: _tmp1} => { + let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_11_TUPLE_PREFIX).clone()]); + _tmp2.fields_vec_mut().push( { - let mut _tmp4 = std::vec::Vec::new(); - _tmp4.push(_Any::from(_tmp0.as_ref())); - _tmp4.push(_Any::from(_tmp1.as_ref())); - for _tmp5 in _tmp2 {_tmp4.push(_Any::from(_tmp5));} - preserves::value::Value::Sequence(_tmp4).wrap() + let mut _tmp3 = std::vec::Vec::new(); + for _tmp4 in _tmp0 {_tmp3.push(_Any::from(_tmp4));} + preserves::value::Value::Sequence(_tmp3).wrap() } ); - _tmp3.finish().wrap() + _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); + _tmp2.finish().wrap() + }, + CompoundPattern::Dict {entries: _tmp0} => { + let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_12_DICT).clone()]); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + _tmp1.finish().wrap() }, - Definition::Pattern(_tmp0) => _Any::from(_tmp0.as_ref()), } } } @@ -819,6 +734,109 @@ impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, } } +fn _any_parse_definition_or(value: &_Any) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_13_OR { return Err(_support::ParseError::conformance_error("schema.Definition::or")); } + let _tmp1 = (); + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Definition::or")); } + let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?; + if _tmp2.len() < 2 { return Err(_support::ParseError::conformance_error("schema.Definition::or")); } + let _tmp3 = NamedAlternative::try_from((&_tmp2[0]))?; + let _tmp4 = NamedAlternative::try_from((&_tmp2[1]))?; + let mut _tmp5 = std::vec::Vec::new(); + for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedAlternative::try_from(_tmp6)?; _tmp5.push(_tmp7);} + Ok(Definition::Or { + pattern_0: std::boxed::Box::new(_tmp3), + pattern_1: std::boxed::Box::new(_tmp4), + pattern_n: _tmp5 + }) +} + +fn _any_parse_definition_and(value: &_Any) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_14_AND { return Err(_support::ParseError::conformance_error("schema.Definition::and")); } + let _tmp1 = (); + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Definition::and")); } + let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?; + if _tmp2.len() < 2 { return Err(_support::ParseError::conformance_error("schema.Definition::and")); } + let _tmp3 = NamedPattern::try_from((&_tmp2[0]))?; + let _tmp4 = NamedPattern::try_from((&_tmp2[1]))?; + let mut _tmp5 = std::vec::Vec::new(); + for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedPattern::try_from(_tmp6)?; _tmp5.push(_tmp7);} + Ok(Definition::And { + pattern_0: std::boxed::Box::new(_tmp3), + pattern_1: std::boxed::Box::new(_tmp4), + pattern_n: _tmp5 + }) +} + +fn _any_parse_definition_pattern(value: &_Any) -> std::result::Result { + let _tmp0 = Pattern::try_from(value)?; + Ok(Definition::Pattern(std::boxed::Box::new(_tmp0))) +} + +impl std::convert::TryFrom<&_Any> for Definition { + type Error = _support::ParseError; + fn try_from(value: &_Any) -> std::result::Result { + if let Ok(r) = _any_parse_definition_or(value) { return Ok(r); } + if let Ok(r) = _any_parse_definition_and(value) { return Ok(r); } + if let Ok(r) = _any_parse_definition_pattern(value) { return Ok(r); } + Err(_support::ParseError::conformance_error("schema.Definition")) + } +} + +impl std::convert::From<&Definition> for _Any { + fn from(value: &Definition) -> Self { + match value { + Definition::Or {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => { + let mut _tmp3 = preserves::value::Record(vec![(&*_any_::LIT_13_OR).clone()]); + _tmp3.fields_vec_mut().push( + { + let mut _tmp4 = std::vec::Vec::new(); + _tmp4.push(_Any::from(_tmp0.as_ref())); + _tmp4.push(_Any::from(_tmp1.as_ref())); + for _tmp5 in _tmp2 {_tmp4.push(_Any::from(_tmp5));} + preserves::value::Value::Sequence(_tmp4).wrap() + } + ); + _tmp3.finish().wrap() + }, + Definition::And {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => { + let mut _tmp3 = preserves::value::Record(vec![(&*_any_::LIT_14_AND).clone()]); + _tmp3.fields_vec_mut().push( + { + let mut _tmp4 = std::vec::Vec::new(); + _tmp4.push(_Any::from(_tmp0.as_ref())); + _tmp4.push(_Any::from(_tmp1.as_ref())); + for _tmp5 in _tmp2 {_tmp4.push(_Any::from(_tmp5));} + preserves::value::Value::Sequence(_tmp4).wrap() + } + ); + _tmp3.finish().wrap() + }, + Definition::Pattern(_tmp0) => _Any::from(_tmp0.as_ref()), + } + } +} + +impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Definitions { + fn deserialize(r: &mut R) -> std::result::Result { + r.open_dictionary()?; + let mut _tmp1 = _support::B::Type::default(); + let mut _tmp0 = preserves::value::Map::new(); + while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? { + _tmp1.shift(Some(_support::B::Item::DictionaryKey)); + r.boundary(&_tmp1)?; + let _tmp2 = r.next_symbol()?.into_owned(); + _tmp1.shift(Some(_support::B::Item::DictionaryValue)); + r.boundary(&_tmp1)?; + let _tmp3 = Definition::deserialize(r)?; + _tmp0.insert(_tmp2, _tmp3); + } + Ok(Definitions(_tmp0)) + } +} + impl std::convert::TryFrom<&_Any> for Definitions { type Error = _support::ParseError; fn try_from(value: &_Any) -> std::result::Result { @@ -839,7 +857,7 @@ impl std::convert::From<&Definitions> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Definitions { +impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for DictionaryEntries { fn deserialize(r: &mut R) -> std::result::Result { r.open_dictionary()?; let mut _tmp1 = _support::B::Type::default(); @@ -847,13 +865,13 @@ impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? { _tmp1.shift(Some(_support::B::Item::DictionaryKey)); r.boundary(&_tmp1)?; - let _tmp2 = r.next_symbol()?.into_owned(); + let _tmp2 = r.demand_next(true)?; _tmp1.shift(Some(_support::B::Item::DictionaryValue)); r.boundary(&_tmp1)?; - let _tmp3 = Definition::deserialize(r)?; + let _tmp3 = NamedSimplePattern::deserialize(r)?; _tmp0.insert(_tmp2, _tmp3); } - Ok(Definitions(_tmp0)) + Ok(DictionaryEntries(_tmp0)) } } @@ -877,21 +895,29 @@ impl std::convert::From<&DictionaryEntries> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for DictionaryEntries { - fn deserialize(r: &mut R) -> std::result::Result { - r.open_dictionary()?; - let mut _tmp1 = _support::B::Type::default(); - let mut _tmp0 = preserves::value::Map::new(); - while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? { - _tmp1.shift(Some(_support::B::Item::DictionaryKey)); - r.boundary(&_tmp1)?; - let _tmp2 = r.demand_next(true)?; - _tmp1.shift(Some(_support::B::Item::DictionaryValue)); - r.boundary(&_tmp1)?; - let _tmp3 = NamedSimplePattern::deserialize(r)?; - _tmp0.insert(_tmp2, _tmp3); +fn read_embedded_type_name_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { + let _tmp0 = Ref::deserialize(r)?; + Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0))) +} + +fn read_embedded_type_name_false<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { + match r.next_token(true)? { + preserves::value::Token::Atom(v) => match v.value() { + preserves::value::Value::Boolean(w) if !*w => {} + _ => return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false"))?, } - Ok(DictionaryEntries(_tmp0)) + _ => return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false"))?, + } + let _tmp0 = (); + Ok(EmbeddedTypeName::False) +} + +impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for EmbeddedTypeName { + fn deserialize(r: &mut R) -> std::result::Result { + let _mark = r.mark()?; + match read_embedded_type_name_ref(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } + match read_embedded_type_name_false(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } + Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName")) } } @@ -924,29 +950,18 @@ impl std::convert::From<&EmbeddedTypeName> for _Any { } } -fn read_embedded_type_name_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - let _tmp0 = Ref::deserialize(r)?; - Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0))) -} - -fn read_embedded_type_name_false<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - match r.next_token(true)? { - preserves::value::Token::Atom(v) => match v.value() { - preserves::value::Value::Boolean(w) if !*w => {} - _ => return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false"))?, - } - _ => return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false"))?, - } - let _tmp0 = (); - Ok(EmbeddedTypeName::False) -} - -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for EmbeddedTypeName { +impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for ModulePath { fn deserialize(r: &mut R) -> std::result::Result { - let _mark = r.mark()?; - match read_embedded_type_name_ref(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } - match read_embedded_type_name_false(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } - Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName")) + r.open_sequence()?; + let mut _tmp1 = _support::B::Type::default(); + let mut _tmp0 = std::vec::Vec::new(); + while !r.close_compound(&mut _tmp1, &_support::B::Item::SequenceValue)? { + _tmp1.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp1)?; + let _tmp2 = r.next_symbol()?.into_owned(); + _tmp0.push(_tmp2); + } + Ok(ModulePath(_tmp0)) } } @@ -971,18 +986,21 @@ impl std::convert::From<&ModulePath> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for ModulePath { +impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Modules { fn deserialize(r: &mut R) -> std::result::Result { - r.open_sequence()?; + r.open_dictionary()?; let mut _tmp1 = _support::B::Type::default(); - let mut _tmp0 = std::vec::Vec::new(); - while !r.close_compound(&mut _tmp1, &_support::B::Item::SequenceValue)? { - _tmp1.shift(Some(_support::B::Item::SequenceValue)); + let mut _tmp0 = preserves::value::Map::new(); + while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? { + _tmp1.shift(Some(_support::B::Item::DictionaryKey)); r.boundary(&_tmp1)?; - let _tmp2 = r.next_symbol()?.into_owned(); - _tmp0.push(_tmp2); + let _tmp2 = ModulePath::deserialize(r)?; + _tmp1.shift(Some(_support::B::Item::DictionaryValue)); + r.boundary(&_tmp1)?; + let _tmp3 = Schema::deserialize(r)?; + _tmp0.insert(_tmp2, _tmp3); } - Ok(ModulePath(_tmp0)) + Ok(Modules(_tmp0)) } } @@ -1006,21 +1024,18 @@ impl std::convert::From<&Modules> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Modules { +impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedAlternative { fn deserialize(r: &mut R) -> std::result::Result { - r.open_dictionary()?; - let mut _tmp1 = _support::B::Type::default(); - let mut _tmp0 = preserves::value::Map::new(); - while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? { - _tmp1.shift(Some(_support::B::Item::DictionaryKey)); - r.boundary(&_tmp1)?; - let _tmp2 = ModulePath::deserialize(r)?; - _tmp1.shift(Some(_support::B::Item::DictionaryValue)); - r.boundary(&_tmp1)?; - let _tmp3 = Schema::deserialize(r)?; - _tmp0.insert(_tmp2, _tmp3); - } - Ok(Modules(_tmp0)) + r.open_sequence()?; + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp0)?; + let _tmp1 = r.next_str()?.into_owned(); + _tmp0.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp0)?; + let _tmp2 = Pattern::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::SequenceValue)?; + Ok(NamedAlternative {variant_label: _tmp1, pattern: _tmp2}) } } @@ -1047,18 +1062,22 @@ impl std::convert::From<&NamedAlternative> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedAlternative { +fn read_named_pattern_named<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { + let _tmp0 = Binding::deserialize(r)?; + Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0))) +} + +fn read_named_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { + let _tmp0 = Pattern::deserialize(r)?; + Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0))) +} + +impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedPattern { fn deserialize(r: &mut R) -> std::result::Result { - r.open_sequence()?; - let mut _tmp0 = _support::B::Type::default(); - _tmp0.shift(Some(_support::B::Item::SequenceValue)); - r.boundary(&_tmp0)?; - let _tmp1 = r.next_str()?.into_owned(); - _tmp0.shift(Some(_support::B::Item::SequenceValue)); - r.boundary(&_tmp0)?; - let _tmp2 = Pattern::deserialize(r)?; - r.ensure_complete(_tmp0, &_support::B::Item::SequenceValue)?; - Ok(NamedAlternative {variant_label: _tmp1, pattern: _tmp2}) + let _mark = r.mark()?; + match read_named_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } + match read_named_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } + Err(_support::ParseError::conformance_error("schema.NamedPattern")) } } @@ -1090,22 +1109,22 @@ impl std::convert::From<&NamedPattern> for _Any { } } -fn read_named_pattern_named<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_named_simple_pattern_named<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = Binding::deserialize(r)?; - Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0))) + Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0))) } -fn read_named_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - let _tmp0 = Pattern::deserialize(r)?; - Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0))) +fn read_named_simple_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { + let _tmp0 = SimplePattern::deserialize(r)?; + Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedPattern { +impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedSimplePattern { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; - match read_named_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } - match read_named_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } - Err(_support::ParseError::conformance_error("schema.NamedPattern")) + match read_named_simple_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } + match read_named_simple_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } + Err(_support::ParseError::conformance_error("schema.NamedSimplePattern")) } } @@ -1137,22 +1156,22 @@ impl std::convert::From<&NamedSimplePattern> for _Any { } } -fn read_named_simple_pattern_named<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - let _tmp0 = Binding::deserialize(r)?; - Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0))) -} - -fn read_named_simple_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_pattern_simple_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = SimplePattern::deserialize(r)?; - Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0))) + Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedSimplePattern { +fn read_pattern_compound_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { + let _tmp0 = CompoundPattern::deserialize(r)?; + Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0))) +} + +impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Pattern { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; - match read_named_simple_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } - match read_named_simple_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } - Err(_support::ParseError::conformance_error("schema.NamedSimplePattern")) + match read_pattern_simple_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } + match read_pattern_compound_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } + Err(_support::ParseError::conformance_error("schema.Pattern")) } } @@ -1184,50 +1203,6 @@ impl std::convert::From<&Pattern> for _Any { } } -fn read_pattern_simple_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - let _tmp0 = SimplePattern::deserialize(r)?; - Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0))) -} - -fn read_pattern_compound_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - let _tmp0 = CompoundPattern::deserialize(r)?; - Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0))) -} - -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Pattern { - fn deserialize(r: &mut R) -> std::result::Result { - let _mark = r.mark()?; - match read_pattern_simple_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } - match read_pattern_compound_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } - Err(_support::ParseError::conformance_error("schema.Pattern")) - } -} - -impl std::convert::TryFrom<&_Any> for Ref { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_16_REF { return Err(_support::ParseError::conformance_error("schema.Ref")); } - let _tmp1 = (); - if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.Ref")); } - let _tmp2 = ModulePath::try_from((&_tmp0.fields()[0]))?; - let _tmp3 = (&_tmp0.fields()[1]).value().to_symbol()?; - Ok(Ref {module: _tmp2, name: _tmp3.clone()}) - } -} - -impl std::convert::From<&Ref> for _Any { - fn from(value: &Ref) -> Self { - let Ref {module: _tmp0, name: _tmp1} = value; - { - let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_16_REF).clone()]); - _tmp2.fields_vec_mut().push(_Any::from(_tmp0)); - _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp1).wrap()); - _tmp2.finish().wrap() - } - } -} - impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Ref { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; @@ -1253,39 +1228,27 @@ impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, } } -impl std::convert::TryFrom<&_Any> for Schema { +impl std::convert::TryFrom<&_Any> for Ref { type Error = _support::ParseError; fn try_from(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_17_SCHEMA { return Err(_support::ParseError::conformance_error("schema.Schema")); } + if _tmp0.label() != &*_any_::LIT_16_REF { return Err(_support::ParseError::conformance_error("schema.Ref")); } let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Schema")); } - let _tmp2 = (&_tmp0.fields()[0]).value().to_dictionary()?; - let _tmp3 = _tmp2.get(&*_any_::LIT_18_DEFINITIONS).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; - let _tmp4 = Definitions::try_from(_tmp3)?; - let _tmp5 = _tmp2.get(&*_any_::LIT_19_EMBEDDED_TYPE).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; - let _tmp6 = EmbeddedTypeName::try_from(_tmp5)?; - let _tmp7 = _tmp2.get(&*_any_::LIT_20_VERSION).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; - let _tmp8 = Version::try_from(_tmp7)?; - Ok(Schema {definitions: _tmp4, embedded_type: _tmp6, version: _tmp8}) + if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.Ref")); } + let _tmp2 = ModulePath::try_from((&_tmp0.fields()[0]))?; + let _tmp3 = (&_tmp0.fields()[1]).value().to_symbol()?; + Ok(Ref {module: _tmp2, name: _tmp3.clone()}) } } -impl std::convert::From<&Schema> for _Any { - fn from(value: &Schema) -> Self { - let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = value; +impl std::convert::From<&Ref> for _Any { + fn from(value: &Ref) -> Self { + let Ref {module: _tmp0, name: _tmp1} = value; { - let mut _tmp3 = preserves::value::Record(vec![(&*_any_::LIT_17_SCHEMA).clone()]); - _tmp3.fields_vec_mut().push( - { - let mut _tmp4 = preserves::value::Map::new(); - _tmp4.insert((&*_any_::LIT_18_DEFINITIONS).clone(), _Any::from(_tmp0)); - _tmp4.insert((&*_any_::LIT_19_EMBEDDED_TYPE).clone(), _Any::from(_tmp1)); - _tmp4.insert((&*_any_::LIT_20_VERSION).clone(), _Any::from(_tmp2)); - preserves::value::Value::Dictionary(_tmp4).wrap() - } - ); - _tmp3.finish().wrap() + let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_16_REF).clone()]); + _tmp2.fields_vec_mut().push(_Any::from(_tmp0)); + _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp1).wrap()); + _tmp2.finish().wrap() } } } @@ -1348,123 +1311,39 @@ impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, } } -fn _any_parse_simple_pattern_any(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_21_ANY { return Err(_support::ParseError::conformance_error("schema.SimplePattern::any")); } - let _tmp0 = (); - Ok(SimplePattern::Any) -} - -fn _any_parse_simple_pattern_atom(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_22_ATOM { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); } - let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); } - let _tmp2 = AtomKind::try_from((&_tmp0.fields()[0]))?; - Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)}) -} - -fn _any_parse_simple_pattern_embedded(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_23_EMBEDDED { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); } - let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; - Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)}) -} - -fn _any_parse_simple_pattern_lit(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_24_LIT { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); } - let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); } - let _tmp2 = (&_tmp0.fields()[0]); - Ok(SimplePattern::Lit {value: _tmp2.clone()}) -} - -fn _any_parse_simple_pattern_seqof(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_25_SEQOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); } - let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; - Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)}) -} - -fn _any_parse_simple_pattern_setof(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_26_SETOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); } - let _tmp1 = (); - if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; - Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)}) -} - -fn _any_parse_simple_pattern_dictof(value: &_Any) -> std::result::Result { - let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_27_DICTOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); } - let _tmp1 = (); - if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; - let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]))?; - Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)}) -} - -fn _any_parse_simple_pattern_ref(value: &_Any) -> std::result::Result { - let _tmp0 = Ref::try_from(value)?; - Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0))) -} - -impl std::convert::TryFrom<&_Any> for SimplePattern { +impl std::convert::TryFrom<&_Any> for Schema { type Error = _support::ParseError; fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_simple_pattern_any(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_atom(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_embedded(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_lit(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_seqof(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_setof(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_dictof(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_ref(value) { return Ok(r); } - Err(_support::ParseError::conformance_error("schema.SimplePattern")) + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_17_SCHEMA { return Err(_support::ParseError::conformance_error("schema.Schema")); } + let _tmp1 = (); + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Schema")); } + let _tmp2 = (&_tmp0.fields()[0]).value().to_dictionary()?; + let _tmp3 = _tmp2.get(&*_any_::LIT_18_DEFINITIONS).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; + let _tmp4 = Definitions::try_from(_tmp3)?; + let _tmp5 = _tmp2.get(&*_any_::LIT_19_EMBEDDED_TYPE).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; + let _tmp6 = EmbeddedTypeName::try_from(_tmp5)?; + let _tmp7 = _tmp2.get(&*_any_::LIT_20_VERSION).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; + let _tmp8 = Version::try_from(_tmp7)?; + Ok(Schema {definitions: _tmp4, embedded_type: _tmp6, version: _tmp8}) } } -impl std::convert::From<&SimplePattern> for _Any { - fn from(value: &SimplePattern) -> Self { - match value { - SimplePattern::Any => (&*_any_::LIT_21_ANY).clone(), - SimplePattern::Atom {atom_kind: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_22_ATOM).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); - _tmp1.finish().wrap() - }, - SimplePattern::Embedded {interface: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_23_EMBEDDED).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); - _tmp1.finish().wrap() - }, - SimplePattern::Lit {value: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_24_LIT).clone()]); - _tmp1.fields_vec_mut().push(_tmp0.clone()); - _tmp1.finish().wrap() - }, - SimplePattern::Seqof {pattern: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_25_SEQOF).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); - _tmp1.finish().wrap() - }, - SimplePattern::Setof {pattern: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_26_SETOF).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); - _tmp1.finish().wrap() - }, - SimplePattern::Dictof {key: _tmp0, value: _tmp1} => { - let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_27_DICTOF).clone()]); - _tmp2.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); - _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); - _tmp2.finish().wrap() - }, - SimplePattern::Ref(_tmp0) => _Any::from(_tmp0.as_ref()), +impl std::convert::From<&Schema> for _Any { + fn from(value: &Schema) -> Self { + let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = value; + { + let mut _tmp3 = preserves::value::Record(vec![(&*_any_::LIT_17_SCHEMA).clone()]); + _tmp3.fields_vec_mut().push( + { + let mut _tmp4 = preserves::value::Map::new(); + _tmp4.insert((&*_any_::LIT_18_DEFINITIONS).clone(), _Any::from(_tmp0)); + _tmp4.insert((&*_any_::LIT_19_EMBEDDED_TYPE).clone(), _Any::from(_tmp1)); + _tmp4.insert((&*_any_::LIT_20_VERSION).clone(), _Any::from(_tmp2)); + preserves::value::Value::Dictionary(_tmp4).wrap() + } + ); + _tmp3.finish().wrap() } } } @@ -1624,17 +1503,125 @@ impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, } } -impl std::convert::TryFrom<&_Any> for Version { +fn _any_parse_simple_pattern_any(value: &_Any) -> std::result::Result { + if value != &*_any_::LIT_21_ANY { return Err(_support::ParseError::conformance_error("schema.SimplePattern::any")); } + let _tmp0 = (); + Ok(SimplePattern::Any) +} + +fn _any_parse_simple_pattern_atom(value: &_Any) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_22_ATOM { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); } + let _tmp1 = (); + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); } + let _tmp2 = AtomKind::try_from((&_tmp0.fields()[0]))?; + Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)}) +} + +fn _any_parse_simple_pattern_embedded(value: &_Any) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_23_EMBEDDED { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); } + let _tmp1 = (); + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); } + let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; + Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)}) +} + +fn _any_parse_simple_pattern_lit(value: &_Any) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_24_LIT { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); } + let _tmp1 = (); + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); } + let _tmp2 = (&_tmp0.fields()[0]); + Ok(SimplePattern::Lit {value: _tmp2.clone()}) +} + +fn _any_parse_simple_pattern_seqof(value: &_Any) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_25_SEQOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); } + let _tmp1 = (); + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); } + let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; + Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)}) +} + +fn _any_parse_simple_pattern_setof(value: &_Any) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_26_SETOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); } + let _tmp1 = (); + if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); } + let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; + Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)}) +} + +fn _any_parse_simple_pattern_dictof(value: &_Any) -> std::result::Result { + let _tmp0 = value.value().to_record(None)?; + if _tmp0.label() != &*_any_::LIT_27_DICTOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); } + let _tmp1 = (); + if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); } + let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; + let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]))?; + Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)}) +} + +fn _any_parse_simple_pattern_ref(value: &_Any) -> std::result::Result { + let _tmp0 = Ref::try_from(value)?; + Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0))) +} + +impl std::convert::TryFrom<&_Any> for SimplePattern { type Error = _support::ParseError; fn try_from(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_28_1 { return Err(_support::ParseError::conformance_error("schema.Version")); } - let _tmp0 = (); - Ok(Version) + if let Ok(r) = _any_parse_simple_pattern_any(value) { return Ok(r); } + if let Ok(r) = _any_parse_simple_pattern_atom(value) { return Ok(r); } + if let Ok(r) = _any_parse_simple_pattern_embedded(value) { return Ok(r); } + if let Ok(r) = _any_parse_simple_pattern_lit(value) { return Ok(r); } + if let Ok(r) = _any_parse_simple_pattern_seqof(value) { return Ok(r); } + if let Ok(r) = _any_parse_simple_pattern_setof(value) { return Ok(r); } + if let Ok(r) = _any_parse_simple_pattern_dictof(value) { return Ok(r); } + if let Ok(r) = _any_parse_simple_pattern_ref(value) { return Ok(r); } + Err(_support::ParseError::conformance_error("schema.SimplePattern")) } } -impl std::convert::From<&Version> for _Any { - fn from(value: &Version) -> Self {let Version = value; (&*_any_::LIT_28_1).clone()} +impl std::convert::From<&SimplePattern> for _Any { + fn from(value: &SimplePattern) -> Self { + match value { + SimplePattern::Any => (&*_any_::LIT_21_ANY).clone(), + SimplePattern::Atom {atom_kind: _tmp0} => { + let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_22_ATOM).clone()]); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + _tmp1.finish().wrap() + }, + SimplePattern::Embedded {interface: _tmp0} => { + let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_23_EMBEDDED).clone()]); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + _tmp1.finish().wrap() + }, + SimplePattern::Lit {value: _tmp0} => { + let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_24_LIT).clone()]); + _tmp1.fields_vec_mut().push(_tmp0.clone()); + _tmp1.finish().wrap() + }, + SimplePattern::Seqof {pattern: _tmp0} => { + let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_25_SEQOF).clone()]); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + _tmp1.finish().wrap() + }, + SimplePattern::Setof {pattern: _tmp0} => { + let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_26_SETOF).clone()]); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + _tmp1.finish().wrap() + }, + SimplePattern::Dictof {key: _tmp0, value: _tmp1} => { + let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_27_DICTOF).clone()]); + _tmp2.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); + _tmp2.finish().wrap() + }, + SimplePattern::Ref(_tmp0) => _Any::from(_tmp0.as_ref()), + } + } } impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Version { @@ -1650,3 +1637,16 @@ impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, Ok(Version) } } + +impl std::convert::TryFrom<&_Any> for Version { + type Error = _support::ParseError; + fn try_from(value: &_Any) -> std::result::Result { + if value != &*_any_::LIT_28_1 { return Err(_support::ParseError::conformance_error("schema.Version")); } + let _tmp0 = (); + Ok(Version) + } +} + +impl std::convert::From<&Version> for _Any { + fn from(value: &Version) -> Self {let Version = value; (&*_any_::LIT_28_1).clone()} +}