263 lines
8.6 KiB
Rust
263 lines
8.6 KiB
Rust
#![feature(proc_macro_span)]
|
|
|
|
use syndicate::value::IOValue;
|
|
use syndicate::value::NestedValue;
|
|
use syndicate::value::Value;
|
|
use syndicate::value::text::iovalue_from_str;
|
|
|
|
use proc_macro2::Span;
|
|
use proc_macro2::TokenStream;
|
|
|
|
use quote::quote;
|
|
|
|
use std::convert::TryFrom;
|
|
|
|
use syn::parse_macro_input;
|
|
use syn::ExprLit;
|
|
use syn::Ident;
|
|
use syn::Lit;
|
|
use syn::LitByteStr;
|
|
|
|
mod dur;
|
|
mod pat;
|
|
mod stx;
|
|
mod val;
|
|
|
|
use pat::lit;
|
|
|
|
enum SymbolVariant<'a> {
|
|
Normal(&'a str),
|
|
#[allow(dead_code)] // otherwise we get 'warning: field `0` is never read'
|
|
Binder(&'a str),
|
|
Substitution(&'a str),
|
|
Discard,
|
|
}
|
|
|
|
fn compile_sequence_members(vs: &[IOValue]) -> Vec<TokenStream> {
|
|
vs.iter().enumerate().map(|(i, f)| {
|
|
let p = compile_pattern(f);
|
|
quote!((syndicate::value::Value::from(#i).wrap(), #p))
|
|
}).collect::<Vec<_>>()
|
|
}
|
|
|
|
fn analyze_symbol(s: &str, allow_binding_and_substitution: bool) -> SymbolVariant {
|
|
if !allow_binding_and_substitution {
|
|
SymbolVariant::Normal(s)
|
|
} else if s.starts_with("$") {
|
|
SymbolVariant::Binder(&s[1..])
|
|
} else if s.starts_with("=") {
|
|
SymbolVariant::Substitution(&s[1..])
|
|
} else if s == "_" {
|
|
SymbolVariant::Discard
|
|
} else {
|
|
SymbolVariant::Normal(s)
|
|
}
|
|
}
|
|
|
|
struct ValueCompiler {
|
|
allow_binding_and_substitution: bool,
|
|
}
|
|
|
|
impl ValueCompiler {
|
|
fn for_patterns() -> Self {
|
|
ValueCompiler {
|
|
allow_binding_and_substitution: false,
|
|
}
|
|
}
|
|
|
|
fn for_templates() -> Self {
|
|
ValueCompiler {
|
|
allow_binding_and_substitution: true,
|
|
}
|
|
}
|
|
|
|
fn compile(&self, v: &IOValue) -> TokenStream {
|
|
#[allow(non_snake_case)]
|
|
let V_: TokenStream = quote!(syndicate::value);
|
|
|
|
let walk = |w| self.compile(w);
|
|
|
|
match v.value() {
|
|
Value::Boolean(b) =>
|
|
quote!(#V_::Value::from(#b).wrap()),
|
|
Value::Double(d) => {
|
|
let d = d.0;
|
|
quote!(#V_::Value::from(#d).wrap())
|
|
}
|
|
Value::SignedInteger(i) => {
|
|
let i = i128::try_from(i).expect("Literal integer out-of-range");
|
|
quote!(#V_::Value::from(#i).wrap())
|
|
}
|
|
Value::String(s) =>
|
|
quote!(#V_::Value::from(#s).wrap()),
|
|
Value::ByteString(bs) => {
|
|
let bs = LitByteStr::new(bs, Span::call_site());
|
|
quote!(#V_::Value::from(#bs).wrap())
|
|
}
|
|
Value::Symbol(s) => match analyze_symbol(&s, self.allow_binding_and_substitution) {
|
|
SymbolVariant::Normal(s) =>
|
|
quote!(#V_::Value::symbol(#s).wrap()),
|
|
SymbolVariant::Binder(_) |
|
|
SymbolVariant::Discard =>
|
|
panic!("Binding/Discard not supported here"),
|
|
SymbolVariant::Substitution(s) => {
|
|
let i = Ident::new(s, Span::call_site());
|
|
quote!(#i)
|
|
}
|
|
}
|
|
Value::Record(r) => {
|
|
let arity = r.arity();
|
|
let label = walk(r.label());
|
|
let fs: Vec<_> = r.fields().iter().map(walk).collect();
|
|
quote!({
|
|
let mut ___r = #V_::Value::record(#label, #arity);
|
|
#(___r.fields_vec_mut().push(#fs);)*
|
|
___r.finish().wrap()
|
|
})
|
|
}
|
|
Value::Sequence(vs) => {
|
|
let vs: Vec<_> = vs.iter().map(walk).collect();
|
|
quote!(#V_::Value::from(vec![#(#vs),*]).wrap())
|
|
}
|
|
Value::Set(vs) => {
|
|
let vs: Vec<_> = vs.iter().map(walk).collect();
|
|
quote!({
|
|
let mut ___s = #V_::Set::new();
|
|
#(___s.insert(#vs);)*
|
|
#V_::Value::from(___s).wrap()
|
|
})
|
|
}
|
|
Value::Dictionary(d) => {
|
|
let members: Vec<_> = d.iter().map(|(k, v)| {
|
|
let k = walk(k);
|
|
let v = walk(v);
|
|
quote!(___d.insert(#k, #v))
|
|
}).collect();
|
|
quote!({
|
|
let mut ___d = #V_::Map::new();
|
|
#(#members;)*
|
|
#V_::Value::from(___d).wrap()
|
|
})
|
|
}
|
|
Value::Embedded(_) =>
|
|
panic!("Embedded values in compile-time Preserves templates not (yet?) supported"),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn compile_pattern(v: &IOValue) -> TokenStream {
|
|
#[allow(non_snake_case)]
|
|
let P_: TokenStream = quote!(syndicate::schemas::dataspace_patterns);
|
|
#[allow(non_snake_case)]
|
|
let V_: TokenStream = quote!(syndicate::value);
|
|
#[allow(non_snake_case)]
|
|
let MapFrom_: TokenStream = quote!(<#V_::Map<_, _>>::from);
|
|
|
|
match v.value() {
|
|
Value::Symbol(s) => match analyze_symbol(&s, true) {
|
|
SymbolVariant::Binder(_) =>
|
|
quote!(#P_::Pattern::Bind{ pattern: Box::new(#P_::Pattern::Discard) }),
|
|
SymbolVariant::Discard =>
|
|
quote!(#P_::Pattern::Discard),
|
|
SymbolVariant::Substitution(s) =>
|
|
lit(Ident::new(s, Span::call_site())),
|
|
SymbolVariant::Normal(_) =>
|
|
lit(ValueCompiler::for_patterns().compile(v)),
|
|
}
|
|
Value::Record(r) => {
|
|
match r.label().value().as_symbol() {
|
|
None => panic!("Record labels in patterns must be symbols"),
|
|
Some(label) =>
|
|
if label.starts_with("$") && r.arity() == 1 {
|
|
let nested = compile_pattern(&r.fields()[0]);
|
|
quote!(#P_::Pattern::Bind{ pattern: Box::new(#nested) })
|
|
} else {
|
|
let label_stx = if label.starts_with("=") {
|
|
let id = Ident::new(&label[1..], Span::call_site());
|
|
quote!(#id)
|
|
} else {
|
|
quote!(#V_::Value::symbol(#label).wrap())
|
|
};
|
|
let members = compile_sequence_members(r.fields());
|
|
quote!(#P_::Pattern::Group {
|
|
type_: Box::new(#P_::GroupType::Rec { label: #label_stx }),
|
|
entries: #MapFrom_([#(#members),*]),
|
|
})
|
|
}
|
|
}
|
|
}
|
|
Value::Sequence(vs) => {
|
|
let members = compile_sequence_members(vs);
|
|
quote!(#P_::Pattern::Group {
|
|
type_: Box::new(#P_::GroupType::Arr),
|
|
entries: #MapFrom_([#(#members),*]),
|
|
})
|
|
}
|
|
Value::Set(_) =>
|
|
panic!("Cannot match sets in patterns"),
|
|
Value::Dictionary(d) => {
|
|
let members = d.iter().map(|(k, v)| {
|
|
let k = ValueCompiler::for_patterns().compile(k);
|
|
let v = compile_pattern(v);
|
|
quote!((#k, #v))
|
|
}).collect::<Vec<_>>();
|
|
quote!(#P_::Pattern::Group {
|
|
type_: Box::new(#P_::GroupType::Dict),
|
|
entries: #MapFrom_([#(#members),*]),
|
|
})
|
|
}
|
|
_ => lit(ValueCompiler::for_patterns().compile(v)),
|
|
}
|
|
}
|
|
|
|
#[proc_macro]
|
|
pub fn pattern_str(src: proc_macro::TokenStream) -> proc_macro::TokenStream {
|
|
if let Lit::Str(s) = parse_macro_input!(src as ExprLit).lit {
|
|
match iovalue_from_str(&s.value()) {
|
|
Ok(v) => {
|
|
let e = compile_pattern(&v);
|
|
// println!("{:#}", &e);
|
|
return e.into();
|
|
}
|
|
Err(_) => (),
|
|
}
|
|
}
|
|
|
|
panic!("Expected literal string containing the pattern and no more");
|
|
}
|
|
|
|
#[proc_macro]
|
|
pub fn template(src: proc_macro::TokenStream) -> proc_macro::TokenStream {
|
|
if let Lit::Str(s) = parse_macro_input!(src as ExprLit).lit {
|
|
match iovalue_from_str(&s.value()) {
|
|
Ok(v) => {
|
|
let e = ValueCompiler::for_templates().compile(&v);
|
|
// println!("{:#}", &e);
|
|
return e.into();
|
|
}
|
|
Err(_) => (),
|
|
}
|
|
}
|
|
|
|
panic!("Expected literal string containing the template and no more");
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
#[proc_macro]
|
|
pub fn pattern(src: proc_macro::TokenStream) -> proc_macro::TokenStream {
|
|
pat::pattern(src)
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
#[proc_macro]
|
|
pub fn during(src: proc_macro::TokenStream) -> proc_macro::TokenStream {
|
|
dur::during(src)
|
|
}
|
|
|
|
#[proc_macro]
|
|
pub fn on_message(src: proc_macro::TokenStream) -> proc_macro::TokenStream {
|
|
dur::on_message(src)
|
|
}
|