melior_macro/
lib.rs

1mod attribute;
2mod dialect;
3mod operation;
4mod parse;
5mod pass;
6mod r#type;
7mod utility;
8
9use dialect::DialectInput;
10use parse::{DialectOperationSet, IdentifierList, PassSet};
11use proc_macro::TokenStream;
12use quote::quote;
13use std::error::Error;
14use syn::parse_macro_input;
15
16/// Generates a dialect module from a TableGen file.
17///
18/// # Examples
19///
20/// ```rust
21/// melior::dialect! {
22///     name: "func",
23///     files: ["IR/FuncOps.td", "TransformOps/FuncTransformOps.td", "Transforms/Passes.td"],
24///     include_directories: ["mlir/Dialect/Func"],
25///     include_directory_env_vars: ["ENV_VAR_FOR_MLIR_DIALECT_DIR"],
26/// }
27/// ```
28#[proc_macro]
29pub fn dialect(input: TokenStream) -> TokenStream {
30    let input = parse_macro_input!(input as DialectInput);
31    dialect::generate_dialect(input).unwrap_or_else(|error| error.to_compile_error())
32}
33
34#[proc_macro]
35pub fn binary_operations(stream: TokenStream) -> TokenStream {
36    let set = parse_macro_input!(stream as DialectOperationSet);
37
38    convert_result(operation::generate_binary(set.dialect(), set.identifiers()))
39}
40
41#[proc_macro]
42pub fn unary_operations(stream: TokenStream) -> TokenStream {
43    let set = parse_macro_input!(stream as DialectOperationSet);
44
45    convert_result(operation::generate_unary(set.dialect(), set.identifiers()))
46}
47
48#[proc_macro]
49pub fn typed_unary_operations(stream: TokenStream) -> TokenStream {
50    let set = parse_macro_input!(stream as DialectOperationSet);
51
52    convert_result(operation::generate_typed_unary(
53        set.dialect(),
54        set.identifiers(),
55    ))
56}
57
58#[proc_macro]
59pub fn type_check_functions(stream: TokenStream) -> TokenStream {
60    let identifiers = parse_macro_input!(stream as IdentifierList);
61
62    convert_result(r#type::generate(identifiers.identifiers()))
63}
64
65#[proc_macro]
66pub fn attribute_check_functions(stream: TokenStream) -> TokenStream {
67    let identifiers = parse_macro_input!(stream as IdentifierList);
68
69    convert_result(attribute::generate(identifiers.identifiers()))
70}
71
72#[proc_macro]
73pub fn conversion_passes(stream: TokenStream) -> TokenStream {
74    let identifiers = parse_macro_input!(stream as IdentifierList);
75
76    convert_result(pass::generate(identifiers.identifiers(), |mut name| {
77        name = name.strip_prefix("Conversion").unwrap();
78        name = name.strip_prefix("Convert").unwrap_or(name);
79        name = name.strip_suffix("ConversionPass").unwrap_or(name);
80        name.strip_suffix("Pass").unwrap_or(name).into()
81    }))
82}
83
84#[proc_macro]
85pub fn passes(stream: TokenStream) -> TokenStream {
86    let set = parse_macro_input!(stream as PassSet);
87
88    convert_result(pass::generate(set.identifiers(), |name| {
89        name.strip_prefix(&set.prefix().value()).unwrap().into()
90    }))
91}
92
93fn convert_result(result: Result<TokenStream, Box<dyn Error>>) -> TokenStream {
94    result.unwrap_or_else(|error| {
95        let message = error.to_string();
96
97        quote! { compile_error!(#message) }.into()
98    })
99}