wasmtime 16.0.0 → 17.0.1

data/ext/cargo-vendor/cranelift-entity-0.104.1/src/primary.rs

@@ -0,0 +1,541 @@
+//! Densely numbered entity references as mapping keys.
+use crate::boxed_slice::BoxedSlice;
+use crate::iter::{IntoIter, Iter, IterMut};
+use crate::keys::Keys;
+use crate::EntityRef;
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::iter::FromIterator;
+use core::marker::PhantomData;
+use core::mem;
+use core::ops::{Index, IndexMut};
+use core::slice;
+#[cfg(feature = "enable-serde")]
+use serde_derive::{Deserialize, Serialize};
+
+/// A primary mapping `K -> V` allocating dense entity references.
+///
+/// The `PrimaryMap` data structure uses the dense index space to implement a map with a vector.
+///
+/// A primary map contains the main definition of an entity, and it can be used to allocate new
+/// entity references with the `push` method.
+///
+/// There should only be a single `PrimaryMap` instance for a given `EntityRef` type, otherwise
+/// conflicting references will be created. Using unknown keys for indexing will cause a panic.
+///
+/// Note that `PrimaryMap` doesn't implement `Deref` or `DerefMut`, which would allow
+/// `&PrimaryMap<K, V>` to convert to `&[V]`. One of the main advantages of `PrimaryMap` is
+/// that it only allows indexing with the distinct `EntityRef` key type, so converting to a
+/// plain slice would make it easier to use incorrectly. To make a slice of a `PrimaryMap`, use
+/// `into_boxed_slice`.
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    elems: Vec<V>,
+    unused: PhantomData<K>,
+}
+
+impl<K, V> PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    /// Create a new empty map.
+    pub fn new() -> Self {
+        Self {
+            elems: Vec::new(),
+            unused: PhantomData,
+        }
+    }
+
+    /// Create a new empty map with the given capacity.
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            elems: Vec::with_capacity(capacity),
+            unused: PhantomData,
+        }
+    }
+
+    /// Check if `k` is a valid key in the map.
+    pub fn is_valid(&self, k: K) -> bool {
+        k.index() < self.elems.len()
+    }
+
+    /// Get the element at `k` if it exists.
+    pub fn get(&self, k: K) -> Option<&V> {
+        self.elems.get(k.index())
+    }
+
+    /// Get the element at `k` if it exists, mutable version.
+    pub fn get_mut(&mut self, k: K) -> Option<&mut V> {
+        self.elems.get_mut(k.index())
+    }
+
+    /// Is this map completely empty?
+    pub fn is_empty(&self) -> bool {
+        self.elems.is_empty()
+    }
+
+    /// Get the total number of entity references created.
+    pub fn len(&self) -> usize {
+        self.elems.len()
+    }
+
+    /// Iterate over all the keys in this map.
+    pub fn keys(&self) -> Keys<K> {
+        Keys::with_len(self.elems.len())
+    }
+
+    /// Iterate over all the values in this map.
+    pub fn values(&self) -> slice::Iter<V> {
+        self.elems.iter()
+    }
+
+    /// Iterate over all the values in this map, mutable edition.
+    pub fn values_mut(&mut self) -> slice::IterMut<V> {
+        self.elems.iter_mut()
+    }
+
+    /// Iterate over all the keys and values in this map.
+    pub fn iter(&self) -> Iter<K, V> {
+        Iter::new(self.elems.iter())
+    }
+
+    /// Iterate over all the keys and values in this map, mutable edition.
+    pub fn iter_mut(&mut self) -> IterMut<K, V> {
+        IterMut::new(self.elems.iter_mut())
+    }
+
+    /// Remove all entries from this map.
+    pub fn clear(&mut self) {
+        self.elems.clear()
+    }
+
+    /// Get the key that will be assigned to the next pushed value.
+    pub fn next_key(&self) -> K {
+        K::new(self.elems.len())
+    }
+
+    /// Append `v` to the mapping, assigning a new key which is returned.
+    pub fn push(&mut self, v: V) -> K {
+        let k = self.next_key();
+        self.elems.push(v);
+        k
+    }
+
+    /// Returns the last element that was inserted in the map.
+    pub fn last(&self) -> Option<(K, &V)> {
+        let len = self.elems.len();
+        let last = self.elems.last()?;
+        Some((K::new(len - 1), last))
+    }
+
+    /// Returns the last element that was inserted in the map.
+    pub fn last_mut(&mut self) -> Option<(K, &mut V)> {
+        let len = self.elems.len();
+        let last = self.elems.last_mut()?;
+        Some((K::new(len - 1), last))
+    }
+
+    /// Reserves capacity for at least `additional` more elements to be inserted.
+    pub fn reserve(&mut self, additional: usize) {
+        self.elems.reserve(additional)
+    }
+
+    /// Reserves the minimum capacity for exactly `additional` more elements to be inserted.
+    pub fn reserve_exact(&mut self, additional: usize) {
+        self.elems.reserve_exact(additional)
+    }
+
+    /// Shrinks the capacity of the `PrimaryMap` as much as possible.
+    pub fn shrink_to_fit(&mut self) {
+        self.elems.shrink_to_fit()
+    }
+
+    /// Consumes this `PrimaryMap` and produces a `BoxedSlice`.
+    pub fn into_boxed_slice(self) -> BoxedSlice<K, V> {
+        unsafe { BoxedSlice::<K, V>::from_raw(Box::<[V]>::into_raw(self.elems.into_boxed_slice())) }
+    }
+
+    /// Returns mutable references to many elements at once.
+    ///
+    /// Returns an error if an element does not exist, or if the same key was passed more than
+    /// once.
+    // This implementation is taken from the unstable `get_many_mut`.
+    //
+    // Once it has been stabilised we can call that method directly.
+    pub fn get_many_mut<const N: usize>(
+        &mut self,
+        indices: [K; N],
+    ) -> Result<[&mut V; N], GetManyMutError<K>> {
+        for (i, &idx) in indices.iter().enumerate() {
+            if idx.index() >= self.len() {
+                return Err(GetManyMutError::DoesNotExist(idx));
+            }
+            for &idx2 in &indices[..i] {
+                if idx == idx2 {
+                    return Err(GetManyMutError::MultipleOf(idx));
+                }
+            }
+        }
+
+        let slice: *mut V = self.elems.as_mut_ptr();
+        let mut arr: mem::MaybeUninit<[&mut V; N]> = mem::MaybeUninit::uninit();
+        let arr_ptr = arr.as_mut_ptr();
+
+        unsafe {
+            for i in 0..N {
+                let idx = *indices.get_unchecked(i);
+                *(*arr_ptr).get_unchecked_mut(i) = &mut *slice.add(idx.index());
+            }
+            Ok(arr.assume_init())
+        }
+    }
+
+    /// Performs a binary search on the values with a key extraction function.
+    ///
+    /// Assumes that the values are sorted by the key extracted by the function.
+    ///
+    /// If the value is found then `Ok(K)` is returned, containing the entity key
+    /// of the matching value.
+    ///
+    /// If there are multiple matches, then any one of the matches could be returned.
+    ///
+    /// If the value is not found then Err(K) is returned, containing the entity key
+    /// where a matching element could be inserted while maintaining sorted order.
+    pub fn binary_search_values_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<K, K>
+    where
+        F: FnMut(&'a V) -> B,
+        B: Ord,
+    {
+        self.elems
+            .binary_search_by_key(b, f)
+            .map(|i| K::new(i))
+            .map_err(|i| K::new(i))
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum GetManyMutError<K> {
+    DoesNotExist(K),
+    MultipleOf(K),
+}
+
+impl<K, V> Default for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    fn default() -> PrimaryMap<K, V> {
+        PrimaryMap::new()
+    }
+}
+
+/// Immutable indexing into an `PrimaryMap`.
+/// The indexed value must be in the map.
+impl<K, V> Index<K> for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    type Output = V;
+
+    fn index(&self, k: K) -> &V {
+        &self.elems[k.index()]
+    }
+}
+
+/// Mutable indexing into an `PrimaryMap`.
+impl<K, V> IndexMut<K> for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    fn index_mut(&mut self, k: K) -> &mut V {
+        &mut self.elems[k.index()]
+    }
+}
+
+impl<K, V> IntoIterator for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    type Item = (K, V);
+    type IntoIter = IntoIter<K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter::new(self.elems.into_iter())
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    type Item = (K, &'a V);
+    type IntoIter = Iter<'a, K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Iter::new(self.elems.iter())
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a mut PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    type Item = (K, &'a mut V);
+    type IntoIter = IterMut<'a, K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IterMut::new(self.elems.iter_mut())
+    }
+}
+
+impl<K, V> FromIterator<V> for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    fn from_iter<T>(iter: T) -> Self
+    where
+        T: IntoIterator<Item = V>,
+    {
+        Self {
+            elems: Vec::from_iter(iter),
+            unused: PhantomData,
+        }
+    }
+}
+
+impl<K, V> From<Vec<V>> for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    fn from(elems: Vec<V>) -> Self {
+        Self {
+            elems,
+            unused: PhantomData,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // `EntityRef` impl for testing.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    struct E(u32);
+
+    impl EntityRef for E {
+        fn new(i: usize) -> Self {
+            E(i as u32)
+        }
+        fn index(self) -> usize {
+            self.0 as usize
+        }
+    }
+
+    #[test]
+    fn basic() {
+        let r0 = E(0);
+        let r1 = E(1);
+        let m = PrimaryMap::<E, isize>::new();
+
+        let v: Vec<E> = m.keys().collect();
+        assert_eq!(v, []);
+
+        assert!(!m.is_valid(r0));
+        assert!(!m.is_valid(r1));
+    }
+
+    #[test]
+    fn push() {
+        let mut m = PrimaryMap::new();
+        let k0: E = m.push(12);
+        let k1 = m.push(33);
+
+        assert_eq!(m[k0], 12);
+        assert_eq!(m[k1], 33);
+
+        let v: Vec<E> = m.keys().collect();
+        assert_eq!(v, [k0, k1]);
+    }
+
+    #[test]
+    fn iter() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 0;
+        for (key, value) in &m {
+            assert_eq!(key.index(), i);
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+        i = 0;
+        for (key_mut, value_mut) in m.iter_mut() {
+            assert_eq!(key_mut.index(), i);
+            match i {
+                0 => assert_eq!(*value_mut, 12),
+                1 => assert_eq!(*value_mut, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+    }
+
+    #[test]
+    fn iter_rev() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 2;
+        for (key, value) in m.iter().rev() {
+            i -= 1;
+            assert_eq!(key.index(), i);
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+        }
+
+        i = 2;
+        for (key, value) in m.iter_mut().rev() {
+            i -= 1;
+            assert_eq!(key.index(), i);
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+        }
+    }
+    #[test]
+    fn keys() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 0;
+        for key in m.keys() {
+            assert_eq!(key.index(), i);
+            i += 1;
+        }
+    }
+
+    #[test]
+    fn keys_rev() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 2;
+        for key in m.keys().rev() {
+            i -= 1;
+            assert_eq!(key.index(), i);
+        }
+    }
+
+    #[test]
+    fn values() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 0;
+        for value in m.values() {
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+        i = 0;
+        for value_mut in m.values_mut() {
+            match i {
+                0 => assert_eq!(*value_mut, 12),
+                1 => assert_eq!(*value_mut, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+    }
+
+    #[test]
+    fn values_rev() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 2;
+        for value in m.values().rev() {
+            i -= 1;
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+        }
+        i = 2;
+        for value_mut in m.values_mut().rev() {
+            i -= 1;
+            match i {
+                0 => assert_eq!(*value_mut, 12),
+                1 => assert_eq!(*value_mut, 33),
+                _ => panic!(),
+            }
+        }
+    }
+
+    #[test]
+    fn from_iter() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let n = m.values().collect::<PrimaryMap<E, _>>();
+        assert!(m.len() == n.len());
+        for (me, ne) in m.values().zip(n.values()) {
+            assert!(*me == **ne);
+        }
+    }
+
+    #[test]
+    fn from_vec() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let n = PrimaryMap::<E, &usize>::from(m.values().collect::<Vec<_>>());
+        assert!(m.len() == n.len());
+        for (me, ne) in m.values().zip(n.values()) {
+            assert!(*me == **ne);
+        }
+    }
+
+    #[test]
+    fn get_many_mut() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        let _0 = m.push(0);
+        let _1 = m.push(1);
+        let _2 = m.push(2);
+
+        assert_eq!([&mut 0, &mut 2], m.get_many_mut([_0, _2]).unwrap());
+        assert_eq!(
+            m.get_many_mut([_0, _0]),
+            Err(GetManyMutError::MultipleOf(_0))
+        );
+        assert_eq!(
+            m.get_many_mut([E(4)]),
+            Err(GetManyMutError::DoesNotExist(E(4)))
+        );
+    }
+}

