waddling-errors-macros 0.7.3

//! Implementation of the `sequence!` proc macro

use proc_macro::TokenStream;
use quote::quote;
use std::collections::{HashMap, HashSet};
use syn::{
    Attribute, Ident, LitInt, LitStr, Result, Token, UseTree,
    parse::{Parse, ParseStream},
    punctuated::Punctuated,
    token::{Brace, Comma},
};

pub fn expand(input: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(input as SequenceInput);
    let output = input.generate();
    TokenStream::from(output)
}

struct SequenceInput {
    imports: Vec<SequenceImport>,
    sequences: Punctuated<SequenceItem, Comma>,
}

/// Represents a single import statement: use path::{item1, item2};
struct SequenceImport {
    path: syn::Path,
    items: Vec<Ident>,
}

impl Parse for SequenceInput {
    fn parse(input: ParseStream) -> Result<Self> {
        let mut imports = Vec::new();

        // Parse optional import statements
        while input.peek(Token![use]) {
            input.parse::<Token![use]>()?;

            // Parse use tree (e.g., crate::module::{Item1, Item2})
            let use_tree: UseTree = input.parse()?;

            // Extract path and items from UseTree
            if let Some(import) = SequenceInput::extract_import_from_use_tree(&use_tree)? {
                imports.push(import);
            }

            // Parse semicolon
            input.parse::<Token![;]>()?;

            // Optional comma after import
            if input.peek(Token![,]) {
                input.parse::<Token![,]>()?;
            }
        }

        // Parse local sequence definitions
        let sequences = input.parse_terminated(SequenceItem::parse, Token![,])?;

        Ok(SequenceInput { imports, sequences })
    }
}

impl SequenceInput {
    /// Extract path and items from a UseTree
    fn extract_import_from_use_tree(tree: &UseTree) -> Result<Option<SequenceImport>> {
        match tree {
            UseTree::Path(use_path) => {
                // Recursively extract from the rest of the path
                let child_import = Self::extract_import_from_use_tree(&use_path.tree)?;
                if let Some(mut import) = child_import {
                    // Prepend this segment to the path
                    let mut segments = syn::punctuated::Punctuated::new();
                    segments.push(use_path.ident.clone().into());
                    for seg in import.path.segments.iter() {
                        segments.push(seg.clone());
                    }
                    import.path = syn::Path {
                        leading_colon: None,
                        segments,
                    };
                    Ok(Some(import))
                } else {
                    Ok(None)
                }
            }
            UseTree::Group(group) => {
                // Extract items from group: {Item1, Item2}
                let mut items = Vec::new();
                for item_tree in &group.items {
                    if let UseTree::Name(name) = item_tree {
                        items.push(name.ident.clone());
                    } else {
                        return Err(syn::Error::new_spanned(
                            item_tree,
                            "only simple identifiers are supported in use statements",
                        ));
                    }
                }

                // Return with empty path (will be filled by parent Path node)
                Ok(Some(SequenceImport {
                    path: syn::Path {
                        leading_colon: None,
                        segments: syn::punctuated::Punctuated::new(),
                    },
                    items,
                }))
            }
            UseTree::Name(_) => {
                // Single item import - not supported for now
                Err(syn::Error::new_spanned(
                    tree,
                    "use grouped imports: use path::{Item1, Item2};",
                ))
            }
            _ => Err(syn::Error::new_spanned(
                tree,
                "unsupported use syntax. Use: use path::{Item1, Item2};",
            )),
        }
    }
}

struct SequenceItem {
    attributes: Vec<Attribute>,
    name: Ident,
    number: LitInt,
    metadata: Option<SequenceMetadata>,
}

impl Parse for SequenceItem {
    fn parse(input: ParseStream) -> Result<Self> {
        let attributes = input.call(Attribute::parse_outer)?;
        let name = input.parse()?;

        // Parse (number)
        let paren_content;
        syn::parenthesized!(paren_content in input);
        let number: LitInt = paren_content.parse()?;

        let metadata = if input.peek(Brace) {
            Some(input.parse()?)
        } else {
            None
        };

        Ok(SequenceItem {
            attributes,
            name,
            number,
            metadata,
        })
    }
}

struct SequenceMetadata {
    description: Option<LitStr>,
    typical_severity: Option<LitStr>,
    hints: Option<Vec<LitStr>>,
    related: Option<Vec<LitStr>>,
    introduced: Option<LitStr>,
}

