Struct NormalizeTable 

pub struct NormalizeTable { /* private fields */ }

The normalized plans for one parsed source tree.

Keyed by the binding-group node’s text_range().start(), exactly as sui_resolve::ResolveTable keys idents. An unrecorded offset means the group needs no normalization — no duplicate static key and no dotted path — so consumers keep their existing path for it.

Implementations

impl NormalizeTable

pub fn new() -> Self

An empty table — every lookup returns None.

pub fn get(&self, text_offset: u32) -> Option<&GroupPlan>

The plan recorded for the group node starting at text_offset, if any.

pub fn len(&self) -> usize

Number of recorded groups. Small by construction — see the module docs.

Examples found in repository

examples/scan.rs (line 80)

fn main() {
    let roots: Vec<PathBuf> = std::env::args().skip(1).map(PathBuf::from).collect();
    if roots.is_empty() {
        eprintln!("usage: scan <dir> [<dir>…]");
        std::process::exit(2);
    }

    let mut files = Vec::new();
    for r in &roots {
        nix_files(r, &mut files);
    }

    let (mut unparseable, mut clean, mut planned, mut rejected) = (0usize, 0usize, 0usize, 0usize);
    let mut groups = 0usize;
    let mut rejects: Vec<(PathBuf, String)> = Vec::new();

    for f in &files {
        let Ok(src) = std::fs::read_to_string(f) else {
            continue;
        };
        let parse = rnix::Root::parse(&src);
        if !parse.errors().is_empty() {
            // rnix could not parse it — not this pass's business, and counted
            // separately so it can never be mistaken for a clean result.
            unparseable += 1;
            continue;
        }
        match sui_normalize::normalize(&parse.tree()) {
            Ok(table) if table.is_empty() => clean += 1,
            Ok(table) => {
                planned += 1;
                groups += table.len();
            }
            Err(e) => {
                rejected += 1;
                rejects.push((f.clone(), e.to_string()));
            }
        }
    }

    println!("scanned    {}", files.len());
    println!("  clean      {clean}   (no duplicate key, no dotted path — untouched)");
    println!("  planned    {planned}   ({groups} binding groups — THE BLAST RADIUS)");
    println!("  rejected   {rejected}   (must be 0 before the rejection tier flips)");
    println!("  unparseable {unparseable}   (rnix could not read; not this pass's business)");

    for (p, e) in rejects.iter().take(25) {
        println!("  REJECT {}: {e}", p.display());
    }
    if rejects.len() > 25 {
        println!("  … and {} more", rejects.len() - 25);
    }
}

pub fn is_empty(&self) -> bool

True when no group needed normalization.

Examples found in repository

examples/scan.rs (line 77)

fn main() {
    let roots: Vec<PathBuf> = std::env::args().skip(1).map(PathBuf::from).collect();
    if roots.is_empty() {
        eprintln!("usage: scan <dir> [<dir>…]");
        std::process::exit(2);
    }

    let mut files = Vec::new();
    for r in &roots {
        nix_files(r, &mut files);
    }

    let (mut unparseable, mut clean, mut planned, mut rejected) = (0usize, 0usize, 0usize, 0usize);
    let mut groups = 0usize;
    let mut rejects: Vec<(PathBuf, String)> = Vec::new();

    for f in &files {
        let Ok(src) = std::fs::read_to_string(f) else {
            continue;
        };
        let parse = rnix::Root::parse(&src);
        if !parse.errors().is_empty() {
            // rnix could not parse it — not this pass's business, and counted
            // separately so it can never be mistaken for a clean result.
            unparseable += 1;
            continue;
        }
        match sui_normalize::normalize(&parse.tree()) {
            Ok(table) if table.is_empty() => clean += 1,
            Ok(table) => {
                planned += 1;
                groups += table.len();
            }
            Err(e) => {
                rejected += 1;
                rejects.push((f.clone(), e.to_string()));
            }
        }
    }

    println!("scanned    {}", files.len());
    println!("  clean      {clean}   (no duplicate key, no dotted path — untouched)");
    println!("  planned    {planned}   ({groups} binding groups — THE BLAST RADIUS)");
    println!("  rejected   {rejected}   (must be 0 before the rejection tier flips)");
    println!("  unparseable {unparseable}   (rnix could not read; not this pass's business)");

    for (p, e) in rejects.iter().take(25) {
        println!("  REJECT {}: {e}", p.display());
    }
    if rejects.len() > 25 {
        println!("  … and {} more", rejects.len() - 25);
    }
}

pub fn iter(&self) -> impl Iterator<Item = (u32, &GroupPlan)>

Iterate the recorded (text_offset, plan) pairs. Consumers merge these into their own per-(source_id, offset) table, exactly as sui-resolve’s consumers do.

Trait Implementations

impl Clone for NormalizeTable

fn clone(&self) -> NormalizeTable

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NormalizeTable

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for NormalizeTable

fn default() -> NormalizeTable

Returns the “default value” for a type.