summaryrefslogtreecommitdiffstats
path: root/third_party/rust/phf
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/phf')
-rw-r--r--third_party/rust/phf/.cargo-checksum.json1
-rw-r--r--third_party/rust/phf/Cargo.toml49
-rw-r--r--third_party/rust/phf/src/lib.rs157
-rw-r--r--third_party/rust/phf/src/map.rs301
-rw-r--r--third_party/rust/phf/src/ordered_map.rs312
-rw-r--r--third_party/rust/phf/src/ordered_set.rs170
-rw-r--r--third_party/rust/phf/src/set.rs147
7 files changed, 1137 insertions, 0 deletions
diff --git a/third_party/rust/phf/.cargo-checksum.json b/third_party/rust/phf/.cargo-checksum.json
new file mode 100644
index 0000000000..7c54676c1b
--- /dev/null
+++ b/third_party/rust/phf/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"29149d1a0e11a422264675eb6229a7827acf187d1c5f8cc4b9c1cb2bf4ac9ae4","src/lib.rs":"a4d7dede221bdc3d69939a066a058e1a627e57777f7beab1baa93e452eb8fe67","src/map.rs":"755c39145d701560be45c731e81f9e3e60c884d00d1b6dea8e4614f9278a9d88","src/ordered_map.rs":"0b18597047bd5c782ccd4b2f54122e88cd020f930aa6f1436c3c5819d729decf","src/ordered_set.rs":"0ed66947623c8a79b1ad2c206ef5a13af701f95c0f36544ab986c9617e2a24a3","src/set.rs":"065a501930c4667877168b99aeca00007dd222865bafc26451cbc9fdf08ad7e6"},"package":"fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259"} \ No newline at end of file
diff --git a/third_party/rust/phf/Cargo.toml b/third_party/rust/phf/Cargo.toml
new file mode 100644
index 0000000000..ca2ce9893e
--- /dev/null
+++ b/third_party/rust/phf/Cargo.toml
@@ -0,0 +1,49 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "phf"
+version = "0.10.1"
+authors = ["Steven Fackler <sfackler@gmail.com>"]
+description = "Runtime support for perfect hash function data structures"
+readme = "../README.md"
+license = "MIT"
+repository = "https://github.com/sfackler/rust-phf"
+[package.metadata.docs.rs]
+features = ["macros"]
+
+[lib]
+name = "phf"
+path = "src/lib.rs"
+test = false
+[dependencies.phf_macros]
+version = "0.10.0"
+optional = true
+
+[dependencies.phf_shared]
+version = "0.10.0"
+default-features = false
+
+[dependencies.proc-macro-hack]
+version = "0.5.4"
+optional = true
+
+[dependencies.serde]
+version = "1.0"
+optional = true
+
+[features]
+default = ["std"]
+macros = ["phf_macros", "proc-macro-hack"]
+std = ["phf_shared/std"]
+uncased = ["phf_shared/uncased"]
+unicase = ["phf_shared/unicase"]
diff --git a/third_party/rust/phf/src/lib.rs b/third_party/rust/phf/src/lib.rs
new file mode 100644
index 0000000000..e60f524b0a
--- /dev/null
+++ b/third_party/rust/phf/src/lib.rs
@@ -0,0 +1,157 @@
+//! Rust-PHF is a library to generate efficient lookup tables at compile time using
+//! [perfect hash functions](http://en.wikipedia.org/wiki/Perfect_hash_function).
+//!
+//! It currently uses the
+//! [CHD algorithm](http://cmph.sourceforge.net/papers/esa09.pdf) and can generate
+//! a 100,000 entry map in roughly .4 seconds. By default statistics are not
+//! produced, but if you set the environment variable `PHF_STATS` it will issue
+//! a compiler note about how long it took.
+//!
+//! MSRV (minimum supported rust version) is Rust 1.46.
+//!
+//! ## Usage
+//!
+//! PHF data structures can be constructed via either the procedural
+//! macros in the `phf_macros` crate or code generation supported by the
+//! `phf_codegen` crate. If you prefer macros, you can easily use them by
+//! enabling the `macros` feature of the `phf` crate, like:
+//!
+//!```toml
+//! [dependencies]
+//! phf = { version = "0.10", features = ["macros"] }
+//! ```
+//!
+//! To compile the `phf` crate with a dependency on
+//! libcore instead of libstd, enabling use in environments where libstd
+//! will not work, set `default-features = false` for the dependency:
+//!
+//! ```toml
+//! [dependencies]
+//! # to use `phf` in `no_std` environments
+//! phf = { version = "0.10", default-features = false }
+//! ```
+//!
+//! ## Example (with the `macros` feature enabled)
+//!
+//! ```rust
+//! use phf::phf_map;
+//!
+//! #[derive(Clone)]
+//! pub enum Keyword {
+//! Loop,
+//! Continue,
+//! Break,
+//! Fn,
+//! Extern,
+//! }
+//!
+//! static KEYWORDS: phf::Map<&'static str, Keyword> = phf_map! {
+//! "loop" => Keyword::Loop,
+//! "continue" => Keyword::Continue,
+//! "break" => Keyword::Break,
+//! "fn" => Keyword::Fn,
+//! "extern" => Keyword::Extern,
+//! };
+//!
+//! pub fn parse_keyword(keyword: &str) -> Option<Keyword> {
+//! KEYWORDS.get(keyword).cloned()
+//! }
+//! ```
+//!
+//! Alternatively, you can use the [`phf_codegen`] crate to generate PHF datatypes
+//! in a build script.
+//!
+//! [`phf_codegen`]: https://docs.rs/phf_codegen
+//!
+//! ## Note
+//!
+//! Currently, the macro syntax has some limitations and may not
+//! work as you want. See [#183] or [#196] for example.
+//!
+//! [#183]: https://github.com/rust-phf/rust-phf/issues/183
+//! [#196]: https://github.com/rust-phf/rust-phf/issues/196
+
+#![doc(html_root_url = "https://docs.rs/phf/0.10")]
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "std")]
+extern crate std as core;
+
+#[cfg(feature = "macros")]
+/// Macro to create a `static` (compile-time) [`Map`].
+///
+/// Requires the `macros` feature.
+///
+/// Supported key expressions are:
+/// - literals: bools, (byte) strings, bytes, chars, and integers (these must have a type suffix)
+/// - arrays of `u8` integers
+/// - `UniCase::unicode(string)` or `UniCase::ascii(string)` if the `unicase` feature is enabled
+///
+/// # Example
+///
+/// ```
+/// use phf::{phf_map, Map};
+///
+/// static MY_MAP: Map<&'static str, u32> = phf_map! {
+/// "hello" => 1,
+/// "world" => 2,
+/// };
+///
+/// fn main () {
+/// assert_eq!(MY_MAP["hello"], 1);
+/// }
+/// ```
+#[proc_macro_hack::proc_macro_hack]
+pub use phf_macros::phf_map;
+
+#[cfg(feature = "macros")]
+/// Macro to create a `static` (compile-time) [`OrderedMap`].
+///
+/// Requires the `macros` feature. Same usage as [`phf_map`].
+#[proc_macro_hack::proc_macro_hack]
+pub use phf_macros::phf_ordered_map;
+
+#[cfg(feature = "macros")]
+/// Macro to create a `static` (compile-time) [`Set`].
+///
+/// Requires the `macros` feature.
+///
+/// # Example
+///
+/// ```
+/// use phf::{phf_set, Set};
+///
+/// static MY_SET: Set<&'static str> = phf_set! {
+/// "hello world",
+/// "hola mundo",
+/// };
+///
+/// fn main () {
+/// assert!(MY_SET.contains("hello world"));
+/// }
+/// ```
+#[proc_macro_hack::proc_macro_hack]
+pub use phf_macros::phf_set;
+
+#[cfg(feature = "macros")]
+/// Macro to create a `static` (compile-time) [`OrderedSet`].
+///
+/// Requires the `macros` feature. Same usage as [`phf_set`].
+#[proc_macro_hack::proc_macro_hack]
+pub use phf_macros::phf_ordered_set;
+
+#[doc(inline)]
+pub use self::map::Map;
+#[doc(inline)]
+pub use self::ordered_map::OrderedMap;
+#[doc(inline)]
+pub use self::ordered_set::OrderedSet;
+#[doc(inline)]
+pub use self::set::Set;
+pub use phf_shared::PhfHash;
+
+pub mod map;
+pub mod ordered_map;
+pub mod ordered_set;
+pub mod set;
diff --git a/third_party/rust/phf/src/map.rs b/third_party/rust/phf/src/map.rs
new file mode 100644
index 0000000000..5b74445c10
--- /dev/null
+++ b/third_party/rust/phf/src/map.rs
@@ -0,0 +1,301 @@
+//! An immutable map constructed at compile time.
+use core::fmt;
+use core::iter::FusedIterator;
+use core::iter::IntoIterator;
+use core::ops::Index;
+use core::slice;
+use phf_shared::{self, HashKey, PhfBorrow, PhfHash};
+#[cfg(feature = "serde")]
+use serde::ser::{Serialize, SerializeMap, Serializer};
+
+/// An immutable map constructed at compile time.
+///
+/// ## Note
+///
+/// The fields of this struct are public so that they may be initialized by the
+/// `phf_map!` macro and code generation. They are subject to change at any
+/// time and should never be accessed directly.
+pub struct Map<K: 'static, V: 'static> {
+ #[doc(hidden)]
+ pub key: HashKey,
+ #[doc(hidden)]
+ pub disps: &'static [(u32, u32)],
+ #[doc(hidden)]
+ pub entries: &'static [(K, V)],
+}
+
+impl<K, V> fmt::Debug for Map<K, V>
+where
+ K: fmt::Debug,
+ V: fmt::Debug,
+{
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt.debug_map().entries(self.entries()).finish()
+ }
+}
+
+impl<'a, K, V, T: ?Sized> Index<&'a T> for Map<K, V>
+where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+{
+ type Output = V;
+
+ fn index(&self, k: &'a T) -> &V {
+ self.get(k).expect("invalid key")
+ }
+}
+
+impl<K, V> Map<K, V> {
+ /// Returns the number of entries in the `Map`.
+ #[inline]
+ pub const fn len(&self) -> usize {
+ self.entries.len()
+ }
+
+ /// Returns true if the `Map` is empty.
+ #[inline]
+ pub const fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+
+ /// Determines if `key` is in the `Map`.
+ pub fn contains_key<T: ?Sized>(&self, key: &T) -> bool
+ where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+ {
+ self.get(key).is_some()
+ }
+
+ /// Returns a reference to the value that `key` maps to.
+ pub fn get<T: ?Sized>(&self, key: &T) -> Option<&V>
+ where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+ {
+ self.get_entry(key).map(|e| e.1)
+ }
+
+ /// Returns a reference to the map's internal static instance of the given
+ /// key.
+ ///
+ /// This can be useful for interning schemes.
+ pub fn get_key<T: ?Sized>(&self, key: &T) -> Option<&K>
+ where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+ {
+ self.get_entry(key).map(|e| e.0)
+ }
+
+ /// Like `get`, but returns both the key and the value.
+ pub fn get_entry<T: ?Sized>(&self, key: &T) -> Option<(&K, &V)>
+ where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+ {
+ if self.disps.is_empty() {
+ return None;
+ } //Prevent panic on empty map
+ let hashes = phf_shared::hash(key, &self.key);
+ let index = phf_shared::get_index(&hashes, &*self.disps, self.entries.len());
+ let entry = &self.entries[index as usize];
+ let b: &T = entry.0.borrow();
+ if b == key {
+ Some((&entry.0, &entry.1))
+ } else {
+ None
+ }
+ }
+
+ /// Returns an iterator over the key/value pairs in the map.
+ ///
+ /// Entries are returned in an arbitrary but fixed order.
+ pub fn entries(&self) -> Entries<'_, K, V> {
+ Entries {
+ iter: self.entries.iter(),
+ }
+ }
+
+ /// Returns an iterator over the keys in the map.
+ ///
+ /// Keys are returned in an arbitrary but fixed order.
+ pub fn keys(&self) -> Keys<'_, K, V> {
+ Keys {
+ iter: self.entries(),
+ }
+ }
+
+ /// Returns an iterator over the values in the map.
+ ///
+ /// Values are returned in an arbitrary but fixed order.
+ pub fn values(&self) -> Values<'_, K, V> {
+ Values {
+ iter: self.entries(),
+ }
+ }
+}
+
+impl<'a, K, V> IntoIterator for &'a Map<K, V> {
+ type Item = (&'a K, &'a V);
+ type IntoIter = Entries<'a, K, V>;
+
+ fn into_iter(self) -> Entries<'a, K, V> {
+ self.entries()
+ }
+}
+
+/// An iterator over the key/value pairs in a `Map`.
+pub struct Entries<'a, K, V> {
+ iter: slice::Iter<'a, (K, V)>,
+}
+
+impl<'a, K, V> Clone for Entries<'a, K, V> {
+ #[inline]
+ fn clone(&self) -> Self {
+ Self {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<'a, K, V> fmt::Debug for Entries<'a, K, V>
+where
+ K: fmt::Debug,
+ V: fmt::Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<'a, K, V> Iterator for Entries<'a, K, V> {
+ type Item = (&'a K, &'a V);
+
+ fn next(&mut self) -> Option<(&'a K, &'a V)> {
+ self.iter.next().map(|&(ref k, ref v)| (k, v))
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+}
+
+impl<'a, K, V> DoubleEndedIterator for Entries<'a, K, V> {
+ fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
+ self.iter.next_back().map(|e| (&e.0, &e.1))
+ }
+}
+
+impl<'a, K, V> ExactSizeIterator for Entries<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Entries<'a, K, V> {}
+
+/// An iterator over the keys in a `Map`.
+pub struct Keys<'a, K, V> {
+ iter: Entries<'a, K, V>,
+}
+
+impl<'a, K, V> Clone for Keys<'a, K, V> {
+ #[inline]
+ fn clone(&self) -> Self {
+ Self {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<'a, K, V> fmt::Debug for Keys<'a, K, V>
+where
+ K: fmt::Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<'a, K, V> Iterator for Keys<'a, K, V> {
+ type Item = &'a K;
+
+ fn next(&mut self) -> Option<&'a K> {
+ self.iter.next().map(|e| e.0)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+}
+
+impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
+ fn next_back(&mut self) -> Option<&'a K> {
+ self.iter.next_back().map(|e| e.0)
+ }
+}
+
+impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Keys<'a, K, V> {}
+
+/// An iterator over the values in a `Map`.
+pub struct Values<'a, K, V> {
+ iter: Entries<'a, K, V>,
+}
+
+impl<'a, K, V> Clone for Values<'a, K, V> {
+ #[inline]
+ fn clone(&self) -> Self {
+ Self {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<'a, K, V> fmt::Debug for Values<'a, K, V>
+where
+ V: fmt::Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<'a, K, V> Iterator for Values<'a, K, V> {
+ type Item = &'a V;
+
+ fn next(&mut self) -> Option<&'a V> {
+ self.iter.next().map(|e| e.1)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+}
+
+impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
+ fn next_back(&mut self) -> Option<&'a V> {
+ self.iter.next_back().map(|e| e.1)
+ }
+}
+
+impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Values<'a, K, V> {}
+
+#[cfg(feature = "serde")]
+impl<K, V> Serialize for Map<K, V>
+where
+ K: Serialize,
+ V: Serialize,
+{
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let mut map = serializer.serialize_map(Some(self.len()))?;
+ for (k, v) in self.entries() {
+ map.serialize_entry(k, v)?;
+ }
+ map.end()
+ }
+}
diff --git a/third_party/rust/phf/src/ordered_map.rs b/third_party/rust/phf/src/ordered_map.rs
new file mode 100644
index 0000000000..c8d5ac59bf
--- /dev/null
+++ b/third_party/rust/phf/src/ordered_map.rs
@@ -0,0 +1,312 @@
+//! An order-preserving immutable map constructed at compile time.
+use core::fmt;
+use core::iter::FusedIterator;
+use core::iter::IntoIterator;
+use core::ops::Index;
+use core::slice;
+use phf_shared::{self, HashKey, PhfBorrow, PhfHash};
+
+/// An order-preserving immutable map constructed at compile time.
+///
+/// Unlike a `Map`, iteration order is guaranteed to match the definition
+/// order.
+///
+/// ## Note
+///
+/// The fields of this struct are public so that they may be initialized by the
+/// `phf_ordered_map!` macro and code generation. They are subject to change at
+/// any time and should never be accessed directly.
+pub struct OrderedMap<K: 'static, V: 'static> {
+ #[doc(hidden)]
+ pub key: HashKey,
+ #[doc(hidden)]
+ pub disps: &'static [(u32, u32)],
+ #[doc(hidden)]
+ pub idxs: &'static [usize],
+ #[doc(hidden)]
+ pub entries: &'static [(K, V)],
+}
+
+impl<K, V> fmt::Debug for OrderedMap<K, V>
+where
+ K: fmt::Debug,
+ V: fmt::Debug,
+{
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt.debug_map().entries(self.entries()).finish()
+ }
+}
+
+impl<'a, K, V, T: ?Sized> Index<&'a T> for OrderedMap<K, V>
+where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+{
+ type Output = V;
+
+ fn index(&self, k: &'a T) -> &V {
+ self.get(k).expect("invalid key")
+ }
+}
+
+impl<K, V> OrderedMap<K, V> {
+ /// Returns the number of entries in the `OrderedMap`.
+ #[inline]
+ pub const fn len(&self) -> usize {
+ self.entries.len()
+ }
+
+ /// Returns true if the `OrderedMap` is empty.
+ #[inline]
+ pub const fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+
+ /// Returns a reference to the value that `key` maps to.
+ pub fn get<T: ?Sized>(&self, key: &T) -> Option<&V>
+ where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+ {
+ self.get_entry(key).map(|e| e.1)
+ }
+
+ /// Returns a reference to the map's internal static instance of the given
+ /// key.
+ ///
+ /// This can be useful for interning schemes.
+ pub fn get_key<T: ?Sized>(&self, key: &T) -> Option<&K>
+ where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+ {
+ self.get_entry(key).map(|e| e.0)
+ }
+
+ /// Determines if `key` is in the `OrderedMap`.
+ pub fn contains_key<T: ?Sized>(&self, key: &T) -> bool
+ where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+ {
+ self.get(key).is_some()
+ }
+
+ /// Returns the index of the key within the list used to initialize
+ /// the ordered map.
+ pub fn get_index<T: ?Sized>(&self, key: &T) -> Option<usize>
+ where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+ {
+ self.get_internal(key).map(|(i, _)| i)
+ }
+
+ /// Returns references to both the key and values at an index
+ /// within the list used to initialize the ordered map. See `.get_index(key)`.
+ pub fn index(&self, index: usize) -> Option<(&K, &V)> {
+ self.entries.get(index).map(|&(ref k, ref v)| (k, v))
+ }
+
+ /// Like `get`, but returns both the key and the value.
+ pub fn get_entry<T: ?Sized>(&self, key: &T) -> Option<(&K, &V)>
+ where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+ {
+ self.get_internal(key).map(|(_, e)| e)
+ }
+
+ fn get_internal<T: ?Sized>(&self, key: &T) -> Option<(usize, (&K, &V))>
+ where
+ T: Eq + PhfHash,
+ K: PhfBorrow<T>,
+ {
+ if self.disps.is_empty() {
+ return None;
+ } //Prevent panic on empty map
+ let hashes = phf_shared::hash(key, &self.key);
+ let idx_index = phf_shared::get_index(&hashes, &*self.disps, self.idxs.len());
+ let idx = self.idxs[idx_index as usize];
+ let entry = &self.entries[idx];
+
+ let b: &T = entry.0.borrow();
+ if b == key {
+ Some((idx, (&entry.0, &entry.1)))
+ } else {
+ None
+ }
+ }
+
+ /// Returns an iterator over the key/value pairs in the map.
+ ///
+ /// Entries are returned in the same order in which they were defined.
+ pub fn entries(&self) -> Entries<'_, K, V> {
+ Entries {
+ iter: self.entries.iter(),
+ }
+ }
+
+ /// Returns an iterator over the keys in the map.
+ ///
+ /// Keys are returned in the same order in which they were defined.
+ pub fn keys(&self) -> Keys<'_, K, V> {
+ Keys {
+ iter: self.entries(),
+ }
+ }
+
+ /// Returns an iterator over the values in the map.
+ ///
+ /// Values are returned in the same order in which they were defined.
+ pub fn values(&self) -> Values<'_, K, V> {
+ Values {
+ iter: self.entries(),
+ }
+ }
+}
+
+impl<'a, K, V> IntoIterator for &'a OrderedMap<K, V> {
+ type Item = (&'a K, &'a V);
+ type IntoIter = Entries<'a, K, V>;
+
+ fn into_iter(self) -> Entries<'a, K, V> {
+ self.entries()
+ }
+}
+
+/// An iterator over the entries in a `OrderedMap`.
+pub struct Entries<'a, K, V> {
+ iter: slice::Iter<'a, (K, V)>,
+}
+
+impl<'a, K, V> Clone for Entries<'a, K, V> {
+ #[inline]
+ fn clone(&self) -> Self {
+ Self {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<'a, K, V> fmt::Debug for Entries<'a, K, V>
+where
+ K: fmt::Debug,
+ V: fmt::Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<'a, K, V> Iterator for Entries<'a, K, V> {
+ type Item = (&'a K, &'a V);
+
+ fn next(&mut self) -> Option<(&'a K, &'a V)> {
+ self.iter.next().map(|e| (&e.0, &e.1))
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+}
+
+impl<'a, K, V> DoubleEndedIterator for Entries<'a, K, V> {
+ fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
+ self.iter.next_back().map(|e| (&e.0, &e.1))
+ }
+}
+
+impl<'a, K, V> ExactSizeIterator for Entries<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Entries<'a, K, V> {}
+
+/// An iterator over the keys in a `OrderedMap`.
+pub struct Keys<'a, K, V> {
+ iter: Entries<'a, K, V>,
+}
+
+impl<'a, K, V> Clone for Keys<'a, K, V> {
+ #[inline]
+ fn clone(&self) -> Self {
+ Self {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<'a, K, V> fmt::Debug for Keys<'a, K, V>
+where
+ K: fmt::Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<'a, K, V> Iterator for Keys<'a, K, V> {
+ type Item = &'a K;
+
+ fn next(&mut self) -> Option<&'a K> {
+ self.iter.next().map(|e| e.0)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+}
+
+impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
+ fn next_back(&mut self) -> Option<&'a K> {
+ self.iter.next_back().map(|e| e.0)
+ }
+}
+
+impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Keys<'a, K, V> {}
+
+/// An iterator over the values in a `OrderedMap`.
+pub struct Values<'a, K, V> {
+ iter: Entries<'a, K, V>,
+}
+
+impl<'a, K, V> Clone for Values<'a, K, V> {
+ #[inline]
+ fn clone(&self) -> Self {
+ Self {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<'a, K, V> fmt::Debug for Values<'a, K, V>
+where
+ V: fmt::Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<'a, K, V> Iterator for Values<'a, K, V> {
+ type Item = &'a V;
+
+ fn next(&mut self) -> Option<&'a V> {
+ self.iter.next().map(|e| e.1)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+}
+
+impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
+ fn next_back(&mut self) -> Option<&'a V> {
+ self.iter.next_back().map(|e| e.1)
+ }
+}
+
+impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Values<'a, K, V> {}
diff --git a/third_party/rust/phf/src/ordered_set.rs b/third_party/rust/phf/src/ordered_set.rs
new file mode 100644
index 0000000000..e85d45711f
--- /dev/null
+++ b/third_party/rust/phf/src/ordered_set.rs
@@ -0,0 +1,170 @@
+//! An order-preserving immutable set constructed at compile time.
+use crate::{ordered_map, OrderedMap, PhfHash};
+use core::fmt;
+use core::iter::FusedIterator;
+use core::iter::IntoIterator;
+use phf_shared::PhfBorrow;
+
+/// An order-preserving immutable set constructed at compile time.
+///
+/// Unlike a `Set`, iteration order is guaranteed to match the definition
+/// order.
+///
+/// ## Note
+///
+/// The fields of this struct are public so that they may be initialized by the
+/// `phf_ordered_set!` macro and code generation. They are subject to change at
+/// any time and should never be accessed directly.
+pub struct OrderedSet<T: 'static> {
+ #[doc(hidden)]
+ pub map: OrderedMap<T, ()>,
+}
+
+impl<T> fmt::Debug for OrderedSet<T>
+where
+ T: fmt::Debug,
+{
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt.debug_set().entries(self).finish()
+ }
+}
+
+impl<T> OrderedSet<T> {
+ /// Returns the number of elements in the `OrderedSet`.
+ #[inline]
+ pub const fn len(&self) -> usize {
+ self.map.len()
+ }
+
+ /// Returns true if the `OrderedSet` contains no elements.
+ #[inline]
+ pub const fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+
+ /// Returns a reference to the set's internal static instance of the given
+ /// key.
+ ///
+ /// This can be useful for interning schemes.
+ pub fn get_key<U: ?Sized>(&self, key: &U) -> Option<&T>
+ where
+ U: Eq + PhfHash,
+ T: PhfBorrow<U>,
+ {
+ self.map.get_key(key)
+ }
+
+ /// Returns the index of the key within the list used to initialize
+ /// the ordered set.
+ pub fn get_index<U: ?Sized>(&self, key: &U) -> Option<usize>
+ where
+ U: Eq + PhfHash,
+ T: PhfBorrow<U>,
+ {
+ self.map.get_index(key)
+ }
+
+ /// Returns a reference to the key at an index
+ /// within the list used to initialize the ordered set. See `.get_index(key)`.
+ pub fn index(&self, index: usize) -> Option<&T> {
+ self.map.index(index).map(|(k, &())| k)
+ }
+
+ /// Returns true if `value` is in the `OrderedSet`.
+ pub fn contains<U: ?Sized>(&self, value: &U) -> bool
+ where
+ U: Eq + PhfHash,
+ T: PhfBorrow<U>,
+ {
+ self.map.contains_key(value)
+ }
+
+ /// Returns an iterator over the values in the set.
+ ///
+ /// Values are returned in the same order in which they were defined.
+ pub fn iter(&self) -> Iter<'_, T> {
+ Iter {
+ iter: self.map.keys(),
+ }
+ }
+}
+
+impl<T> OrderedSet<T>
+where
+ T: Eq + PhfHash + PhfBorrow<T>,
+{
+ /// Returns true if `other` shares no elements with `self`.
+ #[inline]
+ pub fn is_disjoint(&self, other: &OrderedSet<T>) -> bool {
+ !self.iter().any(|value| other.contains(value))
+ }
+
+ /// Returns true if `other` contains all values in `self`.
+ #[inline]
+ pub fn is_subset(&self, other: &OrderedSet<T>) -> bool {
+ self.iter().all(|value| other.contains(value))
+ }
+
+ /// Returns true if `self` contains all values in `other`.
+ #[inline]
+ pub fn is_superset(&self, other: &OrderedSet<T>) -> bool {
+ other.is_subset(self)
+ }
+}
+
+impl<'a, T> IntoIterator for &'a OrderedSet<T> {
+ type Item = &'a T;
+ type IntoIter = Iter<'a, T>;
+
+ fn into_iter(self) -> Iter<'a, T> {
+ self.iter()
+ }
+}
+
+/// An iterator over the values in a `OrderedSet`.
+pub struct Iter<'a, T> {
+ iter: ordered_map::Keys<'a, T, ()>,
+}
+
+impl<'a, T> Clone for Iter<'a, T> {
+ #[inline]
+ fn clone(&self) -> Self {
+ Self {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<'a, T> fmt::Debug for Iter<'a, T>
+where
+ T: fmt::Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<'a, T> Iterator for Iter<'a, T> {
+ type Item = &'a T;
+
+ #[inline]
+ fn next(&mut self) -> Option<&'a T> {
+ self.iter.next()
+ }
+
+ #[inline]
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+}
+
+impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
+ #[inline]
+ fn next_back(&mut self) -> Option<&'a T> {
+ self.iter.next_back()
+ }
+}
+
+impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
+
+impl<'a, T> FusedIterator for Iter<'a, T> {}
diff --git a/third_party/rust/phf/src/set.rs b/third_party/rust/phf/src/set.rs
new file mode 100644
index 0000000000..d9fdd5bb23
--- /dev/null
+++ b/third_party/rust/phf/src/set.rs
@@ -0,0 +1,147 @@
+//! An immutable set constructed at compile time.
+use core::fmt;
+use core::iter::FusedIterator;
+use core::iter::IntoIterator;
+
+use phf_shared::{PhfBorrow, PhfHash};
+
+use crate::{map, Map};
+
+/// An immutable set constructed at compile time.
+///
+/// ## Note
+///
+/// The fields of this struct are public so that they may be initialized by the
+/// `phf_set!` macro and code generation. They are subject to change at any
+/// time and should never be accessed directly.
+pub struct Set<T: 'static> {
+ #[doc(hidden)]
+ pub map: Map<T, ()>,
+}
+
+impl<T> fmt::Debug for Set<T>
+where
+ T: fmt::Debug,
+{
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt.debug_set().entries(self).finish()
+ }
+}
+
+impl<T> Set<T> {
+ /// Returns the number of elements in the `Set`.
+ #[inline]
+ pub const fn len(&self) -> usize {
+ self.map.len()
+ }
+
+ /// Returns true if the `Set` contains no elements.
+ #[inline]
+ pub const fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+
+ /// Returns a reference to the set's internal static instance of the given
+ /// key.
+ ///
+ /// This can be useful for interning schemes.
+ pub fn get_key<U: ?Sized>(&self, key: &U) -> Option<&T>
+ where
+ U: Eq + PhfHash,
+ T: PhfBorrow<U>,
+ {
+ self.map.get_key(key)
+ }
+
+ /// Returns true if `value` is in the `Set`.
+ pub fn contains<U: ?Sized>(&self, value: &U) -> bool
+ where
+ U: Eq + PhfHash,
+ T: PhfBorrow<U>,
+ {
+ self.map.contains_key(value)
+ }
+
+ /// Returns an iterator over the values in the set.
+ ///
+ /// Values are returned in an arbitrary but fixed order.
+ pub fn iter(&self) -> Iter<'_, T> {
+ Iter {
+ iter: self.map.keys(),
+ }
+ }
+}
+
+impl<T> Set<T>
+where
+ T: Eq + PhfHash + PhfBorrow<T>,
+{
+ /// Returns true if `other` shares no elements with `self`.
+ pub fn is_disjoint(&self, other: &Set<T>) -> bool {
+ !self.iter().any(|value| other.contains(value))
+ }
+
+ /// Returns true if `other` contains all values in `self`.
+ pub fn is_subset(&self, other: &Set<T>) -> bool {
+ self.iter().all(|value| other.contains(value))
+ }
+
+ /// Returns true if `self` contains all values in `other`.
+ pub fn is_superset(&self, other: &Set<T>) -> bool {
+ other.is_subset(self)
+ }
+}
+
+impl<'a, T> IntoIterator for &'a Set<T> {
+ type Item = &'a T;
+ type IntoIter = Iter<'a, T>;
+
+ fn into_iter(self) -> Iter<'a, T> {
+ self.iter()
+ }
+}
+
+/// An iterator over the values in a `Set`.
+pub struct Iter<'a, T: 'static> {
+ iter: map::Keys<'a, T, ()>,
+}
+
+impl<'a, T> Clone for Iter<'a, T> {
+ #[inline]
+ fn clone(&self) -> Self {
+ Self {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<'a, T> fmt::Debug for Iter<'a, T>
+where
+ T: fmt::Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<'a, T> Iterator for Iter<'a, T> {
+ type Item = &'a T;
+
+ fn next(&mut self) -> Option<&'a T> {
+ self.iter.next()
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+}
+
+impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
+ fn next_back(&mut self) -> Option<&'a T> {
+ self.iter.next_back()
+ }
+}
+
+impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
+
+impl<'a, T> FusedIterator for Iter<'a, T> {}