Add --rc-report: static reference-count elision measurement

A read-only analysis over the typed IR classifies each emitted retain by category
(aliasing copy, call argument, spawn argument, borrowed element load, store into
an aggregate) and, for the categories that become a move when the source's last
real use is the retain site, counts how many are movable. A movable retain pairs
with the moved-from variable's drop, so eliding it elides both. Changes no
codegen.

Driven by a --rc-report CLI flag handled at the top like --explain, over the IR
already exposed on the compile result, so no environment reads live in the
library and nothing is threaded into lower_program.

First measurement on the http hello server: call-arg retains dominate (72 of the
97 movable-category retains) and 56 of them are movable, so the calling-convention
retain is the big lever and about 82 percent of movable-category retains are
actually moves.

Author: Axmouth

solid-snake-compiler/src/bytecode_gen.rs

@@ -465,6 +465,181 @@ fn for_each_stmt_var(stmt: &TypedIRStmt, f: &mut impl FnMut(usize)) {
     }
 }
 
+/// Read-only measurement of reference-count elision opportunity over one function body (no codegen
+/// change). It counts each emitted retain by category, and for the categories that are a move when the
+/// source's last real use is the retain site (an aliasing copy, a call argument, or a spawn argument),
+/// how many are movable. A movable retain pairs with the moved-from variable's drop, so eliding it
+/// elides both. The kept categories (a borrowed element load, a store into an aggregate) are genuinely
+/// shared references. See plans/PROFILING.md.
+#[derive(Default, Clone, Copy)]
+pub struct RcElisionReport {
+    pub alias_total: u64,
+    pub alias_movable: u64,
+    pub call_arg_total: u64,
+    pub call_arg_movable: u64,
+    pub spawn_arg_total: u64,
+    pub spawn_arg_movable: u64,
+    pub indexed_load_kept: u64,
+    pub aggregate_store_kept: u64,
+}
+
+impl RcElisionReport {
+    pub fn add(&mut self, other: &RcElisionReport) {
+        self.alias_total += other.alias_total;
+        self.alias_movable += other.alias_movable;
+        self.call_arg_total += other.call_arg_total;
+        self.call_arg_movable += other.call_arg_movable;
+        self.spawn_arg_total += other.spawn_arg_total;
+        self.spawn_arg_movable += other.spawn_arg_movable;
+        self.indexed_load_kept += other.indexed_load_kept;
+        self.aggregate_store_kept += other.aggregate_store_kept;
+    }
+
+    pub fn movable(&self) -> u64 {
+        self.alias_movable + self.call_arg_movable + self.spawn_arg_movable
+    }
+
+    pub fn line(&self) -> String {
+        format!(
+            "rc-elision (static, per function set): alias {}/{} movable, call-arg {}/{} movable, spawn-arg {}/{} movable, indexed-load {} kept, aggregate-store {} kept; movable retains total {} (each pairs with a drop)",
+            self.alias_movable, self.alias_total,
+            self.call_arg_movable, self.call_arg_total,
+            self.spawn_arg_movable, self.spawn_arg_total,
+            self.indexed_load_kept, self.aggregate_store_kept,
+            self.movable(),
+        )
+    }
+}
+
+/// Last index at which each variable is read for a real use (excluding its `Drop`, which is a release
+/// rather than a keeping use). The move signal: when a reference's last real use is a retain site, the
+/// retain transfers the only live reference and can become a move.
+fn last_real_use(ir: &[TypedIRInstruction]) -> HashMap<usize, usize> {
+    let mut last: HashMap<usize, usize> = HashMap::new();
+    for (i, instr) in ir.iter().enumerate() {
+        if matches!(instr.kind, TypedIRStmt::Drop { .. }) {
+            continue;
+        }
+        for_each_stmt_read(&instr.kind, &mut |v| {
+            last.insert(v, i);
+        });
+    }
+    last
+}
+
+/// Visit only the variables a statement reads (its uses), not the variable it defines. The read side
+/// of an `Assign` comes from the value expression, so a self-referential `x = x + 1` still counts the
+/// read of `x`.
+fn for_each_stmt_read(stmt: &TypedIRStmt, f: &mut impl FnMut(usize)) {
+    match stmt {
+        TypedIRStmt::Assign { value, .. } => {
+            for v in value.read_vars() {
+                f(v);
+            }
+        }
+        TypedIRStmt::Drop { target, .. } => f(target.id()),
+        TypedIRStmt::JumpIf { condition, .. } | TypedIRStmt::JumpIfNot { condition, .. } => {
+            f(condition.id())
+        }
+        TypedIRStmt::Jump { .. } | TypedIRStmt::Label(_) => {}
+        TypedIRStmt::Call { args, .. } | TypedIRStmt::CallBuiltin { args, .. } => {
+            for a in args {
+                f(a.id());
+            }
+        }
+        TypedIRStmt::StructNew { args, .. } => {
+            for a in args {
+                f(a.id());
+            }
+        }
+        TypedIRStmt::ArrayNew { elements, .. } => {
+            for e in elements {
+                f(e.id());
+            }
+        }
+        TypedIRStmt::FieldGet { base, .. } => f(base.id()),
+        TypedIRStmt::FieldSet { base, value, .. } => {
+            f(base.id());
+            f(value.id());
+        }
+        TypedIRStmt::Return { value } => {
+            if let Some(v) = value {
+                f(v.id());
+            }
+        }
+    }
+}
+
+/// Classify one function body's retains into elision categories. Read-only, mirrors the retain rules
+/// in `lower_body`/`lower_expr_to_bytecode_stage_one`.
+pub fn analyze_rc_elision(ir: &[TypedIRInstruction]) -> RcElisionReport {
+    let last = last_real_use(ir);
+    let mut r = RcElisionReport::default();
+    let is_movable = |v: usize, i: usize| last.get(&v) == Some(&i);
+    for (i, instr) in ir.iter().enumerate() {
+        match &instr.kind {
+            // Aliasing `q = p` retains the copied reference.
+            TypedIRStmt::Assign {
+                target,
+                value: TypedIRExpr::Var(src),
+            } if is_rc(target.typ()) => {
+                r.alias_total += 1;
+                if is_movable(src.id(), i) {
+                    r.alias_movable += 1;
+                }
+            }
+            // Every reference argument to a user call is retained (the callee drops it).
+            TypedIRStmt::Call { args, .. } => {
+                for a in args {
+                    if is_rc(a.typ()) {
+                        r.call_arg_total += 1;
+                        if is_movable(a.id(), i) {
+                            r.call_arg_movable += 1;
+                        }
+                    }
+                }
+            }
+            TypedIRStmt::CallBuiltin { builtin, args, dest } => match builtin {
+                // Spawn retains its reference arguments (argument zero is the function id).
+                Builtin::CtxNew => {
+                    for (idx, a) in args.iter().enumerate() {
+                        if idx > 0 && is_rc(a.typ()) {
+                            r.spawn_arg_total += 1;
+                            if is_movable(a.id(), i) {
+                                r.spawn_arg_movable += 1;
+                            }
+                        }
+                    }
+                }
+                // A loaded element or map value is a borrowed reference into a live collection, so it
+                // is a genuine new reference that stays counted.
+                Builtin::ArrayGet | Builtin::ListGet | Builtin::MapGet => {
+                    if let Some(d) = dest {
+                        if is_rc(d.typ()) {
+                            r.indexed_load_kept += 1;
+                        }
+                    }
+                }
+                _ => {}
+            },
+            // Storing a reference into an object field or array element makes the aggregate share it,
+            // an escape that stays counted.
+            TypedIRStmt::FieldSet { value, .. } if is_rc(value.typ()) => {
+                r.aggregate_store_kept += 1;
+            }
+            TypedIRStmt::ArrayNew {
+                elem_is_ref: true,
+                elements,
+                ..
+            } => {
+                r.aggregate_store_kept += elements.len() as u64;
+            }
+            _ => {}
+        }
+    }
+    r
+}
+
 /// The variable a statement defines (writes a fresh value into a variable), if any. Used to emit a
 /// store-back when that variable is memory-resident. Statements that only read (drops, jumps,
 /// returns) or write into an object field rather than a variable define nothing.

