code_ownership 2.2.0 → 2.2.1

data/ext/cargo-vendor/rustc-hash-2.1.3/src/lib.rs

@@ -0,0 +1,472 @@
+//! A speedy, non-cryptographic hashing algorithm used by `rustc`.
+//!
+//! # Example
+//!
+//! ```rust
+//! # #[cfg(feature = "std")]
+//! # fn main() {
+//! use rustc_hash::FxHashMap;
+//!
+//! let mut map: FxHashMap<u32, u32> = FxHashMap::default();
+//! map.insert(22, 44);
+//! # }
+//! # #[cfg(not(feature = "std"))]
+//! # fn main() { }
+//! ```
+
+#![no_std]
+#![cfg_attr(feature = "nightly", feature(const_default))]
+#![cfg_attr(feature = "nightly", feature(const_trait_impl))]
+#![cfg_attr(feature = "nightly", feature(derive_const))]
+#![cfg_attr(feature = "nightly", feature(hasher_prefixfree_extras))]
+#![allow(rustc::default_hash_types)]
+
+#[cfg(feature = "std")]
+extern crate std;
+
+#[cfg(feature = "rand")]
+extern crate rand;
+
+#[cfg(feature = "rand")]
+mod random_state;
+
+mod seeded_state;
+
+use core::default::Default;
+use core::hash::{BuildHasher, Hasher};
+#[cfg(feature = "std")]
+use std::collections::{HashMap, HashSet};
+
+/// Type alias for a hash map that uses the Fx hashing algorithm.
+#[cfg(feature = "std")]
+pub type FxHashMap<K, V> = HashMap<K, V, FxBuildHasher>;
+
+/// Type alias for a hash set that uses the Fx hashing algorithm.
+#[cfg(feature = "std")]
+pub type FxHashSet<V> = HashSet<V, FxBuildHasher>;
+
+#[cfg(feature = "rand")]
+pub use random_state::{FxHashMapRand, FxHashSetRand, FxRandomState};
+
+pub use seeded_state::FxSeededState;
+#[cfg(feature = "std")]
+pub use seeded_state::{FxHashMapSeed, FxHashSetSeed};
+
+/// A speedy hash algorithm for use within rustc. The hashmap in liballoc
+/// by default uses SipHash which isn't quite as speedy as we want. In the
+/// compiler we're not really worried about DOS attempts, so we use a fast
+/// non-cryptographic hash.
+///
+/// The current implementation is a fast polynomial hash with a single
+/// bit rotation as a finishing step designed by Orson Peters.
+#[derive(Clone)]
+#[cfg_attr(not(feature = "nightly"), derive(Default))]
+#[cfg_attr(feature = "nightly", derive_const(Default))]
+pub struct FxHasher {
+    hash: usize,
+}
+
+// One might view a polynomial hash
+//    m[0] * k    + m[1] * k^2  + m[2] * k^3  + ...
+// as a multilinear hash with keystream k[..]
+//    m[0] * k[0] + m[1] * k[1] + m[2] * k[2] + ...
+// where keystream k just happens to be generated using a multiplicative
+// congruential pseudorandom number generator (MCG). For that reason we chose a
+// constant that was found to be good for a MCG in:
+//     "Computationally Easy, Spectrally Good Multipliers for Congruential
+//     Pseudorandom Number Generators" by Guy Steele and Sebastiano Vigna.
+#[cfg(target_pointer_width = "64")]
+const K: usize = 0xf1357aea2e62a9c5;
+#[cfg(target_pointer_width = "32")]
+const K: usize = 0x93d765dd;
+
+impl FxHasher {
+    /// Creates a `fx` hasher with a given seed.
+    pub const fn with_seed(seed: usize) -> FxHasher {
+        FxHasher { hash: seed }
+    }
+
+    /// Creates a default `fx` hasher.
+    pub const fn default() -> FxHasher {
+        FxHasher { hash: 0 }
+    }
+}
+
+impl FxHasher {
+    #[inline]
+    fn add_to_hash(&mut self, i: usize) {
+        self.hash = self.hash.wrapping_add(i).wrapping_mul(K);
+    }
+}
+
+impl Hasher for FxHasher {
+    #[inline]
+    fn write(&mut self, bytes: &[u8]) {
+        // Compress the byte string to a single u64 and add to our hash.
+        self.write_u64(hash_bytes(bytes));
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.add_to_hash(i as usize);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.add_to_hash(i as usize);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.add_to_hash(i as usize);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.add_to_hash(i as usize);
+        #[cfg(target_pointer_width = "32")]
+        self.add_to_hash((i >> 32) as usize);
+    }
+
+    #[inline]
+    fn write_u128(&mut self, i: u128) {
+        self.add_to_hash(i as usize);
+        #[cfg(target_pointer_width = "32")]
+        self.add_to_hash((i >> 32) as usize);
+        self.add_to_hash((i >> 64) as usize);
+        #[cfg(target_pointer_width = "32")]
+        self.add_to_hash((i >> 96) as usize);
+    }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.add_to_hash(i);
+    }
+
+    #[cfg(feature = "nightly")]
+    #[inline]
+    fn write_length_prefix(&mut self, _len: usize) {
+        // Most cases will specialize hash_slice to call write(), which encodes
+        // the length already in a more efficient manner than we could here. For
+        // HashDoS-resistance you would still need to include this for the
+        // non-slice collection hashes, but for the purposes of rustc we do not
+        // care and do not wish to pay the performance penalty of mixing in len
+        // for those collections.
+    }
+
+    #[cfg(feature = "nightly")]
+    #[inline]
+    fn write_str(&mut self, s: &str) {
+        // Similarly here, write already encodes the length, so nothing special
+        // is needed.
+        self.write(s.as_bytes())
+    }
+
+    #[inline]
+    fn finish(&self) -> u64 {
+        // Since we used a multiplicative hash our top bits have the most
+        // entropy (with the top bit having the most, decreasing as you go).
+        // As most hash table implementations (including hashbrown) compute
+        // the bucket index from the bottom bits we want to move bits from the
+        // top to the bottom. Ideally we'd rotate left by exactly the hash table
+        // size, but as we don't know this we'll choose 26 bits, giving decent
+        // entropy up until 2^26 table sizes. On 32-bit hosts we'll dial it
+        // back down a bit to 15 bits.
+
+        #[cfg(target_pointer_width = "64")]
+        const ROTATE: u32 = 26;
+        #[cfg(target_pointer_width = "32")]
+        const ROTATE: u32 = 15;
+
+        self.hash.rotate_left(ROTATE) as u64
+
+        // A bit reversal would be even better, except hashbrown also expects
+        // good entropy in the top 7 bits and a bit reverse would fill those
+        // bits with low entropy. More importantly, bit reversals are very slow
+        // on x86-64. A byte reversal is relatively fast, but still has a 2
+        // cycle latency on x86-64 compared to the 1 cycle latency of a rotate.
+        // It also suffers from the hashbrown-top-7-bit-issue.
+    }
+}
+
+// Nothing special, digits of pi.
+const SEED1: u64 = 0x243f6a8885a308d3;
+const SEED2: u64 = 0x13198a2e03707344;
+const PREVENT_TRIVIAL_ZERO_COLLAPSE: u64 = 0xa4093822299f31d0;
+
+#[inline]
+fn multiply_mix(x: u64, y: u64) -> u64 {
+    // The following code path is only fast if 64-bit to 128-bit widening
+    // multiplication is supported by the architecture. Most 64-bit
+    // architectures except SPARC64 and Wasm64 support it. However, the target
+    // pointer width doesn't always indicate that we are dealing with a 64-bit
+    // architecture, as there are ABIs that reduce the pointer width, especially
+    // on AArch64 and x86-64. WebAssembly (regardless of pointer width) supports
+    // 64-bit to 128-bit widening multiplication with the `wide-arithmetic`
+    // proposal.
+    if cfg!(any(
+        all(
+            target_pointer_width = "64",
+            not(any(target_arch = "sparc64", target_arch = "wasm64")),
+        ),
+        target_arch = "aarch64",
+        target_arch = "x86_64",
+        all(target_family = "wasm", target_feature = "wide-arithmetic"),
+    )) {
+        // We compute the full u64 x u64 -> u128 product, this is a single mul
+        // instruction on x86-64, one mul plus one mulhi on ARM64.
+        let full = (x as u128).wrapping_mul(y as u128);
+        let lo = full as u64;
+        let hi = (full >> 64) as u64;
+
+        // The middle bits of the full product fluctuate the most with small
+        // changes in the input. This is the top bits of lo and the bottom bits
+        // of hi. We can thus make the entire output fluctuate with small
+        // changes to the input by XOR'ing these two halves.
+        lo ^ hi
+
+        // Unfortunately both 2^64 + 1 and 2^64 - 1 have small prime factors,
+        // otherwise combining with + or - could result in a really strong hash, as:
+        //     x * y = 2^64 * hi + lo = (-1) * hi + lo = lo - hi,   (mod 2^64 + 1)
+        //     x * y = 2^64 * hi + lo =    1 * hi + lo = lo + hi,   (mod 2^64 - 1)
+        // Multiplicative hashing is universal in a field (like mod p).
+    } else {
+        // u64 x u64 -> u128 product is prohibitively expensive on 32-bit.
+        // Decompose into 32-bit parts.
+        let lx = x as u32;
+        let ly = y as u32;
+        let hx = (x >> 32) as u32;
+        let hy = (y >> 32) as u32;
+
+        // u32 x u32 -> u64 the low bits of one with the high bits of the other.
+        let afull = (lx as u64).wrapping_mul(hy as u64);
+        let bfull = (hx as u64).wrapping_mul(ly as u64);
+
+        // Combine, swapping low/high of one of them so the upper bits of the
+        // product of one combine with the lower bits of the other.
+        afull ^ bfull.rotate_right(32)
+    }
+}
+
+/// A wyhash-inspired non-collision-resistant hash for strings/slices designed
+/// by Orson Peters, with a focus on small strings and small codesize.
+///
+/// The 64-bit version of this hash passes the SMHasher3 test suite on the full
+/// 64-bit output, that is, f(hash_bytes(b) ^ f(seed)) for some good avalanching
+/// permutation f() passed all tests with zero failures. When using the 32-bit
+/// version of multiply_mix this hash has a few non-catastrophic failures where
+/// there are a handful more collisions than an optimal hash would give.
+///
+/// We don't bother avalanching here as we'll feed this hash into a
+/// multiplication after which we take the high bits, which avalanches for us.
+#[inline]
+fn hash_bytes(bytes: &[u8]) -> u64 {
+    let len = bytes.len();
+    let mut s0 = SEED1;
+    let mut s1 = SEED2;
+
+    if len <= 16 {
+        // XOR the input into s0, s1.
+        if len >= 8 {
+            s0 ^= u64::from_le_bytes(bytes[0..8].try_into().unwrap());
+            s1 ^= u64::from_le_bytes(bytes[len - 8..].try_into().unwrap());
+        } else if len >= 4 {
+            s0 ^= u32::from_le_bytes(bytes[0..4].try_into().unwrap()) as u64;
+            s1 ^= u32::from_le_bytes(bytes[len - 4..].try_into().unwrap()) as u64;
+        } else if len > 0 {
+            let lo = bytes[0];
+            let mid = bytes[len / 2];
+            let hi = bytes[len - 1];
+            s0 ^= lo as u64;
+            s1 ^= ((hi as u64) << 8) | mid as u64;
+        }
+    } else {
+        // Handle bulk (can partially overlap with suffix).
+        let mut bulk = &bytes[..(len - 1)];
+        while let Some((chunk, rest)) = bulk.split_first_chunk::<16>() {
+            let x = u64::from_le_bytes((&chunk[..8]).try_into().unwrap());
+            let y = u64::from_le_bytes((&chunk[8..]).try_into().unwrap());
+
+            // Replace s1 with a mix of s0, x, and y, and s0 with s1.
+            // This ensures the compiler can unroll this loop into two
+            // independent streams, one operating on s0, the other on s1.
+            //
+            // Since zeroes are a common input we prevent an immediate trivial
+            // collapse of the hash function by XOR'ing a constant with y.
+            let t = multiply_mix(s0 ^ x, PREVENT_TRIVIAL_ZERO_COLLAPSE ^ y);
+            s0 = s1;
+            s1 = t;
+            bulk = rest;
+        }
+
+        let suffix = &bytes[len - 16..];
+        s0 ^= u64::from_le_bytes(suffix[0..8].try_into().unwrap());
+        s1 ^= u64::from_le_bytes(suffix[8..16].try_into().unwrap());
+    }
+
+    multiply_mix(s0, s1) ^ (len as u64)
+}
+
+/// An implementation of [`BuildHasher`] that produces [`FxHasher`]s.
+///
+/// ```
+/// use std::hash::BuildHasher;
+/// use rustc_hash::FxBuildHasher;
+/// assert_ne!(FxBuildHasher.hash_one(1), FxBuildHasher.hash_one(2));
+/// ```
+#[derive(Copy, Clone)]
+#[cfg_attr(not(feature = "nightly"), derive(Default))]
+#[cfg_attr(feature = "nightly", derive_const(Default))]
+pub struct FxBuildHasher;
+
+impl BuildHasher for FxBuildHasher {
+    type Hasher = FxHasher;
+    fn build_hasher(&self) -> FxHasher {
+        FxHasher::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(any(target_pointer_width = "64", target_pointer_width = "32")))]
+    compile_error!("The test suite only supports 64 bit and 32 bit usize");
+
+    use crate::{FxBuildHasher, FxHasher};
+    use core::hash::{BuildHasher, Hash, Hasher};
+
+    macro_rules! test_hash {
+        (
+            $(
+                hash($value:expr) == $result:expr,
+            )*
+        ) => {
+            $(
+                assert_eq!(FxBuildHasher.hash_one($value), $result);
+            )*
+        };
+    }
+
+    const B32: bool = cfg!(target_pointer_width = "32");
+
+    #[test]
+    fn unsigned() {
+        test_hash! {
+            hash(0_u8) == 0,
+            hash(1_u8) == if B32 { 3001993707 } else { 12157901119326311915 },
+            hash(100_u8) == if B32 { 3844759569 } else { 16751747135202103309 },
+            hash(u8::MAX) == if B32 { 999399879 } else { 1211781028898739645 },
+
+            hash(0_u16) == 0,
+            hash(1_u16) == if B32 { 3001993707 } else { 12157901119326311915 },
+            hash(100_u16) == if B32 { 3844759569 } else { 16751747135202103309 },
+            hash(u16::MAX) == if B32 { 3440503042 } else { 16279819243059860173 },
+
+            hash(0_u32) == 0,
+            hash(1_u32) == if B32 { 3001993707 } else { 12157901119326311915 },
+            hash(100_u32) == if B32 { 3844759569 } else { 16751747135202103309 },
+            hash(u32::MAX) == if B32 { 1293006356 } else { 7729994835221066939 },
+
+            hash(0_u64) == 0,
+            hash(1_u64) == if B32 { 275023839 } else { 12157901119326311915 },
+            hash(100_u64) == if B32 { 1732383522 } else { 16751747135202103309 },
+            hash(u64::MAX) == if B32 { 1017982517 } else { 6288842954450348564 },
+
+            hash(0_u128) == 0,
+            hash(1_u128) == if B32 { 1860738631 } else { 13032756267696824044 },
+            hash(100_u128) == if B32 { 1389515751 } else { 12003541609544029302 },
+            hash(u128::MAX) == if B32 { 2156022013 } else { 11702830760530184999 },
+
+            hash(0_usize) == 0,
+            hash(1_usize) == if B32 { 3001993707 } else { 12157901119326311915 },
+            hash(100_usize) == if B32 { 3844759569 } else { 16751747135202103309 },
+            hash(usize::MAX) == if B32 { 1293006356 } else { 6288842954450348564 },
+        }
+    }
+
+    #[test]
+    fn signed() {
+        test_hash! {
+            hash(i8::MIN) == if B32 { 2000713177 } else { 6684841074112525780 },
+            hash(0_i8) == 0,
+            hash(1_i8) == if B32 { 3001993707 } else { 12157901119326311915 },
+            hash(100_i8) == if B32 { 3844759569 } else { 16751747135202103309 },
+            hash(i8::MAX) == if B32 { 3293686765 } else { 12973684028562874344 },
+
+            hash(i16::MIN) == if B32 { 1073764727 } else { 14218860181193086044 },
+            hash(0_i16) == 0,
+            hash(1_i16) == if B32 { 3001993707 } else { 12157901119326311915 },
+            hash(100_i16) == if B32 { 3844759569 } else { 16751747135202103309 },
+            hash(i16::MAX) == if B32 { 2366738315 } else { 2060959061933882993 },
+
+            hash(i32::MIN) == if B32 { 16384 } else { 9943947977240134995 },
+            hash(0_i32) == 0,
+            hash(1_i32) == if B32 { 3001993707 } else { 12157901119326311915 },
+            hash(100_i32) == if B32 { 3844759569 } else { 16751747135202103309 },
+            hash(i32::MAX) == if B32 { 1293022740 } else { 16232790931690483559 },
+
+            hash(i64::MIN) == if B32 { 16384 } else { 33554432 },
+            hash(0_i64) == 0,
+            hash(1_i64) == if B32 { 275023839 } else { 12157901119326311915 },
+            hash(100_i64) == if B32 { 1732383522 } else { 16751747135202103309 },
+            hash(i64::MAX) == if B32 { 1017998901 } else { 6288842954483902996 },
+
+            hash(i128::MIN) == if B32 { 16384 } else { 33554432 },
+            hash(0_i128) == 0,
+            hash(1_i128) == if B32 { 1860738631 } else { 13032756267696824044 },
+            hash(100_i128) == if B32 { 1389515751 } else { 12003541609544029302 },
+            hash(i128::MAX) == if B32 { 2156005629 } else { 11702830760496630567 },
+
+            hash(isize::MIN) == if B32 { 16384 } else { 33554432 },
+            hash(0_isize) == 0,
+            hash(1_isize) == if B32 { 3001993707 } else { 12157901119326311915 },
+            hash(100_isize) == if B32 { 3844759569 } else { 16751747135202103309 },
+            hash(isize::MAX) == if B32 { 1293022740 } else { 6288842954483902996 },
+        }
+    }
+
+    // Avoid relying on any `Hash` implementations in the standard library.
+    struct HashBytes(&'static [u8]);
+    impl Hash for HashBytes {
+        fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+            state.write(self.0);
+        }
+    }
+
+    #[test]
+    fn bytes() {
+        test_hash! {
+            hash(HashBytes(&[])) == if B32 { 2673204745 } else { 17606491139363777937 },
+            hash(HashBytes(&[0])) == if B32 { 2948228584 } else { 5448590020104574886 },
+            hash(HashBytes(&[0, 0, 0, 0, 0, 0])) == if B32 { 3223252423 } else { 16766921560080789783 },
+            hash(HashBytes(&[1])) == if B32 { 2943445104 } else { 5922447956811044110 },
+            hash(HashBytes(&[2])) == if B32 { 1055423297 } else { 5229781508510959783 },
+            hash(HashBytes(b"uwu")) == if B32 { 2699662140 } else { 7168164714682931527 },
+            hash(HashBytes(b"These are some bytes for testing rustc_hash.")) == if B32 { 2303640537 } else { 2349210501944688211 },
+        }
+    }
+
+    #[test]
+    fn with_seed_actually_different() {
+        let seeds = [
+            [1, 2],
+            [42, 17],
+            [124436707, 99237],
+            [usize::MIN, usize::MAX],
+        ];
+
+        for [a_seed, b_seed] in seeds {
+            let a = || FxHasher::with_seed(a_seed);
+            let b = || FxHasher::with_seed(b_seed);
+
+            for x in u8::MIN..=u8::MAX {
+                let mut a = a();
+                let mut b = b();
+
+                x.hash(&mut a);
+                x.hash(&mut b);
+
+                assert_ne!(a.finish(), b.finish())
+            }
+        }
+    }
+}

