wasmtime 11.0.0 → 12.0.1

data/ext/cargo-vendor/cranelift-wasm-0.99.1/src/sections_translator.rs

@@ -0,0 +1,420 @@
+//! Helper functions to gather information for each of the non-function sections of a
+//! WebAssembly module.
+//!
+//! The code of these helper functions is straightforward since they only read metadata
+//! about linear memories, tables, globals, etc. and store them for later use.
+//!
+//! The special case of the initialize expressions for table elements offsets or global variables
+//! is handled, according to the semantics of WebAssembly, to only specific expressions that are
+//! interpreted on the fly.
+use crate::environ::ModuleEnvironment;
+use crate::wasm_unsupported;
+use crate::{
+    DataIndex, ElemIndex, FuncIndex, GlobalIndex, GlobalInit, Memory, MemoryIndex, TableIndex, Tag,
+    TagIndex, TypeIndex, WasmError, WasmResult,
+};
+use cranelift_entity::packed_option::ReservedValue;
+use cranelift_entity::EntityRef;
+use std::boxed::Box;
+use std::vec::Vec;
+use wasmparser::{
+    self, Data, DataKind, DataSectionReader, Element, ElementItems, ElementKind,
+    ElementSectionReader, Export, ExportSectionReader, ExternalKind, FunctionSectionReader,
+    GlobalSectionReader, ImportSectionReader, MemorySectionReader, MemoryType, NameSectionReader,
+    Naming, Operator, StructuralType, TableSectionReader, TagSectionReader, TagType, TypeRef,
+    TypeSectionReader,
+};
+
+fn memory(ty: MemoryType) -> Memory {
+    Memory {
+        minimum: ty.initial,
+        maximum: ty.maximum,
+        shared: ty.shared,
+        memory64: ty.memory64,
+    }
+}
+
+fn tag(e: TagType) -> Tag {
+    match e.kind {
+        wasmparser::TagKind::Exception => Tag {
+            ty: TypeIndex::from_u32(e.func_type_idx),
+        },
+    }
+}
+
+/// Parses the Type section of the wasm module.
+pub fn parse_type_section<'a>(
+    types: TypeSectionReader<'a>,
+    environ: &mut dyn ModuleEnvironment<'a>,
+) -> WasmResult<()> {
+    let count = types.count();
+    environ.reserve_types(count)?;
+
+    for entry in types {
+        let entry = entry?;
+        if entry.is_final || entry.supertype_idx.is_some() {
+            unimplemented!("gc proposal");
+        }
+        match entry.structural_type {
+            StructuralType::Func(wasm_func_ty) => {
+                let ty = environ.convert_func_type(&wasm_func_ty);
+                environ.declare_type_func(ty)?;
+            }
+            StructuralType::Array(_) | StructuralType::Struct(_) => {
+                unimplemented!("gc proposal");
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Parses the Import section of the wasm module.
+pub fn parse_import_section<'data>(
+    imports: ImportSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_imports(imports.count())?;
+
+    for entry in imports {
+        let import = entry?;
+        match import.ty {
+            TypeRef::Func(sig) => {
+                environ.declare_func_import(
+                    TypeIndex::from_u32(sig),
+                    import.module,
+                    import.name,
+                )?;
+            }
+            TypeRef::Memory(ty) => {
+                environ.declare_memory_import(memory(ty), import.module, import.name)?;
+            }
+            TypeRef::Tag(e) => {
+                environ.declare_tag_import(tag(e), import.module, import.name)?;
+            }
+            TypeRef::Global(ty) => {
+                let ty = environ.convert_global_type(&ty);
+                environ.declare_global_import(ty, import.module, import.name)?;
+            }
+            TypeRef::Table(ty) => {
+                let ty = environ.convert_table_type(&ty);
+                environ.declare_table_import(ty, import.module, import.name)?;
+            }
+        }
+    }
+
+    environ.finish_imports()?;
+    Ok(())
+}
+
+/// Parses the Function section of the wasm module.
+pub fn parse_function_section(
+    functions: FunctionSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    let num_functions = functions.count();
+    if num_functions == std::u32::MAX {
+        // We reserve `u32::MAX` for our own use in cranelift-entity.
+        return Err(WasmError::ImplLimitExceeded);
+    }
+
+    environ.reserve_func_types(num_functions)?;
+
+    for entry in functions {
+        let sigindex = entry?;
+        environ.declare_func_type(TypeIndex::from_u32(sigindex))?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Table section of the wasm module.
+pub fn parse_table_section(
+    tables: TableSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_tables(tables.count())?;
+
+    for entry in tables {
+        let ty = environ.convert_table_type(&entry?.ty);
+        environ.declare_table(ty)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Memory section of the wasm module.
+pub fn parse_memory_section(
+    memories: MemorySectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_memories(memories.count())?;
+
+    for entry in memories {
+        let memory = memory(entry?);
+        environ.declare_memory(memory)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Tag section of the wasm module.
+pub fn parse_tag_section(
+    tags: TagSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_tags(tags.count())?;
+
+    for entry in tags {
+        let tag = tag(entry?);
+        environ.declare_tag(tag)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Global section of the wasm module.
+pub fn parse_global_section(
+    globals: GlobalSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_globals(globals.count())?;
+
+    for entry in globals {
+        let wasmparser::Global { ty, init_expr } = entry?;
+        let mut init_expr_reader = init_expr.get_binary_reader();
+        let initializer = match init_expr_reader.read_operator()? {
+            Operator::I32Const { value } => GlobalInit::I32Const(value),
+            Operator::I64Const { value } => GlobalInit::I64Const(value),
+            Operator::F32Const { value } => GlobalInit::F32Const(value.bits()),
+            Operator::F64Const { value } => GlobalInit::F64Const(value.bits()),
+            Operator::V128Const { value } => {
+                GlobalInit::V128Const(u128::from_le_bytes(*value.bytes()))
+            }
+            Operator::RefNull { hty: _ } => GlobalInit::RefNullConst,
+            Operator::RefFunc { function_index } => {
+                GlobalInit::RefFunc(FuncIndex::from_u32(function_index))
+            }
+            Operator::GlobalGet { global_index } => {
+                GlobalInit::GetGlobal(GlobalIndex::from_u32(global_index))
+            }
+            ref s => {
+                return Err(wasm_unsupported!(
+                    "unsupported init expr in global section: {:?}",
+                    s
+                ));
+            }
+        };
+        let ty = environ.convert_global_type(&ty);
+        environ.declare_global(ty, initializer)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Export section of the wasm module.
+pub fn parse_export_section<'data>(
+    exports: ExportSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_exports(exports.count())?;
+
+    for entry in exports {
+        let Export {
+            name,
+            ref kind,
+            index,
+        } = entry?;
+
+        // The input has already been validated, so we should be able to
+        // assume valid UTF-8 and use `from_utf8_unchecked` if performance
+        // becomes a concern here.
+        let index = index as usize;
+        match *kind {
+            ExternalKind::Func => environ.declare_func_export(FuncIndex::new(index), name)?,
+            ExternalKind::Table => environ.declare_table_export(TableIndex::new(index), name)?,
+            ExternalKind::Memory => environ.declare_memory_export(MemoryIndex::new(index), name)?,
+            ExternalKind::Tag => environ.declare_tag_export(TagIndex::new(index), name)?,
+            ExternalKind::Global => environ.declare_global_export(GlobalIndex::new(index), name)?,
+        }
+    }
+
+    environ.finish_exports()?;
+    Ok(())
+}
+
+/// Parses the Start section of the wasm module.
+pub fn parse_start_section(index: u32, environ: &mut dyn ModuleEnvironment) -> WasmResult<()> {
+    environ.declare_start_func(FuncIndex::from_u32(index))?;
+    Ok(())
+}
+
+fn read_elems(items: &ElementItems) -> WasmResult<Box<[FuncIndex]>> {
+    let mut elems = Vec::new();
+    match items {
+        ElementItems::Functions(funcs) => {
+            for func in funcs.clone() {
+                elems.push(FuncIndex::from_u32(func?));
+            }
+        }
+        ElementItems::Expressions(_ty, funcs) => {
+            for func in funcs.clone() {
+                let idx = match func?.get_binary_reader().read_operator()? {
+                    Operator::RefNull { .. } => FuncIndex::reserved_value(),
+                    Operator::RefFunc { function_index } => FuncIndex::from_u32(function_index),
+                    s => {
+                        return Err(WasmError::Unsupported(format!(
+                            "unsupported init expr in element section: {:?}",
+                            s
+                        )));
+                    }
+                };
+                elems.push(idx);
+            }
+        }
+    }
+    Ok(elems.into_boxed_slice())
+}
+
+/// Parses the Element section of the wasm module.
+pub fn parse_element_section<'data>(
+    elements: ElementSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_table_elements(elements.count())?;
+
+    for (index, entry) in elements.into_iter().enumerate() {
+        let Element {
+            kind,
+            items,
+            range: _,
+        } = entry?;
+        let segments = read_elems(&items)?;
+        match kind {
+            ElementKind::Active {
+                table_index,
+                offset_expr,
+            } => {
+                let mut offset_expr_reader = offset_expr.get_binary_reader();
+                let (base, offset) = match offset_expr_reader.read_operator()? {
+                    Operator::I32Const { value } => (None, value as u32),
+                    Operator::GlobalGet { global_index } => {
+                        (Some(GlobalIndex::from_u32(global_index)), 0)
+                    }
+                    ref s => {
+                        return Err(wasm_unsupported!(
+                            "unsupported init expr in element section: {:?}",
+                            s
+                        ));
+                    }
+                };
+                environ.declare_table_elements(
+                    TableIndex::from_u32(table_index.unwrap_or(0)),
+                    base,
+                    offset,
+                    segments,
+                )?
+            }
+            ElementKind::Passive => {
+                let index = ElemIndex::from_u32(index as u32);
+                environ.declare_passive_element(index, segments)?;
+            }
+            ElementKind::Declared => {
+                environ.declare_elements(segments)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Parses the Data section of the wasm module.
+pub fn parse_data_section<'data>(
+    data: DataSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_data_initializers(data.count())?;
+
+    for (index, entry) in data.into_iter().enumerate() {
+        let Data {
+            kind,
+            data,
+            range: _,
+        } = entry?;
+        match kind {
+            DataKind::Active {
+                memory_index,
+                offset_expr,
+            } => {
+                let mut offset_expr_reader = offset_expr.get_binary_reader();
+                let (base, offset) = match offset_expr_reader.read_operator()? {
+                    Operator::I32Const { value } => (None, value as u64),
+                    Operator::I64Const { value } => (None, value as u64),
+                    Operator::GlobalGet { global_index } => {
+                        (Some(GlobalIndex::from_u32(global_index)), 0)
+                    }
+                    ref s => {
+                        return Err(wasm_unsupported!(
+                            "unsupported init expr in data section: {:?}",
+                            s
+                        ))
+                    }
+                };
+                environ.declare_data_initialization(
+                    MemoryIndex::from_u32(memory_index),
+                    base,
+                    offset,
+                    data,
+                )?;
+            }
+            DataKind::Passive => {
+                let index = DataIndex::from_u32(index as u32);
+                environ.declare_passive_data(index, data)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Parses the Name section of the wasm module.
+pub fn parse_name_section<'data>(
+    names: NameSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    for subsection in names {
+        match subsection? {
+            wasmparser::Name::Function(names) => {
+                for name in names {
+                    let Naming { index, name } = name?;
+                    // We reserve `u32::MAX` for our own use in cranelift-entity.
+                    if index != u32::max_value() {
+                        environ.declare_func_name(FuncIndex::from_u32(index), name);
+                    }
+                }
+            }
+            wasmparser::Name::Module { name, .. } => {
+                environ.declare_module_name(name);
+            }
+            wasmparser::Name::Local(reader) => {
+                for f in reader {
+                    let f = f?;
+                    if f.index == u32::max_value() {
+                        continue;
+                    }
+                    for name in f.names {
+                        let Naming { index, name } = name?;
+                        environ.declare_local_name(FuncIndex::from_u32(f.index), index, name)
+                    }
+                }
+            }
+            wasmparser::Name::Label(_)
+            | wasmparser::Name::Type(_)
+            | wasmparser::Name::Table(_)
+            | wasmparser::Name::Global(_)
+            | wasmparser::Name::Memory(_)
+            | wasmparser::Name::Element(_)
+            | wasmparser::Name::Data(_)
+            | wasmparser::Name::Unknown { .. } => {}
+        }
+    }
+    Ok(())
+}

data/ext/cargo-vendor/cranelift-wasm-0.99.1/tests/wasm_testsuite.rs

@@ -0,0 +1,153 @@
+use cranelift_codegen::isa::{CallConv, TargetFrontendConfig};
+use cranelift_codegen::print_errors::pretty_verifier_error;
+use cranelift_codegen::settings::{self, Flags};
+use cranelift_codegen::verifier;
+use cranelift_wasm::{translate_module, DummyEnvironment, FuncIndex};
+use std::fs;
+use std::path::Path;
+use target_lexicon::PointerWidth;
+
+#[test]
+fn testsuite() {
+    let mut paths: Vec<_> = fs::read_dir("./wasmtests")
+        .unwrap()
+        .map(|r| r.unwrap())
+        .filter(|p| {
+            // Ignore files starting with `.`, which could be editor temporary files
+            if let Some(stem) = p.path().file_stem() {
+                if let Some(stemstr) = stem.to_str() {
+                    return !stemstr.starts_with('.');
+                }
+            }
+            false
+        })
+        .collect();
+    paths.sort_by_key(|dir| dir.path());
+    let flags = Flags::new(settings::builder());
+    for path in paths {
+        let path = path.path();
+        println!("=== {} ===", path.display());
+        let data = read_module(&path);
+        handle_module(data, &flags);
+    }
+}
+
+#[test]
+fn use_name_section() {
+    let data = wat::parse_str(
+        r#"
+        (module $module_name
+            (func $func_name (local $loc_name i32)
+            )
+        )"#,
+    )
+    .unwrap();
+
+    let mut dummy_environ = DummyEnvironment::new(TargetFrontendConfig {
+        default_call_conv: CallConv::SystemV,
+        pointer_width: PointerWidth::U32,
+    });
+
+    translate_module(data.as_ref(), &mut dummy_environ).unwrap();
+
+    assert_eq!(
+        dummy_environ.get_func_name(FuncIndex::from_u32(0)).unwrap(),
+        "func_name"
+    );
+}
+
+fn read_module(path: &Path) -> Vec<u8> {
+    match path.extension() {
+        None => {
+            panic!("the file extension is not wasm or wat");
+        }
+        Some(ext) => match ext.to_str() {
+            Some("wasm") => std::fs::read(path).expect("error reading wasm file"),
+            Some("wat") => wat::parse_file(path)
+                .map_err(|e| e.to_string())
+                .expect("failed to parse wat"),
+            None | Some(&_) => panic!("the file extension for {:?} is not wasm or wat", path),
+        },
+    }
+}
+
+fn handle_module(data: Vec<u8>, flags: &Flags) {
+    let mut dummy_environ = DummyEnvironment::new(TargetFrontendConfig {
+        default_call_conv: CallConv::SystemV,
+        pointer_width: PointerWidth::U64,
+    });
+
+    translate_module(&data, &mut dummy_environ).unwrap();
+
+    for func in dummy_environ.info.function_bodies.values() {
+        verifier::verify_function(func, flags)
+            .map_err(|errors| panic!("{}", pretty_verifier_error(func, None, errors)))
+            .unwrap();
+    }
+}
+
+#[test]
+fn reachability_is_correct() {
+    let tests = vec![
+        (
+            r#"
+        (module (func (param i32)
+         (loop
+          (block
+           local.get 0
+           br_if 0
+           br 1))))"#,
+            vec![
+                (true, true),  // Loop
+                (true, true),  // Block
+                (true, true),  // LocalGet
+                (true, true),  // BrIf
+                (true, false), // Br
+                (false, true), // End
+                (true, true),  // End
+                (true, true),  // End
+            ],
+        ),
+        (
+            r#"
+        (module (func (param i32)
+         (loop
+          (block
+           br 1
+           nop))))"#,
+            vec![
+                (true, true),   // Loop
+                (true, true),   // Block
+                (true, false),  // Br
+                (false, false), // Nop
+                (false, false), // Nop
+                (false, false), // Nop
+                (false, false), // End
+            ],
+        ),
+        (
+            r#"
+        (module (func (param i32) (result i32)
+          i32.const 1
+          return
+          i32.const 42))"#,
+            vec![
+                (true, true),   // I32Const
+                (true, false),  // Return
+                (false, false), // I32Const
+                (false, false), // End
+            ],
+        ),
+    ];
+
+    for (wat, expected_reachability) in tests {
+        println!("testing wat:\n{}", wat);
+        let mut env = DummyEnvironment::new(TargetFrontendConfig {
+            default_call_conv: CallConv::SystemV,
+            pointer_width: PointerWidth::U64,
+        });
+        env.test_expected_reachability(expected_reachability);
+        let data = wat::parse_str(wat).unwrap();
+        translate_module(data.as_ref(), &mut env).unwrap();
+    }
+}

data/ext/cargo-vendor/fs-set-times-0.20.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"CODE_OF_CONDUCT.md":"f33ae4ad95574e715b8a9da0674dae8c03f849166117feb1d6fabe17a1130031","COPYRIGHT":"e196ffeb5ab101e9ec8bbe395c9f367c5380ee2d28c47e5c03371523798a9af7","Cargo.toml":"d0b469a7cb47450d166a1e53343130f830c5fb96ef2388571260f2928d4a7362","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-Apache-2.0_WITH_LLVM-exception":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","ORG_CODE_OF_CONDUCT.md":"a62b69bf86e605ee1bcbb2f0a12ba79e4cebb6983a7b6491949750aecc4f2178","README.md":"72d68487884aed494cae030f0dc6e288f41f3a7237984e6aa824742f09827036","SECURITY.md":"4d75afb09dd28eb5982e3a1f768ee398d90204669ceef3240a16b31dcf04148a","src/lib.rs":"87fc968b87a2a5e6f17c67db27d42ee83282af9f97c623777609a7403b79ea84","src/set_times.rs":"518cb1d7b319039a66991f1592cf2f78123d2c5d8fdcc325dfdc053600e144eb","src/system_time_spec.rs":"5013826089a1cbd77a5002d1159c36f621dc7ccca03d958fcc7a5014077547ea"},"package":"dd738b84894214045e8414eaded76359b4a5773f0a0a56b16575110739cdcf39"}

data/ext/cargo-vendor/fs-set-times-0.20.0/Cargo.toml

@@ -0,0 +1,45 @@
+# 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 = "fs-set-times"
+version = "0.20.0"
+authors = ["Dan Gohman <dev@sunfishcode.online>"]
+exclude = ["/.github"]
+description = "Set filesystem timestamps"
+documentation = "https://docs.rs/fs-set-times"
+readme = "README.md"
+keywords = [
+    "api",
+    "file",
+]
+categories = ["filesystem"]
+license = "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT"
+repository = "https://github.com/bytecodealliance/fs-set-times"
+
+[dependencies.io-lifetimes]
+version = "2.0.0"
+default-features = false
+
+[target."cfg(not(windows))".dependencies.rustix]
+version = "0.38.0"
+features = [
+    "fs",
+    "time",
+]
+
+[target."cfg(windows)".dependencies.windows-sys]
+version = "0.48.0"
+features = [
+    "Win32_Foundation",
+    "Win32_Storage_FileSystem",
+]

data/ext/cargo-vendor/futures-0.3.28/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"f6608fc3b8f2c4ceff1d038056f9ae359c2c77d72f83158867abcf53a4c957b0","LICENSE-APACHE":"275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427","LICENSE-MIT":"6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd","README.md":"842d0b8a539ab13ba2b9863cd8fb27da4fc7e9def1aefeb21db5aa04269b1e34","src/lib.rs":"bb07f533ba89a36c0385b57de17d51bf23ccab9e13e00ec812a74f376df15930","tests/_require_features.rs":"5ad24019430b498addfc1fd853e955c7b646d78d0727a8ca29f586c9aab45cff","tests/async_await_macros.rs":"87863f5b73217d727a4789d69229ab5dd85252b8e76a1aca0220feb98a0922af","tests/auto_traits.rs":"d5e0e5ed4b6b93103a5d5725cca87b3c65a07c3f891f8c8f52e7d66e3a991833","tests/bilock.rs":"bd0bf617352528f686b3fbb1847f4da9f6fe351e456e0bdce888bc738311fa83","tests/compat.rs":"1449926cc046d2ae9f86a263efd9353ca8e174ea546c083b360136c5a2aef1d1","tests/eager_drop.rs":"dc25d067207c06bbe094752d70bf161e206f00e162ffa3219583c8b4eb0816a1","tests/eventual.rs":"9050809e5196d0870a3ee2a268a5b4b398739b01617e1e317a673ac0660974cf","tests/future_abortable.rs":"4c81607472a85c5d87a5fe8a510a24cf1e8793fedf7f6cd6741ba1efd66615cd","tests/future_basic_combinators.rs":"4508c1250b85a4f749b7261bbd0ba728d3970e7ba277e84a006e76cf068fb54f","tests/future_fuse.rs":"bb63141f1486e755d0cdea1d93e302ad864a2186aa5287f909a0b3a922e82065","tests/future_inspect.rs":"9c03ceb770ce04fe9fd88a3489362642a0e34ae86a7b4958703e89e8b7a1ecf4","tests/future_join.rs":"f59d7b948df7019e52f902ca7aef17f89ad26582bd1902d520ba99f6f61ba508","tests/future_join_all.rs":"6adacfca4d33a769dbe72fd04c54b49580ecd7a9994a185cfe97dd7a2b55c298","tests/future_obj.rs":"a6aae88a194dc7d3bb961c20db78f180a01796cf7ea4bf106da98c40d89ed36d","tests/future_select_all.rs":"4cefc84d6b7ae2cf0007912cd0325fff6b926a4c26310e7b14a21868de61616f","tests/future_select_ok.rs":"1cabd03268641e1ac42b880344528bad73e3aeb6d6a8a141e652f339dd40184b","tests/future_shared.rs":"4f2cba1e74dacc4fc6b92eef04700df832533efe4fe6a392e3fd0f655b5b8450","tests/future_try_flatten_stream.rs":"aa4542b5d88f62522b736fac4567613081df45ad3eb54b0b659cdadc9409c4db","tests/future_try_join_all.rs":"cca2c5a3b42fe4bf9705301cd1450b30a3822736c5c09793eee06b28ce686a19","tests/io_buf_reader.rs":"1d60479224d5aa9378d4aed6246362b08a823ee7c9977f6a5e44fce7c40116be","tests/io_buf_writer.rs":"8f7a78ab2955d2beb69d0881321d4191235540aef6448e875e7f76a2ffc55b89","tests/io_cursor.rs":"cba5a7b968b9f816ac33316ce1e4da67cb320aa5a21332c0f9a45694fa445dd7","tests/io_line_writer.rs":"5b1140de776a721a677911496daa4e7956cc52cc08838d593ab300a93e0d7984","tests/io_lines.rs":"72a310c885591793ed724d0aa2158ac2c9d1af22de417044d96b714f78317586","tests/io_read.rs":"e0a8fa9b27e042f03c9fe14e8f0f329a67e24afad1ce40b906a1ab4d2abef23a","tests/io_read_exact.rs":"42049cd67589992dc09764ffb3836c475115b26dee441fd4cc7e847b2d166667","tests/io_read_line.rs":"f360c30c32fc8c73b371281e86c3f1095da7ef23b702debb30d335046dc77dac","tests/io_read_to_end.rs":"ea3e961e39a0b92930bded05e8ba26e4902461ab53818843d40fae8065b1a803","tests/io_read_to_string.rs":"824921601ac49f15b9a0b349c900f9cc9081cf2646e6a86f443166f841f1320e","tests/io_read_until.rs":"36d9a98149b2410894121ccba49e5134e3209826b2225acfc787016cea2bc92a","tests/io_window.rs":"0d18334b1eb35f5e93099e19c0cab22abe5971d8531176b81345fc89d07692a8","tests/io_write.rs":"701032ff3d5a6e6a3d8cb4e373d1c93e4708f2e5ee0a6742fa626f27b6094b4d","tests/lock_mutex.rs":"eb47121b842096353165b1444bf679a2df0103b181f811b40042f5c3f1d00c73","tests/macro_comma_support.rs":"627024ccadfe95194469d5bae2cc29b897b0118a664d7222408a2e234a10e939","tests/object_safety.rs":"9d047190387ed8334113687003c23407c80c858411f5ec7d5c505500f9639dfc","tests/oneshot.rs":"2109a8b3b524f4b36be9fb100f9b8c0d38bbd38d51716adcafdb65994b4a81d6","tests/ready_queue.rs":"6380025061025c27cb3b521df9520f169c7aa8e1802b881d539023bb4651744a","tests/recurse.rs":"b01b3d73b69ad90a767d297f974dac435817c39e12556fa6a3e6c725dd84f706","tests/sink.rs":"d9b2ddcbbb6af9e36d057db97dbba233547be645a7e4901b2842a4671f9f0212","tests/sink_fanout.rs":"67ab58422040308353955311f75222e55378e4cc34557c7b34140bd20c259132","tests/stream.rs":"049762ea6dad747cc9e7609f63487e25065a4c0032488e276f65fd522a07867c","tests/stream_abortable.rs":"60052b83b5eeb2395b77bc213f35098d2d5880529f0d83884582a8bbff78b139","tests/stream_buffer_unordered.rs":"143ee19056b9ee9e480903cf4a1b00da7d4e528c5804569bf8c40869e6ac6eed","tests/stream_catch_unwind.rs":"5cdaaf70436c49d3a7107bdc5547ddb8757c3d2057635aded70e485d0cb9cbfc","tests/stream_futures_ordered.rs":"f9083bd8cfa86620c51abffc390564432022b5c8d15a7cba15dd5cb53ae99dd6","tests/stream_futures_unordered.rs":"c888112d760db856e4d9191a2a6a3aa4a757d65e47a12fcd16fc5be7bf0b3e78","tests/stream_into_async_read.rs":"00ecb18289ebc8f46ea0cf43e0dce0631d7698bd1303a7bcd84d0addc9d8b645","tests/stream_peekable.rs":"c0addb0c510e13183ba3d6102633b75a9223651ae80a64542e913c712fe69a30","tests/stream_select_all.rs":"3a9045754939da5b30305e78f0571d79a03aaa77030c6ccf82225f076e9843c9","tests/stream_select_next_some.rs":"871edcee3ffc16c697251b29c9ba500aa4e3e503aa738748d7392e3462c82dce","tests/stream_split.rs":"074e9c9b51b6f7ea83d77347b5a0c8d414ca32b90445fec9b85f7f4cd2a6049f","tests/stream_try_stream.rs":"eba57cdda77f2aeee3a6059d5771c9a100f99a7eeb4460e7f7819803759fba86","tests/stream_unfold.rs":"7c6fbd10c782828793cbe1eb347ec776d99b185dad498e886f7161da76f76880","tests/task_arc_wake.rs":"5a49d074d1d5d9d5ec383dcd9a3868f636c1d7e34662e2573e467948db126206","tests/task_atomic_waker.rs":"8e85b4bc1360788646a52633dfe896d852773d6b482f81626cf534b97b7d937a","tests/test_macro.rs":"a46a946169c342c576936b60909165a50b94350501280ed9bba89d365af69287","tests/try_join.rs":"65f282f8351bd9a74642f2465c7aaf72ee7097002920989f156d60271652549e","tests_disabled/all.rs":"ddcd8fefb0d4a4a91a78328e7e652c35f93dc3669639d76fa0f56452b51abc23","tests_disabled/stream.rs":"8a615a472a35053d12b269d40fe244dfb3ba66fb78d217323aa2be177d5a111e"},"package":"23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"}