impl Parse for SequenceMetadata {
    fn parse(input: ParseStream) -> Result<Self> {
        let content;
        syn::braced!(content in input);

        let mut description = None;
        let mut typical_severity = None;
        let mut hints = None;
        let mut related = None;
        let mut introduced = None;

        while !content.is_empty() {
            let field_name: Ident = content.parse()?;
            content.parse::<Token![:]>()?;

            match field_name.to_string().as_str() {
                "description" => description = Some(content.parse()?),
                "typical_severity" => typical_severity = Some(content.parse()?),
                "hints" => {
                    let array_content;
                    syn::bracketed!(array_content in content);
                    hints = Some(
                        Punctuated::<LitStr, Token![,]>::parse_terminated(&array_content)?
                            .into_iter()
                            .collect(),
                    );
                }
                "related" => {
                    let array_content;
                    syn::bracketed!(array_content in content);
                    related = Some(
                        Punctuated::<LitStr, Token![,]>::parse_terminated(&array_content)?
                            .into_iter()
                            .collect(),
                    );
                }
                "introduced" => introduced = Some(content.parse()?),
                _ => {
                    return Err(syn::Error::new(
                        field_name.span(),
                        format!(
                            "unknown field `{}`. Valid fields: description, typical_severity, hints, related, introduced",
                            field_name
                        ),
                    ));
                }
            }

            if !content.is_empty() {
                content.parse::<Token![,]>()?;
            }
        }

        Ok(SequenceMetadata {
            description,
            typical_severity,
            hints,
            related,
            introduced,
        })
    }
}

impl SequenceInput {
    fn generate(&self) -> proc_macro2::TokenStream {
        // Validate local sequences for conflicts
        if let Err(e) = self.validate_local_sequences() {
            return e.to_compile_error();
        }

        // Generate import re-exports
        let import_reexports = self.generate_import_reexports();

        // Generate local sequence constants and metadata
        let items: Vec<_> = self.sequences.iter().map(|seq| seq.generate()).collect();

        // Generate lookup functions with imports inlined
        let lookup_fns = self.generate_lookup_functions();

        // Generate auto-registration for local sequences
        let auto_registrations = self.generate_auto_registration();

        quote! {
            #import_reexports

            #(#items)*

            #lookup_fns

            #auto_registrations
        }
    }

    /// Validate that local sequences don't have duplicate names or numbers
    fn validate_local_sequences(&self) -> Result<()> {
        let mut seen_names = HashSet::new();
        let mut seen_numbers = HashMap::new();

        for seq in &self.sequences {
            let name = seq.name.to_string();
            let num_value: u16 = seq.number.base10_parse().unwrap_or(0);

            // Check for duplicate names
            if seen_names.contains(&name) {
                return Err(syn::Error::new(
                    seq.name.span(),
                    format!("duplicate sequence name `{}` in this block", name),
                ));
            }
            seen_names.insert(name.clone());

            // Check for duplicate numbers
            if let Some(other_name) = seen_numbers.get(&num_value) {
                return Err(syn::Error::new(
                    seq.number.span(),
                    format!(
                        "duplicate sequence number {} (already used by `{}`)",
                        num_value, other_name
                    ),
                ));
            }
            seen_numbers.insert(num_value, name);
        }

        Ok(())
    }

    /// Generate re-export statements for imported sequences
    fn generate_import_reexports(&self) -> proc_macro2::TokenStream {
        let mut reexports = Vec::new();

        for import in &self.imports {
            let path = &import.path;
            let items = &import.items;

            // Re-export constants
            reexports.push(quote! {
                pub use #path::{#(#items),*};
            });

            // Re-export metadata constants
            let meta_items: Vec<_> = items
                .iter()
                .map(|item| Ident::new(&format!("{}_META", item), item.span()))
                .collect();

            reexports.push(quote! {
                #[cfg(feature = "metadata")]
                pub use #path::{#(#meta_items),*};
            });
        }

        quote! {
            #(#reexports)*
        }
    }