data/ext/cargo-vendor/rustc-hash-2.1.3/src/random_state.rs

@@ -0,0 +1,101 @@
+use std::collections::{HashMap, HashSet};
+
+use crate::FxHasher;
+
+/// Type alias for a hashmap using the `fx` hash algorithm with [`FxRandomState`].
+pub type FxHashMapRand<K, V> = HashMap<K, V, FxRandomState>;
+
+/// Type alias for a hashmap using the `fx` hash algorithm with [`FxRandomState`].
+pub type FxHashSetRand<V> = HashSet<V, FxRandomState>;
+
+/// `FxRandomState` is an alternative state for `HashMap` types.
+///
+/// A particular instance `FxRandomState` will create the same instances of
+/// [`Hasher`], but the hashers created by two different `FxRandomState`
+/// instances are unlikely to produce the same result for the same values.
+#[derive(Clone)]
+pub struct FxRandomState {
+    seed: usize,
+}
+
+impl FxRandomState {
+    /// Constructs a new `FxRandomState` that is initialized with random seed.
+    pub fn new() -> FxRandomState {
+        use rand::Rng;
+        use std::{cell::Cell, thread_local};
+
+        // This mirrors what `std::collections::hash_map::RandomState` does, as of 2024-01-14.
+        //
+        // Basically
+        // 1. Cache result of the rng in a thread local, so repeatedly
+        //    creating maps is cheaper
+        // 2. Change the cached result on every creation, so maps created
+        //    on the same thread don't have the same iteration order
+        thread_local!(static SEED: Cell<usize> = {
+            Cell::new(rand::rng().random_range(..=usize::MAX))
+        });
+
+        SEED.with(|seed| {
+            let s = seed.get();
+            seed.set(s.wrapping_add(1));
+            FxRandomState { seed: s }
+        })
+    }
+}
+
+impl core::hash::BuildHasher for FxRandomState {
+    type Hasher = FxHasher;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        FxHasher::with_seed(self.seed)
+    }
+}
+
+impl Default for FxRandomState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::thread;
+
+    use crate::FxHashMapRand;
+
+    #[test]
+    fn cloned_random_states_are_equal() {
+        let a = FxHashMapRand::<&str, u32>::default();
+        let b = a.clone();
+
+        assert_eq!(a.hasher().seed, b.hasher().seed);
+    }
+
+    #[test]
+    fn random_states_are_different() {
+        let a = FxHashMapRand::<&str, u32>::default();
+        let b = FxHashMapRand::<&str, u32>::default();
+
+        // That's the whole point of them being random!
+        //
+        // N.B.: `FxRandomState` uses a thread-local set to a random value and then incremented,
+        //       which means that this is *guaranteed* to pass :>
+        assert_ne!(a.hasher().seed, b.hasher().seed);
+    }
+
+    #[test]
+    fn random_states_are_different_cross_thread() {
+        // This is similar to the test above, but uses two different threads, so they both get
+        // completely random, unrelated values.
+        //
+        // This means that this test is technically flaky, but the probability of it failing is
+        // `1 / 2.pow(bit_size_of::<usize>())`. Or 1/1.7e19 for 64 bit platforms or 1/4294967295
+        // for 32 bit platforms. I suppose this is acceptable.
+        let a = FxHashMapRand::<&str, u32>::default();
+        let b = thread::spawn(FxHashMapRand::<&str, u32>::default)
+            .join()
+            .unwrap();
+
+        assert_ne!(a.hasher().seed, b.hasher().seed);
+    }
+}

