wasmtime 19.0.2 → 20.0.2

data/ext/cargo-vendor/ahash-0.8.11/tests/bench.rs

@@ -0,0 +1,199 @@
+#![cfg_attr(feature = "specialize", feature(build_hasher_simple_hash_one))]
+
+use ahash::{AHasher, RandomState};
+use criterion::*;
+use fxhash::FxHasher;
+use rand::Rng;
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{BuildHasherDefault, Hash, Hasher};
+
+// Needs to be in sync with `src/lib.rs`
+const AHASH_IMPL: &str = if cfg!(any(
+    all(
+        any(target_arch = "x86", target_arch = "x86_64"),
+        target_feature = "aes",
+        not(miri),
+    ),
+    all(feature = "nightly-arm-aes", target_arch = "aarch64", target_feature = "aes", not(miri)),
+    all(
+        feature = "nightly-arm-aes",
+        target_arch = "arm",
+        target_feature = "aes",
+        not(miri)
+    ),
+)) {
+    "aeshash"
+} else {
+    "fallbackhash"
+};
+
+fn ahash<H: Hash>(b: &H) -> u64 {
+    let build_hasher = RandomState::with_seeds(1, 2, 3, 4);
+    build_hasher.hash_one(b)
+}
+
+fn fnvhash<H: Hash>(b: &H) -> u64 {
+    let mut hasher = fnv::FnvHasher::default();
+    b.hash(&mut hasher);
+    hasher.finish()
+}
+
+fn siphash<H: Hash>(b: &H) -> u64 {
+    let mut hasher = DefaultHasher::default();
+    b.hash(&mut hasher);
+    hasher.finish()
+}
+
+fn fxhash<H: Hash>(b: &H) -> u64 {
+    let mut hasher = FxHasher::default();
+    b.hash(&mut hasher);
+    hasher.finish()
+}
+
+fn seahash<H: Hash>(b: &H) -> u64 {
+    let mut hasher = seahash::SeaHasher::default();
+    b.hash(&mut hasher);
+    hasher.finish()
+}
+
+const STRING_LENGTHS: [u32; 12] = [1, 3, 4, 7, 8, 15, 16, 24, 33, 68, 132, 1024];
+
+fn gen_strings() -> Vec<String> {
+    STRING_LENGTHS
+        .iter()
+        .map(|len| {
+            let mut string = String::default();
+            for pos in 1..=*len {
+                let c = (48 + (pos % 10) as u8) as char;
+                string.push(c);
+            }
+            string
+        })
+        .collect()
+}
+
+macro_rules! bench_inputs {
+    ($group:ident, $hash:ident) => {
+        // Number of iterations per batch should be high enough to hide timing overhead.
+        let size = BatchSize::NumIterations(50_000);
+
+        let mut rng = rand::thread_rng();
+        $group.bench_function("u8", |b| b.iter_batched(|| rng.gen::<u8>(), |v| $hash(&v), size));
+        $group.bench_function("u16", |b| b.iter_batched(|| rng.gen::<u16>(), |v| $hash(&v), size));
+        $group.bench_function("u32", |b| b.iter_batched(|| rng.gen::<u32>(), |v| $hash(&v), size));
+        $group.bench_function("u64", |b| b.iter_batched(|| rng.gen::<u64>(), |v| $hash(&v), size));
+        $group.bench_function("u128", |b| b.iter_batched(|| rng.gen::<u128>(), |v| $hash(&v), size));
+        $group.bench_with_input("strings", &gen_strings(), |b, s| b.iter(|| $hash(black_box(s))));
+    };
+}
+
+fn bench_ahash(c: &mut Criterion) {
+    let mut group = c.benchmark_group(AHASH_IMPL);
+    bench_inputs!(group, ahash);
+}
+
+fn bench_fx(c: &mut Criterion) {
+    let mut group = c.benchmark_group("fx");
+    bench_inputs!(group, fxhash);
+}
+
+fn bench_fnv(c: &mut Criterion) {
+    let mut group = c.benchmark_group("fnv");
+    bench_inputs!(group, fnvhash);
+}
+
+fn bench_sea(c: &mut Criterion) {
+    let mut group = c.benchmark_group("sea");
+    bench_inputs!(group, seahash);
+}
+
+fn bench_sip(c: &mut Criterion) {
+    let mut group = c.benchmark_group("sip");
+    bench_inputs!(group, siphash);
+}
+
+fn bench_map(c: &mut Criterion) {
+    #[cfg(feature = "std")]
+    {
+        let mut group = c.benchmark_group("map");
+        group.bench_function("aHash-alias", |b| {
+            b.iter(|| {
+                let hm: ahash::HashMap<i32, i32> = (0..1_000_000).map(|i| (i, i)).collect();
+                let mut sum = 0;
+                for i in 0..1_000_000 {
+                    if let Some(x) = hm.get(&i) {
+                        sum += x;
+                    }
+                }
+            })
+        });
+        group.bench_function("aHash-hashBrown", |b| {
+            b.iter(|| {
+                let hm: hashbrown::HashMap<i32, i32> = (0..1_000_000).map(|i| (i, i)).collect();
+                let mut sum = 0;
+                for i in 0..1_000_000 {
+                    if let Some(x) = hm.get(&i) {
+                        sum += x;
+                    }
+                }
+            })
+        });
+        group.bench_function("aHash-hashBrown-explicit", |b| {
+            b.iter(|| {
+                let hm: hashbrown::HashMap<i32, i32, RandomState> = (0..1_000_000).map(|i| (i, i)).collect();
+                let mut sum = 0;
+                for i in 0..1_000_000 {
+                    if let Some(x) = hm.get(&i) {
+                        sum += x;
+                    }
+                }
+            })
+        });
+        group.bench_function("aHash-wrapper", |b| {
+            b.iter(|| {
+                let hm: ahash::AHashMap<i32, i32> = (0..1_000_000).map(|i| (i, i)).collect();
+                let mut sum = 0;
+                for i in 0..1_000_000 {
+                    if let Some(x) = hm.get(&i) {
+                        sum += x;
+                    }
+                }
+            })
+        });
+        group.bench_function("aHash-rand", |b| {
+            b.iter(|| {
+                let hm: std::collections::HashMap<i32, i32, RandomState> = (0..1_000_000).map(|i| (i, i)).collect();
+                let mut sum = 0;
+                for i in 0..1_000_000 {
+                    if let Some(x) = hm.get(&i) {
+                        sum += x;
+                    }
+                }
+            })
+        });
+        group.bench_function("aHash-default", |b| {
+            b.iter(|| {
+                let hm: std::collections::HashMap<i32, i32, BuildHasherDefault<AHasher>> =
+                    (0..1_000_000).map(|i| (i, i)).collect();
+                let mut sum = 0;
+                for i in 0..1_000_000 {
+                    if let Some(x) = hm.get(&i) {
+                        sum += x;
+                    }
+                }
+            })
+        });
+    }
+}
+
+criterion_main!(benches);
+
+criterion_group!(
+    benches,
+    bench_ahash,
+    bench_fx,
+    bench_fnv,
+    bench_sea,
+    bench_sip,
+    bench_map
+);

