From dcdfdb8dd968b5be3cffbc5a9c882d1c56c6923a Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Mon, 2 Aug 2021 20:55:44 +0200 Subject: [PATCH] Track boundaries in schema-emitted reader code --- .../preserves-schema/src/compiler/readers.rs | 149 ++++-- .../rust/preserves-schema/src/gen/schema.rs | 426 ++++++++++++------ .../rust/preserves-schema/src/support/mod.rs | 1 + .../rust/preserves/src/value/boundary.rs | 1 + .../rust/preserves/src/value/packed/reader.rs | 1 + .../rust/preserves/src/value/packed/writer.rs | 2 + .../rust/preserves/src/value/text/reader.rs | 1 + .../rust/preserves/src/value/text/writer.rs | 1 + 8 files changed, 413 insertions(+), 169 deletions(-) diff --git a/implementations/rust/preserves-schema/src/compiler/readers.rs b/implementations/rust/preserves-schema/src/compiler/readers.rs index c11d2dd..1605110 100644 --- a/implementations/rust/preserves-schema/src/compiler/readers.rs +++ b/implementations/rust/preserves-schema/src/compiler/readers.rs @@ -14,6 +14,54 @@ use super::context::{ModuleContext, FunctionContext}; use super::names; use super::types::*; +#[derive(Clone)] +struct BoundaryTracker { + tracker_name: String, + item_expr: &'static str, +} + +impl BoundaryTracker { + fn unwrap( + ctxt: &mut FunctionContext, + body: &mut Vec, + open_expr: &'static str, + e: Option<&BoundaryTracker>, + ) -> Self { + match e { + None => Self::new(ctxt, body, open_expr, "_support::B::Item::SequenceValue"), + Some(b) => b.clone(), + } + } + + fn new( + ctxt: &mut FunctionContext, + body: &mut Vec, + open_expr: &'static str, + item_expr: &'static str, + ) -> Self { + let tracker_name = ctxt.gentempname(); + body.push(item(open_expr)); + body.push(item(seq!["let mut ", tracker_name.clone(), " = _support::B::Type::default();"])); + BoundaryTracker { + tracker_name, + item_expr, + } + } + + fn emit_boundary(&self, body: &mut Vec) { + body.push(item(seq![self.tracker_name.clone(), ".shift(Some(", self.item_expr, "));"])); + body.push(item(seq!["r.boundary(&", self.tracker_name.clone(), ")?;"])); + } + + fn emit_loop(&self, body: &mut Vec, inner: Vec) { + body.push(item(seq![ + "while !r.close_compound", parens![ + seq!["&mut ", self.tracker_name.clone()], + seq!["&", self.item_expr]], "? ", + block(inner)])) + } +} + pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { m.define_function( n, @@ -32,7 +80,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { &(n.to_owned() + "::" + name), |mut ctxt| { let mut body = Vec::new(); - let dest = pattern_reader(&mut ctxt, pat, false, &mut body); + let dest = pattern_reader(&mut ctxt, pat, None, &mut body); let dest = dest.as_ref().map(String::as_str); construct(&ctxt, ctorname, false, &pattern_type(pat), dest, &mut body); item(seq![ @@ -54,12 +102,12 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { let mut ps = vec![&**pattern_0, &**pattern_1]; ps.extend(pattern_n); for e in &ps { - named_pattern_reader(&mut ctxt, e, false, &mut body); + named_pattern_reader(&mut ctxt, e, None, &mut body); } construct(&ctxt, item(names::render_constructor(n)), true, &record_type(&ps), None, &mut body); } Definition::Pattern(p) => { - let dest = pattern_reader(&mut ctxt, p, false, &mut body); + let dest = pattern_reader(&mut ctxt, p, None, &mut body); let dest = dest.as_ref().map(String::as_str); construct(&ctxt, item(names::render_constructor(n)), true, &pattern_type(p), dest, &mut body); } @@ -175,7 +223,7 @@ fn read_expected_literal_seqs( } } cases.extend(read_expected_literals_cases(ctxt, nested)); - body.push(item(seq!["match r.next_token(false)? ", block(cases)])); + body.push(item(seq!["match r.next_token(true)? ", block(cases)])); } fn read_expected_literals_cases( @@ -256,19 +304,19 @@ fn read_expected_literals( possibilities: LiteralCases, ) { let cases = read_expected_literals_cases(ctxt, possibilities); - body.push(item(seq!["match r.next_token(false)? ", block(cases)])); + body.push(item(seq!["match r.next_token(true)? ", block(cases)])); } fn simple_pattern_reader( ctxt: &mut FunctionContext, p: &SimplePattern, - in_sequence: bool, + boundary_tracker: Option<&BoundaryTracker>, body: &mut Vec, ) -> String { let dest = ctxt.gentempname(); match p { SimplePattern::Any => { - ctxt.define_atom(body, &dest, item("r.demand_next(false)?")); + ctxt.define_atom(body, &dest, item("r.demand_next(true)?")); dest }, SimplePattern::Atom { atom_kind: k } => { @@ -285,8 +333,9 @@ fn simple_pattern_reader( dest }, SimplePattern::Embedded { .. } => { + // TODO: Is this right? If so, why doesn't it expect *two* Embedded tags in a row?? body.push(item("r.open_embedded()?;")); - ctxt.define_atom(body, &dest, item("r.demand_next(false)?.value().to_embedded()?.clone()")); + ctxt.define_atom(body, &dest, item("r.demand_next(true)?.value().to_embedded()?.clone()")); body.push(item("r.close_embedded()?;")); dest }, @@ -297,38 +346,45 @@ fn simple_pattern_reader( dest }, SimplePattern::Seqof { pattern } => { - if !in_sequence { - body.push(item("r.open_sequence()?;")); - } + let boundary_tracker = BoundaryTracker::unwrap( + ctxt, body, "r.open_sequence()?;", boundary_tracker); let mut inner = Vec::new(); - let item_dest = simple_pattern_reader(ctxt, pattern, false, &mut inner); + boundary_tracker.emit_boundary(&mut inner); + let item_dest = simple_pattern_reader(ctxt, pattern, None, &mut inner); inner.push(item(seq![dest.to_owned(), ".push(", store_wrap(true, &field_type(pattern), &item_dest), ");"])); ctxt.declare_compound(body, &dest, item("std::vec::Vec::new()")); - body.push(item(seq!["while !(r.close_compound()?) ", block(inner)])); + boundary_tracker.emit_loop(body, inner); dest }, SimplePattern::Setof { pattern } => { - body.push(item("r.open_set()?;")); + let boundary_tracker = BoundaryTracker::new( + ctxt, body, "r.open_set()?;", "_support::B::Item::SetValue"); let mut inner = Vec::new(); - let item_dest = simple_pattern_reader(ctxt, pattern, false, &mut inner); + boundary_tracker.emit_boundary(&mut inner); + let item_dest = simple_pattern_reader(ctxt, pattern, None, &mut inner); inner.push(item(seq![dest.to_owned(), ".insert(", store_wrap(true, &field_type(pattern), &item_dest), ");"])); ctxt.declare_compound(body, &dest, item("preserves::value::Set::new()")); - body.push(item(seq!["while !(r.close_compound()?) ", block(inner)])); + boundary_tracker.emit_loop(body, inner); dest }, SimplePattern::Dictof { key, value } => { - body.push(item("r.open_dictionary()?;")); + let mut boundary_tracker = BoundaryTracker::new( + ctxt, body, "r.open_dictionary()?;", "_support::B::Item::DictionaryKey"); let mut inner = Vec::new(); - let key_dest = simple_pattern_reader(ctxt, key, false, &mut inner); - let value_dest = simple_pattern_reader(ctxt, value, false, &mut inner); + boundary_tracker.emit_boundary(&mut inner); + let key_dest = simple_pattern_reader(ctxt, key, None, &mut inner); + boundary_tracker.item_expr = "_support::B::Item::DictionaryValue"; + boundary_tracker.emit_boundary(&mut inner); + let value_dest = simple_pattern_reader(ctxt, value, None, &mut inner); inner.push(item(seq![ dest.to_owned(), ".insert(", store_wrap(true, &field_type(key), &key_dest), ", ", store_wrap(true, &field_type(value), &value_dest), ");"])); ctxt.declare_compound(body, &dest, item("preserves::value::Map::new()")); - body.push(item(seq!["while !(r.close_compound()?) ", block(inner)])); + boundary_tracker.item_expr = "_support::B::Item::DictionaryKey"; + boundary_tracker.emit_loop(body, inner); dest }, SimplePattern::Ref(r) => { @@ -342,16 +398,16 @@ fn simple_pattern_reader( fn named_pattern_reader( ctxt: &mut FunctionContext, p: &NamedPattern, - in_sequence: bool, + boundary_tracker: Option<&BoundaryTracker>, body: &mut Vec, ) { match p { NamedPattern::Anonymous(p) => { - pattern_reader(ctxt, p, in_sequence, body); + pattern_reader(ctxt, p, boundary_tracker, body); }, NamedPattern::Named(b) => { let Binding { name, pattern} = &**b; - let dest = simple_pattern_reader(ctxt, pattern, in_sequence, body); + let dest = simple_pattern_reader(ctxt, pattern, boundary_tracker, body); let capture_ty = field_type(pattern); ctxt.capture(names::render_fieldname(name), capture_ty, dest); } @@ -361,48 +417,63 @@ fn named_pattern_reader( fn pattern_reader( ctxt: &mut FunctionContext, p: &Pattern, - in_sequence: bool, + boundary_tracker: Option<&BoundaryTracker>, body: &mut Vec, ) -> Option { match p { Pattern::SimplePattern(s) => - Some(simple_pattern_reader(ctxt, s, in_sequence, body)), + Some(simple_pattern_reader(ctxt, s, boundary_tracker, body)), Pattern::CompoundPattern(c) => { match &**c { CompoundPattern::Rec { label, fields } => { - body.push(item("r.open_record(None)?;")); - named_pattern_reader(ctxt, &**label, false, body); - named_pattern_reader(ctxt, &**fields, true, body); + let mut boundary_tracker = BoundaryTracker::new( + ctxt, body, "r.open_record(None)?;", "_support::B::Item::RecordLabel"); + boundary_tracker.emit_boundary(body); + boundary_tracker.item_expr = "_support::B::Item::RecordField"; + named_pattern_reader(ctxt, &**label, None, body); + named_pattern_reader(ctxt, &**fields, Some(&boundary_tracker), body); }, CompoundPattern::Tuple { patterns } => { - if !in_sequence { - body.push(item("r.open_sequence()?;")); + let boundary_tracker = BoundaryTracker::unwrap( + ctxt, body, "r.open_sequence()?;", boundary_tracker); + for p in patterns { + boundary_tracker.emit_boundary(body); + named_pattern_reader(ctxt, p, None, body); } - for p in patterns { named_pattern_reader(ctxt, p, false, body); } - body.push(item("r.ensure_complete()?;")); + body.push(item(seq!["r.ensure_complete", parens![ + boundary_tracker.tracker_name.clone(), + seq!["&", boundary_tracker.item_expr]], "?;"])); }, CompoundPattern::TuplePrefix { fixed, variable } => { - if !in_sequence { - body.push(item("r.open_sequence()?;")); + let boundary_tracker = BoundaryTracker::unwrap( + ctxt, body, "r.open_sequence()?;", boundary_tracker); + for p in fixed { + boundary_tracker.emit_boundary(body); + named_pattern_reader(ctxt, p, None, body); } - for p in fixed { named_pattern_reader(ctxt, p, false, body); } - named_pattern_reader(ctxt, &promote(variable), true, body); + named_pattern_reader(ctxt, &promote(variable), Some(&boundary_tracker), body); }, CompoundPattern::Dict { entries } => { - body.push(item("r.open_dictionary()?;")); + let boundary_tracker = BoundaryTracker::new( + ctxt, body, "r.open_dictionary()?;", "_support::B::Item::DictionaryKey"); let mut inner = Vec::new(); + boundary_tracker.emit_boundary(&mut inner); + let mut val_boundary_tracker = boundary_tracker.clone(); + val_boundary_tracker.item_expr = "_support::B::Item::DictionaryValue"; body.extend(ctxt.with_indefinite_mode(|ctxt| { read_expected_literals(ctxt, &mut inner, entries.0.iter().map(move |(key_lit, value_pat)| { let value_pat = value_pat.clone(); + let val_boundary_tracker = val_boundary_tracker.clone(); let f: LiteralContinuation = Box::new( move |ctxt: &mut FunctionContext, innerinner: &mut Vec| { - named_pattern_reader(ctxt, &promote(&value_pat), false, innerinner); + val_boundary_tracker.emit_boundary(innerinner); + named_pattern_reader(ctxt, &promote(&value_pat), None, innerinner); innerinner.push(item("continue;")); }); (key_lit.clone(), f) }).collect()); })); - body.push(item(seq!["while !(r.close_compound()?) ", block(inner)])); + boundary_tracker.emit_loop(body, inner); } } None diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs index 03e4571..a4fc2b7 100644 --- a/implementations/rust/preserves-schema/src/gen/schema.rs +++ b/implementations/rust/preserves-schema/src/gen/schema.rs @@ -244,7 +244,7 @@ impl std::convert::From<&AtomKind> for _Any { } fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - match r.next_token(false)? { + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Boolean" => {} _ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean"))?, @@ -256,7 +256,7 @@ fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) } fn read_atom_kind_float<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - match r.next_token(false)? { + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Float" => {} _ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Float"))?, @@ -268,7 +268,7 @@ fn read_atom_kind_float<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> } fn read_atom_kind_double<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - match r.next_token(false)? { + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Double" => {} _ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Double"))?, @@ -280,7 +280,7 @@ fn read_atom_kind_double<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) - } fn read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - match r.next_token(false)? { + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "SignedInteger" => {} _ => return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger"))?, @@ -292,7 +292,7 @@ fn read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: & } fn read_atom_kind_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - match r.next_token(false)? { + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "String" => {} _ => return Err(_support::ParseError::conformance_error("schema.AtomKind::String"))?, @@ -304,7 +304,7 @@ fn read_atom_kind_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) - } fn read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - match r.next_token(false)? { + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "ByteString" => {} _ => return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString"))?, @@ -316,7 +316,7 @@ fn read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut } fn read_atom_kind_symbol<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - match r.next_token(false)? { + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Symbol" => {} _ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol"))?, @@ -369,18 +369,25 @@ impl std::convert::From<&Binding> for _Any { impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Binding { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "named" => {} _ => return Err(_support::ParseError::conformance_error("schema.Binding"))?, } _ => return Err(_support::ParseError::conformance_error("schema.Binding"))?, } - let _tmp0 = (); - let _tmp1 = r.next_symbol()?.into_owned(); - let _tmp2 = SimplePattern::deserialize(r)?; - r.ensure_complete()?; - Ok(Binding {name: _tmp1, pattern: _tmp2}) + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp2 = r.next_symbol()?.into_owned(); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp3 = SimplePattern::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(Binding {name: _tmp2, pattern: _tmp3}) } } @@ -410,17 +417,22 @@ impl std::convert::From<&Bundle> for _Any { impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Bundle { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "bundle" => {} _ => return Err(_support::ParseError::conformance_error("schema.Bundle"))?, } _ => return Err(_support::ParseError::conformance_error("schema.Bundle"))?, } - let _tmp0 = (); - let _tmp1 = Modules::deserialize(r)?; - r.ensure_complete()?; - Ok(Bundle {modules: _tmp1}) + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp2 = Modules::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(Bundle {modules: _tmp2}) } } @@ -520,68 +532,104 @@ impl std::convert::From<&CompoundPattern> for _Any { fn read_compound_pattern_rec<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "rec" => {} _ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec"))?, } _ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec"))?, } - let _tmp0 = (); - let _tmp1 = NamedPattern::deserialize(r)?; + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; let _tmp2 = NamedPattern::deserialize(r)?; - r.ensure_complete()?; - Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp1), fields: std::boxed::Box::new(_tmp2)}) + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp3 = NamedPattern::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)}) } fn read_compound_pattern_tuple<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "tuple" => {} _ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple"))?, } _ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple"))?, } - let _tmp0 = (); + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; r.open_sequence()?; - let mut _tmp1 = std::vec::Vec::new(); - while !(r.close_compound()?) {let _tmp2 = NamedPattern::deserialize(r)?; _tmp1.push(_tmp2);} - r.ensure_complete()?; - Ok(CompoundPattern::Tuple {patterns: _tmp1}) + let mut _tmp3 = _support::B::Type::default(); + let mut _tmp2 = std::vec::Vec::new(); + while !r.close_compound(&mut _tmp3, &_support::B::Item::SequenceValue)? { + _tmp3.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp3)?; + let _tmp4 = NamedPattern::deserialize(r)?; + _tmp2.push(_tmp4); + } + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(CompoundPattern::Tuple {patterns: _tmp2}) } fn read_compound_pattern_tuple_prefix<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "tuplePrefix" => {} _ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix"))?, } _ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix"))?, } - let _tmp0 = (); + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; r.open_sequence()?; - let mut _tmp1 = std::vec::Vec::new(); - while !(r.close_compound()?) {let _tmp2 = NamedPattern::deserialize(r)?; _tmp1.push(_tmp2);} - let _tmp3 = NamedSimplePattern::deserialize(r)?; - r.ensure_complete()?; - Ok(CompoundPattern::TuplePrefix {fixed: _tmp1, variable: std::boxed::Box::new(_tmp3)}) + let mut _tmp3 = _support::B::Type::default(); + let mut _tmp2 = std::vec::Vec::new(); + while !r.close_compound(&mut _tmp3, &_support::B::Item::SequenceValue)? { + _tmp3.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp3)?; + let _tmp4 = NamedPattern::deserialize(r)?; + _tmp2.push(_tmp4); + } + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp5 = NamedSimplePattern::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp5)}) } fn read_compound_pattern_dict<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "dict" => {} _ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict"))?, } _ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict"))?, } - let _tmp0 = (); - let _tmp1 = DictionaryEntries::deserialize(r)?; - r.ensure_complete()?; - Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp1)}) + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp2 = DictionaryEntries::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)}) } impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for CompoundPattern { @@ -682,47 +730,77 @@ impl std::convert::From<&Definition> for _Any { fn read_definition_or<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "or" => {} _ => return Err(_support::ParseError::conformance_error("schema.Definition::or"))?, } _ => return Err(_support::ParseError::conformance_error("schema.Definition::or"))?, } - let _tmp0 = (); + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; r.open_sequence()?; - let _tmp1 = NamedAlternative::deserialize(r)?; - let _tmp2 = NamedAlternative::deserialize(r)?; - let mut _tmp3 = std::vec::Vec::new(); - while !(r.close_compound()?) {let _tmp4 = NamedAlternative::deserialize(r)?; _tmp3.push(_tmp4);} - r.ensure_complete()?; + let mut _tmp2 = _support::B::Type::default(); + _tmp2.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp2)?; + let _tmp3 = NamedAlternative::deserialize(r)?; + _tmp2.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp2)?; + let _tmp4 = NamedAlternative::deserialize(r)?; + let mut _tmp5 = std::vec::Vec::new(); + while !r.close_compound(&mut _tmp2, &_support::B::Item::SequenceValue)? { + _tmp2.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp2)?; + let _tmp6 = NamedAlternative::deserialize(r)?; + _tmp5.push(_tmp6); + } + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; Ok(Definition::Or { - pattern_0: std::boxed::Box::new(_tmp1), - pattern_1: std::boxed::Box::new(_tmp2), - pattern_n: _tmp3 + pattern_0: std::boxed::Box::new(_tmp3), + pattern_1: std::boxed::Box::new(_tmp4), + pattern_n: _tmp5 }) } fn read_definition_and<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "and" => {} _ => return Err(_support::ParseError::conformance_error("schema.Definition::and"))?, } _ => return Err(_support::ParseError::conformance_error("schema.Definition::and"))?, } - let _tmp0 = (); + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; r.open_sequence()?; - let _tmp1 = NamedPattern::deserialize(r)?; - let _tmp2 = NamedPattern::deserialize(r)?; - let mut _tmp3 = std::vec::Vec::new(); - while !(r.close_compound()?) {let _tmp4 = NamedPattern::deserialize(r)?; _tmp3.push(_tmp4);} - r.ensure_complete()?; + let mut _tmp2 = _support::B::Type::default(); + _tmp2.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp2)?; + let _tmp3 = NamedPattern::deserialize(r)?; + _tmp2.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp2)?; + let _tmp4 = NamedPattern::deserialize(r)?; + let mut _tmp5 = std::vec::Vec::new(); + while !r.close_compound(&mut _tmp2, &_support::B::Item::SequenceValue)? { + _tmp2.shift(Some(_support::B::Item::SequenceValue)); + r.boundary(&_tmp2)?; + let _tmp6 = NamedPattern::deserialize(r)?; + _tmp5.push(_tmp6); + } + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; Ok(Definition::And { - pattern_0: std::boxed::Box::new(_tmp1), - pattern_1: std::boxed::Box::new(_tmp2), - pattern_n: _tmp3 + pattern_0: std::boxed::Box::new(_tmp3), + pattern_1: std::boxed::Box::new(_tmp4), + pattern_n: _tmp5 }) } @@ -764,11 +842,16 @@ impl std::convert::From<&Definitions> for _Any { 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()?) { - let _tmp1 = r.next_symbol()?.into_owned(); - let _tmp2 = Definition::deserialize(r)?; - _tmp0.insert(_tmp1, _tmp2); + 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)) } @@ -797,11 +880,16 @@ 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()?) { - let _tmp1 = r.demand_next(false)?; - let _tmp2 = NamedSimplePattern::deserialize(r)?; - _tmp0.insert(_tmp1, _tmp2); + 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); } Ok(DictionaryEntries(_tmp0)) } @@ -842,7 +930,7 @@ fn read_embedded_type_name_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mu } fn read_embedded_type_name_false<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - match r.next_token(false)? { + 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"))?, @@ -886,8 +974,14 @@ impl std::convert::From<&ModulePath> for _Any { impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for ModulePath { fn deserialize(r: &mut R) -> std::result::Result { r.open_sequence()?; + let mut _tmp1 = _support::B::Type::default(); let mut _tmp0 = std::vec::Vec::new(); - while !(r.close_compound()?) {let _tmp1 = r.next_symbol()?.into_owned(); _tmp0.push(_tmp1);} + 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)) } } @@ -915,11 +1009,16 @@ impl std::convert::From<&Modules> for _Any { 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_dictionary()?; + let mut _tmp1 = _support::B::Type::default(); let mut _tmp0 = preserves::value::Map::new(); - while !(r.close_compound()?) { - let _tmp1 = ModulePath::deserialize(r)?; - let _tmp2 = Schema::deserialize(r)?; - _tmp0.insert(_tmp1, _tmp2); + 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)) } @@ -951,10 +1050,15 @@ impl std::convert::From<&NamedAlternative> for _Any { 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_sequence()?; - let _tmp0 = r.next_str()?.into_owned(); - let _tmp1 = Pattern::deserialize(r)?; - r.ensure_complete()?; - Ok(NamedAlternative {variant_label: _tmp0, pattern: _tmp1}) + 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}) } } @@ -1127,18 +1231,25 @@ impl std::convert::From<&Ref> for _Any { 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)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "ref" => {} _ => return Err(_support::ParseError::conformance_error("schema.Ref"))?, } _ => return Err(_support::ParseError::conformance_error("schema.Ref"))?, } - let _tmp0 = (); - let _tmp1 = ModulePath::deserialize(r)?; - let _tmp2 = r.next_symbol()?.into_owned(); - r.ensure_complete()?; - Ok(Ref {module: _tmp1, name: _tmp2}) + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp2 = ModulePath::deserialize(r)?; + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp3 = r.next_symbol()?.into_owned(); + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(Ref {module: _tmp2, name: _tmp3}) } } @@ -1182,34 +1293,57 @@ impl std::convert::From<&Schema> for _Any { impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Schema { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "schema" => {} _ => return Err(_support::ParseError::conformance_error("schema.Schema"))?, } _ => return Err(_support::ParseError::conformance_error("schema.Schema"))?, } - let _tmp0 = (); + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; r.open_dictionary()?; - let mut _tmp1 = None; - let mut _tmp2 = None; + let mut _tmp2 = _support::B::Type::default(); let mut _tmp3 = None; - while !(r.close_compound()?) { - match r.next_token(false)? { + let mut _tmp4 = None; + let mut _tmp5 = None; + while !r.close_compound(&mut _tmp2, &_support::B::Item::DictionaryKey)? { + _tmp2.shift(Some(_support::B::Item::DictionaryKey)); + r.boundary(&_tmp2)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { - preserves::value::Value::Symbol(w) if w == "definitions" => {_tmp1 = Some(Definitions::deserialize(r)?); continue;} - preserves::value::Value::Symbol(w) if w == "embeddedType" => {_tmp2 = Some(EmbeddedTypeName::deserialize(r)?); continue;} - preserves::value::Value::Symbol(w) if w == "version" => {_tmp3 = Some(Version::deserialize(r)?); continue;} + preserves::value::Value::Symbol(w) if w == "definitions" => { + _tmp2.shift(Some(_support::B::Item::DictionaryValue)); + r.boundary(&_tmp2)?; + _tmp3 = Some(Definitions::deserialize(r)?); + continue; + } + preserves::value::Value::Symbol(w) if w == "embeddedType" => { + _tmp2.shift(Some(_support::B::Item::DictionaryValue)); + r.boundary(&_tmp2)?; + _tmp4 = Some(EmbeddedTypeName::deserialize(r)?); + continue; + } + preserves::value::Value::Symbol(w) if w == "version" => { + _tmp2.shift(Some(_support::B::Item::DictionaryValue)); + r.boundary(&_tmp2)?; + _tmp5 = Some(Version::deserialize(r)?); + continue; + } _ => return Err(_support::ParseError::conformance_error("schema.Schema"))?, } _ => return Err(_support::ParseError::conformance_error("schema.Schema"))?, } } - r.ensure_complete()?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; Ok(Schema { - definitions: _tmp1.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?, - embedded_type: _tmp2.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?, - version: _tmp3.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))? + definitions: _tmp3.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?, + embedded_type: _tmp4.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?, + version: _tmp5.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))? }) } } @@ -1336,7 +1470,7 @@ impl std::convert::From<&SimplePattern> for _Any { } fn read_simple_pattern_any<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { - match r.next_token(false)? { + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "any" => {} _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::any"))?, @@ -1349,93 +1483,125 @@ fn read_simple_pattern_any<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) fn read_simple_pattern_atom<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "atom" => {} _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom"))?, } _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom"))?, } - let _tmp0 = (); - let _tmp1 = AtomKind::deserialize(r)?; - r.ensure_complete()?; - Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp1)}) + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp2 = AtomKind::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)}) } fn read_simple_pattern_embedded<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "embedded" => {} _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded"))?, } _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded"))?, } - let _tmp0 = (); - let _tmp1 = SimplePattern::deserialize(r)?; - r.ensure_complete()?; - Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp1)}) + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp2 = SimplePattern::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)}) } fn read_simple_pattern_lit<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "lit" => {} _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit"))?, } _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit"))?, } - let _tmp0 = (); - let _tmp1 = r.demand_next(false)?; - r.ensure_complete()?; - Ok(SimplePattern::Lit {value: _tmp1}) + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp2 = r.demand_next(true)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(SimplePattern::Lit {value: _tmp2}) } fn read_simple_pattern_seqof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "seqof" => {} _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof"))?, } _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof"))?, } - let _tmp0 = (); - let _tmp1 = SimplePattern::deserialize(r)?; - r.ensure_complete()?; - Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp1)}) + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp2 = SimplePattern::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)}) } fn read_simple_pattern_setof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "setof" => {} _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof"))?, } _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof"))?, } - let _tmp0 = (); - let _tmp1 = SimplePattern::deserialize(r)?; - r.ensure_complete()?; - Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp1)}) + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp2 = SimplePattern::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)}) } fn read_simple_pattern_dictof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; - match r.next_token(false)? { + let mut _tmp0 = _support::B::Type::default(); + _tmp0.shift(Some(_support::B::Item::RecordLabel)); + r.boundary(&_tmp0)?; + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "dictof" => {} _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof"))?, } _ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof"))?, } - let _tmp0 = (); - let _tmp1 = SimplePattern::deserialize(r)?; + let _tmp1 = (); + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; let _tmp2 = SimplePattern::deserialize(r)?; - r.ensure_complete()?; - Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp1), value: std::boxed::Box::new(_tmp2)}) + _tmp0.shift(Some(_support::B::Item::RecordField)); + r.boundary(&_tmp0)?; + let _tmp3 = SimplePattern::deserialize(r)?; + r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?; + Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)}) } fn read_simple_pattern_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { @@ -1473,7 +1639,7 @@ impl std::convert::From<&Version> for _Any { impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Version { fn deserialize(r: &mut R) -> std::result::Result { - match r.next_token(false)? { + match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::SignedInteger(w) if *w == (1).into() => {} _ => return Err(_support::ParseError::conformance_error("schema.Version"))?, diff --git a/implementations/rust/preserves-schema/src/support/mod.rs b/implementations/rust/preserves-schema/src/support/mod.rs index 0f2bb22..6b8cacf 100644 --- a/implementations/rust/preserves-schema/src/support/mod.rs +++ b/implementations/rust/preserves-schema/src/support/mod.rs @@ -1,6 +1,7 @@ pub use lazy_static::lazy_static; pub use preserves::value::Reader; +pub use preserves::value::boundary as B; use preserves::value::ArcValue; use preserves::value::Domain; diff --git a/implementations/rust/preserves/src/value/boundary.rs b/implementations/rust/preserves/src/value/boundary.rs index b6ebd69..86e85cf 100644 --- a/implementations/rust/preserves/src/value/boundary.rs +++ b/implementations/rust/preserves/src/value/boundary.rs @@ -17,6 +17,7 @@ pub enum Item { } impl Type { + #[inline] pub fn shift(&mut self, i: Option) { let tmp = std::mem::replace(&mut self.opening, i); self.closing = tmp; diff --git a/implementations/rust/preserves/src/value/packed/reader.rs b/implementations/rust/preserves/src/value/packed/reader.rs index 9a43c7d..7491029 100644 --- a/implementations/rust/preserves/src/value/packed/reader.rs +++ b/implementations/rust/preserves/src/value/packed/reader.rs @@ -388,6 +388,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainDecode, S: Binar self.next_compound(Tag::Dictionary, ExpectedKind::Dictionary) } + #[inline] fn boundary(&mut self, _b: &B::Type) -> ReaderResult<()> { Ok(()) } diff --git a/implementations/rust/preserves/src/value/packed/writer.rs b/implementations/rust/preserves/src/value/packed/writer.rs index 855bcce..64be487 100644 --- a/implementations/rust/preserves/src/value/packed/writer.rs +++ b/implementations/rust/preserves/src/value/packed/writer.rs @@ -127,6 +127,7 @@ impl WriteWriter for BinaryOrderWriter { } impl CompoundWriter for PackedWriter { + #[inline] fn boundary(&mut self, b: &B::Type) -> io::Result<()> { if let Some(B::Item::Annotation) = b.opening { self.write_tag(Tag::Annotation)?; @@ -136,6 +137,7 @@ impl CompoundWriter for PackedWriter { } impl CompoundWriter for BinaryOrderWriter { + #[inline] fn boundary(&mut self, b: &B::Type) -> io::Result<()> { match b.closing { Some(B::Item::DictionaryValue) | diff --git a/implementations/rust/preserves/src/value/text/reader.rs b/implementations/rust/preserves/src/value/text/reader.rs index e732edf..e4c2ce7 100644 --- a/implementations/rust/preserves/src/value/text/reader.rs +++ b/implementations/rust/preserves/src/value/text/reader.rs @@ -519,6 +519,7 @@ impl<'a, 'de, D: Embeddable, N: NestedValue, Dec: DomainParse> Reader<'de, Ok(()) } + #[inline] fn boundary(&mut self, b: &B::Type) -> ReaderResult<()> { match b { B::Type { diff --git a/implementations/rust/preserves/src/value/text/writer.rs b/implementations/rust/preserves/src/value/text/writer.rs index 0bdb05b..ae2bc4f 100644 --- a/implementations/rust/preserves/src/value/text/writer.rs +++ b/implementations/rust/preserves/src/value/text/writer.rs @@ -98,6 +98,7 @@ impl TextWriter { } impl CompoundWriter for TextWriter { + #[inline] fn boundary(&mut self, b: &B::Type) -> io::Result<()> { match (b.closing.as_ref(), b.opening.as_ref()) { (None, Some(B::Item::RecordLabel)) |