data/ext/cargo-vendor/rustc-hash-2.1.3/src/seeded_state.rs

@@ -0,0 +1,76 @@
+use crate::FxHasher;
+
+/// Type alias for a hashmap using the `fx` hash algorithm with [`FxSeededState`].
+#[cfg(feature = "std")]
+pub type FxHashMapSeed<K, V> = std::collections::HashMap<K, V, FxSeededState>;
+
+/// Type alias for a hashmap using the `fx` hash algorithm with [`FxSeededState`].
+#[cfg(feature = "std")]
+pub type FxHashSetSeed<V> = std::collections::HashSet<V, FxSeededState>;
+
+/// [`FxSeededState`] is an alternative state for `HashMap` types, allowing to use [`FxHasher`] with a set seed.
+///
+/// ```
+/// # use std::collections::HashMap;
+/// use rustc_hash::FxSeededState;
+///
+/// let mut map = HashMap::with_hasher(FxSeededState::with_seed(12));
+/// map.insert(15, 610);
+/// assert_eq!(map[&15], 610);
+/// ```
+#[derive(Clone)]
+pub struct FxSeededState {
+    seed: usize,
+}
+
+impl FxSeededState {
+    /// Constructs a new `FxSeededState` that is initialized with a `seed`.
+    pub const fn with_seed(seed: usize) -> FxSeededState {
+        Self { seed }
+    }
+}
+
+impl core::hash::BuildHasher for FxSeededState {
+    type Hasher = FxHasher;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        FxHasher::with_seed(self.seed)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::hash::BuildHasher;
+
+    use crate::FxSeededState;
+
+    #[test]
+    fn cloned_seeded_states_are_equal() {
+        let seed = 2;
+        let a = FxSeededState::with_seed(seed);
+        let b = a.clone();
+
+        assert_eq!(a.seed, b.seed);
+        assert_eq!(a.seed, seed);
+
+        assert_eq!(a.build_hasher().hash, b.build_hasher().hash);
+    }
+
+    #[test]
+    fn same_seed_produces_same_hasher() {
+        let seed = 1;
+        let a = FxSeededState::with_seed(seed);
+        let b = FxSeededState::with_seed(seed);
+
+        // The hashers should be the same, as they have the same seed.
+        assert_eq!(a.build_hasher().hash, b.build_hasher().hash);
+    }
+
+    #[test]
+    fn different_states_are_different() {
+        let a = FxSeededState::with_seed(1);
+        let b = FxSeededState::with_seed(2);
+
+        assert_ne!(a.build_hasher().hash, b.build_hasher().hash);
+    }
+}

