diff --git a/implementations/rust/preserves-schema/src/compiler/context.rs b/implementations/rust/preserves-schema/src/compiler/context.rs index 57859b2..d6499d1 100644 --- a/implementations/rust/preserves-schema/src/compiler/context.rs +++ b/implementations/rust/preserves-schema/src/compiler/context.rs @@ -215,7 +215,7 @@ impl<'m, 'b> ModuleContext<'m, 'b> { "'a", seq!["_L: Copy", seq(lts.into_iter().map(|t| item(seq![" + Into<&'a ", t, ">"])).collect())], - seq![self.any_type(), ": preserves::value::NestedValue + 'a"]]) + seq![self.any_type(), ": _support::preserves::value::NestedValue + 'a"]]) } pub fn extract(&mut self) -> Vec { diff --git a/implementations/rust/preserves-schema/src/compiler/mod.rs b/implementations/rust/preserves-schema/src/compiler/mod.rs index 8c30570..896d176 100644 --- a/implementations/rust/preserves-schema/src/compiler/mod.rs +++ b/implementations/rust/preserves-schema/src/compiler/mod.rs @@ -275,9 +275,8 @@ pub fn compile(config: &CompilerConfig) -> io::Result<()> { "use _support::Deserialize;", "use _support::Parse;", "use _support::Unparse;", - "use _support::preserves;", - "use preserves::value::Domain;", - "use preserves::value::NestedValue;", + "use _support::preserves::value::Domain;", + "use _support::preserves::value::NestedValue;", ""]))); let mut emit_items = |items: Vec| { @@ -307,18 +306,17 @@ pub fn compile(config: &CompilerConfig) -> io::Result<()> { lines.push("".to_owned()); lines.push(format!("use {}::support as _support;", &config.support_crate)); - lines.push("use _support::preserves;".to_owned()); lines.push("".to_owned()); lines.push("#[allow(non_snake_case)]".to_owned()); lines.push(Formatter::to_string(item(seq![ - "pub struct ", b.language_struct_name(), anglebrackets!["N: preserves::value::NestedValue"], " ", + "pub struct ", b.language_struct_name(), anglebrackets!["N: _support::preserves::value::NestedValue"], " ", vertical(false, braces(b.literals.iter().map( |(value, name)| item(format!("pub {}: N /* {:?} */", name, value))).collect())) ]))); lines.push("".to_owned()); lines.push(Formatter::to_string(item(seq![ - "impl", anglebrackets!["N: preserves::value::NestedValue"], + "impl", anglebrackets!["N: _support::preserves::value::NestedValue"], " Default for ", b.language_struct_name(), " ", codeblock![ seq!["fn default() -> Self ", codeblock![ seq![b.language_struct_name(), " ", vertical(false, braces(b.literals.iter().map(|(value, name)| { diff --git a/implementations/rust/preserves-schema/src/compiler/parsers.rs b/implementations/rust/preserves-schema/src/compiler/parsers.rs index 5c9419d..bc25553 100644 --- a/implementations/rust/preserves-schema/src/compiler/parsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs @@ -175,7 +175,7 @@ fn simple_pattern_parser( let item_dest = simple_pattern_parser(ctxt, pattern, &tmp, 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()")); + ctxt.declare_compound(body, &dest, item("_support::preserves::value::Set::new()")); body.push(item(seq!["for ", tmp.to_owned(), " in ", src.to_owned(), ".value().to_set()?", " ", codeblock(inner)])); @@ -191,7 +191,7 @@ fn simple_pattern_parser( 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()")); + ctxt.declare_compound(body, &dest, item("_support::preserves::value::Map::new()")); body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")", " in ", src.to_owned(), ".value().to_dictionary()?", " ", codeblock(inner)])); diff --git a/implementations/rust/preserves-schema/src/compiler/readers.rs b/implementations/rust/preserves-schema/src/compiler/readers.rs index 1cf4519..5ece82c 100644 --- a/implementations/rust/preserves-schema/src/compiler/readers.rs +++ b/implementations/rust/preserves-schema/src/compiler/readers.rs @@ -65,12 +65,12 @@ impl BoundaryTracker { 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(), ")?;"])); + body.push(item(seq!["r.reader.boundary(&", self.tracker_name.clone(), ")?;"])); } fn emit_loop(&self, body: &mut Vec, inner: Vec) { body.push(item(seq![ - "while !r.close_compound", parens![ + "while !r.reader.close_compound", parens![ seq!["&mut ", self.tracker_name.clone()], seq!["&", self.item_expr]], "? ", codeblock(inner)])) @@ -89,7 +89,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { Definition::Or { pattern_0, pattern_1, pattern_n } => { let mut ps = vec![&**pattern_0, &**pattern_1]; ps.extend(pattern_n); - ctxt.define_atom(&mut body, "_mark", item("r.mark()?")); + ctxt.define_atom(&mut body, "_mark", item("r.reader.mark()?")); for NamedAlternative { variant_label: name, pattern: pat } in ps { let fname = seq!["read_", names::render_fieldname(n), "_", names::render_fieldname(name)]; let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]); @@ -103,9 +103,10 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { item(seq![ "fn ", fname.clone(), anglebrackets![ "'de", - seq![ctxt.m.any_type(), ": preserves::value::NestedValue"], - seq!["R: _support::Reader<'de, ", ctxt.m.any_type(), ">"]], - "(r: &mut R) -> ", + seq![ctxt.m.any_type(), ": _support::preserves::value::NestedValue"], + seq!["_Dec: _support::DomainDecode<", ctxt.m.any_type(), "::Embedded>"], + "_R: _support::Reader<'de>"], + seq!["(r: &mut _support::preserves::value::ConfiguredReader<'de, ", ctxt.m.any_type(), ", _Dec, _R>) -> "], "std::result::Result<", names::render_constructor(n), ty.generic_arg(ctxt.m), ", _support::ParseError> ", @@ -113,7 +114,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { }); body.push(item(seq![ "match ", fname, "(r) { ", - "Err(e) if e.is_conformance_error() => r.restore(&_mark)?, ", + "Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, ", "result => return result }"])); } body.push(item(seq![ctxt.err_code()])); @@ -122,10 +123,10 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { let mut ps = vec![&**pattern_0, &**pattern_1]; let mut need_restore = false; ps.extend(pattern_n); - ctxt.define_atom(&mut body, "_mark", item("r.mark()?")); + ctxt.define_atom(&mut body, "_mark", item("r.reader.mark()?")); for e in &ps { if need_restore { - body.push(item("r.restore(&_mark)?;")); + body.push(item("r.reader.restore(&_mark)?;")); } else { need_restore = true; } @@ -143,11 +144,12 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { item(seq![ "impl", anglebrackets![ "'de", - seq![ctxt.m.any_type(), ": preserves::value::NestedValue"], - seq!["R: _support::Reader<'de, ", ctxt.m.any_type(), ">"]], " ", - "_support::Deserialize", anglebrackets!["'de", ctxt.m.any_type(), "R"], " ", + seq![ctxt.m.any_type(), ": _support::preserves::value::NestedValue"], + seq!["_Dec: _support::DomainDecode<", ctxt.m.any_type(), "::Embedded>"], + "_R: _support::Reader<'de>"], " ", + "_support::Deserialize", anglebrackets!["'de", ctxt.m.any_type(), "_Dec", "_R"], " ", "for ", names::render_constructor(n), ty.generic_arg(ctxt.m), " ", codeblock![ - seq!["fn deserialize(r: &mut R) -> ", + seq!["fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, ", ctxt.m.any_type(), ", _Dec, _R>) -> ", "std::result::Result ", codeblock(body)]]]) }); @@ -239,7 +241,7 @@ fn read_expected_literal_seqs( None => { let mut inner = Vec::new(); group.into_iter().next().unwrap().1(ctxt, &mut inner); - cases.push(item(seq!["preserves::value::Token::End => ", codeblock(inner)])); + cases.push(item(seq!["_support::preserves::value::Token::End => ", codeblock(inner)])); }, Some(h) => { let tails = group.into_iter().map(|(mut vs, f)| { @@ -253,7 +255,7 @@ fn read_expected_literal_seqs( } } cases.extend(read_expected_literals_cases(ctxt, nested)); - body.push(item(seq!["match r.next_token(true)? ", codeblock(cases)])); + body.push(item(seq!["match r.next_token()? ", codeblock(cases)])); } fn read_expected_literals_cases( @@ -269,7 +271,7 @@ fn read_expected_literals_cases( let mut inner = Vec::new(); p.1(ctxt, &mut inner); subcases.push(item(seq![ - format!("preserves::value::Value::{:?}(w)", cls), + format!("_support::preserves::value::Value::{:?}(w)", cls), match cls { AtomClass::Boolean => match p.0.value().to_boolean().unwrap() { true => " if *w".to_owned(), @@ -291,7 +293,7 @@ fn read_expected_literals_cases( codeblock(inner)])); } subcases.push(item(seq!["_ => return ", ctxt.err_code(), "?,"])); - item(seq!["preserves::value::Token::Atom(v) => match v.value() ", codeblock(subcases)]) + item(seq!["_support::preserves::value::Token::Atom(v) => match v.value() ", codeblock(subcases)]) } ValueClass::Compound(CompoundClass::Record) => { let mut subcases = Vec::new(); @@ -300,7 +302,7 @@ fn read_expected_literals_cases( (r.0.clone(), f) }).collect()); item(seq![ - "preserves::value::Token::Compound(preserves::value::CompoundClass::Record) => ", + "_support::preserves::value::Token::Compound(_support::preserves::value::CompoundClass::Record) => ", codeblock(subcases)]) } ValueClass::Compound(CompoundClass::Sequence) => { @@ -310,7 +312,7 @@ fn read_expected_literals_cases( (s, f) }).collect()); item(seq![ - "preserves::value::Token::Compound(preserves::value::CompoundClass::Sequence) => ", + "_support::preserves::value::Token::Compound(_support::preserves::value::CompoundClass::Sequence) => ", codeblock(subcases)]) } ValueClass::Compound(CompoundClass::Set) => { @@ -334,7 +336,7 @@ fn read_expected_literals( possibilities: LiteralCases, ) { let cases = read_expected_literals_cases(ctxt, possibilities); - body.push(item(seq!["match r.next_token(true)? ", codeblock(cases)])); + body.push(item(seq!["match r.next_token()? ", codeblock(cases)])); } fn simple_pattern_reader( @@ -346,27 +348,27 @@ fn simple_pattern_reader( let dest = ctxt.gentempname(); match p { SimplePattern::Any => { - ctxt.define_atom(body, &dest, item("r.demand_next(true)?")); + ctxt.define_atom(body, &dest, item("r.demand_next()?")); dest }, SimplePattern::Atom { atom_kind: k } => { let reader = match &**k { - AtomKind::Boolean => "r.next_boolean()?", - AtomKind::Float => "r.next_float()?", - AtomKind::Double => "r.next_double()?", - AtomKind::SignedInteger => "r.next_signedinteger()?", - AtomKind::String => "r.next_str()?.into_owned()", - AtomKind::ByteString => "r.next_bytestring()?.into_owned()", - AtomKind::Symbol => "r.next_symbol()?.into_owned()", + AtomKind::Boolean => "r.reader.next_boolean()?", + AtomKind::Float => "r.reader.next_float()?", + AtomKind::Double => "r.reader.next_double()?", + AtomKind::SignedInteger => "r.reader.next_signedinteger()?", + AtomKind::String => "r.reader.next_str()?.into_owned()", + AtomKind::ByteString => "r.reader.next_bytestring()?.into_owned()", + AtomKind::Symbol => "r.reader.next_symbol()?.into_owned()", }; ctxt.define_atom(body, &dest, item(reader.to_owned())); 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(true)?.value().to_embedded()?.clone()")); - body.push(item("r.close_embedded()?;")); + body.push(item("r.reader.open_embedded()?;")); + ctxt.define_atom(body, &dest, item("r.demand_next()?.value().to_embedded()?.clone()")); + body.push(item("r.reader.close_embedded()?;")); dest }, SimplePattern::Lit { value } => { @@ -379,7 +381,7 @@ fn simple_pattern_reader( let compound_dest = ctxt.gentempname(); ctxt.with_definite_mode(|ctxt| { let boundary_tracker = BoundaryTracker::unwrap( - ctxt, body, "r.open_sequence()?;", boundary_tracker); + ctxt, body, "r.reader.open_sequence()?;", boundary_tracker); let mut inner = Vec::new(); boundary_tracker.emit_boundary(&mut inner); let item_dest = simple_pattern_reader(ctxt, pattern, None, &mut inner); @@ -395,13 +397,13 @@ fn simple_pattern_reader( let compound_dest = ctxt.gentempname(); ctxt.with_definite_mode(|ctxt| { let boundary_tracker = BoundaryTracker::new( - ctxt, body, "r.open_set()?;", "_support::B::Item::SetValue"); + ctxt, body, "r.reader.open_set()?;", "_support::B::Item::SetValue"); let mut inner = Vec::new(); boundary_tracker.emit_boundary(&mut inner); let item_dest = simple_pattern_reader(ctxt, pattern, None, &mut inner); inner.push(item(seq![compound_dest.to_owned(), ".insert(", store_wrap(true, &field_type(pattern), &item_dest), ");"])); - ctxt.declare_compound(body, &compound_dest, item("preserves::value::Set::new()")); + ctxt.declare_compound(body, &compound_dest, item("_support::preserves::value::Set::new()")); boundary_tracker.emit_loop(body, inner); }); ctxt.define_atom(body, &dest, item(compound_dest)); @@ -411,7 +413,7 @@ fn simple_pattern_reader( let compound_dest = ctxt.gentempname(); ctxt.with_definite_mode(|ctxt| { let mut boundary_tracker = BoundaryTracker::new( - ctxt, body, "r.open_dictionary()?;", "_support::B::Item::DictionaryKey"); + ctxt, body, "r.reader.open_dictionary()?;", "_support::B::Item::DictionaryKey"); let mut inner = Vec::new(); boundary_tracker.emit_boundary(&mut inner); let key_dest = simple_pattern_reader(ctxt, key, None, &mut inner); @@ -422,7 +424,7 @@ fn simple_pattern_reader( compound_dest.to_owned(), ".insert(", store_wrap(true, &field_type(key), &key_dest), ", ", store_wrap(true, &field_type(value), &value_dest), ");"])); - ctxt.declare_compound(body, &compound_dest, item("preserves::value::Map::new()")); + ctxt.declare_compound(body, &compound_dest, item("_support::preserves::value::Map::new()")); boundary_tracker.item_expr = "_support::B::Item::DictionaryKey"; boundary_tracker.emit_loop(body, inner); }); @@ -469,7 +471,7 @@ fn pattern_reader( match &**c { CompoundPattern::Rec { label, fields } => { let mut boundary_tracker = BoundaryTracker::new( - ctxt, body, "r.open_record(None)?;", "_support::B::Item::RecordLabel"); + ctxt, body, "r.reader.open_record()?;", "_support::B::Item::RecordLabel"); boundary_tracker.emit_boundary(body); boundary_tracker.item_expr = "_support::B::Item::RecordField"; named_pattern_reader(ctxt, &**label, None, body); @@ -477,18 +479,18 @@ fn pattern_reader( }, CompoundPattern::Tuple { patterns } => { let boundary_tracker = BoundaryTracker::unwrap( - ctxt, body, "r.open_sequence()?;", boundary_tracker); + ctxt, body, "r.reader.open_sequence()?;", boundary_tracker); for p in patterns { boundary_tracker.emit_boundary(body); named_pattern_reader(ctxt, p, None, body); } - body.push(item(seq!["r.ensure_complete", parens![ + body.push(item(seq!["r.reader.ensure_complete", parens![ boundary_tracker.tracker_name.clone(), seq!["&", boundary_tracker.item_expr]], "?;"])); }, CompoundPattern::TuplePrefix { fixed, variable } => { let boundary_tracker = BoundaryTracker::unwrap( - ctxt, body, "r.open_sequence()?;", boundary_tracker); + ctxt, body, "r.reader.open_sequence()?;", boundary_tracker); for p in fixed { boundary_tracker.emit_boundary(body); named_pattern_reader(ctxt, p, None, body); @@ -497,7 +499,7 @@ fn pattern_reader( }, CompoundPattern::Dict { entries } => { let boundary_tracker = BoundaryTracker::new( - ctxt, body, "r.open_dictionary()?;", "_support::B::Item::DictionaryKey"); + ctxt, body, "r.reader.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(); diff --git a/implementations/rust/preserves-schema/src/compiler/types.rs b/implementations/rust/preserves-schema/src/compiler/types.rs index 2c659c2..b6ed6eb 100644 --- a/implementations/rust/preserves-schema/src/compiler/types.rs +++ b/implementations/rust/preserves-schema/src/compiler/types.rs @@ -53,7 +53,7 @@ impl compiler::Plugin for TypePlugin { m.define_type(item(vertical(false, seq![ seq!["pub type _Dom = ", m.render_ref(&*r, RefRenderStyle::Bare), ";"], seq!["pub type _Ptr = std::sync::Arc<_Dom>;"], - seq!["pub type _Any = preserves::value::ArcValue<_Ptr>;"] + seq!["pub type _Any = _support::preserves::value::ArcValue<_Ptr>;"] ]))); } } @@ -63,7 +63,7 @@ impl compiler::Plugin for TypePlugin { let ty = definition_type(&m.module_path, n, d); m.define_type(item(ty.render(m, n))); m.define_type(item(seq![ - "impl", ty.generic_decl(m), " preserves::value::Domain for ", + "impl", ty.generic_decl(m), " _support::preserves::value::Domain for ", names::render_constructor(n), ty.generic_arg(m), " {}"])); } } @@ -174,9 +174,9 @@ pub fn field_type(p: &SimplePattern) -> TField { SimplePattern::Atom { atom_kind: k } => match **k { AtomKind::Boolean => TField::Base("bool".to_owned()), - AtomKind::Float => TField::Base("preserves::value::Float".to_owned()), - AtomKind::Double => TField::Base("preserves::value::Double".to_owned()), - AtomKind::SignedInteger => TField::Base("preserves::value::signed_integer::SignedInteger".to_owned()), + AtomKind::Float => TField::Base("_support::preserves::value::Float".to_owned()), + AtomKind::Double => TField::Base("_support::preserves::value::Double".to_owned()), + AtomKind::SignedInteger => TField::Base("_support::preserves::value::signed_integer::SignedInteger".to_owned()), AtomKind::String => TField::Base("std::string::String".to_owned()), AtomKind::ByteString => TField::Base("std::vec::Vec".to_owned()), AtomKind::Symbol => TField::Base("std::string::String".to_owned()), @@ -200,8 +200,8 @@ impl TField { TField::Any => seq![ctxt.any_type()], TField::Embedded => seq![ctxt.any_type(), "::Embedded"], TField::Array(t) => seq!["std::vec::Vec<", t.render(ctxt, false), ">"], - TField::Set(t) => seq!["preserves::value::Set<", t.render(ctxt, false), ">"], - TField::Map(k, v) => seq!["preserves::value::Map", + TField::Set(t) => seq!["_support::preserves::value::Set<", t.render(ctxt, false), ">"], + TField::Map(k, v) => seq!["_support::preserves::value::Map", anglebrackets![k.render(ctxt, false), v.render(ctxt, false)]], TField::Ref(r) => @@ -294,7 +294,7 @@ impl TDefinition { pub fn generic_decl(&self, ctxt: &ModuleContext) -> Item { if self.has_embedded(ctxt.bundle) { item(anglebrackets![ - seq![ctxt.any_type(), ": preserves::value::NestedValue"]]) + seq![ctxt.any_type(), ": _support::preserves::value::NestedValue"]]) } else { item("") } @@ -303,9 +303,9 @@ impl TDefinition { pub fn generic_decl_with_defaults(&self, ctxt: &ModuleContext) -> Item { if self.has_embedded(ctxt.bundle) { item(anglebrackets![ - seq![ctxt.any_type(), ": preserves::value::NestedValue = ", + seq![ctxt.any_type(), ": _support::preserves::value::NestedValue = ", match ctxt.schema.embedded_type { - EmbeddedTypeName::False => "preserves::value::IOValue", + EmbeddedTypeName::False => "_support::preserves::value::IOValue", EmbeddedTypeName::Ref(_) => "_Any", }]]) } else { diff --git a/implementations/rust/preserves-schema/src/compiler/unparsers.rs b/implementations/rust/preserves-schema/src/compiler/unparsers.rs index eec1cb9..8f323e9 100644 --- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs @@ -85,7 +85,7 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) { let (patpat, vc) = destruct(&mut ctxt, item(names::render_constructor(n)), true, &record_type(&ps)); body.push(item(seq!["let ", patpat, " = self;"])); body.push(item(seq![ - "preserves::value::merge(vec!", brackets(ps.iter().map( + "_support::preserves::value::merge(vec!", brackets(ps.iter().map( |p| named_pattern_unparser(&mut ctxt, p, &vc)).collect() ), ").expect", parens![escape_string(&( "merge of ".to_owned() + &ctxt.fully_qualified_error_context()))]])); @@ -144,15 +144,15 @@ fn simple_pattern_unparser( SimplePattern::Atom { atom_kind: k } => { match &**k { AtomKind::Symbol => - item(seq!["preserves::value::Value::symbol(", src.as_ref().unwrap().to_owned(), ").wrap()"]), + item(seq!["_support::preserves::value::Value::symbol(", src.as_ref().unwrap().to_owned(), ").wrap()"]), AtomKind::ByteString => - item(seq!["preserves::value::Value::ByteString(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]), + item(seq!["_support::preserves::value::Value::ByteString(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]), _ => - item(seq!["preserves::value::Value::from(", src.as_ref().unwrap().to_owned(), ").wrap()"]) + item(seq!["_support::preserves::value::Value::from(", src.as_ref().unwrap().to_owned(), ").wrap()"]) } } SimplePattern::Embedded { .. } => - item(seq!["preserves::value::Value::Embedded(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]), + item(seq!["_support::preserves::value::Value::Embedded(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]), SimplePattern::Lit { value } => item(seq![parens![ctxt.m.define_literal(value)], ".clone()"]), SimplePattern::Seqof { pattern } => { @@ -169,7 +169,7 @@ fn simple_pattern_unparser( } SimplePattern::Setof { pattern } => { let tmp = ctxt.gentempname(); - item(seq!["preserves::value::Value::Set(", + item(seq!["_support::preserves::value::Value::Set(", src.as_ref().unwrap().to_owned(), ".iter().map(|", tmp.to_owned(), "| ", simple_pattern_unparser(ctxt, pattern, &normal_src(tmp, true)), ").collect()).wrap()"]) @@ -177,7 +177,7 @@ fn simple_pattern_unparser( SimplePattern::Dictof { key, value } => { let tmp_key = ctxt.gentempname(); let tmp_value = ctxt.gentempname(); - item(seq!["preserves::value::Value::Dictionary(", + item(seq!["_support::preserves::value::Value::Dictionary(", src.as_ref().unwrap().to_owned(), ".iter().map(|(", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")| ", parens![simple_pattern_unparser(ctxt, key, &normal_src(tmp_key, true)), @@ -225,7 +225,7 @@ fn pattern_unparser( let rtmp = ctxt.gentempname(); let mut body = Vec::new(); let init_expr = item(seq![ - "preserves::value::Record(vec![", + "_support::preserves::value::Record(vec![", named_pattern_unparser(ctxt, label, &normal_none(vc.is_struct)), "])"]); ctxt.declare_compound(&mut body, &rtmp, init_expr); @@ -256,13 +256,13 @@ fn pattern_unparser( CompoundPattern::Dict { entries } => { let dtmp = ctxt.gentempname(); let mut body = Vec::new(); - ctxt.declare_compound(&mut body, &dtmp, item("preserves::value::Map::new()")); + ctxt.declare_compound(&mut body, &dtmp, item("_support::preserves::value::Map::new()")); for (key_lit, value_pat) in entries.0.iter() { body.push(item(seq![dtmp.clone(), ".insert", parens![ seq![parens![ctxt.m.define_literal(key_lit)], ".clone()"], named_pattern_unparser(ctxt, &promote(value_pat), &normal_none(vc.is_struct))], ";"])); } - body.push(item(seq!["preserves::value::Value::Dictionary(", dtmp, ").wrap()"])); + body.push(item(seq!["_support::preserves::value::Value::Dictionary(", dtmp, ").wrap()"])); item(codeblock(body)) } } @@ -283,7 +283,7 @@ fn sequenceify<'a>( ctxt.declare_compound(&mut body, &rtmp, item("std::vec::Vec::new()")); FieldsSink { finish: item(seq![ - "preserves::value::Value::Sequence", parens![rtmp.clone()], ".wrap()"]), + "_support::preserves::value::Value::Sequence", parens![rtmp.clone()], ".wrap()"]), vec_expr: item(rtmp), body: body, }