ruka_mir/

naming.rs

//! Stable naming helpers used by MIR browser graphs and backends.

use std::collections::HashSet;

use cranelift_entity::EntityRef;
use heck::ToSnakeCase;
use unicode_ident::{is_xid_continue, is_xid_start};

use crate::{LocalKind, MirFuncId, MirFunction, MirLocalId, MirProgram};

/// Stable synthesized identifiers for functions in a MIR program.
#[derive(Debug, Clone)]
pub struct ProgramNames {
    function_idents: Vec<String>,
}

impl ProgramNames {
    /// Build a stable set of function identifiers for a MIR program.
    pub fn from_program(program: &MirProgram) -> Self {
        let mut used = HashSet::new();
        let mut function_idents = Vec::with_capacity(program.functions.len());
        for (func_id, function) in program.functions.iter() {
            let base = if function.name.is_empty() {
                format!("fn_{}", func_id.index())
            } else {
                format!("fn_{}", mangle_canonical_ident(&function.name))
            };
            let ident = unique_name(&base, &mut used);
            function_idents.push(ident);
        }
        Self { function_idents }
    }

    /// Return the emitted identifier for a MIR function id.
    pub fn function_ident(&self, func_id: MirFuncId) -> &str {
        &self.function_idents[func_id.index()]
    }
}

/// Stable synthesized identifiers for locals in one MIR function.
#[derive(Debug, Clone)]
pub struct FunctionNames {
    local_idents: Vec<String>,
}

impl FunctionNames {
    /// Build stable local identifiers for a MIR function.
    pub fn from_function(function: &MirFunction) -> Self {
        let mut used = HashSet::new();
        let mut local_idents = Vec::with_capacity(function.locals.len());

        for (local_id, info) in function.locals.iter() {
            let base = match info.kind {
                LocalKind::Param => match &info.debug_name {
                    Some(name) if !name.is_empty() => format!("p_{name}"),
                    _ => format!("p_{}", local_id.index()),
                },
                LocalKind::Binding => match &info.debug_name {
                    Some(name) if !name.is_empty() => format!("v_{name}"),
                    _ => format!("v_{}", local_id.index()),
                },
                LocalKind::Temp => match &info.debug_name {
                    Some(name) if !name.is_empty() => format!("t_{name}"),
                    _ => format!("t_{}", local_id.index()),
                },
            };

            let ident = unique_name(&sanitize_ident(&base, "t_"), &mut used);
            local_idents.push(ident);
        }

        Self { local_idents }
    }

    /// Return the emitted identifier for a MIR local id.
    pub fn local_ident(&self, local_id: MirLocalId) -> &str {
        &self.local_idents[local_id.index()]
    }

    /// Build an identifier for an incoming block parameter binding.
    pub fn incoming_param_ident(&self, local_id: MirLocalId, index: usize) -> String {
        format!("in_{}_{}", self.local_ident(local_id), index)
    }
}

/// Build a valid synthetic temporary identifier for generated Rust.
///
/// ```
/// let ident = ruka_mir::naming::synthetic_temp_ident("match-value");
/// assert_eq!(ident, "t_match_value");
/// ```
pub fn synthetic_temp_ident(stem: &str) -> String {
    sanitize_ident(&format!("t_{stem}"), "t")
}

/// Mangle a canonical source-level identifier into a Rust-compatible name.
pub fn mangle_canonical_ident(name: &str) -> String {
    let mut out = String::new();
    let mut chars = name.chars().peekable();

    while let Some(ch) = chars.next() {
        match ch {
            '_' => out.push_str("__"),
            '[' => out.push_str("_l"),
            ']' => out.push_str("_r"),
            ';' => out.push_str("_m"),
            ':' => {
                if chars.peek() == Some(&':') {
                    chars.next();
                    out.push_str("_d");
                } else {
                    panic!("unsupported character in canonical name for mangling: standalone `:`");
                }
            }
            ',' => {
                if chars.peek() == Some(&' ') {
                    chars.next();
                    out.push_str("_c");
                } else {
                    panic!("unsupported character in canonical name for mangling: expected `, `");
                }
            }
            'A'..='Z' | 'a'..='z' | '0'..='9' => out.push(ch),
            _ => panic!("unsupported character in canonical name for mangling: `{ch}`"),
        }
    }

    if out.is_empty() {
        panic!("cannot mangle empty canonical name");
    }
    if out.as_bytes()[0].is_ascii_digit() {
        panic!("canonical name cannot start with a digit: `{name}`");
    }
    out
}

fn unique_name(base: &str, used: &mut HashSet<String>) -> String {
    if used.insert(base.to_owned()) {
        return base.to_owned();
    }

    let mut suffix = 2usize;
    loop {
        let candidate = format!("{base}_{suffix}");
        if used.insert(candidate.clone()) {
            return candidate;
        }
        suffix += 1;
    }
}

fn sanitize_ident(raw: &str, fallback_prefix: &str) -> String {
    let snake = raw.to_snake_case();
    let mut out = String::new();

    for (index, ch) in snake.chars().enumerate() {
        if index == 0 {
            if is_xid_start(ch) || ch == '_' {
                out.push(ch);
            } else if is_xid_continue(ch) {
                out.push('_');
                out.push(ch);
            } else {
                out.push('_');
            }
        } else if is_xid_continue(ch) {
            out.push(ch);
        } else {
            out.push('_');
        }
    }

    if out.is_empty() || out == "_" {
        out = fallback_prefix.to_owned();
    }

    if is_rust_keyword(&out) {
        out.push('_');
    }

    out
}

fn is_rust_keyword(ident: &str) -> bool {
    matches!(
        ident,
        "as" | "break"
            | "const"
            | "continue"
            | "crate"
            | "else"
            | "enum"
            | "extern"
            | "false"
            | "fn"
            | "for"
            | "if"
            | "impl"
            | "in"
            | "let"
            | "loop"
            | "match"
            | "mod"
            | "move"
            | "mut"
            | "pub"
            | "ref"
            | "return"
            | "self"
            | "Self"
            | "static"
            | "struct"
            | "super"
            | "trait"
            | "true"
            | "type"
            | "unsafe"
            | "use"
            | "where"
            | "while"
            | "async"
            | "await"
            | "dyn"
            | "abstract"
            | "become"
            | "box"
            | "do"
            | "final"
            | "macro"
            | "override"
            | "priv"
            | "try"
            | "typeof"
            | "unsized"
            | "virtual"
            | "yield"
    )
}

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

    #[test]
    fn mangles_canonical_names_with_pair_escapes() {
        assert_eq!(
            mangle_canonical_ident("Pair[i64, String]"),
            "Pair_li64_cString_r"
        );
        assert_eq!(
            mangle_canonical_ident("Boxed[i64]::clone_from"),
            "Boxed_li64_r_dclone__from"
        );
    }

    #[test]
    #[should_panic(expected = "expected `, `")]
    fn rejects_comma_without_space() {
        let _ = mangle_canonical_ident("Pair[i64,String]");
    }
}