use preserves::value::Map;
use preserves_schema::compiler::*;
use preserves_schema::compiler::types::Purpose;
use preserves_schema::gen::schema::Schema;
use proc_macro2::Span;
use quote::ToTokens;
use quote::quote;
use std::fmt::Display;
use syn::LitStr;
use syn::Token;
use syn::parenthesized;
use syn::parse::Parser;
use syn::punctuated::Punctuated;
mod kw {
use syn::custom_keyword;
custom_keyword!(load);
custom_keyword!(cross_reference);
custom_keyword!(external_module);
}
#[derive(Debug)]
enum Instruction {
Namespace(String),
Load(LitStr),
CrossReference {
namespace: String,
bundle_path: LitStr,
},
ExternalModule {
module_path: ModulePath,
namespace: String,
}
}
fn syn_path_string(p: syn::Path) -> String {
p.to_token_stream().to_string().replace(&[' ', '\t', '\n', '\r'], "")
}
fn syn_litstr_resolve(s: &syn::LitStr) -> String {
let s: String = s.value();
match s.chars().nth(0) {
Some('/') => s.into(),
Some('<') => match &s[1..].split_once('>') {
Some((envvar, remainder)) => match std::env::var(envvar) {
Ok(p) => p + "/" + remainder,
Err(_) => panic!("No such environment variable: {:?}", s),
}
None => panic!("Invalid relative path syntax: {:?}", s),
},
_ => panic!("Invalid path syntax: {:?}", s)
}
}
impl syn::parse::Parse for Instruction {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let lookahead = input.lookahead1();
if lookahead.peek(kw::load) {
let _: kw::load = input.parse()?;
let content;
let _ = parenthesized!(content in input);
let bundle_path: syn::LitStr = content.parse()?;
Ok(Instruction::Load(bundle_path))
} else if lookahead.peek(kw::cross_reference) {
let _: kw::cross_reference = input.parse()?;
let content;
let _ = parenthesized!(content in input);
let namespace: syn::Path = content.parse()?;
let _: Token![=] = content.parse()?;
let bundle_path: syn::LitStr = content.parse()?;
Ok(Instruction::CrossReference {
namespace: syn_path_string(namespace),
bundle_path,
})
} else if lookahead.peek(kw::external_module) {
let _: kw::external_module = input.parse()?;
let content;
let _ = parenthesized!(content in input);
let module_path = Punctuated::<syn::Ident, syn::Token![.]>::parse_separated_nonempty(&content)?;
let _: Token![=] = content.parse()?;
let namespace: syn::Path = content.parse()?;
Ok(Instruction::ExternalModule {
module_path: module_path.into_iter().map(|p| p.to_string()).collect(),
namespace: syn_path_string(namespace),
})
} else {
let ns: syn::Path = input.parse()?;
Ok(Instruction::Namespace(syn_path_string(ns)))
}
}
}
struct ModuleTree {
own_body: String,
children: Map<String, ModuleTree>,
}
impl Default for ModuleTree {
fn default() -> Self {
ModuleTree {
own_body: String::new(),
children: Map::default(),
}
}
}
impl ModuleTree {
fn build(outputs: Map<Option<ModulePath>, String>) -> Self {
let mut mt = ModuleTree::default();
for (p, c) in outputs.into_iter() {
match p {
None => mt.own_body = c,
Some(k) => {
let mut r = &mut mt;
for e in k { r = mt.children.entry(names::render_modname(&e)).or_default(); }
r.own_body = c;
}
}
}
mt
}
}
impl Display for ModuleTree {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.own_body)?;
for (label, mt) in self.children.iter() {
write!(f, "\npub mod {} {{ ", label)?;
mt.fmt(f)?;
write!(f, "}}")?;
}
Ok(())
}
}
#[proc_macro]
pub fn compile_preserves_schemas(src: proc_macro::TokenStream) -> proc_macro::TokenStream {
let instructions = Punctuated::<Instruction, syn::Token![,]>::parse_terminated
.parse(src)
.expect("valid sequence of compile_preserves_schemas instructions");
let mut namespace = None::<String>;
let mut bundles_to_load = Vec::<LitStr>::new();
let mut bundles_to_xref = Vec::<LitStr>::new();
let mut external_modules = Vec::<ExternalModule>::new();
for i in instructions.into_iter() {
match i {
Instruction::Namespace(n) => {
if namespace.is_some() {
panic!("Only one namespace is permitted")
}
namespace = Some(n)
}
Instruction::Load(p) => bundles_to_load.push(p),
Instruction::ExternalModule { module_path, namespace } => {
external_modules.push(ExternalModule::new(module_path, &namespace));
}
Instruction::CrossReference { namespace, bundle_path } => {
let mut bundle = Map::<ModulePath, Schema>::new();
let is_schema = load_schema_or_bundle(&mut bundle, &syn_litstr_resolve(&bundle_path).into())
.expect("Invalid schema/bundle binary");
bundles_to_xref.push(bundle_path);
for (k, _v) in bundle.into_iter() {
external_modules.push(if is_schema {
ExternalModule::new(k, &namespace)
} else {
let ns = namespace.clone();
let mut pieces = vec![ns.clone()];
pieces.extend(
k.iter().map(|p| names::render_modname(&p)).collect::<Vec<_>>());
ExternalModule::new(k, &pieces.join("::"))
.set_fallback_language_types(
move |v| vec![format!("{}::Language<{}>", ns, v)].into_iter().collect())
});
}
}
}
}
let namespace = namespace.expect("Missing namespace");
let mut dependency_paths = Vec::<syn::LitStr>::new();
let mut c = CompilerConfig::new(namespace.clone());
for b in bundles_to_load.into_iter() {
dependency_paths.push(syn::LitStr::new(&syn_litstr_resolve(&b), Span::call_site()));
load_schema_or_bundle_with_purpose(&mut c.bundle, &syn_litstr_resolve(&b).into(), Purpose::Codegen)
.expect(&b.value());
}
for b in bundles_to_xref.into_iter() {
dependency_paths.push(syn::LitStr::new(&syn_litstr_resolve(&b), Span::call_site()));
load_schema_or_bundle_with_purpose(&mut c.bundle, &syn_litstr_resolve(&b).into(), Purpose::Xref)
.expect(&b.value());
}
for m in external_modules.into_iter() {
c.add_external_module(m);
}
let mut outputs = Map::<Option<ModulePath>, String>::new();
let mut collector = CodeCollector {
emit_mod_declarations: false,
collect_module: CodeModuleCollector::Custom {
collect_output: &mut |p, c| {
outputs.insert(p.cloned(), c.to_owned());
Ok(())
},
},
};
compile(&c, &mut collector).expect("Compilation failed");
let top_module_source = format!(
"pub mod {} {{ {} }}",
names::render_modname(namespace.split("::").last().unwrap()),
ModuleTree::build(outputs));
let top_module: syn::Item = syn::parse_str(&top_module_source)
.expect("Invalid generated code");
quote!{
#( const _: &'static [u8] = include_bytes!(#dependency_paths); )*
#top_module
}.into()
}