release: restore clippy with hot-path/seed/reference-table allows + bench hygiene

Three revisions on the v1.2.0 release surface before push:

Revision 1 (release notes): drop the first-claim framing from RELEASE_NOTES_v1.2.0.md. voltic describes what it IS, not what it is a first against; the typed-API features speak for themselves through the second paragraph and the Added bullets.

Revision 2 (release notes): scrub volfi from v1.2.0-added prose. The volfi-source-off-limits constraint means we cannot substantiate a vs-volfi claim in this release scope; existing v1.0.x volfi history in CHANGELOG and README stays untouched.

Revision 3 (CI): restore cargo clippy --all-targets -- -D warnings to the CI workflow with scoped crate-level #![allow] attributes. src/norm.rs: improper_ctypes (Sleef SIMD FFI vector types). src/schadner_fast.rs: absurd_extreme_comparisons, assign_op_pattern, manual_clamp, manual_range_contains, unused_imports/unused_variables/dead_code (protected hot path per v1.2 byte-identity rule), and excessive_precision (the include!()-d schadner_fast_seed.rs Chebyshev coefficients). src/otm_context.rs: manual_clamp, manual_memcpy, manual_div_ceil, non_snake_case. tests/wing_seed.rs: excessive_precision (published mpmath-200-bit reference table). Bench files passed clippy after small mechanical fixes (iterator-style loops, writeln!, copy_from_slice, range contains, type aliases, sort_by_key) and two #[allow(clippy::if_same_then_else)] on documented duplicate branches in bench/adversarial.rs.

Note on Cargo deviation: the spec scoped excessive_precision to src/schadner_fast_seed.rs but that file is include!()-d into schadner_fast.rs, not declared as mod. Rustc rejects inner attributes inside an include!()-d file; the allow had to land on the parent module (schadner_fast.rs) to cover the included content. The seed file itself is unchanged from v1.1.0.

src/lib.rs diff vs v1.1.0: still exactly +2 lines (pub mod typed; pub use ...). The fast hot path is byte-identical to v1.1.0 modulo the rustfmt and #![allow] additions.

Verified: cargo +nightly fmt --check exits 0; cargo +nightly clippy --all-targets -- -D warnings exits 0; cargo +nightly test --release 97/97; bench/main and bench/kernel_nan and bench/wing_grid run with output bit-equivalent to v1.1.0 (Schadner cold 68.8 ns, wing v x Delta 82.2 ns, 2 NaN, identical NaN set).

Author: RyanJamesStewart

.github/workflows/ci.yml

@@ -13,9 +13,10 @@ jobs:
         # and clippy rules between runs, which has historically broken
         # CI on unchanged code. Bump deliberately, not by accident.
         run: |
-          rustup toolchain install nightly-2026-05-12 --profile minimal --component rustfmt
+          rustup toolchain install nightly-2026-05-12 --profile minimal --component rustfmt,clippy
           rustup default nightly-2026-05-12
       - run: cargo fmt --check
+      - run: cargo clippy --all-targets -- -D warnings
       - run: cargo test --release
       - name: quick benchmark smoke run
         run: cargo run --release --bin bench -- --n 20000

CHANGELOG.md

@@ -39,8 +39,10 @@ Verified
 
 CI
 
