fix unused functions warnings by either deleting or gating behind cfgs

src/decoding/bit_reader.rs

@@ -120,9 +120,4 @@ impl<'s> BitReader<'s> {
 
         Ok(value)
     }
-
-    pub fn reset(&mut self, new_source: &'s [u8]) {
-        self.idx = 0;
-        self.source = new_source;
-    }
 }

src/decoding/bit_reader_reverse.rs

@@ -220,11 +220,4 @@ impl<'s> BitReaderReversed<'s> {
 
         value_masked
     }
-
-    pub fn reset(&mut self, new_source: &'s [u8]) {
-        self.idx = new_source.len() as isize * 8;
-        self.source = new_source;
-        self.bit_container = 0;
-        self.bits_in_container = 0;
-    }
 }

src/decoding/decodebuffer.rs

@@ -59,10 +59,6 @@ impl DecodeBuffer {
         self.buffer.len()
     }
 
-    pub fn is_empty(&self) -> bool {
-        self.buffer.is_empty()
-    }
-
     pub fn push(&mut self, data: &[u8]) {
         self.buffer.extend(data);
         self.total_output_counter += data.len() as u64;

src/decoding/frame.rs

@@ -113,6 +113,7 @@ impl FrameDescriptor {
 
     /// This bit is reserved for some future feature, a compliant decoder **must ensure**
     /// that this value is set to zero.
+    #[expect(dead_code)]
     pub fn reserved_flag(&self) -> bool {
         ((self.0 >> 3) & 0x1) == 1
     }

src/decoding/ringbuffer.rs

@@ -57,11 +57,6 @@ impl RingBuffer {
         self.tail = 0;
     }
 
-    /// Whether the buffer is empty
-    pub fn is_empty(&self) -> bool {
-        self.head == self.tail
-    }
-
     /// Ensure that there's space for `amount` elements in the buffer.
     pub fn reserve(&mut self, amount: usize) {
         let free = self.free();

src/fse/fse_encoder.rs

@@ -11,6 +11,7 @@ impl<V: AsMut<Vec<u8>>> FSEEncoder<'_, V> {
         FSEEncoder { table, writer }
     }
 
+    #[cfg(any(test, feature = "fuzz_exports"))]
     pub fn into_table(self) -> FSETable {
         self.table
     }
@@ -21,6 +22,7 @@ impl<V: AsMut<Vec<u8>>> FSEEncoder<'_, V> {
     /// * Encoded data
     /// * Last state index
     /// * Padding bits to fill up last byte
+    #[cfg(any(test, feature = "fuzz_exports"))]
     pub fn encode(&mut self, data: &[u8]) {
         self.write_table();
 

src/fse/mod.rs

@@ -15,9 +15,7 @@
 mod fse_decoder;
 
 pub use fse_decoder::*;
-use fse_encoder::FSEEncoder;
 
-use crate::{decoding::bit_reader_reverse::BitReaderReversed, encoding::bit_writer::BitWriter};
 pub mod fse_encoder;
 
 #[test]
@@ -30,6 +28,7 @@ fn tables_equal() {
     check_tables(&dec_table, &enc_table);
 }
 
+#[cfg(any(test, feature = "fuzz_exports"))]
 fn check_tables(dec_table: &fse_decoder::FSETable, enc_table: &fse_encoder::FSETable) {
     for (idx, dec_state) in dec_table.decode.iter().enumerate() {
         let enc_states = &enc_table.states[dec_state.symbol as usize];
@@ -79,6 +78,9 @@ fn roundtrip() {
 /// Asserts that the decoded data equals the input
 #[cfg(any(test, feature = "fuzz_exports"))]
 pub fn round_trip(data: &[u8]) {
+    use crate::{decoding::bit_reader_reverse::BitReaderReversed, encoding::bit_writer::BitWriter};
+    use fse_encoder::FSEEncoder;
+
     if data.len() < 2 {
         return;
     }

src/huff0/huff0_decoder.rs

@@ -56,16 +56,6 @@ impl<'t> HuffmanDecoder<'t> {
         HuffmanDecoder { table, state: 0 }
     }
 
-    /// Re-initialize the decoder, using the new table if one is provided.
-    /// This might used for treeless blocks, because they re-use the table from old
-    /// data.
-    pub fn reset(mut self, new_table: Option<&'t HuffmanTable>) {
-        self.state = 0;
-        if let Some(next_table) = new_table {
-            self.table = next_table;
-        }
-    }
-
     /// Decode the symbol the internal state (cursor) is pointed at and return the
     /// decoded literal.
     pub fn decode_symbol(&mut self) -> u8 {

src/huff0/mod.rs

@@ -3,11 +3,7 @@
 /// used symbols get longer codes. Codes are prefix free, meaning no two codes
 /// will start with the same sequence of bits.
 mod huff0_decoder;
-use alloc::vec::Vec;
-
 pub use huff0_decoder::*;
-
-use crate::{decoding::bit_reader_reverse::BitReaderReversed, encoding::bit_writer::BitWriter};
 pub mod huff0_encoder;
 
 /// Only needed for testing.
@@ -17,6 +13,9 @@ pub mod huff0_encoder;
 /// Asserts that the decoded data equals the input
 #[cfg(any(test, feature = "fuzz_exports"))]
 pub fn round_trip(data: &[u8]) {
+    use crate::{decoding::bit_reader_reverse::BitReaderReversed, encoding::bit_writer::BitWriter};
+    use alloc::vec::Vec;
+
     if data.len() < 2 {
         return;
     }
@@ -58,6 +57,7 @@ pub fn round_trip(data: &[u8]) {
 
 #[test]
 fn roundtrip() {
+    use alloc::vec::Vec;
     round_trip(&[1, 1, 1, 1, 2, 3]);
     round_trip(&[1, 1, 1, 1, 2, 3, 5, 45, 12, 90]);