solid-snake-compiler/src/main.rs

@@ -55,6 +55,11 @@ struct Cli {
     #[arg(long)]
     explain: bool,
 
+    /// Print the static reference-count elision report (how much emitted retain traffic is a movable
+    /// last-use) and exit without running. Changes no codegen. See plans/PROFILING.md.
+    #[arg(long = "rc-report")]
+    rc_report: bool,
+
     /// Disable optimizations (constant folding), so runtime paths run instead of being folded away
     #[arg(long = "no-opt")]
     no_opt: bool,
@@ -96,6 +101,19 @@ fn main() {
         return;
     }
 
+    // `--rc-report` prints the static reference-count elision report and exits without running.
+    if cli.rc_report {
+        match runner::compile_named(&source, &label, opts) {
+            Ok(compiled) => println!("{}", runner::rc_report(&compiled.ir_functions)),
+            Err(failure) => {
+                for err in failure.errors.err_iter() {
+                    report_error_attributed(err, &failure.sources);
+                }
+            }
+        }
+        return;
+    }
+
     // Run the injected program first, then optionally stay in an interactive session, so the
     // session continues from a process that has already executed the given code.
     compile_and_run(&source, &label, cli.verbose, opts);

solid-snake-compiler/src/runner.rs

@@ -251,6 +251,18 @@ pub fn run_streaming(
 /// buffer and appended, which is both the efficient shape and a dogfood of the growable-string
 /// pattern the language now supports. Used by the CLI `--explain` flag, and handy for debugging
 /// lowering (which source construct produced which IR).
+/// A read-only reference-count elision report over the whole program's IR, for `--rc-report`. It sums
+/// the per-function retain-category counts, so the movable share of the emitted retain traffic is
+/// visible before any elision is applied. Changes no codegen.
+pub fn rc_report(ir_functions: &[TypedIrFunction]) -> String {
+    use crate::bytecode_gen::{analyze_rc_elision, RcElisionReport};
+    let mut report = RcElisionReport::default();
+    for func in ir_functions {
+        report.add(&analyze_rc_elision(&func.body));
+    }
+    report.line()
+}
+
 pub fn explain(source: &str, ir_functions: &[TypedIrFunction]) -> String {
     use std::fmt::Write as _;