Refactor dialect macros

macro/src/dialect.rs

@@ -30,7 +30,12 @@ pub fn generate_dialect(input: DialectInput) -> Result<TokenStream, Box<dyn std:
     }
 
     // spell-checker: disable-next-line
-    for path in input.includes().chain([&*llvm_config("--includedir")?]) {
+    let llvm_include_directory = llvm_config("--includedir")?;
+
+    for path in input
+        .include_directories()
+        .chain([llvm_include_directory.as_str()])
+    {
         parser = parser.add_include_path(path);
     }
 
@@ -61,7 +66,8 @@ fn generate_dialect_module(
         .collect::<Result<Vec<_>, _>>()?
         .into_iter()
         .filter(|operation| operation.dialect_name() == dialect_name)
-        .collect::<Vec<_>>();
+        .map(|operation| operation.to_tokens())
+        .collect::<Result<Vec<_>, _>>()?;
 
     let doc = format!(
         "`{name}` dialect.\n\n{}",

macro/src/dialect/error.rs

@@ -83,16 +83,19 @@ impl From<FromUtf8Error> for Error {
 pub enum OdsError {
     ExpectedSuperClass(&'static str),
     InvalidTrait,
+    UnexpectedSuperClass(&'static str),
 }
 
 impl Display for OdsError {
     fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
         match self {
-            Self::ExpectedSuperClass(class) => write!(
-                formatter,
-                "expected this record to be a subclass of {class}",
-            ),
+            Self::ExpectedSuperClass(class) => {
+                write!(formatter, "record should be a sub-class of {class}",)
+            }
             Self::InvalidTrait => write!(formatter, "record is not a supported trait"),
+            Self::UnexpectedSuperClass(class) => {
+                write!(formatter, "record should not be a sub-class of {class}",)
+            }
         }
     }
 }

macro/src/dialect/input.rs

@@ -1,13 +1,14 @@
-use proc_macro2::Ident;
-use quote::format_ident;
+mod input_field;
+
+use self::input_field::InputField;
 use std::ops::Deref;
-use syn::{bracketed, parse::Parse, punctuated::Punctuated, LitStr, Token};
+use syn::{parse::Parse, punctuated::Punctuated, Token};
 
 pub struct DialectInput {
     name: String,
     table_gen: Option<String>,
     td_file: Option<String>,
-    includes: Vec<String>,
+    include_directories: Vec<String>,
 }
 
 impl DialectInput {
@@ -23,8 +24,8 @@ impl DialectInput {
         self.td_file.as_deref()
     }
 
-    pub fn includes(&self) -> impl Iterator<Item = &str> {
-        self.includes.iter().map(Deref::deref)
+    pub fn include_directories(&self) -> impl Iterator<Item = &str> {
+        self.include_directories.iter().map(Deref::deref)
     }
 }
 
@@ -40,7 +41,7 @@ impl Parse for DialectInput {
                 InputField::Name(field) => name = Some(field.value()),
                 InputField::TableGen(td) => table_gen = Some(td.value()),
                 InputField::TdFile(file) => td_file = Some(file.value()),
-                InputField::Includes(field) => {
+                InputField::IncludeDirectories(field) => {
                     includes = field.into_iter().map(|literal| literal.value()).collect()
                 }
             }
@@ -50,38 +51,7 @@ impl Parse for DialectInput {
             name: name.ok_or(input.error("dialect name required"))?,
             table_gen,
             td_file,
-            includes,
+            include_directories: includes,
         })
     }
 }
-
-enum InputField {
-    Name(LitStr),
-    TableGen(LitStr),
-    TdFile(LitStr),
-    Includes(Punctuated<LitStr, Token![,]>),
-}
-
-impl Parse for InputField {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let ident = input.parse::<Ident>()?;
-
-        input.parse::<Token![:]>()?;
-
-        if ident == format_ident!("name") {
-            Ok(Self::Name(input.parse()?))
-        } else if ident == format_ident!("table_gen") {
-            Ok(Self::TableGen(input.parse()?))
-        } else if ident == format_ident!("td_file") {
-            Ok(Self::TdFile(input.parse()?))
-        } else if ident == format_ident!("include_dirs") {
-            let content;
-            bracketed!(content in input);
-            Ok(Self::Includes(
-                Punctuated::<LitStr, Token![,]>::parse_terminated(&content)?,
-            ))
-        } else {
-            Err(input.error(format!("invalid field {}", ident)))
-        }
-    }
-}

macro/src/dialect/input/input_field.rs

@@ -0,0 +1,34 @@
+use proc_macro2::Ident;
+use quote::format_ident;
+use syn::{bracketed, parse::Parse, punctuated::Punctuated, LitStr, Token};
+
+pub enum InputField {
+    Name(LitStr),
+    TableGen(LitStr),
+    TdFile(LitStr),
+    IncludeDirectories(Punctuated<LitStr, Token![,]>),
+}
+
+impl Parse for InputField {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let ident = input.parse::<Ident>()?;
+
+        input.parse::<Token![:]>()?;
+
+        if ident == format_ident!("name") {
+            Ok(Self::Name(input.parse()?))
+        } else if ident == format_ident!("table_gen") {
+            Ok(Self::TableGen(input.parse()?))
+        } else if ident == format_ident!("td_file") {
+            Ok(Self::TdFile(input.parse()?))
+        } else if ident == format_ident!("include_dirs") {
+            let content;
+            bracketed!(content in input);
+            Ok(Self::IncludeDirectories(
+                Punctuated::<LitStr, Token![,]>::parse_terminated(&content)?,
+            ))
+        } else {
+            Err(input.error(format!("invalid field {}", ident)))
+        }
+    }
+}