    /// Generate lookup functions with imported sequences inlined
    fn generate_lookup_functions(&self) -> proc_macro2::TokenStream {
        let mut metadata_arms = Vec::new();
        let mut name_arms = Vec::new();

        // Local sequences first (highest priority)
        for seq in &self.sequences {
            let name = &seq.name;
            let meta_name = Ident::new(&format!("{}_META", seq.name), seq.name.span());
            let name_str = seq.name.to_string();

            metadata_arms.push(quote! {
                #name => Some(&#meta_name)
            });

            name_arms.push(quote! {
                #name => Some(#name_str)
            });
        }

        // Imported sequences (explicit, in import order)
        for import in &self.imports {
            let path = &import.path;

            for item in &import.items {
                let meta_name = Ident::new(&format!("{}_META", item), item.span());
                let item_str = item.to_string();

                metadata_arms.push(quote! {
                    #item => Some(&#path::#meta_name)
                });

                name_arms.push(quote! {
                    #item => Some(#item_str)
                });
            }
        }

        quote! {
            /// Look up sequence metadata by number
            ///
            /// This function includes both local sequences and imported sequences.
            /// Local sequences are checked first, then imported sequences in import order.
            #[cfg(feature = "metadata")]
            pub fn lookup_sequence_metadata(number: u16) -> Option<&'static waddling_errors::metadata::SequenceMetadata> {
                match number {
                    #(#metadata_arms),*,
                    _ => None,
                }
            }

            /// Look up sequence name by number
            ///
            /// This function includes both local sequences and imported sequences.
            /// Local sequences are checked first, then imported sequences in import order.
            pub fn lookup_sequence_name(number: u16) -> Option<&'static str> {
                match number {
                    #(#name_arms),*,
                    _ => None,
                }
            }
        }
    }

    /// Generate auto-registration code for local sequences
    fn generate_auto_registration(&self) -> proc_macro2::TokenStream {
        // Generate registration for each local sequence
        let registrations: Vec<_> = self
            .sequences
            .iter()
            .map(|seq| {
                let name = &seq.name;
                let name_str = name.to_string();
                let number = &seq.number;
                let meta_name = Ident::new(&format!("{}_META", name), name.span());

                // Generate unique function name for this sequence
                let register_fn_name = Ident::new(
                    &format!("__register_sequence_{}", name_str.to_lowercase()),
                    name.span(),
                );

                quote! {
                    #[cfg(all(feature = "auto-register", feature = "metadata"))]
                    #[::waddling_errors::internal::ctor::ctor]
                    fn #register_fn_name() {
                        ::waddling_errors::registry::register_sequence(
                            #name_str,
                            #number,
                            #meta_name.description,
                            #meta_name.typical_severity,
                            #meta_name.hints,
                        );
                    }
                }
            })
            .collect();

        quote! {
            #(#registrations)*
        }
    }
}

impl SequenceItem {
    fn generate(&self) -> proc_macro2::TokenStream {
        let name = &self.name;
        let number = &self.number;
        let attributes = &self.attributes;

        // Parse number value for validation
        let num_value: u16 = self.number.base10_parse().unwrap_or(0);

        // Generate doc comment from description if present
        let doc_comment = self
            .metadata
            .as_ref()
            .and_then(|m| m.description.as_ref())
            .map(|desc| {
                quote! {
                    #[doc = ""]
                    #[doc = #desc]
                    #[doc = ""]
                }
            });

        // Generate constant
        let const_def = quote! {
            #(#attributes)*
            #doc_comment
            #[doc = concat!("Sequence value: ", stringify!(#number))]
            pub const #name: u16 = #number;

            // Compile-time validation
            const _: () = {
                if #num_value == 0 {
                    panic!(concat!(
                        "Sequence ", stringify!(#name),
                        " cannot be 0. Use values 1-999."
                    ));
                }
                if #num_value > 999 {
                    panic!(concat!(
                        "Sequence ", stringify!(#name),
                        " (value: ", stringify!(#num_value), ") exceeds maximum (999). WDP spec requires 001-999."
                    ));
                }
            };
        };

        // Generate metadata constant if feature enabled
        let metadata_const = self.generate_metadata_const();

        quote! {
            #const_def
            #metadata_const
        }
    }

    fn generate_metadata_const(&self) -> proc_macro2::TokenStream {
        let name = &self.name;
        let number = &self.number;
        let name_str = name.to_string();

        if let Some(metadata) = &self.metadata {
            let description = metadata
                .description
                .as_ref()
                .map(|d| quote! { Some(#d) })
                .unwrap_or_else(|| quote! { None });

            let typical_severity = metadata
                .typical_severity
                .as_ref()
                .map(|s| quote! { Some(#s) })
                .unwrap_or_else(|| quote! { None });

            let hints = metadata
                .hints
                .as_ref()
                .map(|arr| quote! { &[#(#arr),*] })
                .unwrap_or_else(|| quote! { &[] });

            let related = metadata
                .related
                .as_ref()
                .map(|arr| quote! { &[#(#arr),*] })
                .unwrap_or_else(|| quote! { &[] });

            let introduced = metadata
                .introduced
                .as_ref()
                .map(|i| quote! { Some(#i) })
                .unwrap_or_else(|| quote! { None });

            let meta_name = Ident::new(&format!("{}_META", name), name.span());

            quote! {
                #[cfg(feature = "metadata")]
                #[allow(non_upper_case_globals)]
                pub const #meta_name: waddling_errors::metadata::SequenceMetadata =
                    waddling_errors::metadata::SequenceMetadata {
                        number: #number,
                        name: #name_str,
                        description: #description,
                        typical_severity: #typical_severity,
                        hints: #hints,
                        related: #related,
                        introduced: #introduced,
                    };
            }
        } else {
            // No metadata, generate minimal version
            let meta_name = Ident::new(&format!("{}_META", name), name.span());

            quote! {
                #[cfg(feature = "metadata")]
                #[allow(non_upper_case_globals)]
                pub const #meta_name: waddling_errors::metadata::SequenceMetadata =
                    waddling_errors::metadata::SequenceMetadata {
                        number: #number,
                        name: #name_str,
                        description: None,
                        typical_severity: None,
                        hints: &[],
                        related: &[],
                        introduced: None,
                    };
            }
        }
    }
}