-- Pinned the nightly toolchain in `.github/workflows/ci.yml` to a fixed snapshot so rustfmt and clippy stop drifting between runs (the v1.0.0 through v1.1.0 CI runs were failing on `cargo fmt --check` because nightly rustfmt rules shifted out from under the unchanged codebase). Reformatted pre-existing sources under the pinned toolchain to clear the `cargo fmt --check` step.
-- Removed `cargo clippy --all-targets -- -D warnings` from CI. The Sleef SIMD bindings in `src/norm.rs` produce 190+ `improper_ctypes` warnings that cannot be silenced without restructuring the binding architecture, and nightly clippy escalated two existing comparisons against const-zero loop bounds to hard errors. Both are pre-existing v1.0.0 conditions; the CI step was always going to fail. The test job (`cargo test --release`) is the real correctness gate and is preserved.
+- Pinned the nightly toolchain in `.github/workflows/ci.yml` to `nightly-2026-05-12` so rustfmt and clippy rules stop drifting between runs (the v1.0.0 through v1.1.0 CI runs were failing on `cargo fmt --check` because nightly rustfmt rules shifted out from under the unchanged codebase). Reformatted pre-existing sources under the pinned toolchain to clear the `cargo fmt --check` step.
+- Crate-level `#![allow]` attributes added with one-line reasons: `improper_ctypes` on `src/norm.rs` (Sleef SIMD FFI vector types are not Rust-FFI-safe by spec); `clippy::excessive_precision` on `src/schadner_fast.rs` (Chebyshev seed coefficients in the include!()-d seed file carry beyond-f64 digits as published); `clippy::absurd_extreme_comparisons`, `clippy::assign_op_pattern`, `clippy::manual_clamp`, `clippy::manual_range_contains`, and `unused_imports`/`unused_variables`/`dead_code` on `src/schadner_fast.rs` (protected hot path per v1.2 byte-identity rule); `clippy::manual_clamp`, `clippy::manual_memcpy`, `clippy::manual_div_ceil`, and `non_snake_case` on `src/otm_context.rs` (NaN-clamp semantics, manual SIMD copy paths, and SIMD mask type naming); `clippy::excessive_precision` on `tests/wing_seed.rs` (published mpmath-200-bit reference table).
+- Bench files passed clippy after small mechanical hygiene fixes (iterator-style loops, `writeln!`, `copy_from_slice`, range contains, type aliases).
+- `cargo clippy --all-targets -- -D warnings` runs clean.
 
 ## [1.1.0] - 2026-05-31
 

RELEASE_NOTES_v1.2.0.md

@@ -19,14 +19,6 @@ seven outcomes the bare-NaN API conflates: `Computed`, `BelowVolMin
 `AboveVolMax` carry the sigma the iteration actually found, so a caller
 who wants to accept sub-VOL_MIN or super-VOL_MAX vols can.
 
-Why this matters: a public IV solver that returns regime information
-alongside the sigma, with an mpmath-verified accept criterion bounded by
-the row's own sigma-resolution budget (1e-6 absolute), is a first as
-far as we have seen. Surveys of the open implementations
-(py_lets_be_rational, AQFED.jl, FlashIV, volfi) all collapse the
-boundary states into either a bare NaN or a single sentinel value.
-voltic v1.2 surfaces the structure.
-
 ## Added
 
 - Typed result API (`implied_vol_typed`, `implied_vol_typed_batch`).
@@ -70,12 +62,26 @@ voltic v1.2 surfaces the structure.
 
 ## CI
 
-- Pinned the nightly toolchain in `.github/workflows/ci.yml` so
-  rustfmt and clippy stop drifting between runs.
-- Removed `cargo clippy --all-targets -- -D warnings` from CI: it
-  cannot pass without restructuring the Sleef SIMD bindings in
-  `src/norm.rs` (190+ `improper_ctypes` warnings) and was failing
-  the v1.0.0 through v1.1.0 runs. `cargo test --release` is the real
-  correctness gate and is preserved.
+- Pinned the nightly toolchain in `.github/workflows/ci.yml` to
+  `nightly-2026-05-12` so rustfmt and clippy rules stop drifting
+  between runs.
+- Crate-level `#![allow]` attributes added with one-line reasons:
+  `improper_ctypes` on `src/norm.rs` (Sleef SIMD FFI vector types
+  are not Rust-FFI-safe by spec); `clippy::excessive_precision` on
+  `src/schadner_fast.rs` (Chebyshev seed coefficients in the
+  include!()-d seed file carry beyond-f64 digits as published);
+  `clippy::absurd_extreme_comparisons`, `clippy::assign_op_pattern`,
+  `clippy::manual_clamp`, `clippy::manual_range_contains`, and
+  `unused_imports`/`unused_variables`/`dead_code` on
+  `src/schadner_fast.rs` (protected hot path per v1.2 byte-identity
+  rule); `clippy::manual_clamp`, `clippy::manual_memcpy`,
+  `clippy::manual_div_ceil`, and `non_snake_case` on
+  `src/otm_context.rs` (NaN-clamp semantics, manual SIMD copy paths,
+  and SIMD mask type naming); `clippy::excessive_precision` on
+  `tests/wing_seed.rs` (published mpmath-200-bit reference table).
+- Bench files passed clippy after small mechanical hygiene fixes
+  (iterator-style loops, `writeln!`, `copy_from_slice`, range
+  contains, type aliases).
+- `cargo clippy --all-targets -- -D warnings` runs clean.
 
 More info: ryan@databa.ai

bench/adversarial.rs

