chore: clean up dead code and compiler warnings

Gate test-only functions with #[cfg(test)], prefix unused variables,
and convert doc comments on macros to regular comments.

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

Author: jensens

CHANGES.md

@@ -2,6 +2,10 @@
 
 ## 1.6.0 (unreleased)
 
+- Clean up dead code and compiler warnings: gate test-only functions with
+  `#[cfg(test)]`, prefix unused variables, convert doc comments on macros
+  to regular comments
+
 ## 1.5.0 (2026-02-25)
 
 - Direct PickleValue → JSON string writer (`json_writer.rs`), bypassing

src/json.rs

@@ -19,6 +19,7 @@ pub fn pickle_value_to_json(val: &PickleValue) -> Result<Value, CodecError> {
 /// Like `pickle_value_to_json` but with PG-specific transformations:
 /// - Null-byte sanitization: strings containing `\0` → `{"@ns": base64}`
 /// - Persistent ref compaction: `(oid_bytes, None)` → `{"@ref": "hex_oid"}`
+#[cfg(test)]
 pub fn pickle_value_to_json_pg(val: &PickleValue) -> Result<Value, CodecError> {
     pickle_value_to_json_impl(val, true, true, 0)
 }

src/json_writer.rs

@@ -9,6 +9,7 @@ pub struct JsonWriter {
 }
 
 impl JsonWriter {
+    #[cfg(test)]
     pub fn new() -> Self {
         Self {
             buf: String::new(),
@@ -22,11 +23,13 @@ impl JsonWriter {
     }
 
     /// Consume the writer and return the JSON string.
+    #[cfg(test)]
     pub fn into_string(self) -> String {
         self.buf
     }
 
     /// Borrow the inner buffer (for length checks, etc.).
+    #[cfg(test)]
     #[inline]
     pub fn as_str(&self) -> &str {
         &self.buf

src/known_types.rs

@@ -98,7 +98,7 @@ pub fn try_write_instance_typed(
 fn write_datetime(
     w: &mut JsonWriter,
     args: &PickleValue,
-    write_val: &dyn Fn(&mut JsonWriter, &PickleValue) -> Result<(), CodecError>,
+    _write_val: &dyn Fn(&mut JsonWriter, &PickleValue) -> Result<(), CodecError>,
 ) -> Result<bool, CodecError> {
     let tuple_items = match args {
         PickleValue::Tuple(items) => items,

src/lib.rs

@@ -61,7 +61,7 @@ fn dict_to_pickle(py: Python<'_>, obj: &Bound<'_, PyDict>) -> PyResult<Py<PyByte
 #[pyfunction]
 fn decode_zodb_record(py: Python<'_>, data: &[u8]) -> PyResult<Py<PyAny>> {
     // Release GIL during pure-Rust pickle parsing
-    let (class_val, state_val, module, name) = py.detach(|| {
+    let (_class_val, state_val, module, name) = py.detach(|| {
         let (class_val, state_val) = decode_zodb_pickles(data).map_err(CodecError::from)?;
         let (module, name) = zodb::extract_class_info(&class_val);
         Ok::<_, PyErr>((class_val, state_val, module, name))
@@ -95,7 +95,7 @@ fn decode_zodb_record(py: Python<'_>, data: &[u8]) -> PyResult<Py<PyAny>> {
 fn decode_zodb_record_for_pg(py: Python<'_>, data: &[u8]) -> PyResult<Py<PyAny>> {
     // Release GIL during pure-Rust pickle parsing + ref extraction.
     // This allows other Python threads to run during the CPU-bound phase.
-    let (class_val, state_val, module, name, refs) = py.detach(|| {
+    let (_class_val, state_val, module, name, refs) = py.detach(|| {
         let (class_val, state_val) = decode_zodb_pickles(data).map_err(CodecError::from)?;
         let (module, name) = zodb::extract_class_info(&class_val);
         let mut refs = Vec::new();

src/opcodes.rs

@@ -76,6 +76,9 @@ pub const MEMOIZE: u8 = 0x94; // store top in memo (auto-incrementing key)
 pub const FRAME: u8 = 0x95; // framing for protocol 4+
 
 // -- Protocol 5 --
+#[allow(dead_code)]
 pub const BYTEARRAY8: u8 = 0x96; // push bytearray
+#[allow(dead_code)]
 pub const NEXT_BUFFER: u8 = 0x97; // push next out-of-band buffer
+#[allow(dead_code)]
 pub const READONLY_BUFFER: u8 = 0x98; // make top-of-stack read-only

src/pyconv.rs

@@ -1780,20 +1780,17 @@ pub fn encode_pyobject_as_pickle(
     Ok(buf)
 }
 
-/// Encode a ZODB record (class + state) directly to concatenated pickle bytes.
-/// Writes both the class pickle and state pickle directly, skipping
-/// all PickleValue intermediate allocations.
-/// Thread-local reusable buffer for encode_zodb_record_direct.
-/// Avoids repeated Vec allocation + growth across calls — the buffer
-/// retains its capacity from previous calls, so subsequent encodes
-/// skip the initial growth phase.
+// Thread-local reusable buffer for encode_zodb_record_direct.
+// Avoids repeated Vec allocation + growth across calls — the buffer
+// retains its capacity from previous calls, so subsequent encodes
+// skip the initial growth phase.
 thread_local! {
     static ENCODE_BUF: std::cell::RefCell<Vec<u8>> =
         const { std::cell::RefCell::new(Vec::new()) };
-    /// Cache of class pickle bytes per (module, name) pair.
-    /// Uses Vec for linear search — with ~6 distinct classes in a typical
-    /// ZODB database, linear search is faster than hashing and avoids
-    /// allocating key strings on every lookup.
+    // Cache of class pickle bytes per (module, name) pair.
+    // Uses Vec for linear search — with ~6 distinct classes in a typical
+    // ZODB database, linear search is faster than hashing and avoids
+    // allocating key strings on every lookup.
     static CLASS_PICKLE_CACHE: std::cell::RefCell<Vec<(String, String, Vec<u8>)>> =
         const { std::cell::RefCell::new(Vec::new()) };
 }

src/zodb.rs

@@ -1,3 +1,4 @@
+#[cfg(test)]
 use crate::error::CodecError;
 use crate::types::PickleValue;
 
@@ -20,6 +21,7 @@ use serde_json::{json, Value};
 ///
 /// We need to find the boundary between the two pickles.
 /// The first pickle ends at its STOP opcode (0x2e = '.').
+#[cfg(test)]
 pub fn split_zodb_record(data: &[u8]) -> Result<(&[u8], &[u8]), CodecError> {
     // We need to properly walk the first pickle to find its STOP opcode.
     // Simple approach: scan for STOP, but STOP byte (0x2e) can appear inside
@@ -31,6 +33,7 @@ pub fn split_zodb_record(data: &[u8]) -> Result<(&[u8], &[u8]), CodecError> {
 /// Find the end (exclusive) of the first pickle in the data.
 /// This walks the pickle opcodes to correctly skip over string/bytes
 /// data that might contain the STOP byte.
+#[cfg(test)]
 fn find_pickle_end(data: &[u8]) -> Result<usize, CodecError> {
     use crate::opcodes::*;
     let mut pos = 0;