data/ext/cargo-vendor/cranelift-frontend-0.104.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"0f105cbfc75eb5c6569f4a3bc6ca2187e7adce3ac6c11a34f8ce4a522126509b","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"dea43e8044284df50f8b8772e9b48ba8b109b45c74111ff73619775d57ad8d67","src/frontend.rs":"712cbce058ca2aea229debf0600c6b0eee0d02d3102bf49a52db96f67e3a0d03","src/lib.rs":"1fcaf7c33f40aff0aa778bd1b54049478ec26517c342140f40538528940a5a1d","src/ssa.rs":"9d1a47cb6d6328f31997f0ee09b0326067e4507284f363e5d09074e2c306f303","src/switch.rs":"ca77eeb97db8c43566c5cfc1cc5e7a0c394fc72e306b985117e47d6d6f5bb5cc","src/variable.rs":"ad628b3c6de9a8c008dc31f869bf9d853f2dd3b590dc4e2e3c6da70ba6bf7adf"},"package":"67150a1fef9857caba710f8c0c8223d640f02c0e5d1ebbfc75ed62912599cb6b"}

data/ext/cargo-vendor/cranelift-frontend-0.104.1/Cargo.toml

@@ -0,0 +1,68 @@
+# 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 = "2021"
+name = "cranelift-frontend"
+version = "0.104.1"
+authors = ["The Cranelift Project Developers"]
+description = "Cranelift IR builder helper"
+documentation = "https://docs.rs/cranelift-frontend"
+readme = "README.md"
+categories = ["no-std"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.cranelift-codegen]
+version = "0.104.1"
+features = [
+    "std",
+    "unwind",
+]
+default-features = false
+
+[dependencies.hashbrown]
+version = "0.14"
+optional = true
+default-features = false
+
+[dependencies.log]
+version = "0.4.8"
+default-features = false
+
+[dependencies.smallvec]
+version = "1.6.1"
+features = ["union"]
+
+[dependencies.target-lexicon]
+version = "0.12.12"
+features = ["std"]
+default-features = false
+
+[dev-dependencies.similar]
+version = "2.1.0"
+
+[features]
+core = [
+    "hashbrown",
+    "cranelift-codegen/core",
+]
+default = ["std"]
+std = ["cranelift-codegen/std"]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/cranelift-isle-0.104.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"4842f7c03a4809c2b8cb0414b0df06c7520f60d78d38f9f11fbc962d4ef1a6fc","README.md":"cde3f7281c7a6c3195784341904495770914d41414546e65e0b4e66478676121","build.rs":"8375c4b7b30a6e381790be5dceed9b093a85edfdfdfd346f63a92c112f158454","isle_examples/fail/bad_converters.isle":"3c439432aca313302fc0bd360b48b3e0229074b7e630e8099a6f01ff7966f913","isle_examples/fail/bound_var_type_mismatch.isle":"c846f2a17a0e774fb4d389bfde643d501805c932bf8e062ef346abdfaf744de4","isle_examples/fail/converter_extractor_constructor.isle":"9603f8e41be92f30b0f2a513e4ad788b53423c61d5391ffba86d45163f36345a","isle_examples/fail/error1.isle":"016096ba09f12c36a22b8398606f99ea0eb54976d9d56cfecd65c25d6ac7f298","isle_examples/fail/extra_parens.isle":"60410fd0b1ebbe38c2059358e7ebe9c39f7e30ad5e7f8c629cbe600d98c48611","isle_examples/fail/impure_expression.isle":"85362308be72512aa508e501a20155a5a76f394ac14b62bd246421deeea384aa","isle_examples/fail/impure_rhs.isle":"c9efb0c694494938bdc85c9cb6985df2dc33ace980e1fb8f80bf3960e7dfcc3f","isle_examples/fail/multi_internal_etor.isle":"1da74314c83125528b3acc36582800423d9f972af7fd06f15b6b4c1f8d6eb9c6","isle_examples/fail/multi_prio.isle":"1b9a780f03cf824d4a2d1de69378ccb6586bcb9a1f514638363600028e78c5de","isle_examples/link/borrows.isle":"9a78ab0461496be950c070da48ac0be03aea83afa9f7efbfbcaeee86ee340485","isle_examples/link/borrows_main.rs":"d14d5c191613c45a2687493ace29e8dcda532be9a09a792ee04d96b7a2994978","isle_examples/link/iflets.isle":"fc9074e965b9eaf8ee57484108556ed09bfa7b122ba1a072fe1404483213bb6b","isle_examples/link/iflets_main.rs":"71d96686f7bea89a084fa676d87f198c630e9f8e23ad1927ea0df15af3eba19d","isle_examples/link/multi_constructor.isle":"eaacf20ed3f8701dde763f99aa64bbbadf51c4165347ba481798d6fb2deb7cf6","isle_examples/link/multi_constructor_main.rs":"2961d23ec3c2699ab2c5bddbc1f1c88c1c8611595afb8ef4623bf6c2a07acbe3","isle_examples/link/multi_extractor.isle":"50b858ecf8be26f77bd112b9b75a88caac1420d8bcf89ad1369a0b7965822aa4","isle_examples/link/multi_extractor_main.rs":"15899c5462790fd1508024dc52017fea1bdef65608fecbfc9baca1c478ebd7eb","isle_examples/link/test.isle":"283ec1108eb3391454d6b6d083f58dffb5804a988627d8b95294c935c497d275","isle_examples/link/test_main.rs":"0362fa81349db33cda6b97d81da90a86509d52e8085ad499bd5be18724965878","isle_examples/pass/bound_var.isle":"cbd97a1a25879e6afd78357811fb1f277e2585a5e74acc595c8e027936f07b8e","isle_examples/pass/construct_and_extract.isle":"203c0a8c762603f22a1f2593b2b9f427c14e63f18c56ef8d1d6107634af3bdcd","isle_examples/pass/conversions.isle":"3e9820cd9eb6223026994a971f3c64a5e4045450451d650d244afb531a1b3fb8","isle_examples/pass/conversions_extern.isle":"24ca717c100bf477efad53c5adb207f88bf33e7c0ea07ec4d485cb86b8da996b","isle_examples/pass/let.isle":"cc6eb7b5685f265135692d1203b83431df5ef089064608cf6fe4feb4286e5d0f","isle_examples/pass/nodebug.isle":"16e58d125a37fe001c03136a70c5270d2b90a719ee266a39705aaabb2aadf174","isle_examples/pass/prio_trie_bug.isle":"f0a5f6290822ce8498756e7bbd892124355ec2a7faa200792395fc5c3385f467","isle_examples/pass/test2.isle":"d767d11f4dffc25b47fe29e6ae9f90eb36d247ee80cc98a2ffe938130b0776e7","isle_examples/pass/test3.isle":"8f0fa6c70f5ffa8713c912f4409b195980bd2c37b1e393973085975fa62049d3","isle_examples/pass/test4.isle":"a580492320964fabc0cb2fec66fd94b2759342088f9e74152d616a4d82d517f3","isle_examples/pass/tutorial.isle":"23c16d1a0af4c2a212cb581d6e1f7a9538c4507af1daf68434b9073d0f38d94c","isle_examples/run/iconst.isle":"0c38f0352da2b0e295cc075febfedb7fd20dbe7483520640f8f1bf59da7223b9","isle_examples/run/iconst_main.rs":"f1b921b205d0f6120faaccd8138e5db8c42e9ab548eb3fbef643f3cfc8be03d0","isle_examples/run/let_shadowing.isle":"46fb8bb300b31081a5dcb5061efe21ee573c007b5b425bd51afd08c67293341e","isle_examples/run/let_shadowing_main.rs":"466f9b79f06f1cfa259c4f9c05a892df99d3fd0de1e62b97a6ab372f4509f6a9","src/ast.rs":"a14a10e77b705d5809cef3e772b67e49d36a05464e4c1af810413989ae0d6569","src/codegen.rs":"83a9839b249df6e72628e65ec0482486da269f710a71ca64908653ea258c5fd2","src/compile.rs":"beaf5bb5ba6b8ee14e5ded9be3f5374d1f46b4d211d9bbe04b504c19d8664aaf","src/error.rs":"15d5cb5dde6c4d997e107320521e42ca75d9118d5a0949c97d3eec8d60c61964","src/lexer.rs":"3828292eb2a682999501aef82d4ea7de757ae084d4f92ff1a1f1cee28cfecdf1","src/lib.rs":"232d341fd343a5476a69ea607e1bb956c97dc051d2c2f33baedfa5f971b4e873","src/log.rs":"abfe10789b25940da3a559bb7be30f928bb35574b4a8f0875bdd75350d25c0e9","src/overlap.rs":"923eb3770e1a2a4a05dd05982f3c591cbc2c5bf49b62674eae92ceb906506a66","src/parser.rs":"22c8bb28a9f89b73e78cd40f5ce6809708e6f5b41ffa1bdae67f1cab55ba2d50","src/sema.rs":"ebb37f519c25aff73c967eb769b97cbe9a5c477408772708a82f171deb530b24","src/serialize.rs":"9126bfbb79440e68a0c5149e5c1232378a8db977c7a40200d0dc62da8a05f814","src/trie_again.rs":"e8571b42a9a3f9e5083d4ccdeaa4fbab14a209b6d30fc8d5d4884dd7b83fce2b","tests/run_tests.rs":"3c86434adcf2e6b28db7719286f2328c347fd0f5bb7827f607d3a7686021732e"},"package":"eb7ceea70d3e0d7f69df7657f99de902e32016731c5a8d2788c1df0215f00952"}