data/ext/cargo-vendor/{serde-1.0.228 → serde-1.0.229}/.cargo-checksum.json

@@ -1 +1 @@
-{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"399aaf38fec4939d8009dbb5e40edd613aefad660ded89ad5040a22b1f7140f9","Cargo.lock":"4c5bf070ad8c1c8beee68d9c477e909332e942aac79cfdc8a6b1f0de572c9073","Cargo.toml":"d7fc24e39691a0831eaa0eac677b46ecbae407a40fa816b904759822d10f42e8","Cargo.toml.orig":"0b7df7944cba2a0646daa431efdc9f8b200bc6beb586cd71e302a102d17c4c60","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"d40eb47c3c6e3780359df6fe40d40a35725c843df0e3b845e10ecf2a15048664","build.rs":"c99c25e1a11f3e51b61dd8c25bdbfbd090e43e5f1f2014f41f28e214dd8310d5","crates-io.md":"00b72e63d4f3393e28f9a219c8cb8c122013d82f0d10d6d551e239b13c5ba9e4","src/core/crate_root.rs":"157ca402e23c32f11a4f1797c81afb5e9f08df96768012cf3e3199153aafb2dd","src/core/de/ignored_any.rs":"6480f2b2a83dc4764d01b2eec7309729eef2492eede2e5ee98d23a60b05198eb","src/core/de/impls.rs":"9fb7a0322af51971fe1fa8f5b56c7ca3716622a6e9127b86bddfc0742c11383c","src/core/de/mod.rs":"5ec8602d593915e0cf480b0ce67b02f6ab066dac34725237d2c7b4a6ef12a845","src/core/de/value.rs":"fb6fef6d23d95d516c6e1d6b5cefd8b98ba3881214a82a8a7e0a8ffbb0a12083","src/core/format.rs":"c85071b016df643b161859682d21ce34fa0ebf2a3bdbeeea69859da48f5d934f","src/core/lib.rs":"5789fbaa20497111e3efa2af8a3c1d18bb41c0c0480b542d26a2573e8ff5cf5c","src/core/macros.rs":"a61c9d19b210697304328e6bb9380a1de713e21042256df90a2b4553f178b0be","src/core/private/content.rs":"5fdfb2bb95ecc80375507acb813a4c640496385e56fc99ab448f6b19e01fcc01","src/core/private/doc.rs":"abe656c015267555ca26ebbcf2f4dcc52c719a0b9ade3a5ed4635b2784699b8c","src/core/private/mod.rs":"3bb3427ec80077b9df1853aa17681de796de0179d74871a96b88b72469de6cfc","src/core/private/seed.rs":"3f6e098c5bd314788370dcaf3ab0152fcd7feb6bcf36a9c51808938cd58071eb","src/core/private/size_hint.rs":"350694a2abaad94ca5d33958710a5bb8973a2ea1a3dcc50a41405c943761b81f","src/core/private/string.rs":"c1500fd4b64c24a5e45fa5f48c85c802816d6954a2999a72fc5a8861687212d4","src/core/ser/fmt.rs":"bd129d9f085933b76dafef6eb43ffac893c1f6484a3064dcd82faeeebc3b203c","src/core/ser/impls.rs":"5ee7efc439345e8665da0bd79bc06c02a0506e5fd0f3a4cf11af0c7197eaa643","src/core/ser/impossible.rs":"283f628d5107aa030d2e96eeb1dee187f0ac18c24d517edeb51738ab15dfb871","src/core/ser/mod.rs":"ec097d92c8545356961e977a4c9650361cadd1d3a243d805ae7b0e0e589ae803","src/core/std_error.rs":"b36fd6a2b6898770b9f1c51517eb362af115767d0f7cb4a713e1b949530ffa8a","src/integer128.rs":"a5ca321ace6b11b71f637397cf4ea41992545a9c297a23230c8a9e8b92db71fa","src/lib.rs":"2e01b1191da5bc6be5ca1f208c362bc5b4e5f9fefc0b097433b9aef19a0af926","src/private/de.rs":"68ee17774d3bbc693d9f19803747fa2c3afdb7046482e6d94ac6cf7db5a4fe20","src/private/mod.rs":"52cc5b33364b13724ea4c2989f3ccd8ba02a2ef903761499e15264835ff76388","src/private/ser.rs":"bea364a6199b57c2aa5a96a6bb0530176850dbeaaee908a6307fe610c873c8e3"},"package":"9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"}
+{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"a5356e10a935346365e8744c75a7a6eb0ee0edbfb8074b712b19953c6e02e57e","Cargo.lock":"27e973a8db87258e9d422ae4b72bfccbb55f2e91393f447b5943a45b90b3f9f2","Cargo.toml":"6883caefd46e86eb15d22d3a6d274ad304c5e7934ab70eb58d81b7c4a29ef9db","Cargo.toml.orig":"137d4b56580e6b18d0cad4a86aea12a8b83b8f985a931b089de553161c35af56","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"0a33359b87747c0ae2437374c1dd4fc4d151ae3122b3931e2757b45d0ed519b8","build.rs":"e2ea6a7a82f5404c3e28cb055883c737ee7903367a10206fbb47b75c009f0eb3","crates-io.md":"00b72e63d4f3393e28f9a219c8cb8c122013d82f0d10d6d551e239b13c5ba9e4","src/core/crate_root.rs":"157ca402e23c32f11a4f1797c81afb5e9f08df96768012cf3e3199153aafb2dd","src/core/de/ignored_any.rs":"6480f2b2a83dc4764d01b2eec7309729eef2492eede2e5ee98d23a60b05198eb","src/core/de/impls.rs":"2f8e2ef9d343875bb996319e69feae0dee2287e2548cedd8d3c752b64812331c","src/core/de/mod.rs":"5ec8602d593915e0cf480b0ce67b02f6ab066dac34725237d2c7b4a6ef12a845","src/core/de/value.rs":"fb6fef6d23d95d516c6e1d6b5cefd8b98ba3881214a82a8a7e0a8ffbb0a12083","src/core/format.rs":"c85071b016df643b161859682d21ce34fa0ebf2a3bdbeeea69859da48f5d934f","src/core/lib.rs":"4e5c396d38ff5d9abf45b826a67ec3444654ed0802d057f46400ebe26f5879f8","src/core/macros.rs":"a61c9d19b210697304328e6bb9380a1de713e21042256df90a2b4553f178b0be","src/core/private/content.rs":"5fdfb2bb95ecc80375507acb813a4c640496385e56fc99ab448f6b19e01fcc01","src/core/private/doc.rs":"abe656c015267555ca26ebbcf2f4dcc52c719a0b9ade3a5ed4635b2784699b8c","src/core/private/mod.rs":"3bb3427ec80077b9df1853aa17681de796de0179d74871a96b88b72469de6cfc","src/core/private/seed.rs":"3f6e098c5bd314788370dcaf3ab0152fcd7feb6bcf36a9c51808938cd58071eb","src/core/private/size_hint.rs":"350694a2abaad94ca5d33958710a5bb8973a2ea1a3dcc50a41405c943761b81f","src/core/private/string.rs":"c1500fd4b64c24a5e45fa5f48c85c802816d6954a2999a72fc5a8861687212d4","src/core/ser/fmt.rs":"bd129d9f085933b76dafef6eb43ffac893c1f6484a3064dcd82faeeebc3b203c","src/core/ser/impls.rs":"5ee7efc439345e8665da0bd79bc06c02a0506e5fd0f3a4cf11af0c7197eaa643","src/core/ser/impossible.rs":"283f628d5107aa030d2e96eeb1dee187f0ac18c24d517edeb51738ab15dfb871","src/core/ser/mod.rs":"ec097d92c8545356961e977a4c9650361cadd1d3a243d805ae7b0e0e589ae803","src/core/std_error.rs":"b36fd6a2b6898770b9f1c51517eb362af115767d0f7cb4a713e1b949530ffa8a","src/integer128.rs":"a5ca321ace6b11b71f637397cf4ea41992545a9c297a23230c8a9e8b92db71fa","src/lib.rs":"9fcd921cee5dc64077f4027a3b42347253fdc3f3d9b88660e8c872c316db3620","src/private/de.rs":"68ee17774d3bbc693d9f19803747fa2c3afdb7046482e6d94ac6cf7db5a4fe20","src/private/mod.rs":"52cc5b33364b13724ea4c2989f3ccd8ba02a2ef903761499e15264835ff76388","src/private/ser.rs":"bea364a6199b57c2aa5a96a6bb0530176850dbeaaee908a6307fe610c873c8e3"},"package":"4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"}

data/ext/cargo-vendor/serde-1.0.229/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "7fc3b4c30c94f73a96ebd1553f2b090d928fc3a8"
+  },
+  "path_in_vcs": "serde"
+}