From 70990d2371e344a1c3ff93dadecacf640aa62780 Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Wed, 30 Jun 2021 16:07:49 +0200 Subject: [PATCH] Better names for literal constants --- .../rust/preserves-schema/Cargo.toml | 1 + .../preserves-schema/src/compiler/context.rs | 20 +- .../rust/preserves-schema/src/gen/schema.rs | 174 +++++++++--------- 3 files changed, 107 insertions(+), 88 deletions(-) diff --git a/implementations/rust/preserves-schema/Cargo.toml b/implementations/rust/preserves-schema/Cargo.toml index 1d0c6e6..24a914a 100644 --- a/implementations/rust/preserves-schema/Cargo.toml +++ b/implementations/rust/preserves-schema/Cargo.toml @@ -13,6 +13,7 @@ preserves = { path = "../preserves", version = "0.14.0" } structopt = "0.3.14" glob = "0.3.0" +regex = "1.5.4" convert_case = "0.4.0" diff --git a/implementations/rust/preserves-schema/src/compiler/context.rs b/implementations/rust/preserves-schema/src/compiler/context.rs index 87ac2e9..063fb5e 100644 --- a/implementations/rust/preserves-schema/src/compiler/context.rs +++ b/implementations/rust/preserves-schema/src/compiler/context.rs @@ -3,7 +3,13 @@ use crate::syntax::block::Item; use crate::syntax::block::constructors::*; use crate::gen::schema::*; +use convert_case::{Case, Casing}; + +use lazy_static::lazy_static; + use preserves::value::Map; +use preserves::value::NestedValue; +use preserves::value::Value; use super::CompilerConfig; use super::names; @@ -28,6 +34,10 @@ pub struct Capture { pub source_expr: String, } +lazy_static! { + static ref ID_RE: regex::Regex = regex::Regex::new(r"^[a-zA-Z][a-zA-Z_0-9]*$").unwrap(); +} + impl<'m> ModuleContext<'m> { pub fn new(config: &'m CompilerConfig) -> Self { ModuleContext { @@ -39,7 +49,15 @@ impl<'m> ModuleContext<'m> { } pub fn define_literal(&mut self, v: &_Any) -> String { - let next_id = format!("LIT{}", self.literals.len()); + let prefix = format!("LIT_{}", self.literals.len()); + let next_id = match v.value() { + Value::Boolean(b) => prefix + "_" + &b.to_string(), + Value::Symbol(s) => if ID_RE.is_match(&s) { prefix + "_" + s } else { prefix }, + Value::String(s) => if ID_RE.is_match(&s) { prefix + "_" + s } else { prefix }, + Value::SignedInteger(n) => prefix + "_" + &n.to_string(), + _ => prefix + }; + let next_id = next_id.to_case(Case::UpperSnake); "&*".to_owned() + self.literals.entry(v.clone()).or_insert(next_id) } diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs index 66dda6a..7de7aae 100644 --- a/implementations/rust/preserves-schema/src/gen/schema.rs +++ b/implementations/rust/preserves-schema/src/gen/schema.rs @@ -7,35 +7,35 @@ use preserves::value::NestedValue; use crate::support as _support; _support::lazy_static! { - pub static ref LIT15: preserves::value::IOValue = /* #f */ preserves::value::packed::from_bytes(&vec![128]).unwrap(); - pub static ref LIT28: preserves::value::IOValue = /* 1 */ preserves::value::packed::from_bytes(&vec![145]).unwrap(); - pub static ref LIT0: preserves::value::IOValue = /* Boolean */ preserves::value::packed::from_bytes(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).unwrap(); - pub static ref LIT5: preserves::value::IOValue = /* ByteString */ preserves::value::packed::from_bytes(&vec![179, 10, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103]).unwrap(); - pub static ref LIT2: preserves::value::IOValue = /* Double */ preserves::value::packed::from_bytes(&vec![179, 6, 68, 111, 117, 98, 108, 101]).unwrap(); - pub static ref LIT1: preserves::value::IOValue = /* Float */ preserves::value::packed::from_bytes(&vec![179, 5, 70, 108, 111, 97, 116]).unwrap(); - pub static ref LIT3: preserves::value::IOValue = /* SignedInteger */ preserves::value::packed::from_bytes(&vec![179, 13, 83, 105, 103, 110, 101, 100, 73, 110, 116, 101, 103, 101, 114]).unwrap(); - pub static ref LIT4: preserves::value::IOValue = /* String */ preserves::value::packed::from_bytes(&vec![179, 6, 83, 116, 114, 105, 110, 103]).unwrap(); - pub static ref LIT6: preserves::value::IOValue = /* Symbol */ preserves::value::packed::from_bytes(&vec![179, 6, 83, 121, 109, 98, 111, 108]).unwrap(); - pub static ref LIT14: preserves::value::IOValue = /* and */ preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 100]).unwrap(); - pub static ref LIT21: preserves::value::IOValue = /* any */ preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 121]).unwrap(); - pub static ref LIT22: preserves::value::IOValue = /* atom */ preserves::value::packed::from_bytes(&vec![179, 4, 97, 116, 111, 109]).unwrap(); - pub static ref LIT8: preserves::value::IOValue = /* bundle */ preserves::value::packed::from_bytes(&vec![179, 6, 98, 117, 110, 100, 108, 101]).unwrap(); - pub static ref LIT18: preserves::value::IOValue = /* definitions */ preserves::value::packed::from_bytes(&vec![179, 11, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 115]).unwrap(); - pub static ref LIT12: preserves::value::IOValue = /* dict */ preserves::value::packed::from_bytes(&vec![179, 4, 100, 105, 99, 116]).unwrap(); - pub static ref LIT27: preserves::value::IOValue = /* dictof */ preserves::value::packed::from_bytes(&vec![179, 6, 100, 105, 99, 116, 111, 102]).unwrap(); - pub static ref LIT23: preserves::value::IOValue = /* embedded */ preserves::value::packed::from_bytes(&vec![179, 8, 101, 109, 98, 101, 100, 100, 101, 100]).unwrap(); - pub static ref LIT19: preserves::value::IOValue = /* embeddedType */ preserves::value::packed::from_bytes(&vec![179, 12, 101, 109, 98, 101, 100, 100, 101, 100, 84, 121, 112, 101]).unwrap(); - pub static ref LIT24: preserves::value::IOValue = /* lit */ preserves::value::packed::from_bytes(&vec![179, 3, 108, 105, 116]).unwrap(); - pub static ref LIT7: preserves::value::IOValue = /* named */ preserves::value::packed::from_bytes(&vec![179, 5, 110, 97, 109, 101, 100]).unwrap(); - pub static ref LIT13: preserves::value::IOValue = /* or */ preserves::value::packed::from_bytes(&vec![179, 2, 111, 114]).unwrap(); - pub static ref LIT9: preserves::value::IOValue = /* rec */ preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 99]).unwrap(); - pub static ref LIT16: preserves::value::IOValue = /* ref */ preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 102]).unwrap(); - pub static ref LIT17: preserves::value::IOValue = /* schema */ preserves::value::packed::from_bytes(&vec![179, 6, 115, 99, 104, 101, 109, 97]).unwrap(); - pub static ref LIT25: preserves::value::IOValue = /* seqof */ preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 113, 111, 102]).unwrap(); - pub static ref LIT26: preserves::value::IOValue = /* setof */ preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 116, 111, 102]).unwrap(); - pub static ref LIT10: preserves::value::IOValue = /* tuple */ preserves::value::packed::from_bytes(&vec![179, 5, 116, 117, 112, 108, 101]).unwrap(); - pub static ref LIT11: preserves::value::IOValue = /* tuplePrefix */ preserves::value::packed::from_bytes(&vec![179, 11, 116, 117, 112, 108, 101, 80, 114, 101, 102, 105, 120]).unwrap(); - pub static ref LIT20: preserves::value::IOValue = /* version */ preserves::value::packed::from_bytes(&vec![179, 7, 118, 101, 114, 115, 105, 111, 110]).unwrap(); + pub static ref LIT_15_FALSE: preserves::value::IOValue = /* #f */ preserves::value::packed::from_bytes(&vec![128]).unwrap(); + pub static ref LIT_28_1: preserves::value::IOValue = /* 1 */ preserves::value::packed::from_bytes(&vec![145]).unwrap(); + pub static ref LIT_0_BOOLEAN: preserves::value::IOValue = /* Boolean */ preserves::value::packed::from_bytes(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).unwrap(); + pub static ref LIT_5_BYTE_STRING: preserves::value::IOValue = /* ByteString */ preserves::value::packed::from_bytes(&vec![179, 10, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103]).unwrap(); + pub static ref LIT_2_DOUBLE: preserves::value::IOValue = /* Double */ preserves::value::packed::from_bytes(&vec![179, 6, 68, 111, 117, 98, 108, 101]).unwrap(); + pub static ref LIT_1_FLOAT: preserves::value::IOValue = /* Float */ preserves::value::packed::from_bytes(&vec![179, 5, 70, 108, 111, 97, 116]).unwrap(); + pub static ref LIT_3_SIGNED_INTEGER: preserves::value::IOValue = /* SignedInteger */ preserves::value::packed::from_bytes(&vec![179, 13, 83, 105, 103, 110, 101, 100, 73, 110, 116, 101, 103, 101, 114]).unwrap(); + pub static ref LIT_4_STRING: preserves::value::IOValue = /* String */ preserves::value::packed::from_bytes(&vec![179, 6, 83, 116, 114, 105, 110, 103]).unwrap(); + pub static ref LIT_6_SYMBOL: preserves::value::IOValue = /* Symbol */ preserves::value::packed::from_bytes(&vec![179, 6, 83, 121, 109, 98, 111, 108]).unwrap(); + pub static ref LIT_14_AND: preserves::value::IOValue = /* and */ preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 100]).unwrap(); + pub static ref LIT_21_ANY: preserves::value::IOValue = /* any */ preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 121]).unwrap(); + pub static ref LIT_22_ATOM: preserves::value::IOValue = /* atom */ preserves::value::packed::from_bytes(&vec![179, 4, 97, 116, 111, 109]).unwrap(); + pub static ref LIT_8_BUNDLE: preserves::value::IOValue = /* bundle */ preserves::value::packed::from_bytes(&vec![179, 6, 98, 117, 110, 100, 108, 101]).unwrap(); + pub static ref LIT_18_DEFINITIONS: preserves::value::IOValue = /* definitions */ preserves::value::packed::from_bytes(&vec![179, 11, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 115]).unwrap(); + pub static ref LIT_12_DICT: preserves::value::IOValue = /* dict */ preserves::value::packed::from_bytes(&vec![179, 4, 100, 105, 99, 116]).unwrap(); + pub static ref LIT_27_DICTOF: preserves::value::IOValue = /* dictof */ preserves::value::packed::from_bytes(&vec![179, 6, 100, 105, 99, 116, 111, 102]).unwrap(); + pub static ref LIT_23_EMBEDDED: preserves::value::IOValue = /* embedded */ preserves::value::packed::from_bytes(&vec![179, 8, 101, 109, 98, 101, 100, 100, 101, 100]).unwrap(); + pub static ref LIT_19_EMBEDDED_TYPE: preserves::value::IOValue = /* embeddedType */ preserves::value::packed::from_bytes(&vec![179, 12, 101, 109, 98, 101, 100, 100, 101, 100, 84, 121, 112, 101]).unwrap(); + pub static ref LIT_24_LIT: preserves::value::IOValue = /* lit */ preserves::value::packed::from_bytes(&vec![179, 3, 108, 105, 116]).unwrap(); + pub static ref LIT_7_NAMED: preserves::value::IOValue = /* named */ preserves::value::packed::from_bytes(&vec![179, 5, 110, 97, 109, 101, 100]).unwrap(); + pub static ref LIT_13_OR: preserves::value::IOValue = /* or */ preserves::value::packed::from_bytes(&vec![179, 2, 111, 114]).unwrap(); + pub static ref LIT_9_REC: preserves::value::IOValue = /* rec */ preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 99]).unwrap(); + pub static ref LIT_16_REF: preserves::value::IOValue = /* ref */ preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 102]).unwrap(); + pub static ref LIT_17_SCHEMA: preserves::value::IOValue = /* schema */ preserves::value::packed::from_bytes(&vec![179, 6, 115, 99, 104, 101, 109, 97]).unwrap(); + pub static ref LIT_25_SEQOF: preserves::value::IOValue = /* seqof */ preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 113, 111, 102]).unwrap(); + pub static ref LIT_26_SETOF: preserves::value::IOValue = /* setof */ preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 116, 111, 102]).unwrap(); + pub static ref LIT_10_TUPLE: preserves::value::IOValue = /* tuple */ preserves::value::packed::from_bytes(&vec![179, 5, 116, 117, 112, 108, 101]).unwrap(); + pub static ref LIT_11_TUPLE_PREFIX: preserves::value::IOValue = /* tuplePrefix */ preserves::value::packed::from_bytes(&vec![179, 11, 116, 117, 112, 108, 101, 80, 114, 101, 102, 105, 120]).unwrap(); + pub static ref LIT_20_VERSION: preserves::value::IOValue = /* version */ preserves::value::packed::from_bytes(&vec![179, 7, 118, 101, 114, 115, 105, 111, 110]).unwrap(); } pub type _Ptr = preserves::value::IOValue; @@ -133,43 +133,43 @@ pub enum SimplePattern { pub struct Version; fn _parse_atom_kind_boolean(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT0 { return Err(_support::ParseError::ConformanceError); } + if value != &*LIT_0_BOOLEAN { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(AtomKind::Boolean) } fn _parse_atom_kind_float(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT1 { return Err(_support::ParseError::ConformanceError); } + if value != &*LIT_1_FLOAT { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(AtomKind::Float) } fn _parse_atom_kind_double(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT2 { return Err(_support::ParseError::ConformanceError); } + if value != &*LIT_2_DOUBLE { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(AtomKind::Double) } fn _parse_atom_kind_signed_integer(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT3 { return Err(_support::ParseError::ConformanceError); } + if value != &*LIT_3_SIGNED_INTEGER { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(AtomKind::SignedInteger) } fn _parse_atom_kind_string(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT4 { return Err(_support::ParseError::ConformanceError); } + if value != &*LIT_4_STRING { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(AtomKind::String) } fn _parse_atom_kind_byte_string(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT5 { return Err(_support::ParseError::ConformanceError); } + if value != &*LIT_5_BYTE_STRING { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(AtomKind::ByteString) } fn _parse_atom_kind_symbol(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT6 { return Err(_support::ParseError::ConformanceError); } + if value != &*LIT_6_SYMBOL { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(AtomKind::Symbol) } @@ -192,13 +192,13 @@ impl std::convert::TryFrom for AtomKind { impl std::convert::From<&AtomKind> for preserves::value::IOValue { fn from(value: &AtomKind) -> Self { match value { - AtomKind::Boolean => (&*LIT0).clone(), - AtomKind::Float => (&*LIT1).clone(), - AtomKind::Double => (&*LIT2).clone(), - AtomKind::SignedInteger => (&*LIT3).clone(), - AtomKind::String => (&*LIT4).clone(), - AtomKind::ByteString => (&*LIT5).clone(), - AtomKind::Symbol => (&*LIT6).clone(), + AtomKind::Boolean => (&*LIT_0_BOOLEAN).clone(), + AtomKind::Float => (&*LIT_1_FLOAT).clone(), + AtomKind::Double => (&*LIT_2_DOUBLE).clone(), + AtomKind::SignedInteger => (&*LIT_3_SIGNED_INTEGER).clone(), + AtomKind::String => (&*LIT_4_STRING).clone(), + AtomKind::ByteString => (&*LIT_5_BYTE_STRING).clone(), + AtomKind::Symbol => (&*LIT_6_SYMBOL).clone(), } } } @@ -208,7 +208,7 @@ impl std::convert::TryFrom for Binding { fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT7 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_7_NAMED { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 2 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = (&_tmp0.fields()[0]).value().to_symbol()?; @@ -221,7 +221,7 @@ impl std::convert::From<&Binding> for preserves::value::IOValue { fn from(value: &Binding) -> Self { let Binding {name: _tmp0, pattern: _tmp1} = value; { - let mut _tmp2 = preserves::value::Record(vec![(&*LIT7).clone()]); + let mut _tmp2 = preserves::value::Record(vec![(&*LIT_7_NAMED).clone()]); _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp0).wrap()); _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1)); _tmp2.finish().wrap() @@ -234,7 +234,7 @@ impl std::convert::TryFrom for Bundle { fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT8 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_8_BUNDLE { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = Modules::try_from((&_tmp0.fields()[0]).clone())?; @@ -246,7 +246,7 @@ impl std::convert::From<&Bundle> for preserves::value::IOValue { fn from(value: &Bundle) -> Self { let Bundle {modules: _tmp0} = value; { - let mut _tmp1 = preserves::value::Record(vec![(&*LIT8).clone()]); + let mut _tmp1 = preserves::value::Record(vec![(&*LIT_8_BUNDLE).clone()]); _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0)); _tmp1.finish().wrap() } @@ -255,7 +255,7 @@ impl std::convert::From<&Bundle> for preserves::value::IOValue { fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT9 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_9_REC { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 2 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = NamedPattern::try_from((&_tmp0.fields()[0]).clone())?; @@ -265,7 +265,7 @@ fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result fn _parse_compound_pattern_tuple(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT10 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_10_TUPLE { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence()?; @@ -276,7 +276,7 @@ fn _parse_compound_pattern_tuple(value: &preserves::value::IOValue) -> std::resu fn _parse_compound_pattern_tuple_prefix(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT11 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_11_TUPLE_PREFIX { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 2 { return Err(_support::ParseError::ConformanceError); } let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence()?; @@ -288,7 +288,7 @@ fn _parse_compound_pattern_tuple_prefix(value: &preserves::value::IOValue) -> st fn _parse_compound_pattern_dict(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT12 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_12_DICT { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = DictionaryEntries::try_from((&_tmp0.fields()[0]).clone())?; @@ -311,13 +311,13 @@ impl std::convert::From<&CompoundPattern> for preserves::value::IOValue { fn from(value: &CompoundPattern) -> Self { match value { CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => { - let mut _tmp2 = preserves::value::Record(vec![(&*LIT9).clone()]); + let mut _tmp2 = preserves::value::Record(vec![(&*LIT_9_REC).clone()]); _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref())); _tmp2.finish().wrap() }, CompoundPattern::Tuple {patterns: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*LIT10).clone()]); + let mut _tmp1 = preserves::value::Record(vec![(&*LIT_10_TUPLE).clone()]); _tmp1.fields_vec_mut().push( { let mut _tmp2 = vec![]; @@ -328,7 +328,7 @@ impl std::convert::From<&CompoundPattern> for preserves::value::IOValue { _tmp1.finish().wrap() }, CompoundPattern::TuplePrefix {fixed: _tmp0, variable: _tmp1} => { - let mut _tmp2 = preserves::value::Record(vec![(&*LIT11).clone()]); + let mut _tmp2 = preserves::value::Record(vec![(&*LIT_11_TUPLE_PREFIX).clone()]); _tmp2.fields_vec_mut().push( { let mut _tmp3 = vec![]; @@ -340,7 +340,7 @@ impl std::convert::From<&CompoundPattern> for preserves::value::IOValue { _tmp2.finish().wrap() }, CompoundPattern::Dict {entries: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*LIT12).clone()]); + let mut _tmp1 = preserves::value::Record(vec![(&*LIT_12_DICT).clone()]); _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); _tmp1.finish().wrap() }, @@ -350,7 +350,7 @@ impl std::convert::From<&CompoundPattern> for preserves::value::IOValue { fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT13 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_13_OR { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?; @@ -368,7 +368,7 @@ fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Resul fn _parse_definition_and(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT14 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_14_AND { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?; @@ -404,7 +404,7 @@ impl std::convert::From<&Definition> for preserves::value::IOValue { fn from(value: &Definition) -> Self { match value { Definition::Or {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => { - let mut _tmp3 = preserves::value::Record(vec![(&*LIT13).clone()]); + let mut _tmp3 = preserves::value::Record(vec![(&*LIT_13_OR).clone()]); _tmp3.fields_vec_mut().push( { let mut _tmp4 = vec![]; @@ -417,7 +417,7 @@ impl std::convert::From<&Definition> for preserves::value::IOValue { _tmp3.finish().wrap() }, Definition::And {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => { - let mut _tmp3 = preserves::value::Record(vec![(&*LIT14).clone()]); + let mut _tmp3 = preserves::value::Record(vec![(&*LIT_14_AND).clone()]); _tmp3.fields_vec_mut().push( { let mut _tmp4 = vec![]; @@ -485,7 +485,7 @@ fn _parse_embedded_type_name_ref(value: &preserves::value::IOValue) -> std::resu } fn _parse_embedded_type_name_false(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT15 { return Err(_support::ParseError::ConformanceError); } + if value != &*LIT_15_FALSE { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(EmbeddedTypeName::False) } @@ -504,7 +504,7 @@ impl std::convert::From<&EmbeddedTypeName> for preserves::value::IOValue { fn from(value: &EmbeddedTypeName) -> Self { match value { EmbeddedTypeName::Ref(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()), - EmbeddedTypeName::False => (&*LIT15).clone(), + EmbeddedTypeName::False => (&*LIT_15_FALSE).clone(), } } } @@ -668,7 +668,7 @@ impl std::convert::TryFrom for Ref { fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT16 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_16_REF { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 2 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = ModulePath::try_from((&_tmp0.fields()[0]).clone())?; @@ -681,7 +681,7 @@ impl std::convert::From<&Ref> for preserves::value::IOValue { fn from(value: &Ref) -> Self { let Ref {module: _tmp0, name: _tmp1} = value; { - let mut _tmp2 = preserves::value::Record(vec![(&*LIT16).clone()]); + let mut _tmp2 = preserves::value::Record(vec![(&*LIT_16_REF).clone()]); _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0)); _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp1).wrap()); _tmp2.finish().wrap() @@ -694,15 +694,15 @@ impl std::convert::TryFrom for Schema { fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT17 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_17_SCHEMA { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = (&_tmp0.fields()[0]).value().to_dictionary()?; - let _tmp3 = _tmp2.get(&*LIT18).ok_or(_support::ParseError::ConformanceError)?; + let _tmp3 = _tmp2.get(&*LIT_18_DEFINITIONS).ok_or(_support::ParseError::ConformanceError)?; let _tmp4 = Definitions::try_from(_tmp3.clone())?; - let _tmp5 = _tmp2.get(&*LIT19).ok_or(_support::ParseError::ConformanceError)?; + let _tmp5 = _tmp2.get(&*LIT_19_EMBEDDED_TYPE).ok_or(_support::ParseError::ConformanceError)?; let _tmp6 = EmbeddedTypeName::try_from(_tmp5.clone())?; - let _tmp7 = _tmp2.get(&*LIT20).ok_or(_support::ParseError::ConformanceError)?; + let _tmp7 = _tmp2.get(&*LIT_20_VERSION).ok_or(_support::ParseError::ConformanceError)?; let _tmp8 = Version::try_from(_tmp7.clone())?; Ok(Schema {definitions: _tmp4, embedded_type: _tmp6, version: _tmp8}) } @@ -712,13 +712,13 @@ impl std::convert::From<&Schema> for preserves::value::IOValue { fn from(value: &Schema) -> Self { let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = value; { - let mut _tmp3 = preserves::value::Record(vec![(&*LIT17).clone()]); + let mut _tmp3 = preserves::value::Record(vec![(&*LIT_17_SCHEMA).clone()]); _tmp3.fields_vec_mut().push( { let mut _tmp4 = preserves::value::Map::new(); - _tmp4.insert((&*LIT18).clone(), preserves::value::IOValue::from(_tmp0)); - _tmp4.insert((&*LIT19).clone(), preserves::value::IOValue::from(_tmp1)); - _tmp4.insert((&*LIT20).clone(), preserves::value::IOValue::from(_tmp2)); + _tmp4.insert((&*LIT_18_DEFINITIONS).clone(), preserves::value::IOValue::from(_tmp0)); + _tmp4.insert((&*LIT_19_EMBEDDED_TYPE).clone(), preserves::value::IOValue::from(_tmp1)); + _tmp4.insert((&*LIT_20_VERSION).clone(), preserves::value::IOValue::from(_tmp2)); preserves::value::Value::Dictionary(_tmp4).wrap() } ); @@ -728,14 +728,14 @@ impl std::convert::From<&Schema> for preserves::value::IOValue { } fn _parse_simple_pattern_any(value: &preserves::value::IOValue) -> std::result::Result { - if value != &*LIT21 { return Err(_support::ParseError::ConformanceError); } + if value != &*LIT_21_ANY { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(SimplePattern::Any) } fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT22 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_22_ATOM { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = AtomKind::try_from((&_tmp0.fields()[0]).clone())?; @@ -744,7 +744,7 @@ fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result: fn _parse_simple_pattern_embedded(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT23 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_23_EMBEDDED { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; @@ -753,7 +753,7 @@ fn _parse_simple_pattern_embedded(value: &preserves::value::IOValue) -> std::res fn _parse_simple_pattern_lit(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT24 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_24_LIT { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = _Any::from_io_value((&_tmp0.fields()[0]))?; @@ -762,7 +762,7 @@ fn _parse_simple_pattern_lit(value: &preserves::value::IOValue) -> std::result:: fn _parse_simple_pattern_seqof(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT25 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_25_SEQOF { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; @@ -771,7 +771,7 @@ fn _parse_simple_pattern_seqof(value: &preserves::value::IOValue) -> std::result fn _parse_simple_pattern_setof(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT26 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_26_SETOF { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; @@ -780,7 +780,7 @@ fn _parse_simple_pattern_setof(value: &preserves::value::IOValue) -> std::result fn _parse_simple_pattern_dictof(value: &preserves::value::IOValue) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*LIT27 { return Err(_support::ParseError::ConformanceError); } + if _tmp0.label() != &*LIT_27_DICTOF { return Err(_support::ParseError::ConformanceError); } let _tmp1 = (); if _tmp0.fields().len() < 2 { return Err(_support::ParseError::ConformanceError); } let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; @@ -812,34 +812,34 @@ impl std::convert::TryFrom for SimplePattern { impl std::convert::From<&SimplePattern> for preserves::value::IOValue { fn from(value: &SimplePattern) -> Self { match value { - SimplePattern::Any => (&*LIT21).clone(), + SimplePattern::Any => (&*LIT_21_ANY).clone(), SimplePattern::Atom {atom_kind: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*LIT22).clone()]); + let mut _tmp1 = preserves::value::Record(vec![(&*LIT_22_ATOM).clone()]); _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); _tmp1.finish().wrap() }, SimplePattern::Embedded {interface: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*LIT23).clone()]); + let mut _tmp1 = preserves::value::Record(vec![(&*LIT_23_EMBEDDED).clone()]); _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); _tmp1.finish().wrap() }, SimplePattern::Lit {value: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*LIT24).clone()]); + let mut _tmp1 = preserves::value::Record(vec![(&*LIT_24_LIT).clone()]); _tmp1.fields_vec_mut().push(_tmp0.to_io_value()); _tmp1.finish().wrap() }, SimplePattern::Seqof {pattern: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*LIT25).clone()]); + let mut _tmp1 = preserves::value::Record(vec![(&*LIT_25_SEQOF).clone()]); _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); _tmp1.finish().wrap() }, SimplePattern::Setof {pattern: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*LIT26).clone()]); + let mut _tmp1 = preserves::value::Record(vec![(&*LIT_26_SETOF).clone()]); _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); _tmp1.finish().wrap() }, SimplePattern::Dictof {key: _tmp0, value: _tmp1} => { - let mut _tmp2 = preserves::value::Record(vec![(&*LIT27).clone()]); + let mut _tmp2 = preserves::value::Record(vec![(&*LIT_27_DICTOF).clone()]); _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref())); _tmp2.finish().wrap() @@ -853,11 +853,11 @@ impl std::convert::TryFrom for Version { type Error = _support::ParseError; fn try_from(value: preserves::value::IOValue) -> std::result::Result { let value = &value; - if value != &*LIT28 { return Err(_support::ParseError::ConformanceError); } + if value != &*LIT_28_1 { return Err(_support::ParseError::ConformanceError); } let _tmp0 = (); Ok(Version) } } -impl std::convert::From<&Version> for preserves::value::IOValue {fn from(value: &Version) -> Self {let Version = value; (&*LIT28).clone()}} +impl std::convert::From<&Version> for preserves::value::IOValue {fn from(value: &Version) -> Self {let Version = value; (&*LIT_28_1).clone()}}