Use thiserror rather than thiserror-core

Cargo.toml

@@ -13,15 +13,16 @@ readme = "Readme.md"
 [dependencies]
 byteorder = { version = "1.4", default-features = false }
 twox-hash = { version = "1.6", default-features = false }
-thiserror = { package = "thiserror-core", version = "1.0.38", default-features = false }
+thiserror = { version = "1.0.38", default-features = false }
+core-error = { version = "0.0.0", default-features = false }
 
 [dev-dependencies]
 criterion = "0.3"
 rand = {version = "0.8.5", features = ["small_rng"]}
 
 [features]
 default = ["std"]
-std = ["thiserror/std"]
+std = []
 
 [[bench]]
 name = "reversedbitreader_bench"

src/blocks/literals_section.rs

@@ -1,5 +1,8 @@
 use super::super::decoding::bit_reader::{BitReader, GetBitsError};
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 pub struct LiteralsSection {
     pub regenerated_size: u32,
     pub compressed_size: Option<u32>,

src/blocks/sequence_section.rs

@@ -3,6 +3,9 @@ pub struct SequencesHeader {
     pub modes: Option<CompressionModes>,
 }
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 #[derive(Clone, Copy)]
 pub struct Sequence {
     pub ll: u32,

src/decoding/bit_reader.rs

@@ -1,3 +1,6 @@
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 pub struct BitReader<'s> {
     idx: usize, //index counts bits already read
     source: &'s [u8],

src/decoding/block_decoder.rs

@@ -13,6 +13,9 @@ use crate::decoding::scratch::DecoderScratch;
 use crate::decoding::sequence_execution::execute_sequences;
 use crate::io::{self, Read};
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 pub struct BlockDecoder {
     header_buffer: [u8; 3],
     internal_state: DecoderState,

src/decoding/decodebuffer.rs

@@ -2,6 +2,9 @@ use crate::io::{Error, Read, Write};
 use alloc::vec::Vec;
 use core::hash::Hasher;
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 use twox_hash::XxHash64;
 
 use super::ringbuffer::RingBuffer;

src/decoding/dictionary.rs

@@ -1,6 +1,9 @@
 use alloc::vec::Vec;
 use core::convert::TryInto;
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 use crate::decoding::scratch::FSEScratch;
 use crate::decoding::scratch::HuffmanScratch;
 use crate::fse::FSETableError;

src/decoding/literals_section_decoder.rs

@@ -4,6 +4,9 @@ use super::scratch::HuffmanScratch;
 use crate::huff0::{HuffmanDecoder, HuffmanDecoderError, HuffmanTableError};
 use alloc::vec::Vec;
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
 pub enum DecompressLiteralsError {

src/decoding/sequence_execution.rs

@@ -1,5 +1,8 @@
 use super::{decodebuffer::DecodebufferError, scratch::DecoderScratch};
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
 pub enum ExecuteSequencesError {

src/decoding/sequence_section_decoder.rs

@@ -6,6 +6,9 @@ use super::scratch::FSEScratch;
 use crate::fse::{FSEDecoder, FSEDecoderError, FSETableError};
 use alloc::vec::Vec;
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
 pub enum DecodeSequenceError {

src/frame.rs

@@ -1,4 +1,8 @@
 use crate::io::{Error, Read};
+
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 pub const MAGIC_NUM: u32 = 0xFD2F_B528;
 pub const MIN_WINDOW_SIZE: u64 = 1024;
 pub const MAX_WINDOW_SIZE: u64 = (1 << 41) + 7 * (1 << 38);

src/frame_decoder.rs

@@ -8,6 +8,9 @@ use alloc::vec::Vec;
 use core::convert::TryInto;
 use core::hash::Hasher;
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 /// This implements a decoder for zstd frames. This decoder is able to decode frames only partially and gives control
 /// over how many bytes/blocks will be decoded at a time (so you don't have to decode a 10GB file into memory all at once).
 /// It reads bytes as needed from a provided source and can be read from to collect partial results.

src/fse/fse_decoder.rs

@@ -2,6 +2,9 @@ use crate::decoding::bit_reader::BitReader;
 use crate::decoding::bit_reader_reverse::{BitReaderReversed, GetBitsError};
 use alloc::vec::Vec;
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 pub struct FSETable {
     pub decode: Vec<Entry>, //used to decode symbols, and calculate the next state
 

src/huff0/huff0_decoder.rs

@@ -2,6 +2,9 @@ use crate::decoding::bit_reader_reverse::{BitReaderReversed, GetBitsError};
 use crate::fse::{FSEDecoder, FSEDecoderError, FSETable, FSETableError};
 use alloc::vec::Vec;
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 pub struct HuffmanTable {
     decode: Vec<Entry>,
 

src/io_nostd.rs

@@ -1,5 +1,8 @@
 use alloc::boxed::Box;
 
+#[cfg(not(feature = "std"))]
+use crate::std;
+
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub enum ErrorKind {
@@ -30,13 +33,13 @@ impl core::fmt::Display for ErrorKind {
 #[derive(Debug)]
 pub struct Error {
     kind: ErrorKind,
-    err: Option<Box<dyn core::error::Error + Send + Sync>>,
+    err: Option<Box<dyn std::error::Error + Send + Sync>>,
 }
 
 impl Error {
     pub fn new<E>(kind: ErrorKind, err: E) -> Self
     where
-        E: Into<Box<dyn core::error::Error + Send + Sync>>,
+        E: Into<Box<dyn std::error::Error + Send + Sync>>,
     {
         Self {
             kind,
@@ -52,15 +55,15 @@ impl Error {
         self.kind
     }
 
-    pub fn get_ref(&self) -> Option<&(dyn core::error::Error + Send + Sync + 'static)> {
+    pub fn get_ref(&self) -> Option<&(dyn std::error::Error + Send + Sync + 'static)> {
         self.err.as_ref().map(|e| e.as_ref())
     }
 
-    pub fn get_mut(&mut self) -> Option<&mut (dyn core::error::Error + Send + Sync + 'static)> {
+    pub fn get_mut(&mut self) -> Option<&mut (dyn std::error::Error + Send + Sync + 'static)> {
         self.err.as_mut().map(|e| e.as_mut())
     }
 
-    pub fn into_inner(self) -> Option<Box<dyn core::error::Error + Send + Sync>> {
+    pub fn into_inner(self) -> Option<Box<dyn std::error::Error + Send + Sync>> {
         self.err
     }
 }
@@ -77,7 +80,7 @@ impl core::fmt::Display for Error {
     }
 }
 
-impl core::error::Error for Error {}
+impl std::error::Error for Error {}
 
 impl From<ErrorKind> for Error {
     fn from(value: ErrorKind) -> Self {

src/lib.rs

@@ -1,10 +1,16 @@
 #![no_std]
 #![deny(trivial_casts, trivial_numeric_casts, rust_2018_idioms)]
-#![cfg_attr(not(feature = "std"), feature(error_in_core))]
 
 #[cfg(feature = "std")]
 extern crate std;
 
+#[cfg(not(feature = "std"))]
+mod std {
+    pub mod error {
+        pub use core_error::Error;
+    }
+}
+
 extern crate alloc;
 
 #[cfg(feature = "std")]