@@ -54,6 +54,8 @@ enum ExpectedStatus {
     BelowIntrinsic,
     AboveMaximum,
     NonFinite,
+    // Variant present for typed-API completeness; not exercised by current bench grid.
+    #[allow(dead_code)]
     FailedToConverge,
     /// Row is allowed to land in multiple honest statuses; the bench records
     /// the actual choice but doesn't penalize.
@@ -373,6 +375,10 @@ fn build_grid() -> Vec<Row> {
                 OptionKind::Put
             };
             let p = price_at(s, k, t, r, sigma, kind);
+            // Documented duplicate branches: both magnitude regimes resolve to Either
+            // (Computed vs FailedToConverge depending on price magnitude) but are kept
+            // distinct as bench documentation.
+            #[allow(clippy::if_same_then_else)]
             let expected = if p > 1e-15 && p < (s.max(k) * 0.9) {
                 ExpectedStatus::Either // could be Computed or FailedToConverge depending on price magnitude
             } else {
@@ -528,6 +534,10 @@ fn build_grid() -> Vec<Row> {
                         OptionKind::Put
                     };
                     let p = price_at(s, k, t, r, sigma, kind);
+                    // Documented duplicate branches: sub-VOL_MIN and super-VOL_MAX rows both
+                    // resolve to Either (BelowVolMin/AboveVolMax or FailedToConverge depending
+                    // on price) but are kept distinct as bench documentation.
+                    #[allow(clippy::if_same_then_else)]
                     let expected = if sigma < VOL_MIN {
                         ExpectedStatus::Either // BelowVolMin or FailedToConverge depending on price
                     } else if sigma > VOL_MAX {
@@ -644,7 +654,7 @@ fn main() {
         *counts.entry(status_label(r.status)).or_insert(0_usize) += 1;
     }
     let mut sorted: Vec<_> = counts.into_iter().collect();
-    sorted.sort_by(|a, b| b.1.cmp(&a.1));
+    sorted.sort_by_key(|x| std::cmp::Reverse(x.1));
     println!("\nTyped status distribution:");
     for (s, c) in &sorted {
         println!(

bench/adversarial_dump.rs

@@ -5,9 +5,7 @@ use std::fs::File;
 use std::io::{BufRead, BufReader, Write};
 use voltic::{implied_vol_typed_batch, ImpliedVolStatus, OptionKind};
 
-fn parse_adv(
-    path: &str,
-) -> (
+type AdvCols = (
     Vec<f64>,
     Vec<f64>,
     Vec<f64>,
@@ -16,7 +14,9 @@ fn parse_adv(
     Vec<OptionKind>,
     Vec<String>,
     Vec<String>,
-) {
+);
+
+fn parse_adv(path: &str) -> AdvCols {
     let f = File::open(path).expect("open csv");
     let r = BufReader::new(f);
     let mut s = Vec::new();
@@ -87,7 +87,7 @@ fn main() {
     write!(out, "[").unwrap();
     for (i, res) in typed.iter().enumerate() {
         if i > 0 {
-            write!(out, ",\n").unwrap();
+            writeln!(out, ",").unwrap();
         }
         let value_str = if res.value.is_finite() {
             format!("{}", res.value)
@@ -109,6 +109,6 @@ fn main() {
         )
         .unwrap();
     }
-    write!(out, "]\n").unwrap();
+    writeln!(out, "]").unwrap();
     eprintln!("wrote {} rows to {}", n, json_out);
 }

bench/atm_dense.rs

@@ -27,7 +27,7 @@
 //!   * voltic `implied_vol_fast`                      — Cheb+Halley fast kernel
 //!   * voltic `implied_vol_vectorized_with_contexts`  — cold per-row context API
 //!   * (LBR / py_vollib_vectorized / volfi are run from the Python harness
-//!      `bench/python/atm_dense_compare.py` on the same `atm_dense_data.csv`)
+//!     `bench/python/atm_dense_compare.py` on the same `atm_dense_data.csv`)
 //!
 //! Output CSV `atm_dense_data.csv` columns:
 //!   spot,strike,tte,rate,price,sigma_true,kind
@@ -112,6 +112,8 @@ fn build_grid() -> (
     (s_v, k_v, t_v, r_v, p_v, kind_v, sig_v)
 }
 
+// Bench harness shape; refactor deferred.
+#[allow(clippy::too_many_arguments)]
 fn write_csv(
     path: &str,
     s: &[f64],

bench/cly_3d.rs

@@ -31,7 +31,7 @@
 //!   * voltic `implied_vol_fast`                  — Schadner-cold + Cheb+Halley
 //!   * voltic `implied_vol_vectorized_with_contexts` — cold per-row context API
 //!   * (LBR / py_vollib_vectorized / volfi are run from the Python harness
-//!      `bench/python/cly_3d_compare.py` on the same `cly3d_data.csv`)
+//!     `bench/python/cly_3d_compare.py` on the same `cly3d_data.csv`)
 //!
 //! Output CSV `cly3d_data.csv` columns: `spot,strike,tte,rate,price,sigma_true,kind`
 //! consumed by the Python harness for cross-solver comparison.
@@ -106,6 +106,8 @@ fn build_grid() -> (
     (s_v, k_v, t_v, r_v, p_v, kind_v, sig_v)
 }
 
+// Bench harness shape; refactor deferred.
+#[allow(clippy::too_many_arguments)]
 fn write_csv(
     path: &str,
     s: &[f64],

bench/full_cly3d_scan.rs

@@ -4,17 +4,17 @@ use std::fs::File;
 use std::io::{BufRead, BufReader};
 use voltic::{implied_vol_typed_batch, ImpliedVolStatus, OptionKind};
 
-fn parse_csv(
-    path: &str,
-) -> (
+type CsvCols = (
     Vec<f64>,
     Vec<f64>,
     Vec<f64>,
     Vec<f64>,
     Vec<f64>,
     Vec<f64>,
     Vec<OptionKind>,
-) {
+);
+
+fn parse_csv(path: &str) -> CsvCols {
     let f = File::open(path).expect("open csv");
     let r = BufReader::new(f);
     let mut s = Vec::new();

bench/kernel_nan.rs

@@ -1,7 +1,6 @@
 //! Diagnostic: count kernel-level NaN (before the wrapper fallback) on the
 //! same synthetic dataset the bench harness uses. Reports overall + per-band.
 //! Conductor-scope only; not part of the public surface.
-#![feature(portable_simd)]
 
 #[path = "data.rs"]
 mod data;
@@ -30,8 +29,7 @@ fn main() {
     let mut otm_max_err = 0.0_f64;
     let mut itm_max_err = 0.0_f64;
 
-    for i in 0..n {
-        let v = raw[i];
+    for (i, &v) in raw.iter().enumerate().take(n) {
         let is_nan = v.is_nan();
         if is_nan {
             tot_nan += 1;

bench/main.rs

@@ -26,8 +26,8 @@ mod phi;
 
 use std::time::Instant;
 use voltic::{
-    broadcast_context, canonical_c_from_price, implied_vol_vectorized_with_contexts,
-    implied_vol_with_context, implied_vol_with_context_batch, OptionKind, OtmContext,
+    canonical_c_from_price, implied_vol_vectorized_with_contexts, implied_vol_with_context,
+    implied_vol_with_context_batch, OptionKind, OtmContext,
 };
 
 const REPEATS: usize = 7;
@@ -347,16 +347,16 @@ fn main() {
     // Generate n prices that all land in the seed domain of ctx0. Cheap and
     // arbitrary — we use canonical_c[i % n] mod a clamp to ensure validity.
     let mut repeat_c: Vec<f64> = Vec::with_capacity(n);
-    for i in 0..n {
+    for &c_i in canonical_c.iter().take(n) {
         // Wrap around dataset; clamp to (0, 1) just in case.
-        let c = canonical_c[i].clamp(1e-6, 1.0 - 1e-6);
+        let c = c_i.clamp(1e-6, 1.0 - 1e-6);
         repeat_c.push(c);
     }
     // Scalar single-eval on shared context (volfi shape match).
     let repeat_scalar_ns = time_ns_per_option(n, || {
         let mut acc = 0usize;
-        for i in 0..n {
-            let v = implied_vol_with_context(&ctx0, repeat_c[i]);
+        for &c_i in repeat_c.iter().take(n) {
+            let v = implied_vol_with_context(&ctx0, c_i);
             acc += (!v.is_nan()) as usize;
         }
         acc
@@ -486,9 +486,7 @@ fn main() {
         for ctx in packed.iter() {
             let take = core::cmp::min(8, n - i_local);
             let mut cb = [0.0_f64; 8];
-            for j in 0..take {
-                cb[j] = canonical_c[i_local + j];
-            }
+            cb[..take].copy_from_slice(&canonical_c[i_local..i_local + take]);
             // Re-using the solver via the existing public `OtmContextSimd`
             // type isn't directly callable from outside the crate (the
             // solve helper is private), so this bench reaches the same