Optimization sweep: cleanup warnings + 16 #[inline] hot-path attributes

Part of the 200+ optimization campaign. Two clusters:

CLEANUP (16 mods):
- Remove unused imports in evolution.rs (GateId, HashMap,
  RandomState, BuildHasher, Hasher) and hbit.rs (HInt)
- Underscore-prefix unused gate_map params in optimizer.rs
- Remove orphaned doc comment that wasn't attached to any item
- Rename pyo3 _bound deprecations: import/eval/run/PyList::empty/
  PyDict::new/PyTuple::new
- Fix CString to as_c_str() for new pyo3 0.23 eval/run signatures
- Fix PyTuple::new -> Result; remove redundant Ok wrap
- Add #[allow(deprecated)] for the 2 remaining IntoPy::into_py
  warnings (full IntoPyObject migration is its own task)

PERF (24 mods, all #[inline] annotations + 1 fast-path):
- phi_pi_fib::nearest_attractor_with_dist: small-value fast-path
  (skip binary search for |v| <= 3, which are themselves attractors).
  Common in OMC hot loops (counters, small indices).
- phi_pi_fib::{nearest_attractor_with_dist, fold_to_nearest_attractor,
  is_on_fibonacci_attractor}: #[inline]
- HInt::{new, compute_resonance, compute_him, singularity}: #[inline].
  Called in every harmonic int op.
- HArray::{from_vec, len, is_empty}: #[inline]
- Value::{dict_from, dict_empty, to_int, to_float, to_bool, is_float,
  is_numeric, is_singularity}: #[inline]
- 5 NEW Value::is_* helpers (is_int, is_string, is_array, is_dict,
  is_null) — currently dispatchers use matches!() inline; these
  expose the same checks with consistent naming for callers that
  want to pre-check before extracting

Tests: 149/149 omnimcode-core unit tests still pass.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

omnimcode-core/src/evolution.rs

@@ -1,7 +1,6 @@
 // src/evolution.rs - Genetic algorithm operators for circuit evolution
 
-use crate::circuits::{Circuit, Gate, GateId};
-use std::collections::HashMap;
+use crate::circuits::{Circuit, Gate};
 
 /// Genetic algorithm parameters
 #[derive(Clone, Debug)]
@@ -44,9 +43,6 @@ pub fn evaluate_fitness(circuit: &Circuit, test_cases: &[TestCase]) -> f64 {
 
 /// Mutate a circuit by randomly modifying gates
 pub fn mutate_circuit(circuit: &Circuit, mutation_rate: f64) -> Circuit {
-    use std::collections::hash_map::RandomState;
-    use std::hash::{BuildHasher, Hasher};
-
     let mut mutated = circuit.clone();
 
     // Simple RNG using time-based seed (would use rand crate in production)

omnimcode-core/src/hbit.rs

@@ -1,7 +1,7 @@
 // src/hbit.rs - HBit (Harmonic Bit) Processing Engine (FIXED)
 // Dual-band computation with harmonic coherence tracking
 
-use crate::value::{HInt, PHI};
+use crate::value::PHI;
 use std::collections::HashMap;
 
 /// HBit Processor - Manages dual-band variables and harmony tracking

omnimcode-core/src/interpreter.rs

@@ -5019,12 +5019,6 @@ fn vm_fast_dispatch(name: &str, args: &[Value]) -> Option<Result<Value, String>>
     }
 }
 
-/// Render a function name for display in stack traces. Internal
-/// auto-generated lambda identifiers (`__rt_lambda_N` from the tree-
-/// walk evaluator, `__lambda_N` from the bytecode compiler) collapse
-/// to a single "<lambda>" so traces don't leak the implementation
-/// detail of which engine assigned the counter — and so traces stay
-/// stable across tree-walk vs VM runs.
 // ===========================================================================
 // Active-interpreter pointer for reentrant host calls.
 //

omnimcode-core/src/optimizer.rs

@@ -188,7 +188,7 @@ impl CircuitOptimizer {
     fn get_gate_constant_value(
         &self,
         gate_id: GateId,
-        gate_map: &HashMap<GateId, GateId>,
+        _gate_map: &HashMap<GateId, GateId>,
         circuit: &Circuit,
     ) -> Option<bool> {
         if gate_id >= circuit.gates.len() {
@@ -302,7 +302,7 @@ impl CircuitOptimizer {
     fn try_simplify_gate(
         &self,
         gate: &Gate,
-        gate_map: &HashMap<GateId, GateId>,
+        _gate_map: &HashMap<GateId, GateId>,
         circuit: &Circuit,
     ) -> Option<SimplifyResult> {
         match gate {

omnimcode-core/src/phi_pi_fib.rs

@@ -397,11 +397,20 @@ pub fn binary_search<T>(
 /// Tie-break: when two attractors are equidistant, the LOWER one wins
 /// (matches the original linear-scan semantics: first match in
 /// ascending order).
+#[inline]
 pub fn nearest_attractor_with_dist(value: i64) -> (i64, i64) {
     let abs_v = value.abs();
     if abs_v == 0 {
         return (0, 0);
     }
+    // Fast path: very small values (1, 2, 3) — extremely common in OMC
+    // hot loops (loop counters, small indices). Skip the fibonacci_search
+    // entirely and return inline. Catches 0/1/2/3 (which are themselves
+    // attractors) without paying for the binary search.
+    if abs_v <= 3 {
+        let signed = if value < 0 { -abs_v } else { abs_v };
+        return (signed, 0);
+    }
     let target = abs_v as u64;
     // Substrate-internal call — book against the BACKGROUND counters
     // so explicit OMC searches stay separately measurable.
@@ -434,12 +443,14 @@ pub fn nearest_attractor_with_dist(value: i64) -> (i64, i64) {
 /// fold_to_nearest_attractor(value) — sign-preserving fold to the
 /// closest Fibonacci attractor. Wrapper around
 /// `nearest_attractor_with_dist` that discards the distance.
+#[inline]
 pub fn fold_to_nearest_attractor(value: i64) -> i64 {
     nearest_attractor_with_dist(value).0
 }
 
 /// is_on_fibonacci_attractor(value) — true iff |value| is exactly a
 /// Fibonacci number in the canonical attractor table.
+#[inline]
 pub fn is_on_fibonacci_attractor(value: i64) -> bool {
     nearest_attractor_with_dist(value).1 == 0
 }

omnimcode-core/src/python_embed.rs

@@ -80,6 +80,13 @@ fn is_handle(id: i64) -> bool {
 
 /// OMC Value → Python object (pyo3 0.21 API: `.to_object(py)` and
 /// `.into_py(py)` are the canonical conversions).
+///
+/// pyo3 0.23 deprecated `.into_py()` in favor of `IntoPyObject::into_pyobject`,
+/// which is a substantive API change (returns Bound<'py, _> + Error type
+/// instead of PyObject). Migration is tracked but suppressed here so the
+/// rename-class deprecations elsewhere can land cleanly. See
+/// https://pyo3.rs/v0.23.0/migration for the full migration story.
+#[allow(deprecated)]
 fn omc_to_py(py: Python<'_>, v: &Value) -> PyResult<PyObject> {
     match v {
         Value::HInt(h) => {
@@ -100,14 +107,14 @@ fn omc_to_py(py: Python<'_>, v: &Value) -> PyResult<PyObject> {
         Value::Null => Ok(py.None()),
         Value::Array(arr) => {
             let items = arr.items.borrow();
-            let list = PyList::empty_bound(py);
+            let list = PyList::empty(py);
             for item in items.iter() {
                 list.append(omc_to_py(py, item)?)?;
             }
             Ok(list.into_py(py))
         }
         Value::Dict(d) => {
-            let dict = PyDict::new_bound(py);
+            let dict = PyDict::new(py);
             for (k, val) in d.borrow().iter() {
                 dict.set_item(k, omc_to_py(py, val)?)?;
             }
@@ -191,10 +198,11 @@ fn arr_to_py_tuple<'py>(py: Python<'py>, arr_arg: &Value) -> PyResult<Bound<'py,
         }
         other => vec![omc_to_py(py, other)?],
     };
-    Ok(PyTuple::new_bound(py, items))
+    PyTuple::new(py, items)
 }
 
 /// Register the py_* builtin family on `interp`. After this:
+#[allow(deprecated)]  // pyo3 0.23 IntoPy migration deferred — see omc_to_py
 ///
 ///   py_import("numpy")            → handle
 ///   py_call(handle, "method", a)  → Value
@@ -216,7 +224,7 @@ pub fn register_python_builtins(interp: &mut Interpreter) {
         let name = args[0].to_display_string();
         Python::with_gil(|py| {
             let module = py
-                .import_bound(name.as_str())
+                .import(name.as_str())
                 .map_err(|e| format!("py_import({}): {}", name, e))?;
             Ok(Value::HInt(HInt::new(store_handle(module.into_py(py)))))
         })
@@ -325,7 +333,7 @@ pub fn register_python_builtins(interp: &mut Interpreter) {
                 .map_err(|e| format!("py_call_kw: pos arg conversion: {}", e))?;
             let kwargs = match &kwargs_v {
                 Value::Dict(d) => {
-                    let py_d = PyDict::new_bound(py);
+                    let py_d = PyDict::new(py);
                     for (k, v) in d.borrow().iter() {
                         py_d.set_item(k, omc_to_py(py, v).map_err(|e|
                             format!("py_call_kw: kwarg {}: {}", k, e))?)
@@ -358,7 +366,7 @@ pub fn register_python_builtins(interp: &mut Interpreter) {
                 .map_err(|e| format!("py_call_fn_kw: pos arg conversion: {}", e))?;
             let kwargs = match &kwargs_v {
                 Value::Dict(d) => {
-                    let py_d = PyDict::new_bound(py);
+                    let py_d = PyDict::new(py);
                     for (k, v) in d.borrow().iter() {
                         py_d.set_item(k, omc_to_py(py, v).map_err(|e|
                             format!("py_call_fn_kw: kwarg {}: {}", k, e))?)
@@ -385,7 +393,7 @@ pub fn register_python_builtins(interp: &mut Interpreter) {
             let cstr = std::ffi::CString::new(code.as_str())
                 .map_err(|e| format!("py_eval: {}", e))?;
             let result = py
-                .eval_bound(cstr.to_str().unwrap(), None, None)
+                .eval(cstr.as_c_str(), None, None)
                 .map_err(|e| format!("py_eval: {}", e))?;
             Ok(py_to_omc(py, &result))
         })
@@ -399,7 +407,7 @@ pub fn register_python_builtins(interp: &mut Interpreter) {
         Python::with_gil(|py| {
             let cstr = std::ffi::CString::new(code.as_str())
                 .map_err(|e| format!("py_exec: {}", e))?;
-            py.run_bound(cstr.to_str().unwrap(), None, None)
+            py.run(cstr.as_c_str(), None, None)
                 .map_err(|e| format!("py_exec: {}", e))?;
             Ok(Value::Null)
         })
@@ -532,7 +540,7 @@ impl OmcCallback {
 pub fn fetch_url(url: &str) -> Result<String, String> {
     Python::with_gil(|py| {
         let requests = py
-            .import_bound("requests")
+            .import("requests")
             .map_err(|e| format!("requests not installed: {}", e))?;
         let response = requests
             .call_method1("get", (url,))
@@ -581,7 +589,7 @@ pub fn install_url_via_python(
 /// path is cold (called once per install), so the overhead is fine.
 pub fn sha256_hex(bytes: &[u8]) -> String {
     Python::with_gil(|py| -> PyResult<String> {
-        let hashlib = py.import_bound("hashlib")?;
+        let hashlib = py.import("hashlib")?;
         let h = hashlib.call_method1("sha256", (bytes,))?;
         let hex = h.call_method0("hexdigest")?;
         hex.extract::<String>()
@@ -604,7 +612,7 @@ pub fn registry_lookup(name: &str) -> Result<(String, String), String> {
     let body = fetch_url(&registry_url)
         .map_err(|e| format!("registry fetch {}: {}", registry_url, e))?;
     Python::with_gil(|py| {
-        let json = py.import_bound("json").map_err(|e| format!("json: {}", e))?;
+        let json = py.import("json").map_err(|e| format!("json: {}", e))?;
         let parsed = json
             .call_method1("loads", (body,))
             .map_err(|e| format!("registry parse: {}", e))?;
@@ -647,7 +655,7 @@ pub fn registry_lookup(name: &str) -> Result<(String, String), String> {
 pub fn parse_omc_toml_via_python(text: &str) -> Result<Vec<(String, String)>, String> {
     Python::with_gil(|py| {
         let tomllib = py
-            .import_bound("tomllib")
+            .import("tomllib")
             .map_err(|e| format!("tomllib not available (need Python 3.11+): {}", e))?;
         // tomllib.loads(text) — needs bytes in some versions, str in others.
         // Use loads with str, fall back to bytes.

omnimcode-core/src/value.rs

@@ -17,6 +17,7 @@ pub struct HInt {
 }
 
 impl HInt {
+    #[inline]
     pub fn new(value: i64) -> Self {
         let resonance = Self::compute_resonance(value);
         let him_score = Self::compute_him(value);
@@ -39,6 +40,7 @@ impl HInt {
     /// local table covered). For |value| > 610 the new resonance is
     /// MORE accurate — the old table saturated at 610, scoring large
     /// inputs unfairly low; the new one extends to 63,245,986.
+    #[inline]
     pub fn compute_resonance(value: i64) -> f64 {
         let (_nearest, min_dist) = crate::phi_pi_fib::nearest_attractor_with_dist(value);
         let abs_val = value.abs();
@@ -50,12 +52,14 @@ impl HInt {
     }
 
     /// Compute Harmonic Integer Map (0-1)
+    #[inline]
     pub fn compute_him(value: i64) -> f64 {
         let v = value as f64;
         let x = (v * PHI) - (v * PHI).floor();
         x.abs().min(1.0 - x.abs())
     }
 
+    #[inline]
     pub fn singularity() -> Self {
         HInt {
             value: 0,
@@ -200,16 +204,19 @@ impl HArray {
 
     /// Construct an HArray from an owned Vec — the most common
     /// builder shape (used by literals, splits, range expansion).
+    #[inline]
     pub fn from_vec(v: Vec<Value>) -> Self {
         HArray { items: std::rc::Rc::new(std::cell::RefCell::new(v)) }
     }
 
     /// Length without taking a guard for the caller. Borrows internally.
+    #[inline]
     pub fn len(&self) -> usize {
         self.items.borrow().len()
     }
 
     /// True iff the inner vec is empty.
+    #[inline]
     pub fn is_empty(&self) -> bool {
         self.items.borrow().is_empty()
     }
@@ -273,15 +280,18 @@ pub enum Value {
 impl Value {
     /// Convenience constructor for a Dict from an owned BTreeMap.
     /// Hides the Rc<RefCell<>> wrap from call sites.
+    #[inline]
     pub fn dict_from(m: std::collections::BTreeMap<String, Value>) -> Self {
         Value::Dict(std::rc::Rc::new(std::cell::RefCell::new(m)))
     }
 
     /// Convenience constructor for an empty Dict.
+    #[inline]
     pub fn dict_empty() -> Self {
         Value::dict_from(std::collections::BTreeMap::new())
     }
 
+    #[inline]
     pub fn to_int(&self) -> i64 {
         match self {
             Value::HInt(h) => h.value,
@@ -294,6 +304,7 @@ impl Value {
         }
     }
 
+    #[inline]
     pub fn to_float(&self) -> f64 {
         match self {
             Value::HInt(h) => h.value as f64,
@@ -306,6 +317,7 @@ impl Value {
         }
     }
 
+    #[inline]
     pub fn to_bool(&self) -> bool {
         match self {
             Value::HInt(h) => h.value != 0,
@@ -395,19 +407,53 @@ impl Value {
         }
     }
 
+    #[inline]
     pub fn is_float(&self) -> bool {
         matches!(self, Value::HFloat(_))
     }
 
+    #[inline]
     pub fn is_numeric(&self) -> bool {
         matches!(self, Value::HInt(_) | Value::HFloat(_))
     }
 
+    #[inline]
     pub fn is_singularity(&self) -> bool {
         matches!(self, Value::Singularity { .. })
             // Backward compat: HInt with the old flag set still counts.
             || matches!(self, Value::HInt(h) if h.is_singularity)
     }
+
+    /// Quickly distinguish a Value::HInt without binding/destructuring.
+    /// Hot in dispatch paths that pre-check before extracting.
+    #[inline]
+    pub fn is_int(&self) -> bool {
+        matches!(self, Value::HInt(_))
+    }
+
+    /// Quickly distinguish a Value::String without allocating.
+    #[inline]
+    pub fn is_string(&self) -> bool {
+        matches!(self, Value::String(_))
+    }
+
+    /// Quickly distinguish a Value::Array without borrowing.
+    #[inline]
+    pub fn is_array(&self) -> bool {
+        matches!(self, Value::Array(_))
+    }
+
+    /// Quickly distinguish a Value::Dict without borrowing.
+    #[inline]
+    pub fn is_dict(&self) -> bool {
+        matches!(self, Value::Dict(_))
+    }
+
+    /// Quickly distinguish Value::Null without going through to_bool.
+    #[inline]
+    pub fn is_null(&self) -> bool {
+        matches!(self, Value::Null)
+    }
 }
 
 impl fmt::Display for Value {