data/ext/cargo-vendor/cranelift-isle-0.104.1/Cargo.toml

@@ -0,0 +1,46 @@
+# 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 = "2021"
+name = "cranelift-isle"
+version = "0.104.1"
+authors = ["The Cranelift Project Developers"]
+description = "ISLE: Instruction Selection and Lowering Expressions. A domain-specific language for instruction selection in Cranelift."
+readme = "README.md"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime/tree/main/cranelift/isle"
+
+[dependencies.codespan-reporting]
+version = "0.11.1"
+optional = true
+
+[dependencies.log]
+version = "0.4.8"
+optional = true
+default-features = false
+
+[dev-dependencies.tempfile]
+version = "3"
+
+[features]
+default = []
+fancy-errors = ["codespan-reporting"]
+logging = ["log"]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/cranelift-native-0.104.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"71f970d747ed5a803293d84211867b2a78f0f1f00b1bcdcaf9f8078292d939ac","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"3dcebfe863bb34056d13c895732889ba1b732f9e958ff3c32284b3565eaacbd6","src/lib.rs":"90b1ac331433e1c4155e978e04357b1a58b81fc140145fcd2a23e40f20a54a7e","src/riscv.rs":"664397ca90791bc0d39e85c6cda176383fef9cff17f9d191f70d1982e2c97313"},"package":"707e5d9384ce4fa3c40af1abf4c3ec49857745cced5187593385f4a2c0b95445"}