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

Update compiler

This commit is contained in:
Tony Garnock-Jones 2022-07-10 18:19:51 +02:00
parent a4cb03ec2f
commit a2443607da
6 changed files with 71 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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<Item> {

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

@ -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<Item>| {
@ -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(), "<N> ", codeblock![
seq!["fn default() -> Self ", codeblock![
seq![b.language_struct_name(), " ", vertical(false, braces(b.literals.iter().map(|(value, name)| {

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

@ -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)]));

84
implementations/rust/preserves-schema/src/compiler/readers.rs
View File

@ -65,12 +65,12 @@ impl BoundaryTracker {
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(), ")?;"]));
body.push(item(seq!["r.reader.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![
"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<Self, _support::ParseError> ",
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();

20
implementations/rust/preserves-schema/src/compiler/types.rs
View File

@ -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<u8>".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 {

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

@ -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,
}