Track boundaries in schema-emitted reader code

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<Item>,
+        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<Item>,
+        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<Item>) {
+        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<Item>, inner: Vec<Item>) {
+        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<Item>,
 ) -> 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 {
+            let boundary_tracker = BoundaryTracker::unwrap(
-                body.push(item("r.open_sequence()?;"));
+                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);
+            boundary_tracker.emit_boundary(&mut inner);
-            let value_dest = simple_pattern_reader(ctxt, value, false, &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<Item>,
 ) {
     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<Item>,
 ) -> Option<String> {
     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)?;"));
+                    let mut boundary_tracker = BoundaryTracker::new(
-                    named_pattern_reader(ctxt, &**label, false, body);
+                        ctxt, body, "r.open_record(None)?;", "_support::B::Item::RecordLabel");
-                    named_pattern_reader(ctxt, &**fields, true, body);
+                    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 {
+                    let boundary_tracker = BoundaryTracker::unwrap(
-                        body.push(item("r.open_sequence()?;"));
+                        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(seq!["r.ensure_complete", parens![
-                    body.push(item("r.ensure_complete()?;"));
+                        boundary_tracker.tracker_name.clone(),
+                        seq!["&", boundary_tracker.item_expr]], "?;"]));
                 },
                 CompoundPattern::TuplePrefix { fixed, variable } => {
-                    if !in_sequence {
+                    let boundary_tracker = BoundaryTracker::unwrap(
-                        body.push(item("r.open_sequence()?;"));
+                        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), Some(&boundary_tracker), body);
-                    named_pattern_reader(ctxt, &promote(variable), true, 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<Item>| {
-                                    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

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<AtomKind, _support::ParseError> {
-    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<AtomKind, _support::ParseError> {
-    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<AtomKind, _support::ParseError> {
-    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<AtomKind, _support::ParseError> {
-    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<AtomKind, _support::ParseError> {
-    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<AtomKind, _support::ParseError> {
-    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<AtomKind, _support::ParseError> {
-    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<Self, _support::ParseError> {
         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 = ();
-        let _tmp1 = r.next_symbol()?.into_owned();
+        _tmp0.shift(Some(_support::B::Item::RecordField));
-        let _tmp2 = SimplePattern::deserialize(r)?;
+        r.boundary(&_tmp0)?;
-        r.ensure_complete()?;
+        let _tmp2 = r.next_symbol()?.into_owned();
-        Ok(Binding {name: _tmp1, pattern: _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(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<Self, _support::ParseError> {
         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 = ();
-        let _tmp1 = Modules::deserialize(r)?;
+        _tmp0.shift(Some(_support::B::Item::RecordField));
-        r.ensure_complete()?;
+        r.boundary(&_tmp0)?;
-        Ok(Bundle {modules: _tmp1})
+        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<CompoundPattern, _support::ParseError> {
     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 = ();
-    let _tmp1 = NamedPattern::deserialize(r)?;
+    _tmp0.shift(Some(_support::B::Item::RecordField));
+    r.boundary(&_tmp0)?;
     let _tmp2 = NamedPattern::deserialize(r)?;
-    r.ensure_complete()?;
+    _tmp0.shift(Some(_support::B::Item::RecordField));
-    Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp1), fields: std::boxed::Box::new(_tmp2)})
+    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<CompoundPattern, _support::ParseError> {
     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();
+    let mut _tmp3 = _support::B::Type::default();
-    while !(r.close_compound()?) {let _tmp2 = NamedPattern::deserialize(r)?; _tmp1.push(_tmp2);}
+    let mut _tmp2 = std::vec::Vec::new();
-    r.ensure_complete()?;
+    while !r.close_compound(&mut _tmp3, &_support::B::Item::SequenceValue)? {
-    Ok(CompoundPattern::Tuple {patterns: _tmp1})
+        _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<CompoundPattern, _support::ParseError> {
     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();
+    let mut _tmp3 = _support::B::Type::default();
-    while !(r.close_compound()?) {let _tmp2 = NamedPattern::deserialize(r)?; _tmp1.push(_tmp2);}
+    let mut _tmp2 = std::vec::Vec::new();
-    let _tmp3 = NamedSimplePattern::deserialize(r)?;
+    while !r.close_compound(&mut _tmp3, &_support::B::Item::SequenceValue)? {
-    r.ensure_complete()?;
+        _tmp3.shift(Some(_support::B::Item::SequenceValue));
-    Ok(CompoundPattern::TuplePrefix {fixed: _tmp1, variable: std::boxed::Box::new(_tmp3)})
+        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<CompoundPattern, _support::ParseError> {
     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 = ();
-    let _tmp1 = DictionaryEntries::deserialize(r)?;
+    _tmp0.shift(Some(_support::B::Item::RecordField));
-    r.ensure_complete()?;
+    r.boundary(&_tmp0)?;
-    Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp1)})
+    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<Definition, _support::ParseError> {
     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 mut _tmp2 = _support::B::Type::default();
-    let _tmp2 = NamedAlternative::deserialize(r)?;
+    _tmp2.shift(Some(_support::B::Item::SequenceValue));
-    let mut _tmp3 = std::vec::Vec::new();
+    r.boundary(&_tmp2)?;
-    while !(r.close_compound()?) {let _tmp4 = NamedAlternative::deserialize(r)?; _tmp3.push(_tmp4);}
+    let _tmp3 = NamedAlternative::deserialize(r)?;
-    r.ensure_complete()?;
+    _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_0: std::boxed::Box::new(_tmp3),
-        pattern_1: std::boxed::Box::new(_tmp2),
+        pattern_1: std::boxed::Box::new(_tmp4),
-        pattern_n: _tmp3
+        pattern_n: _tmp5
     })
 }
 
 fn read_definition_and<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Definition, _support::ParseError> {
     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 mut _tmp2 = _support::B::Type::default();
-    let _tmp2 = NamedPattern::deserialize(r)?;
+    _tmp2.shift(Some(_support::B::Item::SequenceValue));
-    let mut _tmp3 = std::vec::Vec::new();
+    r.boundary(&_tmp2)?;
-    while !(r.close_compound()?) {let _tmp4 = NamedPattern::deserialize(r)?; _tmp3.push(_tmp4);}
+    let _tmp3 = NamedPattern::deserialize(r)?;
-    r.ensure_complete()?;
+    _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_0: std::boxed::Box::new(_tmp3),
-        pattern_1: std::boxed::Box::new(_tmp2),
+        pattern_1: std::boxed::Box::new(_tmp4),
-        pattern_n: _tmp3
+        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<Self, _support::ParseError> {
         r.open_dictionary()?;
+        let mut _tmp1 = _support::B::Type::default();
         let mut _tmp0 = preserves::value::Map::new();
-        while !(r.close_compound()?) {
+        while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? {
-            let _tmp1 = r.next_symbol()?.into_owned();
+            _tmp1.shift(Some(_support::B::Item::DictionaryKey));
-            let _tmp2 = Definition::deserialize(r)?;
+            r.boundary(&_tmp1)?;
-            _tmp0.insert(_tmp1, _tmp2);
+            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<Self, _support::ParseError> {
         r.open_dictionary()?;
+        let mut _tmp1 = _support::B::Type::default();
         let mut _tmp0 = preserves::value::Map::new();
-        while !(r.close_compound()?) {
+        while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? {
-            let _tmp1 = r.demand_next(false)?;
+            _tmp1.shift(Some(_support::B::Item::DictionaryKey));
-            let _tmp2 = NamedSimplePattern::deserialize(r)?;
+            r.boundary(&_tmp1)?;
-            _tmp0.insert(_tmp1, _tmp2);
+            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<EmbeddedTypeName, _support::ParseError> {
-    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<Self, _support::ParseError> {
         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<Self, _support::ParseError> {
         r.open_dictionary()?;
+        let mut _tmp1 = _support::B::Type::default();
         let mut _tmp0 = preserves::value::Map::new();
-        while !(r.close_compound()?) {
+        while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? {
-            let _tmp1 = ModulePath::deserialize(r)?;
+            _tmp1.shift(Some(_support::B::Item::DictionaryKey));
-            let _tmp2 = Schema::deserialize(r)?;
+            r.boundary(&_tmp1)?;
-            _tmp0.insert(_tmp1, _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(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<Self, _support::ParseError> {
         r.open_sequence()?;
-        let _tmp0 = r.next_str()?.into_owned();
+        let mut _tmp0 = _support::B::Type::default();
-        let _tmp1 = Pattern::deserialize(r)?;
+        _tmp0.shift(Some(_support::B::Item::SequenceValue));
-        r.ensure_complete()?;
+        r.boundary(&_tmp0)?;
-        Ok(NamedAlternative {variant_label: _tmp0, pattern: _tmp1})
+        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<Self, _support::ParseError> {
         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 = ();
-        let _tmp1 = ModulePath::deserialize(r)?;
+        _tmp0.shift(Some(_support::B::Item::RecordField));
-        let _tmp2 = r.next_symbol()?.into_owned();
+        r.boundary(&_tmp0)?;
-        r.ensure_complete()?;
+        let _tmp2 = ModulePath::deserialize(r)?;
-        Ok(Ref {module: _tmp1, name: _tmp2})
+        _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<Self, _support::ParseError> {
         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 = _support::B::Type::default();
-        let mut _tmp2 = None;
         let mut _tmp3 = None;
-        while !(r.close_compound()?) {
+        let mut _tmp4 = None;
-            match r.next_token(false)? {
+        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 == "definitions" => {
-                    preserves::value::Value::Symbol(w) if w == "embeddedType" => {_tmp2 = Some(EmbeddedTypeName::deserialize(r)?); continue;}
+                        _tmp2.shift(Some(_support::B::Item::DictionaryValue));
-                    preserves::value::Value::Symbol(w) if w == "version" => {_tmp3 = Some(Version::deserialize(r)?); continue;}
+                        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"))?,
+            definitions: _tmp3.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
-            embedded_type: _tmp2.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
+            embedded_type: _tmp4.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
-            version: _tmp3.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<SimplePattern, _support::ParseError> {
-    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<SimplePattern, _support::ParseError> {
     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 = ();
-    let _tmp1 = AtomKind::deserialize(r)?;
+    _tmp0.shift(Some(_support::B::Item::RecordField));
-    r.ensure_complete()?;
+    r.boundary(&_tmp0)?;
-    Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp1)})
+    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<SimplePattern, _support::ParseError> {
     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 = ();
-    let _tmp1 = SimplePattern::deserialize(r)?;
+    _tmp0.shift(Some(_support::B::Item::RecordField));
-    r.ensure_complete()?;
+    r.boundary(&_tmp0)?;
-    Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp1)})
+    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<SimplePattern, _support::ParseError> {
     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 = ();
-    let _tmp1 = r.demand_next(false)?;
+    _tmp0.shift(Some(_support::B::Item::RecordField));
-    r.ensure_complete()?;
+    r.boundary(&_tmp0)?;
-    Ok(SimplePattern::Lit {value: _tmp1})
+    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<SimplePattern, _support::ParseError> {
     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 = ();
-    let _tmp1 = SimplePattern::deserialize(r)?;
+    _tmp0.shift(Some(_support::B::Item::RecordField));
-    r.ensure_complete()?;
+    r.boundary(&_tmp0)?;
-    Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp1)})
+    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<SimplePattern, _support::ParseError> {
     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 = ();
-    let _tmp1 = SimplePattern::deserialize(r)?;
+    _tmp0.shift(Some(_support::B::Item::RecordField));
-    r.ensure_complete()?;
+    r.boundary(&_tmp0)?;
-    Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp1)})
+    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<SimplePattern, _support::ParseError> {
     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 = ();
-    let _tmp1 = SimplePattern::deserialize(r)?;
+    _tmp0.shift(Some(_support::B::Item::RecordField));
+    r.boundary(&_tmp0)?;
     let _tmp2 = SimplePattern::deserialize(r)?;
-    r.ensure_complete()?;
+    _tmp0.shift(Some(_support::B::Item::RecordField));
-    Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp1), value: std::boxed::Box::new(_tmp2)})
+    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<SimplePattern, _support::ParseError> {
@@ -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<Self, _support::ParseError> {
-        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"))?,

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;

implementations/rust/preserves/src/value/boundary.rs

@@ -17,6 +17,7 @@ pub enum Item {
 }
 
 impl Type {
+    #[inline]
     pub fn shift(&mut self, i: Option<Item>) {
         let tmp = std::mem::replace(&mut self.opening, i);
         self.closing = tmp;

implementations/rust/preserves/src/value/packed/reader.rs

@@ -388,6 +388,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>, S: Binar
         self.next_compound(Tag::Dictionary, ExpectedKind::Dictionary)
     }
 
+    #[inline]
     fn boundary(&mut self, _b: &B::Type) -> ReaderResult<()> {
         Ok(())
     }

implementations/rust/preserves/src/value/packed/writer.rs

@@ -127,6 +127,7 @@ impl WriteWriter for BinaryOrderWriter {
 }
 
 impl<W: io::Write> CompoundWriter for PackedWriter<W> {
+    #[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<W: io::Write> CompoundWriter for PackedWriter<W> {
 }
 
 impl CompoundWriter for BinaryOrderWriter {
+    #[inline]
     fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
         match b.closing {
             Some(B::Item::DictionaryValue) |

implementations/rust/preserves/src/value/text/reader.rs

@@ -519,6 +519,7 @@ impl<'a, 'de, D: Embeddable, N: NestedValue<D>, Dec: DomainParse<D>> Reader<'de,
         Ok(())
     }
 
+    #[inline]
     fn boundary(&mut self, b: &B::Type) -> ReaderResult<()> {
         match b {
             B::Type {

implementations/rust/preserves/src/value/text/writer.rs

@@ -98,6 +98,7 @@ impl<W: io::Write> TextWriter<W> {
 }
 
 impl<W: io::Write> CompoundWriter for TextWriter<W> {
+    #[inline]
     fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
         match (b.closing.as_ref(), b.opening.as_ref()) {
             (None, Some(B::Item::RecordLabel)) |