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