hamelin_translation 0.3.10

//! Unique name generation for normalization passes.

use hamelin_lib::tree::ast::identifier::SimpleIdentifier;

/// Generator for unique identifiers during normalization.
///
/// Produces names like `__alias_0`, `__alias_1`, etc. for a given prefix.
/// The counter is shared across all calls, ensuring uniqueness within a
/// normalization pass.
#[derive(Debug)]
pub struct UniqueNameGenerator {
    prefix: &'static str,
    counter: usize,
}

impl UniqueNameGenerator {
    /// Create a new generator with the given prefix.
    pub fn new(prefix: &'static str) -> Self {
        Self { prefix, counter: 0 }
    }

    /// Generate the next unique name.
    pub fn next(&mut self) -> SimpleIdentifier {
        let name = format!("{}_{}", self.prefix, self.counter);
        self.counter += 1;
        SimpleIdentifier::new(name)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_generates_sequential_names() {
        let mut gen = UniqueNameGenerator::new("__test");

        assert_eq!(gen.next().as_str(), "__test_0");
        assert_eq!(gen.next().as_str(), "__test_1");
        assert_eq!(gen.next().as_str(), "__test_2");
    }

    #[test]
    fn test_different_prefixes_are_independent() {
        let mut alias_gen = UniqueNameGenerator::new("__alias");
        let mut from_gen = UniqueNameGenerator::new("__from");

        assert_eq!(alias_gen.next().as_str(), "__alias_0");
        assert_eq!(from_gen.next().as_str(), "__from_0");
        assert_eq!(alias_gen.next().as_str(), "__alias_1");
        assert_eq!(from_gen.next().as_str(), "__from_1");
    }
}