data/ext/cargo-vendor/ahash-0.8.11/tests/map_tests.rs

@@ -0,0 +1,310 @@
+#![cfg_attr(feature = "specialize", feature(build_hasher_simple_hash_one))]
+
+use std::hash::{BuildHasher, Hash, Hasher};
+
+use ahash::RandomState;
+use criterion::*;
+use fxhash::FxHasher;
+
+fn gen_word_pairs() -> Vec<String> {
+    let words: Vec<_> = r#"
+a, ability, able, about, above, accept, according, account, across, act, action,
+activity, actually, add, address, administration, admit, adult, affect, after,
+again, against, age, agency, agent, ago, agree, agreement, ahead, air, all,
+allow, almost, alone, along, already, also, although, always, American, among,
+amount, analysis, and, animal, another, answer, any, anyone, anything, appear,
+apply, approach, area, argue, arm, around, arrive, art, article, artist, as,
+ask, assume, at, attack, attention, attorney, audience, author, authority,
+available, avoid, away, baby, back, bad, bag, ball, bank, bar, base, be, beat,
+beautiful, because, become, bed, before, begin, behavior, behind, believe,
+benefit, best, better, between, beyond, big, bill, billion, bit, black, blood,
+blue, board, body, book, born, both, box, boy, break, bring, brother, budget,
+build, building, business, but, buy, by, call, camera, campaign, can, cancer,
+candidate, capital, car, card, care, career, carry, case, catch, cause, cell,
+center, central, century, certain, certainly, chair, challenge, chance, change,
+character, charge, check, child, choice, choose, church, citizen, city, civil,
+claim, class, clear, clearly, close, coach, cold, collection, college, color,
+come, commercial, common, community, company, compare, computer, concern,
+condition, conference, Congress, consider, consumer, contain, continue, control,
+cost, could, country, couple, course, court, cover, create, crime, cultural,
+culture, cup, current, customer, cut, dark, data, daughter, day, dead, deal,
+death, debate, decade, decide, decision, deep, defense, degree, Democrat,
+democratic, describe, design, despite, detail, determine, develop, development,
+die, difference, different, difficult, dinner, direction, director, discover,
+discuss, discussion, disease, do, doctor, dog, door, down, draw, dream, drive,
+drop, drug, during, each, early, east, easy, eat, economic, economy, edge,
+education, effect, effort, eight, either, election, else, employee, end, energy,
+enjoy, enough, enter, entire, environment, environmental, especially, establish,
+even, evening, event, ever, every, everybody, everyone, everything, evidence,
+exactly, example, executive, exist, expect, experience, expert, explain, eye,
+face, fact, factor, fail, fall, family, far, fast, father, fear, federal, feel,
+feeling, few, field, fight, figure, fill, film, final, finally, financial, find,
+fine, finger, finish, fire, firm, first, fish, five, floor, fly, focus, follow,
+food, foot, for, force, foreign, forget, form, former, forward, four, free,
+friend, from, front, full, fund, future, game, garden, gas, general, generation,
+get, girl, give, glass, go, goal, good, government, great, green, ground, group,
+grow, growth, guess, gun, guy, hair, half, hand, hang, happen, happy, hard,
+have, he, head, health, hear, heart, heat, heavy, help, her, here, herself,
+high, him, himself, his, history, hit, hold, home, hope, hospital, hot, hotel,
+hour, house, how, however, huge, human, hundred, husband, I, idea, identify, if,
+image, imagine, impact, important, improve, in, include, including, increase,
+indeed, indicate, individual, industry, information, inside, instead,
+institution, interest, interesting, international, interview, into, investment,
+involve, issue, it, item, its, itself, job, join, just, keep, key, kid, kill,
+kind, kitchen, know, knowledge, land, language, large, last, late, later, laugh,
+law, lawyer, lay, lead, leader, learn, least, leave, left, leg, legal, less,
+let, letter, level, lie, life, light, like, likely, line, list, listen, little,
+live, local, long, look, lose, loss, lot, love, low, machine, magazine, main,
+maintain, major, majority, make, man, manage, management, manager, many, market,
+marriage, material, matter, may, maybe, me, mean, measure, media, medical, meet,
+meeting, member, memory, mention, message, method, middle, might, military,
+million, mind, minute, miss, mission, model, modern, moment, money, month, more,
+morning, most, mother, mouth, move, movement, movie, Mr, Mrs, much, music, must,
+my, myself, name, nation, national, natural, nature, near, nearly, necessary,
+need, network, never, new, news, newspaper, next, nice, night, no, none, nor,
+north, not, note, nothing, notice, now, n't, number, occur, of, off, offer,
+office, officer, official, often, oh, oil, ok, old, on, once, one, only, onto,
+open, operation, opportunity, option, or, order, organization, other, others,
+our, out, outside, over, own, owner, page, pain, painting, paper, parent, part,
+participant, particular, particularly, partner, party, pass, past, patient,
+pattern, pay, peace, people, per, perform, performance, perhaps, period, person,
+personal, phone, physical, pick, picture, piece, place, plan, plant, play,
+player, PM, point, police, policy, political, politics, poor, popular,
+population, position, positive, possible, power, practice, prepare, present,
+president, pressure, pretty, prevent, price, private, probably, problem,
+process, produce, product, production, professional, professor, program,
+project, property, protect, prove, provide, public, pull, purpose, push, put,
+quality, question, quickly, quite, race, radio, raise, range, rate, rather,
+reach, read, ready, real, reality, realize, really, reason, receive, recent,
+recently, recognize, record, red, reduce, reflect, region, relate, relationship,
+religious, remain, remember, remove, report, represent, Republican, require,
+research, resource, respond, response, responsibility, rest, result, return,
+reveal, rich, right, rise, risk, road, rock, role, room, rule, run, safe, same,
+save, say, scene, school, science, scientist, score, sea, season, seat, second,
+section, security, see, seek, seem, sell, send, senior, sense, series, serious,
+serve, service, set, seven, several, sex, sexual, shake, share, she, shoot,
+short, shot, should, shoulder, show, side, sign, significant, similar, simple,
+simply, since, sing, single, sister, sit, site, situation, six, size, skill,
+skin, small, smile, so, social, society, soldier, some, somebody, someone,
+something, sometimes, son, song, soon, sort, sound, source, south, southern,
+space, speak, special, specific, speech, spend, sport, spring, staff, stage,
+stand, standard, star, start, state, statement, station, stay, step, still,
+stock, stop, store, story, strategy, street, strong, structure, student, study,
+stuff, style, subject, success, successful, such, suddenly, suffer, suggest,
+summer, support, sure, surface, system, table, take, talk, task, tax, teach,
+teacher, team, technology, television, tell, ten, tend, term, test, than, thank,
+that, the, their, them, themselves, then, theory, there, these, they, thing,
+think, third, this, those, though, thought, thousand, threat, three, through,
+throughout, throw, thus, time, to, today, together, tonight, too, top, total,
+tough, toward, town, trade, traditional, training, travel, treat, treatment,
+tree, trial, trip, trouble, true, truth, try, turn, TV, two, type, under,
+understand, unit, until, up, upon, us, use, usually, value, various, very,
+victim, view, violence, visit, voice, vote, wait, walk, wall, want, war, watch,
+water, way, we, weapon, wear, week, weight, well, west, western, what, whatever,
+when, where, whether, which, while, white, who, whole, whom, whose, why, wide,
+wife, will, win, wind, window, wish, with, within, without, woman, wonder, word,
+work, worker, world, worry, would, write, writer, wrong, yard, yeah, year, yes,
+yet, you, young, your, yourself"#
+        .split(',')
+        .map(|word| word.trim())
+        .collect();
+
+    let mut word_pairs: Vec<_> = Vec::new();
+    for word in &words {
+        for other_word in &words {
+            word_pairs.push(word.to_string() + " " + other_word);
+        }
+    }
+    assert_eq!(1_000_000, word_pairs.len());
+    word_pairs
+}
+
+#[allow(unused)] // False positive
+fn test_hash_common_words<B: BuildHasher>(build_hasher: &B) {
+    let word_pairs: Vec<_> = gen_word_pairs();
+    check_for_collisions(build_hasher, &word_pairs, 32);
+}
+
+#[allow(unused)] // False positive
+fn check_for_collisions<H: Hash, B: BuildHasher>(build_hasher: &B, items: &[H], bucket_count: usize) {
+    let mut buckets = vec![0; bucket_count];
+    for item in items {
+        let value = hash(item, build_hasher) as usize;
+        buckets[value % bucket_count] += 1;
+    }
+    let mean = items.len() / bucket_count;
+    let max = *buckets.iter().max().unwrap();
+    let min = *buckets.iter().min().unwrap();
+    assert!(
+        (min as f64) > (mean as f64) * 0.95,
+        "min: {}, max:{}, {:?}",
+        min,
+        max,
+        buckets
+    );
+    assert!(
+        (max as f64) < (mean as f64) * 1.05,
+        "min: {}, max:{}, {:?}",
+        min,
+        max,
+        buckets
+    );
+}
+
+#[cfg(feature = "specialize")]
+#[allow(unused)] // False positive
+fn hash<H: Hash, B: BuildHasher>(b: &H, build_hasher: &B) -> u64 {
+    build_hasher.hash_one(b)
+}
+
+#[cfg(not(feature = "specialize"))]
+#[allow(unused)] // False positive
+fn hash<H: Hash, B: BuildHasher>(b: &H, build_hasher: &B) -> u64 {
+    let mut hasher = build_hasher.build_hasher();
+    b.hash(&mut hasher);
+    hasher.finish()
+}
+
+#[test]
+fn test_bucket_distribution() {
+    let build_hasher = RandomState::with_seeds(1, 2, 3, 4);
+    test_hash_common_words(&build_hasher);
+    let sequence: Vec<_> = (0..320000).collect();
+    check_for_collisions(&build_hasher, &sequence, 32);
+    let sequence: Vec<_> = (0..2560000).collect();
+    check_for_collisions(&build_hasher, &sequence, 256);
+    let sequence: Vec<_> = (0..320000).map(|i| i * 1024).collect();
+    check_for_collisions(&build_hasher, &sequence, 32);
+    let sequence: Vec<_> = (0..2560000_u64).map(|i| i * 1024).collect();
+    check_for_collisions(&build_hasher, &sequence, 256);
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn test_ahash_alias_map_construction() {
+    let mut map = ahash::HashMap::default();
+    map.insert(1, "test");
+    use ahash::HashMapExt;
+    let mut map = ahash::HashMap::with_capacity(1234);
+    map.insert(1, "test");
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn test_ahash_alias_set_construction() {
+    let mut set = ahash::HashSet::default();
+    set.insert(1);
+
+    use ahash::HashSetExt;
+    let mut set = ahash::HashSet::with_capacity(1235);
+    set.insert(1);
+}
+
+
+#[cfg(feature = "std")]
+#[test]
+fn test_key_ref() {
+    let mut map = ahash::HashMap::default();
+    map.insert(1, "test");
+    assert_eq!(Some((1, "test")), map.remove_entry(&1));
+
+    let mut map = ahash::HashMap::default();
+    map.insert(&1, "test");
+    assert_eq!(Some((&1, "test")), map.remove_entry(&&1));
+
+    let mut m = ahash::HashSet::<Box<String>>::default();
+    m.insert(Box::from("hello".to_string()));
+    assert!(m.contains(&"hello".to_string()));
+
+    let mut m = ahash::HashSet::<String>::default();
+    m.insert("hello".to_string());
+    assert!(m.contains("hello"));
+
+    let mut m = ahash::HashSet::<Box<[u8]>>::default();
+    m.insert(Box::from(&b"hello"[..]));
+    assert!(m.contains(&b"hello"[..]));
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn test_byte_dist() {
+    use rand::{SeedableRng, Rng, RngCore};
+    use pcg_mwc::Mwc256XXA64;
+
+    let mut r = Mwc256XXA64::seed_from_u64(0xe786_c22b_119c_1479);
+    let mut lowest = 2.541;
+    let mut highest = 2.541;
+    for _round in 0..100 {
+        let mut table: [bool; 256 * 8] = [false; 256 * 8];
+        let hasher = RandomState::with_seeds(r.gen(), r.gen(), r.gen(), r.gen());
+        for i in 0..128 {
+            let mut keys: [u8; 8] = hasher.hash_one((i as u64) << 30).to_ne_bytes();
+            //let mut keys = r.next_u64().to_ne_bytes(); //This is a control to test assert sensitivity.
+            for idx in 0..8 {
+                while table[idx * 256 + keys[idx] as usize] {
+                    keys[idx] = keys[idx].wrapping_add(1);
+                }
+                table[idx * 256 + keys[idx] as usize] = true;
+            }
+        }
+
+        for idx in 0..8 {
+            let mut len = 0;
+            let mut total_len = 0;
+            let mut num_seq = 0;
+            for i in 0..256 {
+                if table[idx * 256 + i] {
+                    len += 1;
+                } else if len != 0 {
+                    num_seq += 1;
+                    total_len += len;
+                    len = 0;
+                }
+            }
+            let mean = total_len as f32 / num_seq as f32;
+            println!("Mean sequence length = {}", mean);
+            if mean > highest {
+                highest = mean;
+            }
+            if mean < lowest {
+                lowest = mean;
+            }
+        }
+    }
+    assert!(lowest > 1.9, "Lowest = {}", lowest);
+    assert!(highest < 3.9, "Highest = {}", highest);
+}
+
+
+fn ahash_vec<H: Hash>(b: &Vec<H>) -> u64 {
+    let mut total: u64 = 0;
+    for item in b {
+        let mut hasher = RandomState::with_seeds(12, 34, 56, 78).build_hasher();
+        item.hash(&mut hasher);
+        total = total.wrapping_add(hasher.finish());
+    }
+    total
+}
+
+fn fxhash_vec<H: Hash>(b: &Vec<H>) -> u64 {
+    let mut total: u64 = 0;
+    for item in b {
+        let mut hasher = FxHasher::default();
+        item.hash(&mut hasher);
+        total = total.wrapping_add(hasher.finish());
+    }
+    total
+}
+
+fn bench_ahash_words(c: &mut Criterion) {
+    let words = gen_word_pairs();
+    c.bench_function("aes_words", |b| b.iter(|| black_box(ahash_vec(&words))));
+}
+
+fn bench_fx_words(c: &mut Criterion) {
+    let words = gen_word_pairs();
+    c.bench_function("fx_words", |b| b.iter(|| black_box(fxhash_vec(&words))));
+}
+
+criterion_main!(benches);
+criterion_group!(benches, bench_ahash_words, bench_fx_words,);

data/ext/cargo-vendor/anyhow-1.0.83/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"dea5c3e32cc7450ab3513f3d59face43ce79fb99b514832fd9141a68a7a0612e","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"6e608b9068b4ebab4b85944f047ea386f0288a99c615ac4a32ac45a7da4e5e33","build.rs":"22179bef46f3656c2436c97c2ac9751b26bbd04b67686ea6d75652aa92551fa7","build/probe.rs":"b8b792036f13c9c1fbc6b1244198ea2305e61ddfcda3856563b581dcb1e1fe6e","rust-toolchain.toml":"6bbb61302978c736b2da03e4fb40e3beab908f85d533ab46fd541e637b5f3e0f","src/backtrace.rs":"ea40abc828b93d01272c2d9f4254502ed34934e8c86fc2eac883dd972a09d8b2","src/chain.rs":"e83ee788dc5bb6bebba64356b35abbd5b624f2449d47e3716d02b2473fb8e5c5","src/context.rs":"04e4b80b9f6d8163edc53455b98ab0c40cb9ad104bcf0c74f8075f22024471ab","src/ensure.rs":"d4c2588608e529275bfee1c1afc8860d7def868ab01e95a692a995ee06b2936e","src/error.rs":"a274234af662770340b237c9016beea2f94e7906f3fe69d0d78057929889f25b","src/fmt.rs":"adf4be906b29900153bfb4b767a6049d58697dc3bcce7dfbb85ca773f5de5b33","src/kind.rs":"febaac378b8bfca7b95a76c9bf9fbd8ccdfd0cc1a6277cdc109a2cda5763f16e","src/lib.rs":"0f9901d0bef90203c0a742bb15eebb98adb36406a92eeeb796eae258460f8dcd","src/macros.rs":"17fb103e68a5befa768857314c3ca4d81d1dacfea0738bbb9c7597a485243499","src/ptr.rs":"4cb31d2f815b178daf951bfb94a1930383e056c0ca68d494603f45d8eea35d50","src/wrapper.rs":"4ffdf284d45fee90f11a48e59c493ed1114e1243903ceb265fa89cd4c8c0d338","tests/common/mod.rs":"f9088c2d7afafa64ff730b629272045b776bfafc2f5957508242da630635f2e1","tests/compiletest.rs":"022a8e400ef813d7ea1875b944549cee5125f6a995dc33e93b48cba3e1b57bd1","tests/drop/mod.rs":"08c3e553c1cc0d2dbd936fc45f4b5b1105057186affd6865e8d261e05f0f0646","tests/test_autotrait.rs":"ecccf9202a33611f64b76598806aa82abec2560ae058e32f63fb2fb3ef225be9","tests/test_backtrace.rs":"ed144f90bf62cc441de067f6cee09ece94bca9da8f9b492d11d3dc652ba83e26","tests/test_boxed.rs":"6b26db0e2eb72afe9af7352ea820837aab90f8d486294616dd5dc34c1b94038c","tests/test_chain.rs":"3a8a8d7569913bd98c0e27c69d0bda35101e7fde7c056ed57cdd8ed018e4cbcb","tests/test_context.rs":"8409c53b328562c11e822bd6c3cd17e0d4d50b9bbb8fc3617333fd77303a6a33","tests/test_convert.rs":"7e7a8b4772a427a911014ac4d1083f9519000e786177f898808980dd9bdfde61","tests/test_downcast.rs":"797e69a72d125758c4c4897e5dc776d549d52cc9a6a633e0a33193f588a62b88","tests/test_ensure.rs":"2cd7d9492604dfcb9f81f595e93c559eb8b1881d54b1859ffac42bd1676457dd","tests/test_ffi.rs":"d0cb4c1d6d9154090982dee72ae3ebe05a5981f976058c3250f1c9da5a45edef","tests/test_fmt.rs":"81b14dd207ba5fbf02aaed031646810906c9c9c2fc5cabffc8e88f82462be499","tests/test_macros.rs":"5172f82a6ad25b75f668f6419d161de3d12b8666d54701739fe33e86e4ddf148","tests/test_repr.rs":"034dee888abd08741e11ac2e95ef4fcb2ab3943d0a76e8e976db404658e1a252","tests/test_source.rs":"b80723cf635a4f8c4df21891b34bfab9ed2b2aa407e7a2f826d24e334cd5f88e","tests/ui/chained-comparison.rs":"6504b03d95b5acc232a7f4defc9f343b2be6733bf475fa0992e8e6545b912bd4","tests/ui/chained-comparison.stderr":"7f1d0a8c251b0ede2d30b3087ec157fc660945c97a642c4a5acf5a14ec58de34","tests/ui/empty-ensure.rs":"ab5bf37c846a0d689f26ce9257a27228411ed64154f9c950f1602d88a355d94b","tests/ui/empty-ensure.stderr":"315782f5f4246290fe190e3767b22c3dcaffaabc19c5ace0373537d53e765278","tests/ui/must-use.rs":"fb59860b43f673bf4a430a6036ba463e95028844d8dd4243cfe5ebc7f2be582f","tests/ui/must-use.stderr":"c2848c5f254b4c061eea6714d9baf709924aba06619eaf2a8b3aee1266b75f9e","tests/ui/no-impl.rs":"fab6cbf2f6ea510b86f567dfb3b7c31250a9fd71ae5d110dbb9188be569ec593","tests/ui/no-impl.stderr":"0d8ed712d25de898eae18cfdffc575a47f4d5596346058cf6cd50d016c4f8ce8","tests/ui/temporary-value.rs":"4dcc96271b2403e6372cf4cfc813445e5ce4365fc6e156b6bc38274098499a70","tests/ui/temporary-value.stderr":"171f6c1c962503855480696e5d39e68946ec2a027b61a6f36ca1ad1b40265c5d","tests/ui/wrong-interpolation.rs":"9c44d4674c2dccd27b9dedd03341346ec02d993b41793ee89b5755202e7e367e","tests/ui/wrong-interpolation.stderr":"301e60e2eb9401782c7dc0b3580613a4cb2aafd4cc8065734a630a62e1161aa5"},"package":"25bdb32cbbdce2b519a9cd7df3a678443100e265d5e25ca763b7572a5104f5f3"}

data/ext/cargo-vendor/anyhow-1.0.83/Cargo.toml

@@ -0,0 +1,130 @@
+# 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"
+rust-version = "1.39"
+name = "anyhow"
+version = "1.0.83"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+build = "build.rs"
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Flexible concrete Error type built on std::error::Error"
+documentation = "https://docs.rs/anyhow"
+readme = "README.md"
+keywords = [
+    "error",
+    "error-handling",
+]
+categories = [
+    "rust-patterns",
+    "no-std",
+]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/dtolnay/anyhow"
+
+[package.metadata.docs.rs]
+rustdoc-args = [
+    "--cfg",
+    "doc_cfg",
+    "--generate-link-to-definition",
+]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+name = "anyhow"
+path = "src/lib.rs"
+doc-scrape-examples = false
+
+[[test]]
+name = "test_ensure"
+path = "tests/test_ensure.rs"
+
+[[test]]
+name = "test_chain"
+path = "tests/test_chain.rs"
+
+[[test]]
+name = "test_fmt"
+path = "tests/test_fmt.rs"
+
+[[test]]
+name = "test_source"
+path = "tests/test_source.rs"
+
+[[test]]
+name = "test_repr"
+path = "tests/test_repr.rs"
+
+[[test]]
+name = "test_autotrait"
+path = "tests/test_autotrait.rs"
+
+[[test]]
+name = "test_boxed"
+path = "tests/test_boxed.rs"
+
+[[test]]
+name = "test_backtrace"
+path = "tests/test_backtrace.rs"
+
+[[test]]
+name = "test_convert"
+path = "tests/test_convert.rs"
+
+[[test]]
+name = "test_macros"
+path = "tests/test_macros.rs"
+
+[[test]]
+name = "compiletest"
+path = "tests/compiletest.rs"
+
+[[test]]
+name = "test_context"
+path = "tests/test_context.rs"
+
+[[test]]
+name = "test_ffi"
+path = "tests/test_ffi.rs"
+
+[[test]]
+name = "test_downcast"
+path = "tests/test_downcast.rs"
+
+[dependencies.backtrace]
+version = "0.3.51"
+optional = true
+
+[dev-dependencies.futures]
+version = "0.3"
+default-features = false
+
+[dev-dependencies.rustversion]
+version = "1.0.6"
+
+[dev-dependencies.syn]
+version = "2.0"
+features = ["full"]
+
+[dev-dependencies.thiserror]
+version = "1.0.45"
+
+[dev-dependencies.trybuild]
+version = "1.0.66"
+features = ["diff"]
+
+[features]
+default = ["std"]
+std = []