mod generate_input_mlir;
mod model_io;
use std::ffi::OsStr;
use std::fs;
use std::path::{Path, PathBuf};
use proc_macro2::Span;
use syn::ItemStruct;
use crate::args::{ModelArgs, ModelFormat};
use crate::utils::rust_ident;
pub(crate) use model_io::{ModelIo, TensorInfo};
#[derive(Debug)]
pub(crate) struct Model {
pub(crate) source_path: PathBuf,
pub(crate) compile_input_path: PathBuf,
pub(crate) ir_dump_stem: String,
pub(crate) model_io: ModelIo,
}
pub(crate) fn prepare(args: &ModelArgs, input_struct: &ItemStruct) -> syn::Result<Model> {
let model_path = &args.model_path;
let caller_manifest_dir = std::env::var_os("CARGO_MANIFEST_DIR")
.map(PathBuf::from)
.ok_or_else(|| {
syn::Error::new(
model_path.span(),
"CARGO_MANIFEST_DIR is not set; Cargo must expand #[model] inside a package build",
)
})?;
let path = PathBuf::from(model_path.value());
let path = if path.is_absolute() {
path
} else {
caller_manifest_dir.join(path)
};
let struct_ident = &input_struct.ident;
let format = args.format.map_or_else(|| detect_format(&path), Ok)?;
let expects_directory = format == ModelFormat::Tensorflow;
let struct_name = rust_ident(&struct_ident.to_string());
let model_stem = if expects_directory {
path.file_name()
} else {
path.file_stem()
}
.and_then(OsStr::to_str)
.map(rust_ident)
.unwrap_or_else(|| struct_name.clone());
let (compile_input_path, ir_dump_stem, model_io) = match format {
ModelFormat::Mlir => {
let model_io = model_io::load_mlir(&path)?;
(path.clone(), model_stem.clone(), model_io)
}
ModelFormat::Onnx => {
let model_io = model_io::load_onnx(&path)?;
let output = normalized_path(&struct_name, &model_stem, "tosa.mlir")?;
generate_input_mlir::from_onnx(&path, &output)?;
let ir_dump_stem = rust_ident(output.file_stem().and_then(OsStr::to_str).unwrap());
(output, ir_dump_stem, model_io)
}
ModelFormat::Pytorch => {
let output = normalized_path(&struct_name, &model_stem, "torch.mlir")?;
generate_input_mlir::from_pytorch(&path, &output, &struct_name)?;
let model_io = model_io::load_mlir(&output)?;
(output, struct_name, model_io)
}
ModelFormat::Tensorflow => {
let output = normalized_path(&struct_name, &model_stem, "tensorflow.mlir")?;
let io_output = normalized_path(&struct_name, &model_stem, "tensorflow.json")?;
generate_input_mlir::inspect_tensorflow(&path, &io_output)?;
let model_io = model_io::load_tensorflow_metadata(&io_output)?;
generate_input_mlir::from_tensorflow(&path, &output)?;
(output, "_".to_owned(), model_io)
}
ModelFormat::Tflite => {
let output = normalized_path(&struct_name, &model_stem, "tosa.mlir")?;
generate_input_mlir::from_tflite(&path, &output)?;
let model_io = model_io::load_mlir(&output)?;
let ir_dump_stem = rust_ident(output.file_stem().and_then(OsStr::to_str).unwrap());
(output, ir_dump_stem, model_io)
}
};
model_io.validate()?;
Ok(Model {
source_path: path,
compile_input_path,
ir_dump_stem,
model_io,
})
}
fn normalized_path(struct_name: &str, model_stem: &str, suffix: &str) -> syn::Result<PathBuf> {
let manifest_dir = std::env::var_os("CARGO_MANIFEST_DIR")
.map(PathBuf::from)
.ok_or_else(|| {
syn::Error::new(
Span::call_site(),
"CARGO_MANIFEST_DIR is not set; Cargo must expand #[model] inside a package build",
)
})?;
let out_root = std::env::var_os("OUT_DIR")
.map(PathBuf::from)
.unwrap_or_else(|| manifest_dir.join("target").join("oneliner"));
let output_dir = out_root
.join("frontend")
.join(format!("{struct_name}_{model_stem}"));
fs::create_dir_all(&output_dir).map_err(|error| syn::Error::new(Span::call_site(), error))?;
Ok(output_dir.join(format!("{model_stem}.{suffix}")))
}
fn detect_format(path: &Path) -> syn::Result<ModelFormat> {
let extension = path
.extension()
.and_then(OsStr::to_str)
.map(str::to_ascii_lowercase)
.ok_or_else(|| {
syn::Error::new(
Span::call_site(),
format!(
"model path has no supported extension: {}; expected .mlir, .onnx, .pt2, or .tflite",
path.display()
),
)
})?;
match extension.as_str() {
"mlir" => Ok(ModelFormat::Mlir),
"onnx" => Ok(ModelFormat::Onnx),
"pt2" => Ok(ModelFormat::Pytorch),
"tflite" => Ok(ModelFormat::Tflite),
"pt" | "pth" => Err(syn::Error::new(
Span::call_site(),
format!(
"PyTorch checkpoint '.{extension}' at {} is not a self-contained export; use torch.export.save(..., \"model.pt2\") and pass the .pt2 file to #[model]",
path.display()
),
)),
_ => Err(syn::Error::new(
Span::call_site(),
format!(
"unsupported model format '.{extension}' at {}; expected .mlir, .onnx, .pt2, or .tflite",
path.display()
),
)),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detects_supported_model_formats_case_insensitively() {
assert_eq!(
detect_format(Path::new("model.mlir")).unwrap(),
ModelFormat::Mlir
);
assert_eq!(
detect_format(Path::new("model.ONNX")).unwrap(),
ModelFormat::Onnx
);
assert_eq!(
detect_format(Path::new("model.pt2")).unwrap(),
ModelFormat::Pytorch
);
assert_eq!(
detect_format(Path::new("model.TFLITE")).unwrap(),
ModelFormat::Tflite
);
}
#[test]
fn rejects_ambiguous_pytorch_checkpoint_extensions() {
let error = detect_format(Path::new("model.pth")).unwrap_err();
assert!(error.to_string().contains("use torch.export.save"));
}
}