use syn::spanned::Spanned;
use syn::{AttributeArgs, Lit, LitStr, Meta, NestedMeta};
pub struct ModelArgs {
pub model_path: LitStr,
pub backend: BackendArg,
pub arena: ArenaArg,
pub format: Option<ModelFormat>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BackendArg {
Iree,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ArenaArg {
Owned,
Shared,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ModelFormat {
Mlir,
Onnx,
Pytorch,
Tensorflow,
Tflite,
}
impl ModelArgs {
pub fn parse(args: AttributeArgs) -> syn::Result<Self> {
let mut args = args.into_iter();
let model_path = match args.next() {
Some(NestedMeta::Lit(Lit::Str(path))) => path,
Some(arg) => return Err(syn::Error::new(arg.span(), "expected model path string")),
None => {
return Err(syn::Error::new(
proc_macro2::Span::call_site(),
"missing model path",
));
}
};
let mut backend = None;
let mut arena = None;
let mut format = None;
for arg in args {
match arg {
NestedMeta::Meta(Meta::NameValue(meta)) if meta.path.is_ident("backend") => {
if backend.is_some() {
return Err(syn::Error::new(meta.span(), "duplicate backend option"));
}
backend = Some(parse_backend(meta.lit)?);
}
NestedMeta::Meta(Meta::NameValue(meta)) if meta.path.is_ident("arena") => {
if arena.is_some() {
return Err(syn::Error::new(meta.span(), "duplicate arena option"));
}
arena = Some(parse_arena(meta.lit)?);
}
NestedMeta::Meta(Meta::NameValue(meta)) if meta.path.is_ident("format") => {
if format.is_some() {
return Err(syn::Error::new(meta.span(), "duplicate format option"));
}
format = Some(parse_format(meta.lit)?);
}
other => {
return Err(syn::Error::new(
other.span(),
"unknown #[model] option; expected backend, arena, or format",
));
}
}
}
Ok(Self {
model_path,
backend: backend.unwrap_or(BackendArg::Iree),
arena: arena.unwrap_or(ArenaArg::Owned),
format,
})
}
}
fn parse_format(lit: Lit) -> syn::Result<ModelFormat> {
let Lit::Str(value) = lit else {
return Err(syn::Error::new(
lit.span(),
"format must be a string literal, for example format = \"tensorflow\"",
));
};
match value.value().trim().to_ascii_lowercase().as_str() {
"mlir" => Ok(ModelFormat::Mlir),
"onnx" => Ok(ModelFormat::Onnx),
"pytorch" | "pt2" => Ok(ModelFormat::Pytorch),
"tensorflow" | "tf" => Ok(ModelFormat::Tensorflow),
"tflite" => Ok(ModelFormat::Tflite),
other => Err(syn::Error::new(
value.span(),
format!(
"unknown model format '{other}', expected 'mlir', 'onnx', 'pytorch', 'tensorflow', or 'tflite'"
),
)),
}
}
fn parse_backend(lit: Lit) -> syn::Result<BackendArg> {
let value = match lit {
Lit::Str(value) => value,
other => {
return Err(syn::Error::new(
other.span(),
"backend must be a string literal, for example backend = \"iree\"",
));
}
};
match value.value().trim().to_ascii_lowercase().as_str() {
"iree" => Ok(BackendArg::Iree),
other => Err(syn::Error::new(
value.span(),
format!("unknown backend '{other}', expected 'iree'"),
)),
}
}
fn parse_arena(lit: Lit) -> syn::Result<ArenaArg> {
let value = match lit {
Lit::Str(value) => value,
other => {
return Err(syn::Error::new(
other.span(),
"arena must be a string literal, for example arena = \"shared\"",
));
}
};
match value.value().trim().to_ascii_lowercase().as_str() {
"owned" => Ok(ArenaArg::Owned),
"shared" => Ok(ArenaArg::Shared),
other => Err(syn::Error::new(
value.span(),
format!("unknown arena '{other}', expected 'owned' or 'shared'"),
)),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_duplicate_backend_options() {
let args: AttributeArgs = vec![
syn::parse_quote!("model.tflite"),
syn::parse_quote!(backend = "iree"),
syn::parse_quote!(backend = "iree"),
];
assert!(ModelArgs::parse(args).is_err());
}
#[test]
fn defaults_to_iree() {
let args: AttributeArgs = vec![syn::parse_quote!("model.tflite")];
assert!(ModelArgs::parse(args).is_ok());
}
#[test]
fn parses_tensorflow_format() {
let args: AttributeArgs = vec![
syn::parse_quote!("saved_model"),
syn::parse_quote!(format = "tensorflow"),
];
let args = ModelArgs::parse(args).unwrap();
assert_eq!(args.format, Some(ModelFormat::Tensorflow));
}
}