From 1cb115367ed399840c08dfd4a75fa6b9016d15bf Mon Sep 17 00:00:00 2001 From: Joshua Liebow-Feeser Date: Thu, 14 May 2026 21:44:08 +0000 Subject: [PATCH] [anneal][v2] (Buggy) atomic toolchain management This commit introduces an initial implementation of atomic toolchain installation and garbage collection. However, rigorous concurrency analysis has identified several critical race conditions and robustness flaws in this implementation: 1. Readdir TOCTOU Flaw: `fs::read_dir` is non-atomic. If a concurrent installation creates a temporary symlink and target directory mid-scan, GC can miss the symlink (if placed before the scan cursor in hash order) while discovering the directory (if placed after the cursor). GC will then delete the active directory while it is being populated. 2. Multiple Canonical Destinations Race: `gc` only performs post-iteration symlink verification on the single `dst` path passed to `install`. If multiple canonical toolchains (e.g., arm vs x86) share the parent directory, a concurrent update to another toolchain can be missed during `read_dir` and its valid directory deleted. 3. Unguarded Resource Leak: `std::os::unix::fs::symlink` and `fs::create_dir` are called before the RAII guard is armed. If directory creation fails or a panic occurs, orphaned temporary symlinks are left on disk permanently. 4. Infinite Spin-Loop on Deletion Errors: `while dir_path.exists()` in GC silently ignores all errors from `fs::remove_dir_all`. If a directory cannot be removed due to permission or I/O errors, the worker enters an infinite CPU lockup loop. 5. Readdir Metadata Abortion: Calling `entry.file_type()?` on filesystems where d_type is DT_UNKNOWN triggers `lstat`. If another thread deleted the entry concurrently, this fails with ENOENT and aborts the entire operation. Proposed Holistic Redesign: To address these flaws, we propose moving to a quiescent Readers-Writers synchronization model paired with structured artifact naming: - Directory Locking: Use POSIX file locking on `parent/.lock`. `install` acts as a Reader (`LOCK_SH`), allowing parallel installations. `gc` acts as a Writer (`LOCK_EX | LOCK_NB`), ensuring that garbage collection only runs when zero installations and zero other GC workers are active. - Quiescent Mark-and-Sweep: Under `LOCK_EX`, directory iteration is completely quiescent, eliminating readdir TOCTOU races and metadata deletion errors. - Structured Artifact Lifecycle: Arm the RAII guard prior to creating files. Prefix temporary files distinctively (e.g., `.tmp.*`), allowing GC under exclusive lock to safely identify and sweep any orphaned artifacts from terminated processes. - Unconditional Single Deletion: Remove the `while exists()` spin-loop and perform a single robust deletion per unreachable directory. gherrit-pr-id: G3gq762w6ejo7xxhycou2wdqjw7osy6qd --- .cargo/config.toml | 8 - anneal/.cargo/config.toml | 8 - anneal/v2/Cargo.lock | 536 ++++++ anneal/v2/Cargo.toml | 43 + anneal/v2/foo/Cargo.toml | 11 + anneal/v2/foo/src/atomic.rs | 310 ++++ anneal/v2/foo/src/lib.rs | 318 ++++ anneal/v2/src/main.rs | 19 + anneal/vendor/ascii/.cargo-checksum.json | 1 - anneal/vendor/ascii/.cargo_vcs_info.json | 6 - anneal/vendor/ascii/.github/workflows/ci.yml | 57 - anneal/vendor/ascii/Cargo.toml | 41 - anneal/vendor/ascii/Cargo.toml.orig | 22 - anneal/vendor/ascii/LICENSE-APACHE | 201 --- anneal/vendor/ascii/LICENSE-MIT | 22 - anneal/vendor/ascii/README.md | 64 - anneal/vendor/ascii/RELEASES.md | 193 -- anneal/vendor/ascii/src/ascii_char.rs | 1069 ----------- anneal/vendor/ascii/src/ascii_str.rs | 1600 ----------------- anneal/vendor/ascii/src/ascii_string.rs | 1057 ----------- anneal/vendor/ascii/src/free_functions.rs | 59 - anneal/vendor/ascii/src/lib.rs | 82 - .../ascii/src/serialization/ascii_char.rs | 89 - .../ascii/src/serialization/ascii_str.rs | 79 - .../ascii/src/serialization/ascii_string.rs | 149 -- anneal/vendor/ascii/src/serialization/mod.rs | 3 - anneal/vendor/ascii/tests.rs | 143 -- .../chunked_transfer/.cargo-checksum.json | 1 - .../chunked_transfer/.cargo_vcs_info.json | 6 - .../.github/workflows/rust.yml | 22 - anneal/vendor/chunked_transfer/Cargo.toml | 27 - .../vendor/chunked_transfer/Cargo.toml.orig | 15 - anneal/vendor/chunked_transfer/LICENSE-APACHE | 201 --- anneal/vendor/chunked_transfer/LICENSE-MIT | 22 - anneal/vendor/chunked_transfer/README.md | 59 - .../vendor/chunked_transfer/benches/encode.rs | 22 - anneal/vendor/chunked_transfer/src/decoder.rs | 300 ---- anneal/vendor/chunked_transfer/src/encoder.rs | 207 --- anneal/vendor/chunked_transfer/src/lib.rs | 5 - .../vendor/fancy-regex/.cargo-checksum.json | 2 +- .../tests/oniguruma/.gitattributes | 2 + anneal/vendor/httpdate/.cargo-checksum.json | 1 - anneal/vendor/httpdate/.cargo_vcs_info.json | 6 - .../vendor/httpdate/.github/workflows/ci.yml | 24 - anneal/vendor/httpdate/Cargo.toml | 35 - anneal/vendor/httpdate/Cargo.toml.orig | 18 - anneal/vendor/httpdate/LICENSE-APACHE | 201 --- anneal/vendor/httpdate/LICENSE-MIT | 19 - anneal/vendor/httpdate/README.md | 27 - anneal/vendor/httpdate/benches/benchmarks.rs | 57 - anneal/vendor/httpdate/src/date.rs | 420 ----- anneal/vendor/httpdate/src/lib.rs | 160 -- .../vendor/libtest-mimic/.cargo-checksum.json | 2 +- .../libtest-mimic/tests/real/.gitignore | 3 + .../portable-atomic/.cargo-checksum.json | 2 +- .../vendor/portable-atomic/tests/.gitignore | 1 + anneal/vendor/tiny_http/.cargo-checksum.json | 1 - anneal/vendor/tiny_http/.cargo_vcs_info.json | 6 - .../tiny_http/.github/workflows/ci.yaml | 64 - anneal/vendor/tiny_http/CHANGELOG.md | 172 -- anneal/vendor/tiny_http/Cargo.lock | 395 ---- anneal/vendor/tiny_http/Cargo.toml | 82 - anneal/vendor/tiny_http/Cargo.toml.orig | 37 - anneal/vendor/tiny_http/LICENSE-APACHE | 201 --- anneal/vendor/tiny_http/LICENSE-MIT | 25 - anneal/vendor/tiny_http/README.md | 108 -- anneal/vendor/tiny_http/benches/bench.rs | 80 - .../vendor/tiny_http/examples/hello-world.rs | 26 - .../tiny_http/examples/php-cgi-example.php | 3 - anneal/vendor/tiny_http/examples/php-cgi.rs | 95 - .../tiny_http/examples/readme-example.rs | 19 - .../vendor/tiny_http/examples/serve-root.rs | 58 - anneal/vendor/tiny_http/examples/ssl-cert.pem | 23 - anneal/vendor/tiny_http/examples/ssl-key.pem | 28 - anneal/vendor/tiny_http/examples/ssl.rs | 42 - .../vendor/tiny_http/examples/websockets.rs | 148 -- anneal/vendor/tiny_http/src/client.rs | 309 ---- anneal/vendor/tiny_http/src/common.rs | 440 ----- anneal/vendor/tiny_http/src/connection.rs | 194 -- anneal/vendor/tiny_http/src/lib.rs | 445 ----- anneal/vendor/tiny_http/src/request.rs | 518 ------ anneal/vendor/tiny_http/src/response.rs | 574 ------ anneal/vendor/tiny_http/src/ssl.rs | 20 - anneal/vendor/tiny_http/src/ssl/openssl.rs | 110 -- anneal/vendor/tiny_http/src/ssl/rustls.rs | 120 -- anneal/vendor/tiny_http/src/test.rs | 127 -- .../tiny_http/src/util/custom_stream.rs | 39 - .../vendor/tiny_http/src/util/equal_reader.rs | 131 -- .../vendor/tiny_http/src/util/fused_reader.rs | 48 - .../tiny_http/src/util/messages_queue.rs | 96 - anneal/vendor/tiny_http/src/util/mod.rs | 64 - .../tiny_http/src/util/refined_tcp_stream.rs | 152 -- .../vendor/tiny_http/src/util/sequential.rs | 174 -- anneal/vendor/tiny_http/src/util/task_pool.rs | 137 -- anneal/vendor/tiny_http/tests/input-tests.rs | 122 -- anneal/vendor/tiny_http/tests/network.rs | 222 --- .../tiny_http/tests/non-chunked-buffering.rs | 103 -- anneal/vendor/tiny_http/tests/promptness.rs | 207 --- anneal/vendor/tiny_http/tests/simple-test.rs | 29 - anneal/vendor/tiny_http/tests/support/mod.rs | 40 - anneal/vendor/tiny_http/tests/unblock-test.rs | 34 - anneal/vendor/tiny_http/tests/unix-test.rs | 44 - .../vendor/unicode-ident/.cargo-checksum.json | 2 +- .../vendor/unicode-ident/tests/fst/.gitignore | 1 + anneal/vendor/wasmparser/.cargo-checksum.json | 2 +- anneal/vendor/wasmparser/benches/.gitignore | 1 + .../vendor/wit-component/.cargo-checksum.json | 2 +- anneal/vendor/wit-component/tests/.gitignore | 2 + anneal/vendor/wit-parser/.cargo-checksum.json | 2 +- anneal/vendor/wit-parser/tests/.gitignore | 2 + 110 files changed, 1256 insertions(+), 12927 deletions(-) delete mode 100644 .cargo/config.toml delete mode 100644 anneal/.cargo/config.toml create mode 100644 anneal/v2/Cargo.lock create mode 100644 anneal/v2/Cargo.toml create mode 100644 anneal/v2/foo/Cargo.toml create mode 100644 anneal/v2/foo/src/atomic.rs create mode 100644 anneal/v2/foo/src/lib.rs create mode 100644 anneal/v2/src/main.rs delete mode 100644 anneal/vendor/ascii/.cargo-checksum.json delete mode 100644 anneal/vendor/ascii/.cargo_vcs_info.json delete mode 100644 anneal/vendor/ascii/.github/workflows/ci.yml delete mode 100644 anneal/vendor/ascii/Cargo.toml delete mode 100644 anneal/vendor/ascii/Cargo.toml.orig delete mode 100644 anneal/vendor/ascii/LICENSE-APACHE delete mode 100644 anneal/vendor/ascii/LICENSE-MIT delete mode 100644 anneal/vendor/ascii/README.md delete mode 100644 anneal/vendor/ascii/RELEASES.md delete mode 100644 anneal/vendor/ascii/src/ascii_char.rs delete mode 100644 anneal/vendor/ascii/src/ascii_str.rs delete mode 100644 anneal/vendor/ascii/src/ascii_string.rs delete mode 100644 anneal/vendor/ascii/src/free_functions.rs delete mode 100644 anneal/vendor/ascii/src/lib.rs delete mode 100644 anneal/vendor/ascii/src/serialization/ascii_char.rs delete mode 100644 anneal/vendor/ascii/src/serialization/ascii_str.rs delete mode 100644 anneal/vendor/ascii/src/serialization/ascii_string.rs delete mode 100644 anneal/vendor/ascii/src/serialization/mod.rs delete mode 100644 anneal/vendor/ascii/tests.rs delete mode 100644 anneal/vendor/chunked_transfer/.cargo-checksum.json delete mode 100644 anneal/vendor/chunked_transfer/.cargo_vcs_info.json delete mode 100644 anneal/vendor/chunked_transfer/.github/workflows/rust.yml delete mode 100644 anneal/vendor/chunked_transfer/Cargo.toml delete mode 100644 anneal/vendor/chunked_transfer/Cargo.toml.orig delete mode 100644 anneal/vendor/chunked_transfer/LICENSE-APACHE delete mode 100644 anneal/vendor/chunked_transfer/LICENSE-MIT delete mode 100644 anneal/vendor/chunked_transfer/README.md delete mode 100644 anneal/vendor/chunked_transfer/benches/encode.rs delete mode 100644 anneal/vendor/chunked_transfer/src/decoder.rs delete mode 100644 anneal/vendor/chunked_transfer/src/encoder.rs delete mode 100644 anneal/vendor/chunked_transfer/src/lib.rs create mode 100644 anneal/vendor/fancy-regex/tests/oniguruma/.gitattributes delete mode 100644 anneal/vendor/httpdate/.cargo-checksum.json delete mode 100644 anneal/vendor/httpdate/.cargo_vcs_info.json delete mode 100644 anneal/vendor/httpdate/.github/workflows/ci.yml delete mode 100644 anneal/vendor/httpdate/Cargo.toml delete mode 100644 anneal/vendor/httpdate/Cargo.toml.orig delete mode 100644 anneal/vendor/httpdate/LICENSE-APACHE delete mode 100644 anneal/vendor/httpdate/LICENSE-MIT delete mode 100644 anneal/vendor/httpdate/README.md delete mode 100644 anneal/vendor/httpdate/benches/benchmarks.rs delete mode 100644 anneal/vendor/httpdate/src/date.rs delete mode 100644 anneal/vendor/httpdate/src/lib.rs create mode 100644 anneal/vendor/libtest-mimic/tests/real/.gitignore create mode 100644 anneal/vendor/portable-atomic/tests/.gitignore delete mode 100644 anneal/vendor/tiny_http/.cargo-checksum.json delete mode 100644 anneal/vendor/tiny_http/.cargo_vcs_info.json delete mode 100644 anneal/vendor/tiny_http/.github/workflows/ci.yaml delete mode 100644 anneal/vendor/tiny_http/CHANGELOG.md delete mode 100644 anneal/vendor/tiny_http/Cargo.lock delete mode 100644 anneal/vendor/tiny_http/Cargo.toml delete mode 100644 anneal/vendor/tiny_http/Cargo.toml.orig delete mode 100644 anneal/vendor/tiny_http/LICENSE-APACHE delete mode 100644 anneal/vendor/tiny_http/LICENSE-MIT delete mode 100644 anneal/vendor/tiny_http/README.md delete mode 100644 anneal/vendor/tiny_http/benches/bench.rs delete mode 100644 anneal/vendor/tiny_http/examples/hello-world.rs delete mode 100644 anneal/vendor/tiny_http/examples/php-cgi-example.php delete mode 100644 anneal/vendor/tiny_http/examples/php-cgi.rs delete mode 100644 anneal/vendor/tiny_http/examples/readme-example.rs delete mode 100644 anneal/vendor/tiny_http/examples/serve-root.rs delete mode 100644 anneal/vendor/tiny_http/examples/ssl-cert.pem delete mode 100644 anneal/vendor/tiny_http/examples/ssl-key.pem delete mode 100644 anneal/vendor/tiny_http/examples/ssl.rs delete mode 100644 anneal/vendor/tiny_http/examples/websockets.rs delete mode 100644 anneal/vendor/tiny_http/src/client.rs delete mode 100644 anneal/vendor/tiny_http/src/common.rs delete mode 100644 anneal/vendor/tiny_http/src/connection.rs delete mode 100644 anneal/vendor/tiny_http/src/lib.rs delete mode 100644 anneal/vendor/tiny_http/src/request.rs delete mode 100644 anneal/vendor/tiny_http/src/response.rs delete mode 100644 anneal/vendor/tiny_http/src/ssl.rs delete mode 100644 anneal/vendor/tiny_http/src/ssl/openssl.rs delete mode 100644 anneal/vendor/tiny_http/src/ssl/rustls.rs delete mode 100644 anneal/vendor/tiny_http/src/test.rs delete mode 100644 anneal/vendor/tiny_http/src/util/custom_stream.rs delete mode 100644 anneal/vendor/tiny_http/src/util/equal_reader.rs delete mode 100644 anneal/vendor/tiny_http/src/util/fused_reader.rs delete mode 100644 anneal/vendor/tiny_http/src/util/messages_queue.rs delete mode 100644 anneal/vendor/tiny_http/src/util/mod.rs delete mode 100644 anneal/vendor/tiny_http/src/util/refined_tcp_stream.rs delete mode 100644 anneal/vendor/tiny_http/src/util/sequential.rs delete mode 100644 anneal/vendor/tiny_http/src/util/task_pool.rs delete mode 100644 anneal/vendor/tiny_http/tests/input-tests.rs delete mode 100644 anneal/vendor/tiny_http/tests/network.rs delete mode 100644 anneal/vendor/tiny_http/tests/non-chunked-buffering.rs delete mode 100644 anneal/vendor/tiny_http/tests/promptness.rs delete mode 100644 anneal/vendor/tiny_http/tests/simple-test.rs delete mode 100644 anneal/vendor/tiny_http/tests/support/mod.rs delete mode 100644 anneal/vendor/tiny_http/tests/unblock-test.rs delete mode 100644 anneal/vendor/tiny_http/tests/unix-test.rs create mode 100644 anneal/vendor/unicode-ident/tests/fst/.gitignore create mode 100644 anneal/vendor/wasmparser/benches/.gitignore create mode 100644 anneal/vendor/wit-component/tests/.gitignore create mode 100644 anneal/vendor/wit-parser/tests/.gitignore diff --git a/.cargo/config.toml b/.cargo/config.toml deleted file mode 100644 index 520a2b6347..0000000000 --- a/.cargo/config.toml +++ /dev/null @@ -1,8 +0,0 @@ -[env] -__ZEROCOPY_LOCAL_DEV = "1" - -[source.crates-io] -replace-with = "vendored-sources" - -[source.vendored-sources] -directory = "vendor" diff --git a/anneal/.cargo/config.toml b/anneal/.cargo/config.toml deleted file mode 100644 index 520a2b6347..0000000000 --- a/anneal/.cargo/config.toml +++ /dev/null @@ -1,8 +0,0 @@ -[env] -__ZEROCOPY_LOCAL_DEV = "1" - -[source.crates-io] -replace-with = "vendored-sources" - -[source.vendored-sources] -directory = "vendor" diff --git a/anneal/v2/Cargo.lock b/anneal/v2/Cargo.lock new file mode 100644 index 0000000000..142c6a65a7 --- /dev/null +++ b/anneal/v2/Cargo.lock @@ -0,0 +1,536 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "bitflags" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" + +[[package]] +name = "block-buffer" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be" +dependencies = [ + "hybrid-array", +] + +[[package]] +name = "cargo-anneal" +version = "0.1.0-alpha.22" +dependencies = [ + "foo", + "toml_const", +] + +[[package]] +name = "cc" +version = "1.2.62" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "const-oid" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c" + +[[package]] +name = "cpufeatures" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" +dependencies = [ + "libc", +] + +[[package]] +name = "crypto-common" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77727bb15fa921304124b128af125e7e3b968275d1b108b379190264f4423710" +dependencies = [ + "hybrid-array", +] + +[[package]] +name = "digest" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2" +dependencies = [ + "block-buffer", + "const-oid", + "crypto-common", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys", +] + +[[package]] +name = "fastrand" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" + +[[package]] +name = "filetime" +version = "0.2.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759" +dependencies = [ + "cfg-if", + "libc", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "foo" +version = "0.1.0" +dependencies = [ + "sha2", + "tar", + "tempfile", + "toml_const", + "zstd", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasip2", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" + +[[package]] +name = "hybrid-array" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9155a582abd142abc056962c29e3ce5ff2ad5469f4246b537ed42c5deba857da" +dependencies = [ + "typenum", +] + +[[package]] +name = "indexmap" +version = "2.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom", + "libc", +] + +[[package]] +name = "libc" +version = "0.2.186" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "memchr" +version = "2.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "phf" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7" +dependencies = [ + "phf_macros", + "phf_shared", + "serde", +] + +[[package]] +name = "phf_generator" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2cbb1126afed61dd6368748dae63b1ee7dc480191c6262a3b4ff1e29d86a6c5b" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_macros" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d713258393a82f091ead52047ca779d37e5766226d009de21696c4e667044368" +dependencies = [ + "phf_generator", + "phf_shared", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "phf_shared" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981" +dependencies = [ + "siphasher", +] + +[[package]] +name = "pkg-config" +version = "0.3.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "rustix" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys", +] + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_spanned" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3" +dependencies = [ + "serde", +] + +[[package]] +name = "sha2" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "siphasher" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649" + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tar" +version = "0.4.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973" +dependencies = [ + "filetime", + "libc", + "xattr", +] + +[[package]] +name = "tempfile" +version = "3.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" +dependencies = [ + "fastrand", + "getrandom", + "once_cell", + "rustix", + "windows-sys", +] + +[[package]] +name = "toml" +version = "0.8.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362" +dependencies = [ + "indexmap", + "serde", + "serde_spanned", + "toml_datetime", + "toml_edit", +] + +[[package]] +name = "toml_const" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a93119c23cd286a0e585f25bffcd1c292eaa6b90edfd8d58c442a3d2fe57c1" +dependencies = [ + "phf", + "toml", + "toml_const_macros", +] + +[[package]] +name = "toml_const_macros" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0ca608371311e568b6f918f3cf851640c6811625f39852c188b50ce11e2201b" +dependencies = [ + "indexmap", + "proc-macro2", + "quote", + "syn", + "toml", +] + +[[package]] +name = "toml_datetime" +version = "0.6.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" +dependencies = [ + "serde", +] + +[[package]] +name = "toml_edit" +version = "0.22.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" +dependencies = [ + "indexmap", + "serde", + "serde_spanned", + "toml_datetime", + "toml_write", + "winnow", +] + +[[package]] +name = "toml_write" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801" + +[[package]] +name = "typenum" +version = "1.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de" + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "wasip2" +version = "1.0.3+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "winnow" +version = "0.7.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945" +dependencies = [ + "memchr", +] + +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + +[[package]] +name = "xattr" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156" +dependencies = [ + "libc", + "rustix", +] + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.0.16+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" +dependencies = [ + "cc", + "pkg-config", +] diff --git a/anneal/v2/Cargo.toml b/anneal/v2/Cargo.toml new file mode 100644 index 0000000000..b7aae946f9 --- /dev/null +++ b/anneal/v2/Cargo.toml @@ -0,0 +1,43 @@ +[workspace] +members = [".", "foo"] + +[package] +name = "cargo-anneal" +edition = "2024" +version = "0.1.0-alpha.22" +description = "Formally verify that your safety comments are correct." +categories = [ + "development-tools::cargo-plugins", + "development-tools::testing", + "compilers", + "mathematics", + "security", +] +keywords = ["verification", "cargo", "plugin", "unsafe", "lean"] +authors = ["Joshua Liebow-Feeser "] +license = "BSD-2-Clause OR Apache-2.0 OR MIT" +repository = "https://github.com/google/zerocopy/tree/main/anneal" +publish = true + +exclude = [".*", "testdata"] + +[package.metadata.toolchain.linux.x86_64] +sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +url = "https://example.com/linux-x86_64.tar.zst" + +[package.metadata.toolchain.macos.x86_64] +sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +url = "https://example.com/macos-x86_64.tar.zst" + +[package.metadata.toolchain.linux.aarch64] +sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +url = "https://example.com/linux-aarch64.tar.zst" + +[package.metadata.toolchain.macos.aarch64] +sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +url = "https://example.com/macos-aarch64.tar.zst" + + +[dependencies] +foo = { path = "./foo" } +toml_const = "1.2.1" diff --git a/anneal/v2/foo/Cargo.toml b/anneal/v2/foo/Cargo.toml new file mode 100644 index 0000000000..c2582eb0c5 --- /dev/null +++ b/anneal/v2/foo/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "foo" +version = "0.1.0" +edition = "2024" + +[dependencies] +sha2 = "0.11.0" +tar = "0.4.45" +tempfile = "3.27.0" +toml_const = "1.2.1" +zstd = "0.13.3" diff --git a/anneal/v2/foo/src/atomic.rs b/anneal/v2/foo/src/atomic.rs new file mode 100644 index 0000000000..a4e32428e7 --- /dev/null +++ b/anneal/v2/foo/src/atomic.rs @@ -0,0 +1,310 @@ +// Copyright 2026 The Fuchsia Authors +// +// Licensed under the 2-Clause BSD License , Apache License, Version 2.0 +// , or the MIT +// license , at your option. +// This file may not be copied, modified, or distributed except according to +// those terms. + +use std::{ + fs, + io::Result as IoResult, + path::{Path, PathBuf}, +}; + +/// An RAII guard that manages temporary symlink and directory paths during +/// installation. +/// +/// If the installation succeeds, `disarm()` must be called to relinquish +/// ownership. Otherwise, the `Drop` implementation cleans up the temporary +/// files to prevent leaks. +struct SymlinkInstallGuard { + link_path: PathBuf, + dir_path: PathBuf, + disarmed: bool, +} + +impl SymlinkInstallGuard { + fn new(link_path: PathBuf, dir_path: PathBuf) -> Self { + Self { link_path, dir_path, disarmed: false } + } + + fn disarm(mut self) { + self.disarmed = true; + } +} + +impl Drop for SymlinkInstallGuard { + fn drop(&mut self) { + if !self.disarmed { + let _ = fs::remove_file(&self.link_path); + let _ = fs::remove_dir_all(&self.dir_path); + } + } +} + +/// Populates and installs a directory at `dst` using an atomic symlink-based +/// swap. +/// +/// This function executes the provided `populate` closure within a unique +/// temporary directory and, upon success, atomically updates a symlink at `dst` +/// to point to the newly created directory. Finally, it performs garbage +/// collection to clean up any previously active or orphaned directories. +/// +/// # Algorithm +/// +/// Standard POSIX filesystem directory replacement (`rename(2)` over a +/// non-empty directory) is non-atomic and fails with `ENOTEMPTY`. To guarantee +/// atomic updates, this implementation uses symlinks as the source of truth. +/// +/// 1. Two unique temporary paths in the destination's parent directory are +/// created: one for a temporary symlink (``) and one for the target +/// installation directory (`-`). +/// 2. The temporary symlink `` -> `-` is created *first*, before +/// `-` is created on disk. +/// +/// If a concurrent GC scan runs at any point during directory population, it +/// will observe `` pointing to `-` and treat `-` +/// as reachable, preventing premature deletion. This requires the symlink to +/// be created first. +/// 3. Both paths are managed by an RAII guard (`SymlinkInstallGuard`). If the +/// `populate` closure returns an error or if the process panics, the guard's +/// `Drop` automatically unlinks `` and removes `-`. +/// 4. Once population succeeds, `rename(, dst)` is executed. On +/// POSIX/Linux, renaming a symlink over an existing symlink is atomic. Any +/// concurrent observer reading `dst` will observe either the old directory +/// target or the new directory target. `dst` is never missing or incomplete. +/// 5. Finally, `gc` is invoked to clean up unreachable directories. +pub(crate) fn install(dst: &Path, populate: impl FnOnce(&Path) -> IoResult<()>) -> IoResult<()> { + let parent = dst.parent().expect("dst must have at least one ancestor"); + let file_name = dst.file_name().expect("dst must have a file name"); + + // 1. Generate unique paths for the target directory and the temporary symlink. + let tmp_dir = tempfile::Builder::new().prefix(file_name).tempdir_in(parent)?; + let dir_path = tmp_dir.path().to_path_buf(); + fs::remove_dir(&dir_path)?; + let _ = tmp_dir.keep(); + + let tmp_link = tempfile::Builder::new().prefix("tmp_link_").tempdir_in(parent)?; + let link_path = tmp_link.path().to_path_buf(); + fs::remove_dir(&link_path)?; + let _ = tmp_link.keep(); + + let target_dir_name = dir_path.file_name().expect("dir_path must have a file name"); + + // 2. Create the temporary symlink first before creating the directory. + std::os::unix::fs::symlink(target_dir_name, &link_path)?; + fs::create_dir(&dir_path)?; + + // 3. Guard both paths to guarantee cleanup on error. + let guard = SymlinkInstallGuard::new(link_path, dir_path); + + populate(&guard.dir_path)?; + + // 4. Atomically swap the temporary symlink into the canonical destination. + fs::rename(&guard.link_path, dst)?; + guard.disarm(); + + // 5. Run garbage collection to clean up any previously active or orphaned directories. + gc(parent, dst)?; + + Ok(()) +} + +/// Garbage collects unreachable toolchain directories in `parent`. +fn gc(parent: &Path, canonical_dst: &Path) -> IoResult<()> { + // On Linux, directory iteration (`fs::read_dir`) is not an atomic snapshot. + // If a symlink is renamed while a GC process is iterating `parent`, the + // symlink might be renamed from an unvisited position to an already-visited + // position, causing `read_dir` to miss it. `canonical_dst` is the only + // symlink that might be renamed, so we check it explicitly after doing our + // initial `read_dir` to handle this race condition. + // + // Proof of GC Correctness: + // + // Let $t_{scan}$ be the window during which GC iterates `parent`. Let + // $t_{dst}$ be the exact instant GC explicitly checks + // `fs::read_link(canonical_dst)` strictly after iteration ($t_{scan} < + // t_{dst}$). Let $t_{rename}$ be the instant a concurrent install renames + // `` to `canonical_dst`. + // + // - Case 1 ($t_{rename} < t_{dst}$): At $t_{dst}$, `canonical_dst` points + // to the new directory. Explicitly reading `canonical_dst` at $t_{dst}$ + // captures the directory and marks it reachable. + // - Case 2 ($t_{rename} > t_{dst}$): Since $t_{scan} < t_{dst} < + // t_{rename}$, `` existed in `parent` for the entire duration of + // $t_{scan}$. Thus, directory iteration during $t_{scan}$ is guaranteed + // to yield ``, successfully marking the directory reachable. + + use std::collections::HashSet; + + let mut directories = Vec::new(); + let mut reachable = HashSet::new(); + + // Scan all entries in parent. Every directory pointed to by any symlink is + // reachable. + for entry_res in fs::read_dir(parent)? { + let entry = entry_res?; + let file_type = entry.file_type()?; + + if file_type.is_symlink() { + if let Ok(target) = fs::read_link(entry.path()) { + if let Some(file_name) = target.file_name() { + reachable.insert(file_name.to_os_string()); + } + } + } else if file_type.is_dir() { + directories.push(entry.file_name()); + } + } + + // Post-iteration verification of `canonical_dst` to close the `readdir` + // TOCTOU gap. + if let Ok(target) = fs::read_link(canonical_dst) { + if let Some(file_name) = target.file_name() { + reachable.insert(file_name.to_os_string()); + } + } + + // Delete all unreachable directories. + // + // Soundness under concurrency: + // - Concurrent GC: If multiple GC processes race to delete the same + // unreachable directory, one process may successfully remove files while + // another encounters `ENOENT` mid-deletion. Looping until + // `!dir_path.exists()` while ignoring errors ensures robust cleanup and + // clean termination once the race completes. + // - Concurrent new installations: In-progress installations create + // directories using `tempfile`, which attempts directory creation in a + // loop checking for `EEXIST` with ~56 billion permutations (62^6). An + // active installation can never collide with a directory currently on + // disk. A previously deleted path could theoretically be reused by a + // new installation in between a GC worker scanning the directory's + // symlinks and its directories. We consider the entropy high enough to + // ignore this possibility, especially since it's an easily recoverable + // state (namely, just re-do the installation). + for dir_name in directories { + if !reachable.contains(&dir_name) { + let dir_path = parent.join(dir_name); + while dir_path.exists() { + let _ = fs::remove_dir_all(&dir_path); + } + } + } + + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::fs; + use std::path::Path; + + #[test] + fn test_install_success() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + + install(&dst, |dir| { + fs::write(dir.join("data.txt"), "success content").unwrap(); + Ok(()) + }) + .unwrap(); + + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("data.txt")).unwrap(), "success content"); + } + + #[test] + fn test_install_overwrite() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + + install(&dst, |dir| { + fs::write(dir.join("v1.txt"), "v1").unwrap(); + Ok(()) + }) + .unwrap(); + + install(&dst, |dir| { + fs::write(dir.join("v2.txt"), "v2").unwrap(); + Ok(()) + }) + .unwrap(); + + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("v2.txt")).unwrap(), "v2"); + assert!(!dst.join("v1.txt").exists()); + } + + #[test] + fn test_install_failure_cleanup() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + + let res = install(&dst, |dir| { + fs::write(dir.join("partial.txt"), "partial").unwrap(); + Err(std::io::Error::new(std::io::ErrorKind::Other, "simulated error")) + }); + assert!(res.is_err()); + + assert!(!dst.exists()); + let mut entries = fs::read_dir(temp.path()).unwrap(); + assert!(entries.next().is_none()); + } + + #[test] + fn test_install_overwrite_failure_cleanup() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + + install(&dst, |dir| { + fs::write(dir.join("v1.txt"), "v1").unwrap(); + Ok(()) + }) + .unwrap(); + + let res = install(&dst, |dir| { + fs::write(dir.join("v2.txt"), "v2").unwrap(); + Err(std::io::Error::new(std::io::ErrorKind::Other, "simulated error")) + }); + assert!(res.is_err()); + + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("v1.txt")).unwrap(), "v1"); + assert!(!dst.join("v2.txt").exists()); + + let entries = fs::read_dir(temp.path()).unwrap(); + assert_eq!(entries.count(), 2); + } + + #[test] + #[should_panic(expected = "dst must have a file name")] + fn test_install_no_filename() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join(".."); + let _ = install(&dst, |_| Ok(())); + } + + #[test] + #[should_panic(expected = "dst must have at least one ancestor")] + fn test_install_no_ancestor() { + let dst = Path::new("/"); + let _ = install(dst, |_| Ok(())); + } + + #[test] + fn test_gc_unreachable() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + + let orphan_dir = temp.path().join("orphan_dir"); + fs::create_dir(&orphan_dir).unwrap(); + + install(&dst, |_| Ok(())).unwrap(); + + assert!(!orphan_dir.exists()); + } +} diff --git a/anneal/v2/foo/src/lib.rs b/anneal/v2/foo/src/lib.rs new file mode 100644 index 0000000000..0951bc56cd --- /dev/null +++ b/anneal/v2/foo/src/lib.rs @@ -0,0 +1,318 @@ +// Copyright 2026 The Fuchsia Authors +// +// Licensed under the 2-Clause BSD License , Apache License, Version 2.0 +// , or the MIT +// license , at your option. +// This file may not be copied, modified, or distributed except according to +// those terms. + +use std::{io::Result as IoResult, path::Path}; + +use sha2::Digest as _; + +mod atomic; + +pub struct Config { + pub os: &'static str, + pub arch: &'static str, + pub url: &'static str, + pub sha256: [u8; 32], +} + +impl Config { + // pub fn install(&self) -> IoResult<()> {} + + // pub fn install_from(&self, path: &Path) -> IoResult<()> {} + + fn toolchain_dir_name(&self) -> String { + let sha_prefix = &self.sha256[..8]; + format!("{}-{}-{}", self.os, self.arch, encode_hex(sha_prefix)) + } +} + +/// Extracts the `.tar.zst` from `reader` and installs it at `dst`, optionally +/// validating its hash. +pub(crate) fn install( + mut reader: impl std::io::Read, + dst: &Path, + expected_sha256: Option<[u8; 32]>, +) -> IoResult<()> { + struct HashingReader { + reader: R, + hasher: sha2::Sha256, + } + + impl std::io::Read for HashingReader { + fn read(&mut self, buf: &mut [u8]) -> std::io::Result { + let n = self.reader.read(buf)?; + sha2::Digest::update(&mut self.hasher, &buf[..n]); + Ok(n) + } + } + + atomic::install(dst, |target_dir| { + if let Some(expected) = expected_sha256 { + let mut hash_reader = HashingReader { reader, hasher: sha2::Sha256::new() }; + { + let decoder = zstd::stream::read::Decoder::new(&mut hash_reader)?; + let mut archive = tar::Archive::new(decoder); + archive.unpack(target_dir)?; + } + + let hash: [u8; 32] = sha2::Digest::finalize(hash_reader.hasher).into(); + if hash != expected { + return Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + "sha256 hash mismatch", + )); + } + } else { + let decoder = zstd::stream::read::Decoder::new(&mut reader)?; + let mut archive = tar::Archive::new(decoder); + archive.unpack(target_dir)?; + } + Ok(()) + }) +} + +fn encode_hex(bytes: &[u8]) -> String { + use std::fmt::Write; + let mut s = String::with_capacity(bytes.len() * 2); + for &b in bytes { + write!(&mut s, "{:02x}", b).unwrap(); + } + s +} + +/// **NOTE**: The calling crate must have its own dependency on the `toml_const` +/// crate. +// FIXME: +// - Lift this limitation. +// - Don't require the user to specify os/arch pairs in the macro invocation. +#[macro_export] +macro_rules! config { + ($vis:vis const $name:ident: Config = $cargo_toml_path:literal [ + $(($os:ident, $arch:ident)),* $(,)? + ];) => { + $vis const $name: $crate::Config = { + ::toml_const::toml_const!{ + const MANIFEST: $cargo_toml_path; + } + + let (os, arch, config) = { + use std::env::consts::*; + use $crate::macro_util::pack; + + // NOTE: Rust doesn't support checking `&str`s for equality in a + // `const` context. We work around that limitation by packing + // their bytes into `u128`s, which can be compared. + // + // FIXME: How can we detect if os/arch pairs have been added to + // `Cargo.toml` without being added to the macro invocation? + match (pack(OS), pack(ARCH)) { + $( + (os, arch) if os == pack(stringify!($os)) && arch == pack(stringify!($arch)) => { + let (os, arch) = (stringify!($os), stringify!($arch)); + let config = MANIFEST.package.metadata.toolchain.$os.$arch; + (os, arch, config) + } + )* + _ => panic!("unsupported platform"), + } + }; + + let Some(sha256) = $crate::macro_util::decode_hex(config.sha256) else { + panic!("invalid sha256") + }; + $crate::Config { + os, + arch, + url: config.url, + sha256, + } + }; + } +} + +#[doc(hidden)] +pub mod macro_util { + /// Packs the bytes of `s` into a `u128`. + /// + /// # Panics + /// + /// Panics if `s.as_bytes().len() > 16`. + pub const fn pack(s: &str) -> u128 { + let b = s.as_bytes(); + assert!(b.len() <= 16, "slice too large to pack into u128"); + + let mut res = 0u128; + let mut i = 0; + while i < b.len() { + res |= (b[i] as u128) << (i * 8); + i += 1; + } + res + } + + /// Decodes a hexadecimal string into its byte representation. + pub const fn decode_hex(s: &str) -> Option<[u8; 32]> { + let bytes = s.as_bytes(); + if bytes.len() != 64 { + return None; + } + let mut res = [0u8; 32]; + let mut i = 0; + while i < 32 { + let (h, l) = (bytes[i * 2], bytes[i * 2 + 1]); + let h_nib = match decode_nibble(h) { + Some(n) => n, + None => return None, + }; + let l_nib = match decode_nibble(l) { + Some(n) => n, + None => return None, + }; + res[i] = (h_nib << 4) | l_nib; + i += 1; + } + Some(res) + } + + const fn decode_nibble(c: u8) -> Option { + match c { + b'0'..=b'9' => Some(c - b'0'), + b'a'..=b'f' => Some(c - b'a' + 10), + b'A'..=b'F' => Some(c - b'A' + 10), + _ => None, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::fs; + + fn create_dummy_tar_zst(files: &[(&str, &[u8])]) -> Vec { + let mut zstd_enc = zstd::stream::write::Encoder::new(Vec::new(), 0).unwrap(); + { + let mut tar_builder = tar::Builder::new(&mut zstd_enc); + for (name, content) in files { + let mut header = tar::Header::new_gnu(); + header.set_size(content.len() as u64); + header.set_mode(0o644); + header.set_cksum(); + tar_builder.append_data(&mut header, name, *content).unwrap(); + } + tar_builder.finish().unwrap(); + } + zstd_enc.finish().unwrap() + } + + fn compute_sha256(data: &[u8]) -> [u8; 32] { + let mut hasher = sha2::Sha256::new(); + hasher.update(data); + hasher.finalize().into() + } + + #[test] + fn test_install_new() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let tar_zst = create_dummy_tar_zst(&[ + ("hello.txt", b"hello world"), + ("nested/dir/data.bin", b"\x01\x02\x03"), + ]); + let expected_hash = compute_sha256(&tar_zst); + + install(tar_zst.as_slice(), &dst, Some(expected_hash)).unwrap(); + + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("hello.txt")).unwrap(), "hello world"); + assert_eq!(fs::read(dst.join("nested/dir/data.bin")).unwrap(), b"\x01\x02\x03"); + } + + #[test] + fn test_install_overwrite_dir() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + + let tar_v1 = create_dummy_tar_zst(&[("old_file.txt", b"this should be deleted")]); + install(tar_v1.as_slice(), &dst, None).unwrap(); + assert_eq!(fs::read_to_string(dst.join("old_file.txt")).unwrap(), "this should be deleted"); + + let tar_v2 = create_dummy_tar_zst(&[("new_file.txt", b"new content")]); + let expected_hash = compute_sha256(&tar_v2); + install(tar_v2.as_slice(), &dst, Some(expected_hash)).unwrap(); + + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("new_file.txt")).unwrap(), "new content"); + assert!(!dst.join("old_file.txt").exists()); + } + + #[test] + fn test_install_without_hash_validation() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let tar_zst = create_dummy_tar_zst(&[("hello.txt", b"hello world")]); + + install(tar_zst.as_slice(), &dst, None).unwrap(); + + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("hello.txt")).unwrap(), "hello world"); + } + + #[test] + fn test_install_invalid_archive() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + + let invalid_data = b"definitely not a valid zstd or tar"; + + let result = install(&invalid_data[..], &dst, None); + assert!(result.is_err()); + + assert!(!dst.exists()); + } + + #[test] + fn test_install_hash_mismatch() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let tar_zst = create_dummy_tar_zst(&[("hello.txt", b"hello world")]); + + let bad_hash = [0u8; 32]; + + let result = install(tar_zst.as_slice(), &dst, Some(bad_hash)); + assert!(result.is_err()); + assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::InvalidData); + + assert!(!dst.exists()); + let mut entries = fs::read_dir(temp.path()).unwrap(); + assert!(entries.next().is_none()); + } + + #[test] + fn test_install_overwrite_dir_hash_mismatch() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + + let tar_v1 = create_dummy_tar_zst(&[("existing.txt", b"do not touch")]); + install(tar_v1.as_slice(), &dst, None).unwrap(); + + let tar_v2 = create_dummy_tar_zst(&[("new_file.txt", b"new content")]); + let bad_hash = [1u8; 32]; + + let result = install(tar_v2.as_slice(), &dst, Some(bad_hash)); + assert!(result.is_err()); + assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::InvalidData); + + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("existing.txt")).unwrap(), "do not touch"); + assert!(!dst.join("new_file.txt").exists()); + + let entries = fs::read_dir(temp.path()).unwrap(); + assert_eq!(entries.count(), 2); + } +} diff --git a/anneal/v2/src/main.rs b/anneal/v2/src/main.rs new file mode 100644 index 0000000000..1dcdcd0a81 --- /dev/null +++ b/anneal/v2/src/main.rs @@ -0,0 +1,19 @@ +// Copyright 2026 The Fuchsia Authors +// +// Licensed under the 2-Clause BSD License , Apache License, Version 2.0 +// , or the MIT +// license , at your option. +// This file may not be copied, modified, or distributed except according to +// those terms. + +foo::config! { + const CONFIG: Config = "Cargo.toml" [ + (linux, x86_64), + (linux, aarch64), + (macos, aarch64), + (macos, x86_64), + ]; +} + +fn main() {} diff --git a/anneal/vendor/ascii/.cargo-checksum.json b/anneal/vendor/ascii/.cargo-checksum.json deleted file mode 100644 index f60d070600..0000000000 --- a/anneal/vendor/ascii/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{".cargo_vcs_info.json":"7dc279d6cc614afd157d09eaf63f0249a590d99bd3659976740a48e19b51c783",".github/workflows/ci.yml":"26ca0180639f06c994852c2e6f6c10edbee283d9aa173de9d1a0fde1c50f0d96","Cargo.toml":"466554aebd51e2ff3da0e3b2160c9c77785701812d65f2bbeda5d2d0b3fc0c9e","Cargo.toml.orig":"5199ce15775aa1d2a706f6d2d3a45339fa6ce79fa50b263949cdd023392a3650","LICENSE-APACHE":"fabba0cb7d00a4b3211fdc13699223ab2d22f88678ccd608494cf2b332b903e9","LICENSE-MIT":"7e4b8a17b118d3d7fd7a362a4b6563e0bd98b098a24c4c7f07dd22042091a847","README.md":"c229f6bd9fb52731479c5e1d321b53ef7eb9bb33105b0052870620107add1425","RELEASES.md":"81ec9d5ed1268c499e5a7e4d9d7bbf7469f2e3ddeede45ad62ed5128f700f818","src/ascii_char.rs":"8c4bdedd3bc07387baddbea23cff6a5abd469884f2fe274c6f6a03c00110b549","src/ascii_str.rs":"464c156b2a9f8183e8f472df6b6b34ea8406c19cab85112475669585a607efff","src/ascii_string.rs":"0cc46f26623721221c0635f17951cd2c40ae1aed4a2e08c333802117ebd94640","src/free_functions.rs":"efebe83e30b05d2394f5f491254e868f8b2837029c39159756eda599199c27b8","src/lib.rs":"3f0640d3cb0fd274c7ddd60efc7ab09e633b7ce726ef366fcf468b784be451dc","src/serialization/ascii_char.rs":"09328995f6691f55be8be016e886cfb390eabe0a002057a41f2e6e029ca5588a","src/serialization/ascii_str.rs":"2dea9ba3d101fa42c09645c2889dc02f16ed2a05409f0d2212b8fc75f2e2fe8b","src/serialization/ascii_string.rs":"342f74d9f367f8450ba9f6c8b76022dc04c9af6bd038dc5e4fc99882b7e978c5","src/serialization/mod.rs":"0f92b7e47156ea3b86ef0c6131c749862fc3b3922e9d16ee22264324fed9a56f","tests.rs":"58cff9cd5607746c9334fd07f73bac9db3fd97034232b1a4751024666d3f1657"},"package":"d92bec98840b8f03a5ff5413de5293bfcd8bf96467cf5452609f939ec6f5de16"} \ No newline at end of file diff --git a/anneal/vendor/ascii/.cargo_vcs_info.json b/anneal/vendor/ascii/.cargo_vcs_info.json deleted file mode 100644 index 2887e77a44..0000000000 --- a/anneal/vendor/ascii/.cargo_vcs_info.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "git": { - "sha1": "8605175df3a9bd1c5e36a300fa68eb5b4a181e6f" - }, - "path_in_vcs": "" -} \ No newline at end of file diff --git a/anneal/vendor/ascii/.github/workflows/ci.yml b/anneal/vendor/ascii/.github/workflows/ci.yml deleted file mode 100644 index e8cabbede6..0000000000 --- a/anneal/vendor/ascii/.github/workflows/ci.yml +++ /dev/null @@ -1,57 +0,0 @@ -name: CI - -on: - pull_request: - push: - branches: - - master - -jobs: - test: - name: Test with Rust ${{ matrix.rust }} - runs-on: ubuntu-latest - strategy: - fail-fast: false - matrix: - rust: [1.41.1, stable, beta, nightly] - steps: - - uses: actions/checkout@v2 - - uses: hecrj/setup-rust-action@v1 - with: - rust-version: ${{ matrix.rust }} - - run: cargo test --verbose --all-features - - run: cargo test --verbose --no-default-features --features alloc - - run: cargo test --verbose --no-default-features - - clippy: - name: Lint with Clippy - runs-on: ubuntu-latest - env: - RUSTFLAGS: -Dwarnings - steps: - - uses: actions/checkout@v2 - - uses: hecrj/setup-rust-action@v1 - with: - components: clippy - - run: cargo clippy --all-targets --verbose --no-default-features - - run: cargo clippy --all-targets --verbose --all-features - - test-minimal: - name: Test minimal dependency version with Rust nightly - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - - uses: hecrj/setup-rust-action@v1 - with: - rust-version: nightly - - run: cargo test -Zminimal-versions --verbose --all-features - - miri: - name: Run tests under `miri` to check for UB - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - uses: dtolnay/rust-toolchain@nightly - with: - components: miri - - run: cargo miri test --all-features diff --git a/anneal/vendor/ascii/Cargo.toml b/anneal/vendor/ascii/Cargo.toml deleted file mode 100644 index ce17c6f73b..0000000000 --- a/anneal/vendor/ascii/Cargo.toml +++ /dev/null @@ -1,41 +0,0 @@ -# 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] -name = "ascii" -version = "1.1.0" -authors = [ - "Thomas Bahn ", - "Torbjørn Birch Moltu ", - "Simon Sapin ", -] -description = "ASCII-only equivalents to `char`, `str` and `String`." -documentation = "https://docs.rs/ascii" -readme = "README.md" -license = "Apache-2.0 OR MIT" -repository = "https://github.com/tomprogrammer/rust-ascii" - -[[test]] -name = "tests" -path = "tests.rs" - -[dependencies.serde] -version = "1.0.25" -optional = true - -[dependencies.serde_test] -version = "1.0" -optional = true - -[features] -alloc = [] -default = ["std"] -std = ["alloc"] diff --git a/anneal/vendor/ascii/Cargo.toml.orig b/anneal/vendor/ascii/Cargo.toml.orig deleted file mode 100644 index 8ec25de27d..0000000000 --- a/anneal/vendor/ascii/Cargo.toml.orig +++ /dev/null @@ -1,22 +0,0 @@ -[package] -authors = ["Thomas Bahn ", "Torbjørn Birch Moltu ", "Simon Sapin "] -description = "ASCII-only equivalents to `char`, `str` and `String`." -documentation = "https://docs.rs/ascii" -license = "Apache-2.0 OR MIT" -name = "ascii" -readme = "README.md" -repository = "https://github.com/tomprogrammer/rust-ascii" -version = "1.1.0" - -[dependencies] -serde = { version = "1.0.25", optional = true } -serde_test = { version = "1.0", optional = true } - -[features] -default = ["std"] -std = ["alloc"] -alloc = [] - -[[test]] -name = "tests" -path = "tests.rs" diff --git a/anneal/vendor/ascii/LICENSE-APACHE b/anneal/vendor/ascii/LICENSE-APACHE deleted file mode 100644 index 211fa24663..0000000000 --- a/anneal/vendor/ascii/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/anneal/vendor/ascii/LICENSE-MIT b/anneal/vendor/ascii/LICENSE-MIT deleted file mode 100644 index 84c5b9e430..0000000000 --- a/anneal/vendor/ascii/LICENSE-MIT +++ /dev/null @@ -1,22 +0,0 @@ -MIT License - -Copyright (c) 2017 Thomas Bahn and contributors -Copyright (c) 2014 The Rust Project Developers - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/anneal/vendor/ascii/README.md b/anneal/vendor/ascii/README.md deleted file mode 100644 index 690fd59f23..0000000000 --- a/anneal/vendor/ascii/README.md +++ /dev/null @@ -1,64 +0,0 @@ -# ascii - -A library that provides ASCII-only string and character types, equivalent to the -`char`, `str` and `String` types in the standard library. - -Types and conversion traits are described in the [Documentation](https://docs.rs/ascii). - -You can include this crate in your cargo project by adding it to the -dependencies section in `Cargo.toml`: - -```toml -[dependencies] -ascii = "1.1" -``` - -## Using ascii without libstd - -Most of `AsciiChar` and `AsciiStr` can be used without `std` by disabling the -default features. The owned string type `AsciiString` and the conversion trait -`IntoAsciiString` as well as all methods referring to these types can be -re-enabled by enabling the `alloc` feature. - -Methods referring to `CStr` and `CString` are also unavailable. -The `Error` trait also only exists in `std`, but `description()` is made -available as an inherent method for `ToAsciiCharError` and `AsAsciiStrError` -in `#![no_std]`-mode. - -To use the `ascii` crate in `#![no_std]` mode in your cargo project, -just add the following dependency declaration in `Cargo.toml`: - -```toml -[dependencies] -ascii = { version = "1.1", default-features = false, features = ["alloc"] } -``` - -## Minimum supported Rust version - -The minimum Rust version for 1.1.\* releases is 1.41.1. -Later 1.y.0 releases might require newer Rust versions, but the three most -recent stable releases at the time of publishing will always be supported. -For example this means that if the current stable Rust version is 1.70 when -ascii 1.2.0 is released, then ascii 1.2.\* will not require a newer -Rust version than 1.68. - -## History - -This package included the Ascii types that were removed from the Rust standard -library by the 2014-12 [reform of the `std::ascii` module](https://github.com/rust-lang/rfcs/pull/486). -The API changed significantly since then. - -## License - -Licensed under either of - -* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0) -* MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT) - -at your option. - -### Contribution - -Unless you explicitly state otherwise, any contribution intentionally submitted -for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any -additional terms or conditions. diff --git a/anneal/vendor/ascii/RELEASES.md b/anneal/vendor/ascii/RELEASES.md deleted file mode 100644 index aa1057890f..0000000000 --- a/anneal/vendor/ascii/RELEASES.md +++ /dev/null @@ -1,193 +0,0 @@ -Version 1.1.0 (2022-09-18) -========================== -* Add alloc feature. - This enables `AsciiString` and methods that take or return `Box<[AsciiStr]>` in `!#[no_std]`-mode. -* Add `AsciiStr::into_ascii_string()`, `AsciiString::into_boxed_ascii_str()` and `AsciiString::insert_str()`. -* Implement `From>` and `From` for `AsciiString`. -* Implement `From` for `Box`, `Rc`, `Arc` and `Vec`. -* Make `AsciiString::new()`, `AsciiStr::len()` and `AsciiStr::is_empty()` `const fn`. -* Require Rust 1.44.1. - -Version 1.0.0 (2019-08-26) -========================== - -Breaking changes: - -* Change `AsciiChar.is_whitespace()` to also return true for '\0xb' (vertical tab) and '\0xc' (form feed). -* Remove quickcheck feature. -* Remove `AsciiStr::new()`. -* Rename `AsciiChar::from()` and `AsciiChar::from_unchecked()` to `from_ascii()` and `from_ascii_unchecked()`. -* Rename several `AsciiChar.is_xxx()` methods to `is_ascii_xxx()` (for comsistency with std). -* Rename `AsciiChar::Null` to `Nul` (for consistency with eg. `CStr::from_bytes_with_nul()`). -* Rename `AsciiStr.trim_left()` and `AsciiStr.trim_right()` to `trim_start()` and `trim_end()`. -* Remove impls of the deprecated `std::ascii::AsciiExt` trait. -* Change iterators `Chars`, `CharsMut` and `CharsRef` from type aliases to newtypes. -* Return `impl Trait` from `AsciiStr.lines()` and `AsciiStr.split()`, and remove iterator types `Lines` and `Split`. -* Add `slice_ascii_str()`, `get_ascii()` and `unwrap_ascii()` to the `AsAsciiStr` trait. -* Add `slice_mut_ascii_str()` and `unwrap_ascii_mut()` to the `AsMutAsciiStr` trait. -* Require Rust 1.33.0 for 1.0.\*, and allow later semver-compatible 1.y.0 releases to increase it. - -Additions: - -* Add `const fn` `AsciiChar::new()` which panicks on invalid values. -* Make most `AsciiChar` methods `const fn`. -* Add multiple `AsciiChar::is_[ascii_]xxx()` methods. -* Implement `AsRef` for `AsciiChar`. -* Make `AsciiString`'s `Extend` and `FromIterator` impl generic over all `AsRef`. -* Implement inclusive range indexing for `AsciiStr` (and thereby `AsciiString`). -* Mark `AsciiStr` and `AsciiString` `#[repr(transparent)]` (to `[AsciiChar]` and `Vec` respectively). - -Version 0.9.3 (2019-08-26) -========================== - -Soundness fix: - -**Remove** [unsound](https://github.com/tomprogrammer/rust-ascii/issues/64) impls of `From<&mut AsciiStr>` for `&mut [u8]` and `&mut str`. -This is a breaking change, but theese impls can lead to undefined behavior in safe code. - -If you use this impl and know that non-ASCII values are never inserted into the `[u8]` or `str`, -you can pin ascii to 0.9.2. - -Other changes: - -* Make quickcheck `Arbitrary` impl sometimes produce `AsciiChar::DEL`. -* Implement `Clone`, `Copy` and `Eq` for `ToAsciiCharError`. -* Implement `ToAsciiChar` for `u16`, `u32` and `i8`. - -Version 0.9.2 (2019-07-07) -========================== -* Implement the `IntoAsciiString` trait for `std::ffi::CStr` and `std::ffi::CString` types, - and implemented the `AsAsciiStr` trait for `std::ffi::CStr` type. -* Implement the `IntoAsciiString` for `std::borrow::Cow`, where the inner types themselves - implement `IntoAsciiString`. -* Implement conversions between `AsciiString` and `Cow<'a, AsciiStr>`. -* Implement the `std::ops::AddAssign` trait for `AsciiString`. -* Implement `BorrowMut`, `AsRef<[AsciiChar]>`, `AsRef`, `AsMut<[AsciiChar]>` for `AsciiString`. -* Implement `PartialEq<[u8]>` and `PartialEq<[AsciiChar]>` for `AsciiStr`. -* Add `AsciiStr::first()`, `AsciiStr::last()` and `AsciiStr::split()` methods. -* Implement `DoubleEndedIterator` for `AsciiStr::lines()`. -* Implement `AsRef` and `AsMut for AsciiString`. - -Version 0.8.4 (2017-04-18) -========================== -* Fix the tests when running without std. - -Version 0.8.3 (2017-04-18) -========================== -* Bugfix: `::to_ascii_lowercase` did erroneously convert to uppercase. - -Version 0.8.2 (2017-04-17) -========================== -* Implement `IntoAsciiString` for `&'a str` and `&'a [u8]`. -* Implement the `quickcheck::Arbitrary` trait for `AsciiChar` and `AsciiString`. - The implementation is enabled by the `quickcheck` feature. - -Version 0.8.1 (2017-02-11) -========================== -* Add `Chars`, `CharsMut` and `Lines` iterators. -* Implement `std::fmt::Write` for `AsciiString`. - -Version 0.8.0 (2017-01-02) -========================== - -Breaking changes: - -* Return `FromAsciiError` instead of the input when `AsciiString::from_ascii()` or `into_ascii_string()` fails. -* Replace the `no_std` feature with the additive `std` feature, which is part of the default features. (Issue #29) -* `AsciiChar::is_*()` and `::as_{byte,char}()` take `self` by value instead of by reference. - -Additions: - -* Make `AsciiChar` comparable with `char` and `u8`. -* Add `AsciiChar::as_printable_char()` and the free functions `caret_encode()` and `caret_decode()`. -* Implement some methods from `AsciiExt` and `Error` (which are not in libcore) directly in `core` mode: - * `Ascii{Char,Str}::eq_ignore_ascii_case()` - * `AsciiChar::to_ascii_{upper,lower}case()` - * `AsciiStr::make_ascii_{upper,lower}case()` - * `{ToAsciiChar,AsAsciiStr}Error::description()` - -Version 0.7.1 (2016-08-15) -========================== -* Fix the implementation of `AsciiExt::to_ascii_lowercase()` for `AsciiChar` converting to uppercase. (introduced in 0.7.0) - -Version 0.7.0 (2016-06-25) -========================== -* Rename `Ascii` to `AsciiChar` and convert it into an enum. - (with a variant for every ASCII character) -* Replace `OwnedAsciiCast` with `IntoAsciiString`. -* Replace `AsciiCast` with `As[Mut]AsciiStr` and `IntoAsciiChar`. -* Add *from[_ascii]_unchecked* methods. -* Replace *from_bytes* with *from_ascii* in method names. -* Return `std::error::Error`-implementing types instead of `()` and `None` when - conversion to `AsciiStr` or `AsciiChar` fails. -* Implement `AsciiExt` without the `unstable` Cargo feature flag, which is removed. -* Require Rust 1.9 or later. -* Add `#[no_std]` support in a Cargo feature. -* Implement `From<{&,&mut,Box<}AsciiStr>` for `[Ascii]`, `[u8]` and `str` -* Implement `From<{&,&mut,Box<}[Ascii]>`, `As{Ref,Mut}<[Ascii]>` and Default for `AsciiStr` -* Implement `From>` for `AsciiString`. -* Implement `AsMut` for `AsciiString`. -* Stop some `Ascii::is_xxx()` methods from panicking. -* Add `Ascii::is_whitespace()`. -* Add `AsciiString::as_mut_slice()`. -* Add raw pointer methods on `AsciiString`: - * `from_raw_parts` - * `as_ptr` - * `as_mut_ptr` - -Version 0.6.0 (2015-12-30) -========================== -* Add `Ascii::from_byte()` -* Add `AsciiStr::trim[_{left,right}]()` - -Version 0.5.4 (2015-07-29) -========================== -Implement `IndexMut` for AsciiStr and AsciiString. - -Version 0.5.1 (2015-06-13) -========================== -* Add `Ascii::from()`. -* Implement `Index` for `AsciiStr` and `AsciiString`. -* Implement `Default`,`FromIterator`,`Extend` and `Add` for `AsciiString` -* Added inherent methods on `AsciiString`: - * `with_capacity` - * `push_str` - * `capacity` - * `reserve` - * `reserve_exact` - * `shrink_to_fit` - * `push` - * `truncate` - * `pop` - * `remove` - * `insert` - * `len` - * `is_empty` - * `clear` - -Version 0.5.0 (2015-05-05) -========================== -First release compatible with Rust 1.0.0. diff --git a/anneal/vendor/ascii/src/ascii_char.rs b/anneal/vendor/ascii/src/ascii_char.rs deleted file mode 100644 index 5011949f76..0000000000 --- a/anneal/vendor/ascii/src/ascii_char.rs +++ /dev/null @@ -1,1069 +0,0 @@ -use core::cmp::Ordering; -use core::mem; -use core::{char, fmt}; -#[cfg(feature = "std")] -use std::error::Error; - -#[allow(non_camel_case_types)] -/// An ASCII character. It wraps a `u8`, with the highest bit always zero. -#[derive(Clone, PartialEq, PartialOrd, Ord, Eq, Hash, Copy)] -#[repr(u8)] -pub enum AsciiChar { - /// `'\0'` - Null = 0, - /// [Start Of Heading](http://en.wikipedia.org/wiki/Start_of_Heading) - SOH = 1, - /// [Start Of teXt](http://en.wikipedia.org/wiki/Start_of_Text) - SOX = 2, - /// [End of TeXt](http://en.wikipedia.org/wiki/End-of-Text_character) - ETX = 3, - /// [End Of Transmission](http://en.wikipedia.org/wiki/End-of-Transmission_character) - EOT = 4, - /// [Enquiry](http://en.wikipedia.org/wiki/Enquiry_character) - ENQ = 5, - /// [Acknowledgement](http://en.wikipedia.org/wiki/Acknowledge_character) - ACK = 6, - /// [bell / alarm / audible](http://en.wikipedia.org/wiki/Bell_character) - /// - /// `'\a'` is not recognized by Rust. - Bell = 7, - /// [Backspace](http://en.wikipedia.org/wiki/Backspace) - /// - /// `'\b'` is not recognized by Rust. - BackSpace = 8, - /// `'\t'` - Tab = 9, - /// `'\n'` - LineFeed = 10, - /// [Vertical tab](http://en.wikipedia.org/wiki/Vertical_Tab) - /// - /// `'\v'` is not recognized by Rust. - VT = 11, - /// [Form Feed](http://en.wikipedia.org/wiki/Form_Feed) - /// - /// `'\f'` is not recognized by Rust. - FF = 12, - /// `'\r'` - CarriageReturn = 13, - /// [Shift In](http://en.wikipedia.org/wiki/Shift_Out_and_Shift_In_characters) - SI = 14, - /// [Shift Out](http://en.wikipedia.org/wiki/Shift_Out_and_Shift_In_characters) - SO = 15, - /// [Data Link Escape](http://en.wikipedia.org/wiki/Data_Link_Escape) - DLE = 16, - /// [Device control 1, often XON](http://en.wikipedia.org/wiki/Device_Control_1) - DC1 = 17, - /// Device control 2 - DC2 = 18, - /// Device control 3, Often XOFF - DC3 = 19, - /// Device control 4 - DC4 = 20, - /// [Negative AcKnowledgement](http://en.wikipedia.org/wiki/Negative-acknowledge_character) - NAK = 21, - /// [Synchronous idle](http://en.wikipedia.org/wiki/Synchronous_Idle) - SYN = 22, - /// [End of Transmission Block](http://en.wikipedia.org/wiki/End-of-Transmission-Block_character) - ETB = 23, - /// [Cancel](http://en.wikipedia.org/wiki/Cancel_character) - CAN = 24, - /// [End of Medium](http://en.wikipedia.org/wiki/End_of_Medium) - EM = 25, - /// [Substitute](http://en.wikipedia.org/wiki/Substitute_character) - SUB = 26, - /// [Escape](http://en.wikipedia.org/wiki/Escape_character) - /// - /// `'\e'` is not recognized by Rust. - ESC = 27, - /// [File Separator](http://en.wikipedia.org/wiki/File_separator) - FS = 28, - /// [Group Separator](http://en.wikipedia.org/wiki/Group_separator) - GS = 29, - /// [Record Separator](http://en.wikipedia.org/wiki/Record_separator) - RS = 30, - /// [Unit Separator](http://en.wikipedia.org/wiki/Unit_separator) - US = 31, - /// `' '` - Space = 32, - /// `'!'` - Exclamation = 33, - /// `'"'` - Quotation = 34, - /// `'#'` - Hash = 35, - /// `'$'` - Dollar = 36, - /// `'%'` - Percent = 37, - /// `'&'` - Ampersand = 38, - /// `'\''` - Apostrophe = 39, - /// `'('` - ParenOpen = 40, - /// `')'` - ParenClose = 41, - /// `'*'` - Asterisk = 42, - /// `'+'` - Plus = 43, - /// `','` - Comma = 44, - /// `'-'` - Minus = 45, - /// `'.'` - Dot = 46, - /// `'/'` - Slash = 47, - /// `'0'` - _0 = 48, - /// `'1'` - _1 = 49, - /// `'2'` - _2 = 50, - /// `'3'` - _3 = 51, - /// `'4'` - _4 = 52, - /// `'5'` - _5 = 53, - /// `'6'` - _6 = 54, - /// `'7'` - _7 = 55, - /// `'8'` - _8 = 56, - /// `'9'` - _9 = 57, - /// `':'` - Colon = 58, - /// `';'` - Semicolon = 59, - /// `'<'` - LessThan = 60, - /// `'='` - Equal = 61, - /// `'>'` - GreaterThan = 62, - /// `'?'` - Question = 63, - /// `'@'` - At = 64, - /// `'A'` - A = 65, - /// `'B'` - B = 66, - /// `'C'` - C = 67, - /// `'D'` - D = 68, - /// `'E'` - E = 69, - /// `'F'` - F = 70, - /// `'G'` - G = 71, - /// `'H'` - H = 72, - /// `'I'` - I = 73, - /// `'J'` - J = 74, - /// `'K'` - K = 75, - /// `'L'` - L = 76, - /// `'M'` - M = 77, - /// `'N'` - N = 78, - /// `'O'` - O = 79, - /// `'P'` - P = 80, - /// `'Q'` - Q = 81, - /// `'R'` - R = 82, - /// `'S'` - S = 83, - /// `'T'` - T = 84, - /// `'U'` - U = 85, - /// `'V'` - V = 86, - /// `'W'` - W = 87, - /// `'X'` - X = 88, - /// `'Y'` - Y = 89, - /// `'Z'` - Z = 90, - /// `'['` - BracketOpen = 91, - /// `'\'` - BackSlash = 92, - /// `']'` - BracketClose = 93, - /// `'^'` - Caret = 94, - /// `'_'` - UnderScore = 95, - /// `'`'` - Grave = 96, - /// `'a'` - a = 97, - /// `'b'` - b = 98, - /// `'c'` - c = 99, - /// `'d'` - d = 100, - /// `'e'` - e = 101, - /// `'f'` - f = 102, - /// `'g'` - g = 103, - /// `'h'` - h = 104, - /// `'i'` - i = 105, - /// `'j'` - j = 106, - /// `'k'` - k = 107, - /// `'l'` - l = 108, - /// `'m'` - m = 109, - /// `'n'` - n = 110, - /// `'o'` - o = 111, - /// `'p'` - p = 112, - /// `'q'` - q = 113, - /// `'r'` - r = 114, - /// `'s'` - s = 115, - /// `'t'` - t = 116, - /// `'u'` - u = 117, - /// `'v'` - v = 118, - /// `'w'` - w = 119, - /// `'x'` - x = 120, - /// `'y'` - y = 121, - /// `'z'` - z = 122, - /// `'{'` - CurlyBraceOpen = 123, - /// `'|'` - VerticalBar = 124, - /// `'}'` - CurlyBraceClose = 125, - /// `'~'` - Tilde = 126, - /// [Delete](http://en.wikipedia.org/wiki/Delete_character) - DEL = 127, -} - -impl AsciiChar { - /// Constructs an ASCII character from a `u8`, `char` or other character type. - /// - /// # Errors - /// Returns `Err(())` if the character can't be ASCII encoded. - /// - /// # Example - /// ``` - /// # use ascii::AsciiChar; - /// let a = AsciiChar::from_ascii('g').unwrap(); - /// assert_eq!(a.as_char(), 'g'); - /// ``` - #[inline] - pub fn from_ascii(ch: C) -> Result { - ch.to_ascii_char() - } - - /// Create an `AsciiChar` from a `char`, panicking if it's not ASCII. - /// - /// This function is intended for creating `AsciiChar` values from - /// hardcoded known-good character literals such as `'K'`, `'-'` or `'\0'`, - /// and for use in `const` contexts. - /// Use [`from_ascii()`](#method.from_ascii) instead when you're not - /// certain the character is ASCII. - /// - /// # Examples - /// - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('@'), AsciiChar::At); - /// assert_eq!(AsciiChar::new('C').as_char(), 'C'); - /// ``` - /// - /// In a constant: - /// ``` - /// # use ascii::AsciiChar; - /// const SPLIT_ON: AsciiChar = AsciiChar::new(','); - /// ``` - /// - /// This will not compile: - /// ```compile_fail - /// # use ascii::AsciiChar; - /// const BAD: AsciiChar = AsciiChar::new('Ø'); - /// ``` - /// - /// # Panics - /// - /// This function will panic if passed a non-ASCII character. - /// - /// The panic message might not be the most descriptive due to the - /// current limitations of `const fn`. - #[must_use] - pub const fn new(ch: char) -> AsciiChar { - // It's restricted to this function, and without it - // we'd need to specify `AsciiChar::` or `Self::` 128 times. - #[allow(clippy::enum_glob_use)] - use AsciiChar::*; - - #[rustfmt::skip] - const ALL: [AsciiChar; 128] = [ - Null, SOH, SOX, ETX, EOT, ENQ, ACK, Bell, - BackSpace, Tab, LineFeed, VT, FF, CarriageReturn, SI, SO, - DLE, DC1, DC2, DC3, DC4, NAK, SYN, ETB, - CAN, EM, SUB, ESC, FS, GS, RS, US, - Space, Exclamation, Quotation, Hash, Dollar, Percent, Ampersand, Apostrophe, - ParenOpen, ParenClose, Asterisk, Plus, Comma, Minus, Dot, Slash, - _0, _1, _2, _3, _4, _5, _6, _7, - _8, _9, Colon, Semicolon, LessThan, Equal, GreaterThan, Question, - At, A, B, C, D, E, F, G, - H, I, J, K, L, M, N, O, - P, Q, R, S, T, U, V, W, - X, Y, Z, BracketOpen, BackSlash, BracketClose, Caret, UnderScore, - Grave, a, b, c, d, e, f, g, - h, i, j, k, l, m, n, o, - p, q, r, s, t, u, v, w, - x, y, z, CurlyBraceOpen, VerticalBar, CurlyBraceClose, Tilde, DEL, - ]; - - // We want to slice here and detect `const_err` from rustc if the slice is invalid - #[allow(clippy::indexing_slicing)] - ALL[ch as usize] - } - - /// Constructs an ASCII character from a `u8`, `char` or other character - /// type without any checks. - /// - /// # Safety - /// - /// This function is very unsafe as it can create invalid enum - /// discriminants, which instantly creates undefined behavior. - /// (`let _ = AsciiChar::from_ascii_unchecked(200);` alone is UB). - /// - /// The undefined behavior is not just theoretical either: - /// For example, `[0; 128][AsciiChar::from_ascii_unchecked(255) as u8 as usize] = 0` - /// might not panic, creating a buffer overflow, - /// and `Some(AsciiChar::from_ascii_unchecked(128))` might be `None`. - #[inline] - #[must_use] - pub unsafe fn from_ascii_unchecked(ch: u8) -> Self { - // SAFETY: Caller guarantees `ch` is within bounds of ascii. - unsafe { ch.to_ascii_char_unchecked() } - } - - /// Converts an ASCII character into a `u8`. - #[inline] - #[must_use] - pub const fn as_byte(self) -> u8 { - self as u8 - } - - /// Converts an ASCII character into a `char`. - #[inline] - #[must_use] - pub const fn as_char(self) -> char { - self as u8 as char - } - - // the following methods are like ctype, and the implementation is inspired by musl. - // The ascii_ methods take self by reference for maximum compatibility - // with the corresponding methods on u8 and char. - // It is bad for both usability and performance, but marking those - // that doesn't have a non-ascii sibling #[inline] should - // make the compiler optimize away the indirection. - - /// Turns uppercase into lowercase, but also modifies '@' and '<'..='_' - #[must_use] - const fn to_not_upper(self) -> u8 { - self as u8 | 0b010_0000 - } - - /// Check if the character is a letter (a-z, A-Z) - #[inline] - #[must_use] - pub const fn is_alphabetic(self) -> bool { - (self.to_not_upper() >= b'a') & (self.to_not_upper() <= b'z') - } - - /// Check if the character is a letter (a-z, A-Z). - /// - /// This method is identical to [`is_alphabetic()`](#method.is_alphabetic) - #[inline] - #[must_use] - pub const fn is_ascii_alphabetic(&self) -> bool { - self.is_alphabetic() - } - - /// Check if the character is a digit in the given radix. - /// - /// If the radix is always 10 or 16, - /// [`is_ascii_digit()`](#method.is_ascii_digit) and - /// [`is_ascii_hexdigit()`](#method.is_ascii_hexdigit()) will be faster. - /// - /// # Panics - /// - /// Radixes greater than 36 are not supported and will result in a panic. - #[must_use] - pub fn is_digit(self, radix: u32) -> bool { - match (self as u8, radix) { - (b'0'..=b'9', 0..=36) => u32::from(self as u8 - b'0') < radix, - (b'a'..=b'z', 11..=36) => u32::from(self as u8 - b'a') < radix - 10, - (b'A'..=b'Z', 11..=36) => u32::from(self as u8 - b'A') < radix - 10, - (_, 0..=36) => false, - (_, _) => panic!("radixes greater than 36 are not supported"), - } - } - - /// Check if the character is a number (0-9) - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('0').is_ascii_digit(), true); - /// assert_eq!(AsciiChar::new('9').is_ascii_digit(), true); - /// assert_eq!(AsciiChar::new('a').is_ascii_digit(), false); - /// assert_eq!(AsciiChar::new('A').is_ascii_digit(), false); - /// assert_eq!(AsciiChar::new('/').is_ascii_digit(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_digit(&self) -> bool { - (*self as u8 >= b'0') & (*self as u8 <= b'9') - } - - /// Check if the character is a letter or number - #[inline] - #[must_use] - pub const fn is_alphanumeric(self) -> bool { - self.is_alphabetic() | self.is_ascii_digit() - } - - /// Check if the character is a letter or number - /// - /// This method is identical to [`is_alphanumeric()`](#method.is_alphanumeric) - #[inline] - #[must_use] - pub const fn is_ascii_alphanumeric(&self) -> bool { - self.is_alphanumeric() - } - - /// Check if the character is a space or horizontal tab - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert!(AsciiChar::Space.is_ascii_blank()); - /// assert!(AsciiChar::Tab.is_ascii_blank()); - /// assert!(!AsciiChar::VT.is_ascii_blank()); - /// assert!(!AsciiChar::LineFeed.is_ascii_blank()); - /// assert!(!AsciiChar::CarriageReturn.is_ascii_blank()); - /// assert!(!AsciiChar::FF.is_ascii_blank()); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_blank(&self) -> bool { - (*self as u8 == b' ') | (*self as u8 == b'\t') - } - - /// Check if the character one of ' ', '\t', '\n', '\r', - /// '\0xb' (vertical tab) or '\0xc' (form feed). - #[inline] - #[must_use] - pub const fn is_whitespace(self) -> bool { - let b = self as u8; - self.is_ascii_blank() | (b == b'\n') | (b == b'\r') | (b == 0x0b) | (b == 0x0c) - } - - /// Check if the character is a ' ', '\t', '\n', '\r' or '\0xc' (form feed). - /// - /// This method is NOT identical to `is_whitespace()`. - #[inline] - #[must_use] - pub const fn is_ascii_whitespace(&self) -> bool { - self.is_ascii_blank() - | (*self as u8 == b'\n') - | (*self as u8 == b'\r') - | (*self as u8 == 0x0c/*form feed*/) - } - - /// Check if the character is a control character - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('\0').is_ascii_control(), true); - /// assert_eq!(AsciiChar::new('n').is_ascii_control(), false); - /// assert_eq!(AsciiChar::new(' ').is_ascii_control(), false); - /// assert_eq!(AsciiChar::new('\n').is_ascii_control(), true); - /// assert_eq!(AsciiChar::new('\t').is_ascii_control(), true); - /// assert_eq!(AsciiChar::EOT.is_ascii_control(), true); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_control(&self) -> bool { - ((*self as u8) < b' ') | (*self as u8 == 127) - } - - /// Checks if the character is printable (except space) - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('n').is_ascii_graphic(), true); - /// assert_eq!(AsciiChar::new(' ').is_ascii_graphic(), false); - /// assert_eq!(AsciiChar::new('\n').is_ascii_graphic(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_graphic(&self) -> bool { - self.as_byte().wrapping_sub(b' ' + 1) < 0x5E - } - - /// Checks if the character is printable (including space) - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('n').is_ascii_printable(), true); - /// assert_eq!(AsciiChar::new(' ').is_ascii_printable(), true); - /// assert_eq!(AsciiChar::new('\n').is_ascii_printable(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_printable(&self) -> bool { - self.as_byte().wrapping_sub(b' ') < 0x5F - } - - /// Checks if the character is alphabetic and lowercase (a-z). - /// - /// # Examples - /// ``` - /// use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('a').is_lowercase(), true); - /// assert_eq!(AsciiChar::new('A').is_lowercase(), false); - /// assert_eq!(AsciiChar::new('@').is_lowercase(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_lowercase(self) -> bool { - self.as_byte().wrapping_sub(b'a') < 26 - } - - /// Checks if the character is alphabetic and lowercase (a-z). - /// - /// This method is identical to [`is_lowercase()`](#method.is_lowercase) - #[inline] - #[must_use] - pub const fn is_ascii_lowercase(&self) -> bool { - self.is_lowercase() - } - - /// Checks if the character is alphabetic and uppercase (A-Z). - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('A').is_uppercase(), true); - /// assert_eq!(AsciiChar::new('a').is_uppercase(), false); - /// assert_eq!(AsciiChar::new('@').is_uppercase(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_uppercase(self) -> bool { - self.as_byte().wrapping_sub(b'A') < 26 - } - - /// Checks if the character is alphabetic and uppercase (A-Z). - /// - /// This method is identical to [`is_uppercase()`](#method.is_uppercase) - #[inline] - #[must_use] - pub const fn is_ascii_uppercase(&self) -> bool { - self.is_uppercase() - } - - /// Checks if the character is punctuation - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('n').is_ascii_punctuation(), false); - /// assert_eq!(AsciiChar::new(' ').is_ascii_punctuation(), false); - /// assert_eq!(AsciiChar::new('_').is_ascii_punctuation(), true); - /// assert_eq!(AsciiChar::new('~').is_ascii_punctuation(), true); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_punctuation(&self) -> bool { - self.is_ascii_graphic() & !self.is_alphanumeric() - } - - /// Checks if the character is a valid hex digit - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('5').is_ascii_hexdigit(), true); - /// assert_eq!(AsciiChar::new('a').is_ascii_hexdigit(), true); - /// assert_eq!(AsciiChar::new('F').is_ascii_hexdigit(), true); - /// assert_eq!(AsciiChar::new('G').is_ascii_hexdigit(), false); - /// assert_eq!(AsciiChar::new(' ').is_ascii_hexdigit(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_hexdigit(&self) -> bool { - self.is_ascii_digit() | ((*self as u8 | 0x20_u8).wrapping_sub(b'a') < 6) - } - - /// Unicode has printable versions of the ASCII control codes, like '␛'. - /// - /// This function is identical with `.as_char()` - /// for all values `.is_printable()` returns true for, - /// but replaces the control codes with those unicodes printable versions. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('\0').as_printable_char(), '␀'); - /// assert_eq!(AsciiChar::new('\n').as_printable_char(), '␊'); - /// assert_eq!(AsciiChar::new(' ').as_printable_char(), ' '); - /// assert_eq!(AsciiChar::new('p').as_printable_char(), 'p'); - /// ``` - #[must_use] - pub fn as_printable_char(self) -> char { - match self as u8 { - // Non printable characters - // SAFETY: From codepoint 0x2400 ('␀') to 0x241f (`␟`), there are characters representing - // the unprintable characters from 0x0 to 0x1f, ordered correctly. - // As `b` is guaranteed to be within 0x0 to 0x1f, the conversion represents a - // valid character. - b @ 0x0..=0x1f => unsafe { char::from_u32_unchecked(u32::from('␀') + u32::from(b)) }, - - // 0x7f (delete) has it's own character at codepoint 0x2420, not 0x247f, so it is special - // cased to return it's character - 0x7f => '␡', - - // All other characters are printable, and per function contract use `Self::as_char` - _ => self.as_char(), - } - } - - /// Replaces letters `a` to `z` with `A` to `Z` - pub fn make_ascii_uppercase(&mut self) { - *self = self.to_ascii_uppercase(); - } - - /// Replaces letters `A` to `Z` with `a` to `z` - pub fn make_ascii_lowercase(&mut self) { - *self = self.to_ascii_lowercase(); - } - - /// Maps letters a-z to A-Z and returns any other character unchanged. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('u').to_ascii_uppercase().as_char(), 'U'); - /// assert_eq!(AsciiChar::new('U').to_ascii_uppercase().as_char(), 'U'); - /// assert_eq!(AsciiChar::new('2').to_ascii_uppercase().as_char(), '2'); - /// assert_eq!(AsciiChar::new('=').to_ascii_uppercase().as_char(), '='); - /// assert_eq!(AsciiChar::new('[').to_ascii_uppercase().as_char(), '['); - /// ``` - #[inline] - #[must_use] - #[allow(clippy::indexing_slicing)] // We're sure it'll either access one or the other, as `bool` is either `0` or `1` - pub const fn to_ascii_uppercase(&self) -> Self { - [*self, AsciiChar::new((*self as u8 & 0b101_1111) as char)][self.is_lowercase() as usize] - } - - /// Maps letters A-Z to a-z and returns any other character unchanged. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('U').to_ascii_lowercase().as_char(), 'u'); - /// assert_eq!(AsciiChar::new('u').to_ascii_lowercase().as_char(), 'u'); - /// assert_eq!(AsciiChar::new('2').to_ascii_lowercase().as_char(), '2'); - /// assert_eq!(AsciiChar::new('^').to_ascii_lowercase().as_char(), '^'); - /// assert_eq!(AsciiChar::new('\x7f').to_ascii_lowercase().as_char(), '\x7f'); - /// ``` - #[inline] - #[must_use] - #[allow(clippy::indexing_slicing)] // We're sure it'll either access one or the other, as `bool` is either `0` or `1` - pub const fn to_ascii_lowercase(&self) -> Self { - [*self, AsciiChar::new(self.to_not_upper() as char)][self.is_uppercase() as usize] - } - - /// Compares two characters case-insensitively. - #[inline] - #[must_use] - pub const fn eq_ignore_ascii_case(&self, other: &Self) -> bool { - (self.as_byte() == other.as_byte()) - | (self.is_alphabetic() & (self.to_not_upper() == other.to_not_upper())) - } -} - -impl fmt::Display for AsciiChar { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.as_char().fmt(f) - } -} - -impl fmt::Debug for AsciiChar { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.as_char().fmt(f) - } -} - -impl Default for AsciiChar { - fn default() -> AsciiChar { - AsciiChar::Null - } -} - -macro_rules! impl_into_partial_eq_ord { - ($wider:ty, $to_wider:expr) => { - impl From for $wider { - #[inline] - fn from(a: AsciiChar) -> $wider { - $to_wider(a) - } - } - impl PartialEq<$wider> for AsciiChar { - #[inline] - fn eq(&self, rhs: &$wider) -> bool { - $to_wider(*self) == *rhs - } - } - impl PartialEq for $wider { - #[inline] - fn eq(&self, rhs: &AsciiChar) -> bool { - *self == $to_wider(*rhs) - } - } - impl PartialOrd<$wider> for AsciiChar { - #[inline] - fn partial_cmp(&self, rhs: &$wider) -> Option { - $to_wider(*self).partial_cmp(rhs) - } - } - impl PartialOrd for $wider { - #[inline] - fn partial_cmp(&self, rhs: &AsciiChar) -> Option { - self.partial_cmp(&$to_wider(*rhs)) - } - } - }; -} -impl_into_partial_eq_ord! {u8, AsciiChar::as_byte} -impl_into_partial_eq_ord! {char, AsciiChar::as_char} - -/// Error returned by `ToAsciiChar`. -#[derive(Clone, Copy, PartialEq, Eq)] -pub struct ToAsciiCharError(()); - -const ERRORMSG_CHAR: &str = "not an ASCII character"; - -#[cfg(not(feature = "std"))] -impl ToAsciiCharError { - /// Returns a description for this error, like `std::error::Error::description`. - #[inline] - #[must_use] - #[allow(clippy::unused_self)] - pub const fn description(&self) -> &'static str { - ERRORMSG_CHAR - } -} - -impl fmt::Debug for ToAsciiCharError { - fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { - write!(fmtr, "{}", ERRORMSG_CHAR) - } -} - -impl fmt::Display for ToAsciiCharError { - fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { - write!(fmtr, "{}", ERRORMSG_CHAR) - } -} - -#[cfg(feature = "std")] -impl Error for ToAsciiCharError { - #[inline] - fn description(&self) -> &'static str { - ERRORMSG_CHAR - } -} - -/// Convert `char`, `u8` and other character types to `AsciiChar`. -pub trait ToAsciiChar { - /// Convert to `AsciiChar`. - /// - /// # Errors - /// If `self` is outside the valid ascii range, this returns `Err` - fn to_ascii_char(self) -> Result; - - /// Convert to `AsciiChar` without checking that it is an ASCII character. - /// - /// # Safety - /// Calling this function with a value outside of the ascii range, `0x0` to `0x7f` inclusive, - /// is undefined behavior. - // TODO: Make sure this is the contract we want to express in this function. - // It is ambigous if numbers such as `0xffffff20_u32` are valid ascii characters, - // as this function returns `Ascii::Space` due to the cast to `u8`, even though - // `to_ascii_char` returns `Err()`. - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar; -} - -impl ToAsciiChar for AsciiChar { - #[inline] - fn to_ascii_char(self) -> Result { - Ok(self) - } - - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - self - } -} - -impl ToAsciiChar for u8 { - #[inline] - fn to_ascii_char(self) -> Result { - u32::from(self).to_ascii_char() - } - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - // SAFETY: Caller guarantees `self` is within bounds of the enum - // variants, so this cast successfully produces a valid ascii - // variant - unsafe { mem::transmute::(self) } - } -} - -// Note: Casts to `u8` here does not cause problems, as the negative -// range is mapped outside of ascii bounds and we don't mind losing -// the sign, as long as negative numbers are mapped outside ascii range. -#[allow(clippy::cast_sign_loss)] -impl ToAsciiChar for i8 { - #[inline] - fn to_ascii_char(self) -> Result { - u32::from(self as u8).to_ascii_char() - } - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - // SAFETY: Caller guarantees `self` is within bounds of the enum - // variants, so this cast successfully produces a valid ascii - // variant - unsafe { mem::transmute::(self as u8) } - } -} - -impl ToAsciiChar for char { - #[inline] - fn to_ascii_char(self) -> Result { - u32::from(self).to_ascii_char() - } - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - // SAFETY: Caller guarantees we're within ascii range. - unsafe { u32::from(self).to_ascii_char_unchecked() } - } -} - -impl ToAsciiChar for u32 { - fn to_ascii_char(self) -> Result { - match self { - // SAFETY: We're within the valid ascii range in this branch. - 0x0..=0x7f => Ok(unsafe { self.to_ascii_char_unchecked() }), - _ => Err(ToAsciiCharError(())), - } - } - - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - // Note: This cast discards the top bytes, this may cause problems, see - // the TODO on this method's documentation in the trait. - // SAFETY: Caller guarantees we're within ascii range. - #[allow(clippy::cast_possible_truncation)] // We want to truncate it - unsafe { - (self as u8).to_ascii_char_unchecked() - } - } -} - -impl ToAsciiChar for u16 { - fn to_ascii_char(self) -> Result { - u32::from(self).to_ascii_char() - } - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - // Note: This cast discards the top bytes, this may cause problems, see - // the TODO on this method's documentation in the trait. - // SAFETY: Caller guarantees we're within ascii range. - #[allow(clippy::cast_possible_truncation)] // We want to truncate it - unsafe { - (self as u8).to_ascii_char_unchecked() - } - } -} - -#[cfg(test)] -mod tests { - use super::{AsciiChar, ToAsciiChar, ToAsciiCharError}; - - #[test] - fn to_ascii_char() { - fn generic(ch: C) -> Result { - ch.to_ascii_char() - } - assert_eq!(generic(AsciiChar::A), Ok(AsciiChar::A)); - assert_eq!(generic(b'A'), Ok(AsciiChar::A)); - assert_eq!(generic('A'), Ok(AsciiChar::A)); - assert!(generic(200_u16).is_err()); - assert!(generic('λ').is_err()); - } - - #[test] - fn as_byte_and_char() { - assert_eq!(AsciiChar::A.as_byte(), b'A'); - assert_eq!(AsciiChar::A.as_char(), 'A'); - } - - #[test] - fn new_array_is_correct() { - for byte in 0..128_u8 { - assert_eq!(AsciiChar::new(byte as char).as_byte(), byte); - } - } - - #[test] - fn is_all() { - #![allow(clippy::is_digit_ascii_radix)] // testing it - for byte in 0..128_u8 { - let ch = byte as char; - let ascii = AsciiChar::new(ch); - assert_eq!(ascii.is_alphabetic(), ch.is_alphabetic()); - assert_eq!(ascii.is_ascii_alphabetic(), ch.is_ascii_alphabetic()); - assert_eq!(ascii.is_alphanumeric(), ch.is_alphanumeric()); - assert_eq!(ascii.is_ascii_alphanumeric(), ch.is_ascii_alphanumeric()); - assert_eq!(ascii.is_digit(8), ch.is_digit(8), "is_digit(8) {:?}", ch); - assert_eq!(ascii.is_digit(10), ch.is_digit(10), "is_digit(10) {:?}", ch); - assert_eq!(ascii.is_digit(16), ch.is_digit(16), "is_digit(16) {:?}", ch); - assert_eq!(ascii.is_digit(36), ch.is_digit(36), "is_digit(36) {:?}", ch); - assert_eq!(ascii.is_ascii_digit(), ch.is_ascii_digit()); - assert_eq!(ascii.is_ascii_hexdigit(), ch.is_ascii_hexdigit()); - assert_eq!(ascii.is_ascii_control(), ch.is_ascii_control()); - assert_eq!(ascii.is_ascii_graphic(), ch.is_ascii_graphic()); - assert_eq!(ascii.is_ascii_punctuation(), ch.is_ascii_punctuation()); - assert_eq!( - ascii.is_whitespace(), - ch.is_whitespace(), - "{:?} ({:#04x})", - ch, - byte - ); - assert_eq!( - ascii.is_ascii_whitespace(), - ch.is_ascii_whitespace(), - "{:?} ({:#04x})", - ch, - byte - ); - assert_eq!(ascii.is_uppercase(), ch.is_uppercase()); - assert_eq!(ascii.is_ascii_uppercase(), ch.is_ascii_uppercase()); - assert_eq!(ascii.is_lowercase(), ch.is_lowercase()); - assert_eq!(ascii.is_ascii_lowercase(), ch.is_ascii_lowercase()); - assert_eq!(ascii.to_ascii_uppercase(), ch.to_ascii_uppercase()); - assert_eq!(ascii.to_ascii_lowercase(), ch.to_ascii_lowercase()); - } - } - - #[test] - fn is_digit_strange_radixes() { - assert_eq!(AsciiChar::_0.is_digit(0), '0'.is_digit(0)); - assert_eq!(AsciiChar::_0.is_digit(1), '0'.is_digit(1)); - assert_eq!(AsciiChar::_5.is_digit(5), '5'.is_digit(5)); - assert_eq!(AsciiChar::z.is_digit(35), 'z'.is_digit(35)); - } - - #[test] - #[should_panic] - fn is_digit_bad_radix() { - let _ = AsciiChar::_7.is_digit(37); - } - - #[test] - fn cmp_wider() { - assert_eq!(AsciiChar::A, 'A'); - assert_eq!(b'b', AsciiChar::b); - assert!(AsciiChar::a < 'z'); - } - - #[test] - fn ascii_case() { - assert_eq!(AsciiChar::At.to_ascii_lowercase(), AsciiChar::At); - assert_eq!(AsciiChar::At.to_ascii_uppercase(), AsciiChar::At); - assert_eq!(AsciiChar::A.to_ascii_lowercase(), AsciiChar::a); - assert_eq!(AsciiChar::A.to_ascii_uppercase(), AsciiChar::A); - assert_eq!(AsciiChar::a.to_ascii_lowercase(), AsciiChar::a); - assert_eq!(AsciiChar::a.to_ascii_uppercase(), AsciiChar::A); - - let mut mutable = (AsciiChar::A, AsciiChar::a); - mutable.0.make_ascii_lowercase(); - mutable.1.make_ascii_uppercase(); - assert_eq!(mutable.0, AsciiChar::a); - assert_eq!(mutable.1, AsciiChar::A); - - assert!(AsciiChar::LineFeed.eq_ignore_ascii_case(&AsciiChar::LineFeed)); - assert!(!AsciiChar::LineFeed.eq_ignore_ascii_case(&AsciiChar::CarriageReturn)); - assert!(AsciiChar::z.eq_ignore_ascii_case(&AsciiChar::Z)); - assert!(AsciiChar::Z.eq_ignore_ascii_case(&AsciiChar::z)); - assert!(AsciiChar::A.eq_ignore_ascii_case(&AsciiChar::a)); - assert!(!AsciiChar::K.eq_ignore_ascii_case(&AsciiChar::C)); - assert!(!AsciiChar::Z.eq_ignore_ascii_case(&AsciiChar::DEL)); - assert!(!AsciiChar::BracketOpen.eq_ignore_ascii_case(&AsciiChar::CurlyBraceOpen)); - assert!(!AsciiChar::Grave.eq_ignore_ascii_case(&AsciiChar::At)); - assert!(!AsciiChar::Grave.eq_ignore_ascii_case(&AsciiChar::DEL)); - } - - #[test] - #[cfg(feature = "std")] - fn fmt_ascii() { - assert_eq!(format!("{}", AsciiChar::t), "t"); - assert_eq!(format!("{:?}", AsciiChar::t), "'t'"); - assert_eq!(format!("{}", AsciiChar::LineFeed), "\n"); - assert_eq!(format!("{:?}", AsciiChar::LineFeed), "'\\n'"); - } -} diff --git a/anneal/vendor/ascii/src/ascii_str.rs b/anneal/vendor/ascii/src/ascii_str.rs deleted file mode 100644 index e8a6e12550..0000000000 --- a/anneal/vendor/ascii/src/ascii_str.rs +++ /dev/null @@ -1,1600 +0,0 @@ -#[cfg(feature = "alloc")] -use alloc::borrow::ToOwned; -#[cfg(feature = "alloc")] -use alloc::boxed::Box; -use core::fmt; -use core::ops::{Index, IndexMut}; -use core::ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive}; -use core::slice::{self, Iter, IterMut, SliceIndex}; -#[cfg(feature = "std")] -use std::error::Error; -#[cfg(feature = "std")] -use std::ffi::CStr; - -use ascii_char::AsciiChar; -#[cfg(feature = "alloc")] -use ascii_string::AsciiString; - -/// [`AsciiStr`] represents a byte or string slice that only contains ASCII characters. -/// -/// It wraps an `[AsciiChar]` and implements many of `str`s methods and traits. -/// -/// It can be created by a checked conversion from a `str` or `[u8]`, or borrowed from an -/// `AsciiString`. -#[derive(PartialEq, Eq, PartialOrd, Ord, Hash)] -#[repr(transparent)] -pub struct AsciiStr { - slice: [AsciiChar], -} - -impl AsciiStr { - /// Converts `&self` to a `&str` slice. - #[inline] - #[must_use] - pub fn as_str(&self) -> &str { - // SAFETY: All variants of `AsciiChar` are valid bytes for a `str`. - unsafe { &*(self as *const AsciiStr as *const str) } - } - - /// Converts `&self` into a byte slice. - #[inline] - #[must_use] - pub fn as_bytes(&self) -> &[u8] { - // SAFETY: All variants of `AsciiChar` are valid `u8`, given they're `repr(u8)`. - unsafe { &*(self as *const AsciiStr as *const [u8]) } - } - - /// Returns the entire string as slice of `AsciiChar`s. - #[inline] - #[must_use] - pub const fn as_slice(&self) -> &[AsciiChar] { - &self.slice - } - - /// Returns the entire string as mutable slice of `AsciiChar`s. - #[inline] - #[must_use] - pub fn as_mut_slice(&mut self) -> &mut [AsciiChar] { - &mut self.slice - } - - /// Returns a raw pointer to the `AsciiStr`'s buffer. - /// - /// The caller must ensure that the slice outlives the pointer this function returns, or else it - /// will end up pointing to garbage. Modifying the `AsciiStr` may cause it's buffer to be - /// reallocated, which would also make any pointers to it invalid. - #[inline] - #[must_use] - pub const fn as_ptr(&self) -> *const AsciiChar { - self.as_slice().as_ptr() - } - - /// Returns an unsafe mutable pointer to the `AsciiStr`'s buffer. - /// - /// The caller must ensure that the slice outlives the pointer this function returns, or else it - /// will end up pointing to garbage. Modifying the `AsciiStr` may cause it's buffer to be - /// reallocated, which would also make any pointers to it invalid. - #[inline] - #[must_use] - pub fn as_mut_ptr(&mut self) -> *mut AsciiChar { - self.as_mut_slice().as_mut_ptr() - } - - /// Copies the content of this `AsciiStr` into an owned `AsciiString`. - #[cfg(feature = "alloc")] - #[must_use] - pub fn to_ascii_string(&self) -> AsciiString { - AsciiString::from(self.slice.to_vec()) - } - - /// Converts anything that can represent a byte slice into an `AsciiStr`. - /// - /// # Errors - /// If `bytes` contains a non-ascii byte, `Err` will be returned - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let foo = AsciiStr::from_ascii(b"foo"); - /// let err = AsciiStr::from_ascii("Ŋ"); - /// assert_eq!(foo.unwrap().as_str(), "foo"); - /// assert_eq!(err.unwrap_err().valid_up_to(), 0); - /// ``` - #[inline] - pub fn from_ascii(bytes: &B) -> Result<&AsciiStr, AsAsciiStrError> - where - B: AsRef<[u8]> + ?Sized, - { - bytes.as_ref().as_ascii_str() - } - - /// Converts anything that can be represented as a byte slice to an `AsciiStr` without checking - /// for non-ASCII characters.. - /// - /// # Safety - /// If any of the bytes in `bytes` do not represent valid ascii characters, calling - /// this function is undefined behavior. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let foo = unsafe { AsciiStr::from_ascii_unchecked(&b"foo"[..]) }; - /// assert_eq!(foo.as_str(), "foo"); - /// ``` - #[inline] - #[must_use] - pub unsafe fn from_ascii_unchecked(bytes: &[u8]) -> &AsciiStr { - // SAFETY: Caller guarantees all bytes in `bytes` are valid - // ascii characters. - unsafe { bytes.as_ascii_str_unchecked() } - } - - /// Returns the number of characters / bytes in this ASCII sequence. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let s = AsciiStr::from_ascii("foo").unwrap(); - /// assert_eq!(s.len(), 3); - /// ``` - #[inline] - #[must_use] - pub const fn len(&self) -> usize { - self.slice.len() - } - - /// Returns true if the ASCII slice contains zero bytes. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let mut empty = AsciiStr::from_ascii("").unwrap(); - /// let mut full = AsciiStr::from_ascii("foo").unwrap(); - /// assert!(empty.is_empty()); - /// assert!(!full.is_empty()); - /// ``` - #[inline] - #[must_use] - pub const fn is_empty(&self) -> bool { - self.len() == 0 - } - - /// Returns an iterator over the characters of the `AsciiStr`. - #[inline] - #[must_use] - pub fn chars(&self) -> Chars { - Chars(self.slice.iter()) - } - - /// Returns an iterator over the characters of the `AsciiStr` which allows you to modify the - /// value of each `AsciiChar`. - #[inline] - #[must_use] - pub fn chars_mut(&mut self) -> CharsMut { - CharsMut(self.slice.iter_mut()) - } - - /// Returns an iterator over parts of the `AsciiStr` separated by a character. - /// - /// # Examples - /// ``` - /// # use ascii::{AsciiStr, AsciiChar}; - /// let words = AsciiStr::from_ascii("apple banana lemon").unwrap() - /// .split(AsciiChar::Space) - /// .map(|a| a.as_str()) - /// .collect::>(); - /// assert_eq!(words, ["apple", "banana", "lemon"]); - /// ``` - #[must_use] - pub fn split(&self, on: AsciiChar) -> impl DoubleEndedIterator { - Split { - on, - ended: false, - chars: self.chars(), - } - } - - /// Returns an iterator over the lines of the `AsciiStr`, which are themselves `AsciiStr`s. - /// - /// Lines are ended with either `LineFeed` (`\n`), or `CarriageReturn` then `LineFeed` (`\r\n`). - /// - /// The final line ending is optional. - #[inline] - #[must_use] - pub fn lines(&self) -> impl DoubleEndedIterator { - Lines { string: self } - } - - /// Returns an ASCII string slice with leading and trailing whitespace removed. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let example = AsciiStr::from_ascii(" \twhite \tspace \t").unwrap(); - /// assert_eq!("white \tspace", example.trim()); - /// ``` - #[must_use] - pub fn trim(&self) -> &Self { - self.trim_start().trim_end() - } - - /// Returns an ASCII string slice with leading whitespace removed. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let example = AsciiStr::from_ascii(" \twhite \tspace \t").unwrap(); - /// assert_eq!("white \tspace \t", example.trim_start()); - /// ``` - #[must_use] - pub fn trim_start(&self) -> &Self { - let whitespace_len = self - .chars() - .position(|ch| !ch.is_whitespace()) - .unwrap_or_else(|| self.len()); - - // SAFETY: `whitespace_len` is `0..=len`, which is at most `len`, which is a valid empty slice. - unsafe { self.as_slice().get_unchecked(whitespace_len..).into() } - } - - /// Returns an ASCII string slice with trailing whitespace removed. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let example = AsciiStr::from_ascii(" \twhite \tspace \t").unwrap(); - /// assert_eq!(" \twhite \tspace", example.trim_end()); - /// ``` - #[must_use] - pub fn trim_end(&self) -> &Self { - // Number of whitespace characters counting from the end - let whitespace_len = self - .chars() - .rev() - .position(|ch| !ch.is_whitespace()) - .unwrap_or_else(|| self.len()); - - // SAFETY: `whitespace_len` is `0..=len`, which is at most `len`, which is a valid empty slice, and at least `0`, which is the whole slice. - unsafe { - self.as_slice() - .get_unchecked(..self.len() - whitespace_len) - .into() - } - } - - /// Compares two strings case-insensitively. - #[must_use] - pub fn eq_ignore_ascii_case(&self, other: &Self) -> bool { - self.len() == other.len() - && self - .chars() - .zip(other.chars()) - .all(|(ch, other_ch)| ch.eq_ignore_ascii_case(&other_ch)) - } - - /// Replaces lowercase letters with their uppercase equivalent. - pub fn make_ascii_uppercase(&mut self) { - for ch in self.chars_mut() { - *ch = ch.to_ascii_uppercase(); - } - } - - /// Replaces uppercase letters with their lowercase equivalent. - pub fn make_ascii_lowercase(&mut self) { - for ch in self.chars_mut() { - *ch = ch.to_ascii_lowercase(); - } - } - - /// Returns a copy of this string where letters 'a' to 'z' are mapped to 'A' to 'Z'. - #[cfg(feature = "alloc")] - #[must_use] - pub fn to_ascii_uppercase(&self) -> AsciiString { - let mut ascii_string = self.to_ascii_string(); - ascii_string.make_ascii_uppercase(); - ascii_string - } - - /// Returns a copy of this string where letters 'A' to 'Z' are mapped to 'a' to 'z'. - #[cfg(feature = "alloc")] - #[must_use] - pub fn to_ascii_lowercase(&self) -> AsciiString { - let mut ascii_string = self.to_ascii_string(); - ascii_string.make_ascii_lowercase(); - ascii_string - } - - /// Returns the first character if the string is not empty. - #[inline] - #[must_use] - pub fn first(&self) -> Option { - self.slice.first().copied() - } - - /// Returns the last character if the string is not empty. - #[inline] - #[must_use] - pub fn last(&self) -> Option { - self.slice.last().copied() - } - - /// Converts a [`Box`] into a [`AsciiString`] without copying or allocating. - #[cfg(feature = "alloc")] - #[inline] - #[must_use] - pub fn into_ascii_string(self: Box) -> AsciiString { - let slice = Box::<[AsciiChar]>::from(self); - AsciiString::from(slice.into_vec()) - } -} - -macro_rules! impl_partial_eq { - ($wider: ty) => { - impl PartialEq<$wider> for AsciiStr { - #[inline] - fn eq(&self, other: &$wider) -> bool { - >::as_ref(self) == other - } - } - impl PartialEq for $wider { - #[inline] - fn eq(&self, other: &AsciiStr) -> bool { - self == >::as_ref(other) - } - } - }; -} - -impl_partial_eq! {str} -impl_partial_eq! {[u8]} -impl_partial_eq! {[AsciiChar]} - -#[cfg(feature = "alloc")] -impl ToOwned for AsciiStr { - type Owned = AsciiString; - - #[inline] - fn to_owned(&self) -> AsciiString { - self.to_ascii_string() - } -} - -impl AsRef<[u8]> for AsciiStr { - #[inline] - fn as_ref(&self) -> &[u8] { - self.as_bytes() - } -} -impl AsRef for AsciiStr { - #[inline] - fn as_ref(&self) -> &str { - self.as_str() - } -} -impl AsRef<[AsciiChar]> for AsciiStr { - #[inline] - fn as_ref(&self) -> &[AsciiChar] { - &self.slice - } -} -impl AsMut<[AsciiChar]> for AsciiStr { - #[inline] - fn as_mut(&mut self) -> &mut [AsciiChar] { - &mut self.slice - } -} - -impl Default for &'static AsciiStr { - #[inline] - fn default() -> &'static AsciiStr { - From::from(&[] as &[AsciiChar]) - } -} -impl<'a> From<&'a [AsciiChar]> for &'a AsciiStr { - #[inline] - fn from(slice: &[AsciiChar]) -> &AsciiStr { - let ptr = slice as *const [AsciiChar] as *const AsciiStr; - unsafe { &*ptr } - } -} -impl<'a> From<&'a mut [AsciiChar]> for &'a mut AsciiStr { - #[inline] - fn from(slice: &mut [AsciiChar]) -> &mut AsciiStr { - let ptr = slice as *mut [AsciiChar] as *mut AsciiStr; - unsafe { &mut *ptr } - } -} -#[cfg(feature = "alloc")] -impl From> for Box { - #[inline] - fn from(owned: Box<[AsciiChar]>) -> Box { - let ptr = Box::into_raw(owned) as *mut AsciiStr; - unsafe { Box::from_raw(ptr) } - } -} - -impl AsRef for AsciiStr { - #[inline] - fn as_ref(&self) -> &AsciiStr { - self - } -} -impl AsMut for AsciiStr { - #[inline] - fn as_mut(&mut self) -> &mut AsciiStr { - self - } -} -impl AsRef for [AsciiChar] { - #[inline] - fn as_ref(&self) -> &AsciiStr { - self.into() - } -} -impl AsMut for [AsciiChar] { - #[inline] - fn as_mut(&mut self) -> &mut AsciiStr { - self.into() - } -} - -impl<'a> From<&'a AsciiStr> for &'a [AsciiChar] { - #[inline] - fn from(astr: &AsciiStr) -> &[AsciiChar] { - &astr.slice - } -} -impl<'a> From<&'a mut AsciiStr> for &'a mut [AsciiChar] { - #[inline] - fn from(astr: &mut AsciiStr) -> &mut [AsciiChar] { - &mut astr.slice - } -} -impl<'a> From<&'a AsciiStr> for &'a [u8] { - #[inline] - fn from(astr: &AsciiStr) -> &[u8] { - astr.as_bytes() - } -} -impl<'a> From<&'a AsciiStr> for &'a str { - #[inline] - fn from(astr: &AsciiStr) -> &str { - astr.as_str() - } -} -macro_rules! widen_box { - ($wider: ty) => { - #[cfg(feature = "alloc")] - impl From> for Box<$wider> { - #[inline] - fn from(owned: Box) -> Box<$wider> { - let ptr = Box::into_raw(owned) as *mut $wider; - unsafe { Box::from_raw(ptr) } - } - } - }; -} -widen_box! {[AsciiChar]} -widen_box! {[u8]} -widen_box! {str} - -// allows &AsciiChar to be used by generic AsciiString Extend and FromIterator -impl AsRef for AsciiChar { - fn as_ref(&self) -> &AsciiStr { - slice::from_ref(self).into() - } -} - -impl fmt::Display for AsciiStr { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self.as_str(), f) - } -} - -impl fmt::Debug for AsciiStr { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(self.as_str(), f) - } -} - -macro_rules! impl_index { - ($idx:ty) => { - #[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default - impl Index<$idx> for AsciiStr { - type Output = AsciiStr; - - #[inline] - fn index(&self, index: $idx) -> &AsciiStr { - self.slice[index].as_ref() - } - } - - #[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default - impl IndexMut<$idx> for AsciiStr { - #[inline] - fn index_mut(&mut self, index: $idx) -> &mut AsciiStr { - self.slice[index].as_mut() - } - } - }; -} - -impl_index! { Range } -impl_index! { RangeTo } -impl_index! { RangeFrom } -impl_index! { RangeFull } -impl_index! { RangeInclusive } -impl_index! { RangeToInclusive } - -#[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default -impl Index for AsciiStr { - type Output = AsciiChar; - - #[inline] - fn index(&self, index: usize) -> &AsciiChar { - &self.slice[index] - } -} - -#[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default -impl IndexMut for AsciiStr { - #[inline] - fn index_mut(&mut self, index: usize) -> &mut AsciiChar { - &mut self.slice[index] - } -} - -/// Produces references for compatibility with `[u8]`. -/// -/// (`str` doesn't implement `IntoIterator` for its references, -/// so there is no compatibility to lose.) -impl<'a> IntoIterator for &'a AsciiStr { - type Item = &'a AsciiChar; - type IntoIter = CharsRef<'a>; - #[inline] - fn into_iter(self) -> Self::IntoIter { - CharsRef(self.as_slice().iter()) - } -} - -impl<'a> IntoIterator for &'a mut AsciiStr { - type Item = &'a mut AsciiChar; - type IntoIter = CharsMut<'a>; - #[inline] - fn into_iter(self) -> Self::IntoIter { - self.chars_mut() - } -} - -/// A copying iterator over the characters of an `AsciiStr`. -#[derive(Clone, Debug)] -pub struct Chars<'a>(Iter<'a, AsciiChar>); -impl<'a> Chars<'a> { - /// Returns the ascii string slice with the remaining characters. - #[must_use] - pub fn as_str(&self) -> &'a AsciiStr { - self.0.as_slice().into() - } -} -impl<'a> Iterator for Chars<'a> { - type Item = AsciiChar; - #[inline] - fn next(&mut self) -> Option { - self.0.next().copied() - } - fn size_hint(&self) -> (usize, Option) { - self.0.size_hint() - } -} -impl<'a> DoubleEndedIterator for Chars<'a> { - #[inline] - fn next_back(&mut self) -> Option { - self.0.next_back().copied() - } -} -impl<'a> ExactSizeIterator for Chars<'a> { - fn len(&self) -> usize { - self.0.len() - } -} - -/// A mutable iterator over the characters of an `AsciiStr`. -#[derive(Debug)] -pub struct CharsMut<'a>(IterMut<'a, AsciiChar>); -impl<'a> CharsMut<'a> { - /// Returns the ascii string slice with the remaining characters. - #[must_use] - pub fn into_str(self) -> &'a mut AsciiStr { - self.0.into_slice().into() - } -} -impl<'a> Iterator for CharsMut<'a> { - type Item = &'a mut AsciiChar; - #[inline] - fn next(&mut self) -> Option<&'a mut AsciiChar> { - self.0.next() - } - fn size_hint(&self) -> (usize, Option) { - self.0.size_hint() - } -} -impl<'a> DoubleEndedIterator for CharsMut<'a> { - #[inline] - fn next_back(&mut self) -> Option<&'a mut AsciiChar> { - self.0.next_back() - } -} -impl<'a> ExactSizeIterator for CharsMut<'a> { - fn len(&self) -> usize { - self.0.len() - } -} - -/// An immutable iterator over the characters of an `AsciiStr`. -#[derive(Clone, Debug)] -pub struct CharsRef<'a>(Iter<'a, AsciiChar>); -impl<'a> CharsRef<'a> { - /// Returns the ascii string slice with the remaining characters. - #[must_use] - pub fn as_str(&self) -> &'a AsciiStr { - self.0.as_slice().into() - } -} -impl<'a> Iterator for CharsRef<'a> { - type Item = &'a AsciiChar; - #[inline] - fn next(&mut self) -> Option<&'a AsciiChar> { - self.0.next() - } - fn size_hint(&self) -> (usize, Option) { - self.0.size_hint() - } -} -impl<'a> DoubleEndedIterator for CharsRef<'a> { - #[inline] - fn next_back(&mut self) -> Option<&'a AsciiChar> { - self.0.next_back() - } -} - -/// An iterator over parts of an `AsciiStr` separated by an `AsciiChar`. -/// -/// This type is created by [`AsciiChar::split()`](struct.AsciiChar.html#method.split). -#[derive(Clone, Debug)] -struct Split<'a> { - on: AsciiChar, - ended: bool, - chars: Chars<'a>, -} -impl<'a> Iterator for Split<'a> { - type Item = &'a AsciiStr; - - fn next(&mut self) -> Option<&'a AsciiStr> { - if !self.ended { - let start: &AsciiStr = self.chars.as_str(); - let split_on = self.on; - - if let Some(at) = self.chars.position(|ch| ch == split_on) { - // SAFETY: `at` is guaranteed to be in bounds, as `position` returns `Ok(0..len)`. - Some(unsafe { start.as_slice().get_unchecked(..at).into() }) - } else { - self.ended = true; - Some(start) - } - } else { - None - } - } -} -impl<'a> DoubleEndedIterator for Split<'a> { - fn next_back(&mut self) -> Option<&'a AsciiStr> { - if !self.ended { - let start: &AsciiStr = self.chars.as_str(); - let split_on = self.on; - - if let Some(at) = self.chars.rposition(|ch| ch == split_on) { - // SAFETY: `at` is guaranteed to be in bounds, as `rposition` returns `Ok(0..len)`, and slices `1..`, `2..`, etc... until `len..` inclusive, are valid. - Some(unsafe { start.as_slice().get_unchecked(at + 1..).into() }) - } else { - self.ended = true; - Some(start) - } - } else { - None - } - } -} - -/// An iterator over the lines of the internal character array. -#[derive(Clone, Debug)] -struct Lines<'a> { - string: &'a AsciiStr, -} -impl<'a> Iterator for Lines<'a> { - type Item = &'a AsciiStr; - - fn next(&mut self) -> Option<&'a AsciiStr> { - if let Some(idx) = self - .string - .chars() - .position(|chr| chr == AsciiChar::LineFeed) - { - // SAFETY: `idx` is guaranteed to be `1..len`, as we get it from `position` as `0..len` and make sure it's not `0`. - let line = if idx > 0 - && *unsafe { self.string.as_slice().get_unchecked(idx - 1) } - == AsciiChar::CarriageReturn - { - // SAFETY: As per above, `idx` is guaranteed to be `1..len` - unsafe { self.string.as_slice().get_unchecked(..idx - 1).into() } - } else { - // SAFETY: As per above, `idx` is guaranteed to be `0..len` - unsafe { self.string.as_slice().get_unchecked(..idx).into() } - }; - // SAFETY: As per above, `idx` is guaranteed to be `0..len`, so at the extreme, slicing `len..` is a valid empty slice. - self.string = unsafe { self.string.as_slice().get_unchecked(idx + 1..).into() }; - Some(line) - } else if self.string.is_empty() { - None - } else { - let line = self.string; - // SAFETY: An empty string is a valid string. - self.string = unsafe { AsciiStr::from_ascii_unchecked(b"") }; - Some(line) - } - } -} - -impl<'a> DoubleEndedIterator for Lines<'a> { - fn next_back(&mut self) -> Option<&'a AsciiStr> { - if self.string.is_empty() { - return None; - } - - // If we end with `LF` / `CR/LF`, remove them - if let Some(AsciiChar::LineFeed) = self.string.last() { - // SAFETY: `last()` returned `Some`, so our len is at least 1. - self.string = unsafe { - self.string - .as_slice() - .get_unchecked(..self.string.len() - 1) - .into() - }; - - if let Some(AsciiChar::CarriageReturn) = self.string.last() { - // SAFETY: `last()` returned `Some`, so our len is at least 1. - self.string = unsafe { - self.string - .as_slice() - .get_unchecked(..self.string.len() - 1) - .into() - }; - } - } - - // Get the position of the first `LF` from the end. - let lf_rev_pos = self - .string - .chars() - .rev() - .position(|ch| ch == AsciiChar::LineFeed) - .unwrap_or_else(|| self.string.len()); - - // SAFETY: `lf_rev_pos` will be in range `0..=len`, so `len - lf_rev_pos` - // will be within `0..=len`, making it correct as a start and end - // point for the strings. - let line = unsafe { - self.string - .as_slice() - .get_unchecked(self.string.len() - lf_rev_pos..) - .into() - }; - self.string = unsafe { - self.string - .as_slice() - .get_unchecked(..self.string.len() - lf_rev_pos) - .into() - }; - Some(line) - } -} - -/// Error that is returned when a sequence of `u8` are not all ASCII. -/// -/// Is used by `As[Mut]AsciiStr` and the `from_ascii` method on `AsciiStr` and `AsciiString`. -#[derive(Clone, Copy, PartialEq, Eq, Debug)] -pub struct AsAsciiStrError(usize); - -const ERRORMSG_STR: &str = "one or more bytes are not ASCII"; - -impl AsAsciiStrError { - /// Returns the index of the first non-ASCII byte. - /// - /// It is the maximum index such that `from_ascii(input[..index])` would return `Ok(_)`. - #[inline] - #[must_use] - pub const fn valid_up_to(self) -> usize { - self.0 - } - #[cfg(not(feature = "std"))] - /// Returns a description for this error, like `std::error::Error::description`. - #[inline] - #[must_use] - #[allow(clippy::unused_self)] - pub const fn description(&self) -> &'static str { - ERRORMSG_STR - } -} -impl fmt::Display for AsAsciiStrError { - fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { - write!(fmtr, "the byte at index {} is not ASCII", self.0) - } -} -#[cfg(feature = "std")] -impl Error for AsAsciiStrError { - #[inline] - fn description(&self) -> &'static str { - ERRORMSG_STR - } -} - -/// Convert slices of bytes or [`AsciiChar`] to [`AsciiStr`]. -// Could nearly replace this trait with SliceIndex, but its methods isn't even -// on a path for stabilization. -pub trait AsAsciiStr { - /// Used to constrain `SliceIndex` - #[doc(hidden)] - type Inner; - /// Convert a subslice to an ASCII slice. - /// - /// # Errors - /// Returns `Err` if the range is out of bounds or if not all bytes in the - /// slice are ASCII. The value in the error will be the index of the first - /// non-ASCII byte or the end of the slice. - /// - /// # Examples - /// ``` - /// use ascii::AsAsciiStr; - /// assert!("'zoä'".slice_ascii(..3).is_ok()); - /// assert!("'zoä'".slice_ascii(0..4).is_err()); - /// assert!("'zoä'".slice_ascii(5..=5).is_ok()); - /// assert!("'zoä'".slice_ascii(4..).is_err()); - /// assert!(b"\r\n".slice_ascii(..).is_ok()); - /// ``` - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[Self::Inner], Output = [Self::Inner]>; - /// Convert to an ASCII slice. - /// - /// # Errors - /// Returns `Err` if not all bytes are valid ascii values. - /// - /// # Example - /// ``` - /// use ascii::{AsAsciiStr, AsciiChar}; - /// assert!("ASCII".as_ascii_str().is_ok()); - /// assert!(b"\r\n".as_ascii_str().is_ok()); - /// assert!("'zoä'".as_ascii_str().is_err()); - /// assert!(b"\xff".as_ascii_str().is_err()); - /// assert!([AsciiChar::C][..].as_ascii_str().is_ok()); // infallible - /// ``` - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - self.slice_ascii(..) - } - /// Get a single ASCII character from the slice. - /// - /// Returns `None` if the index is out of bounds or the byte is not ASCII. - /// - /// # Examples - /// ``` - /// use ascii::{AsAsciiStr, AsciiChar}; - /// assert_eq!("'zoä'".get_ascii(4), None); - /// assert_eq!("'zoä'".get_ascii(5), Some(AsciiChar::Apostrophe)); - /// assert_eq!("'zoä'".get_ascii(6), None); - /// ``` - fn get_ascii(&self, index: usize) -> Option { - self.slice_ascii(index..=index) - .ok() - .and_then(AsciiStr::first) - } - /// Convert to an ASCII slice without checking for non-ASCII characters. - /// - /// # Safety - /// Calling this function when `self` contains non-ascii characters is - /// undefined behavior. - /// - /// # Examples - /// - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr; -} - -/// Convert mutable slices of bytes or [`AsciiChar`] to [`AsciiStr`]. -pub trait AsMutAsciiStr: AsAsciiStr { - /// Convert a subslice to an ASCII slice. - /// - /// # Errors - /// This function returns `Err` if range is out of bounds, or if - /// `self` contains non-ascii values - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[Self::Inner], Output = [Self::Inner]>; - - /// Convert to a mutable ASCII slice. - /// - /// # Errors - /// This function returns `Err` if `self` contains non-ascii values - fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError> { - self.slice_ascii_mut(..) - } - - /// Convert to a mutable ASCII slice without checking for non-ASCII characters. - /// - /// # Safety - /// Calling this function when `self` contains non-ascii characters is - /// undefined behavior. - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr; -} - -// These generic implementations mirror the generic implementations for AsRef in core. -impl<'a, T> AsAsciiStr for &'a T -where - T: AsAsciiStr + ?Sized, -{ - type Inner = ::Inner; - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[Self::Inner], Output = [Self::Inner]>, - { - ::slice_ascii(*self, range) - } - - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { ::as_ascii_str_unchecked(*self) } - } -} - -impl<'a, T> AsAsciiStr for &'a mut T -where - T: AsAsciiStr + ?Sized, -{ - type Inner = ::Inner; - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[Self::Inner], Output = [Self::Inner]>, - { - ::slice_ascii(*self, range) - } - - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { ::as_ascii_str_unchecked(*self) } - } -} - -impl<'a, T> AsMutAsciiStr for &'a mut T -where - T: AsMutAsciiStr + ?Sized, -{ - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[Self::Inner], Output = [Self::Inner]>, - { - ::slice_ascii_mut(*self, range) - } - - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { ::as_mut_ascii_str_unchecked(*self) } - } -} - -impl AsAsciiStr for AsciiStr { - type Inner = AsciiChar; - - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[AsciiChar], Output = [AsciiChar]>, - { - self.slice.slice_ascii(range) - } - - #[inline] - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - Ok(self) - } - - #[inline] - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - self - } - - #[inline] - fn get_ascii(&self, index: usize) -> Option { - self.slice.get_ascii(index) - } -} -impl AsMutAsciiStr for AsciiStr { - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[AsciiChar], Output = [AsciiChar]>, - { - self.slice.slice_ascii_mut(range) - } - - #[inline] - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr { - self - } -} - -impl AsAsciiStr for [AsciiChar] { - type Inner = AsciiChar; - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[AsciiChar], Output = [AsciiChar]>, - { - match self.get(range) { - Some(slice) => Ok(slice.into()), - None => Err(AsAsciiStrError(self.len())), - } - } - - #[inline] - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - Ok(self.into()) - } - - #[inline] - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - <&AsciiStr>::from(self) - } - - #[inline] - fn get_ascii(&self, index: usize) -> Option { - self.get(index).copied() - } -} -impl AsMutAsciiStr for [AsciiChar] { - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[AsciiChar], Output = [AsciiChar]>, - { - let len = self.len(); - match self.get_mut(range) { - Some(slice) => Ok(slice.into()), - None => Err(AsAsciiStrError(len)), - } - } - #[inline] - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr { - <&mut AsciiStr>::from(self) - } -} - -impl AsAsciiStr for [u8] { - type Inner = u8; - - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[u8], Output = [u8]>, - { - if let Some(slice) = self.get(range) { - slice.as_ascii_str().map_err(|AsAsciiStrError(not_ascii)| { - let offset = slice.as_ptr() as usize - self.as_ptr() as usize; - AsAsciiStrError(offset + not_ascii) - }) - } else { - Err(AsAsciiStrError(self.len())) - } - } - - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - // is_ascii is likely optimized - if self.is_ascii() { - // SAFETY: `is_ascii` guarantees all bytes are within ascii range. - unsafe { Ok(self.as_ascii_str_unchecked()) } - } else { - Err(AsAsciiStrError( - self.iter().take_while(|&b| b.is_ascii()).count(), - )) - } - } - - #[inline] - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { &*(self as *const [u8] as *const AsciiStr) } - } -} -impl AsMutAsciiStr for [u8] { - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[u8], Output = [u8]>, - { - let (ptr, len) = (self.as_ptr(), self.len()); - if let Some(slice) = self.get_mut(range) { - let slice_ptr = slice.as_ptr(); - slice - .as_mut_ascii_str() - .map_err(|AsAsciiStrError(not_ascii)| { - let offset = slice_ptr as usize - ptr as usize; - AsAsciiStrError(offset + not_ascii) - }) - } else { - Err(AsAsciiStrError(len)) - } - } - - fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError> { - // is_ascii() is likely optimized - if self.is_ascii() { - // SAFETY: `is_ascii` guarantees all bytes are within ascii range. - unsafe { Ok(self.as_mut_ascii_str_unchecked()) } - } else { - Err(AsAsciiStrError( - self.iter().take_while(|&b| b.is_ascii()).count(), - )) - } - } - - #[inline] - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { &mut *(self as *mut [u8] as *mut AsciiStr) } - } -} - -impl AsAsciiStr for str { - type Inner = u8; - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[u8], Output = [u8]>, - { - self.as_bytes().slice_ascii(range) - } - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - self.as_bytes().as_ascii_str() - } - #[inline] - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { self.as_bytes().as_ascii_str_unchecked() } - } -} -impl AsMutAsciiStr for str { - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[u8], Output = [u8]>, - { - // SAFETY: We don't modify the reference in this function, and the caller may - // only modify it to include valid ascii characters. - let bytes = unsafe { self.as_bytes_mut() }; - match bytes.get_mut(range) { - // Valid ascii slice - Some(slice) if slice.is_ascii() => { - // SAFETY: All bytes are ascii, so this cast is valid - let ptr = slice.as_mut_ptr().cast::(); - let len = slice.len(); - - // SAFETY: The pointer is valid for `len` elements, as it came - // from a slice. - unsafe { - let slice = core::slice::from_raw_parts_mut(ptr, len); - Ok(<&mut AsciiStr>::from(slice)) - } - } - Some(slice) => { - let not_ascii_len = slice.iter().copied().take_while(u8::is_ascii).count(); - let offset = slice.as_ptr() as usize - self.as_ptr() as usize; - - Err(AsAsciiStrError(offset + not_ascii_len)) - } - None => Err(AsAsciiStrError(self.len())), - } - } - fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError> { - match self.bytes().position(|b| !b.is_ascii()) { - Some(index) => Err(AsAsciiStrError(index)), - // SAFETY: All bytes were iterated, and all were ascii - None => unsafe { Ok(self.as_mut_ascii_str_unchecked()) }, - } - } - #[inline] - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - &mut *(self as *mut str as *mut AsciiStr) - } -} - -/// Note that the trailing null byte will be removed in the conversion. -#[cfg(feature = "std")] -impl AsAsciiStr for CStr { - type Inner = u8; - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[u8], Output = [u8]>, - { - self.to_bytes().slice_ascii(range) - } - #[inline] - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - self.to_bytes().as_ascii_str() - } - #[inline] - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { self.to_bytes().as_ascii_str_unchecked() } - } -} - -#[cfg(test)] -mod tests { - use super::{AsAsciiStr, AsAsciiStrError, AsMutAsciiStr, AsciiStr}; - #[cfg(feature = "alloc")] - use alloc::string::{String, ToString}; - #[cfg(feature = "alloc")] - use alloc::vec::Vec; - use AsciiChar; - - /// Ensures that common types, `str`, `[u8]`, `AsciiStr` and their - /// references, shared and mutable implement `AsAsciiStr`. - #[test] - fn generic_as_ascii_str() { - // Generic function to ensure `C` implements `AsAsciiStr` - fn generic(c: &C) -> Result<&AsciiStr, AsAsciiStrError> { - c.as_ascii_str() - } - - let arr = [AsciiChar::A]; - let ascii_str = arr.as_ref().into(); - let mut mut_arr = arr; // Note: We need a second copy to prevent overlapping mutable borrows. - let mut_ascii_str = mut_arr.as_mut().into(); - let mut_arr_mut_ref: &mut [AsciiChar] = &mut [AsciiChar::A]; - let mut string_bytes = [b'A']; - let string_mut = unsafe { core::str::from_utf8_unchecked_mut(&mut string_bytes) }; // SAFETY: 'A' is a valid string. - let string_mut_bytes: &mut [u8] = &mut [b'A']; - - // Note: This is a trick because `rustfmt` doesn't support - // attributes on blocks yet. - #[rustfmt::skip] - let _ = [ - assert_eq!(generic::("A" ), Ok(ascii_str)), - assert_eq!(generic::<[u8] >(&b"A"[..] ), Ok(ascii_str)), - assert_eq!(generic::(ascii_str ), Ok(ascii_str)), - assert_eq!(generic::<[AsciiChar] >(&arr ), Ok(ascii_str)), - assert_eq!(generic::<&str >(&"A" ), Ok(ascii_str)), - assert_eq!(generic::<&[u8] >(&&b"A"[..] ), Ok(ascii_str)), - assert_eq!(generic::<&AsciiStr >(&ascii_str ), Ok(ascii_str)), - assert_eq!(generic::<&[AsciiChar] >(&&arr[..] ), Ok(ascii_str)), - assert_eq!(generic::<&mut str >(&string_mut ), Ok(ascii_str)), - assert_eq!(generic::<&mut [u8] >(&string_mut_bytes), Ok(ascii_str)), - assert_eq!(generic::<&mut AsciiStr >(&mut_ascii_str ), Ok(ascii_str)), - assert_eq!(generic::<&mut [AsciiChar]>(&mut_arr_mut_ref ), Ok(ascii_str)), - ]; - } - - #[cfg(feature = "std")] - #[test] - fn cstring_as_ascii_str() { - use std::ffi::CString; - fn generic(c: &C) -> Result<&AsciiStr, AsAsciiStrError> { - c.as_ascii_str() - } - let arr = [AsciiChar::A]; - let ascii_str: &AsciiStr = arr.as_ref().into(); - let cstr = CString::new("A").unwrap(); - assert_eq!(generic(&*cstr), Ok(ascii_str)); - } - - #[test] - fn generic_as_mut_ascii_str() { - fn generic_mut( - c: &mut C, - ) -> Result<&mut AsciiStr, AsAsciiStrError> { - c.as_mut_ascii_str() - } - - let mut arr_mut = [AsciiChar::B]; - let mut ascii_str_mut: &mut AsciiStr = arr_mut.as_mut().into(); - // Need a second reference to prevent overlapping mutable borrows - let mut arr_mut_2 = [AsciiChar::B]; - let ascii_str_mut_2: &mut AsciiStr = arr_mut_2.as_mut().into(); - assert_eq!(generic_mut(&mut ascii_str_mut), Ok(&mut *ascii_str_mut_2)); - assert_eq!(generic_mut(ascii_str_mut), Ok(&mut *ascii_str_mut_2)); - } - - #[test] - fn as_ascii_str() { - macro_rules! err {{$i:expr} => {Err(AsAsciiStrError($i))}} - let s = "abčd"; - let b = s.as_bytes(); - assert_eq!(s.as_ascii_str(), err!(2)); - assert_eq!(b.as_ascii_str(), err!(2)); - let a: &AsciiStr = [AsciiChar::a, AsciiChar::b][..].as_ref(); - assert_eq!(s[..2].as_ascii_str(), Ok(a)); - assert_eq!(b[..2].as_ascii_str(), Ok(a)); - assert_eq!(s.slice_ascii(..2), Ok(a)); - assert_eq!(b.slice_ascii(..2), Ok(a)); - assert_eq!(s.slice_ascii(..=2), err!(2)); - assert_eq!(b.slice_ascii(..=2), err!(2)); - assert_eq!(s.get_ascii(4), Some(AsciiChar::d)); - assert_eq!(b.get_ascii(4), Some(AsciiChar::d)); - assert_eq!(s.get_ascii(3), None); - assert_eq!(b.get_ascii(3), None); - assert_eq!(s.get_ascii(b.len()), None); - assert_eq!(b.get_ascii(b.len()), None); - assert_eq!(a.get_ascii(0), Some(AsciiChar::a)); - assert_eq!(a.get_ascii(a.len()), None); - } - - #[test] - #[cfg(feature = "std")] - fn cstr_as_ascii_str() { - use std::ffi::CStr; - macro_rules! err {{$i:expr} => {Err(AsAsciiStrError($i))}} - let cstr = CStr::from_bytes_with_nul(b"a\xbbcde\xffg\0").unwrap(); - assert_eq!(cstr.as_ascii_str(), err!(1)); - assert_eq!(cstr.slice_ascii(2..), err!(5)); - assert_eq!(cstr.get_ascii(5), None); - assert_eq!(cstr.get_ascii(6), Some(AsciiChar::g)); - assert_eq!(cstr.get_ascii(7), None); - let ascii_slice = &[AsciiChar::X, AsciiChar::Y, AsciiChar::Z, AsciiChar::Null][..]; - let ascii_str: &AsciiStr = ascii_slice.as_ref(); - let cstr = CStr::from_bytes_with_nul(ascii_str.as_bytes()).unwrap(); - assert_eq!(cstr.slice_ascii(..2), Ok(&ascii_str[..2])); - assert_eq!(cstr.as_ascii_str(), Ok(&ascii_str[..3])); - } - - #[test] - #[cfg(feature = "alloc")] - fn as_mut_ascii_str() { - macro_rules! err {{$i:expr} => {Err(AsAsciiStrError($i))}} - let mut s: String = "abčd".to_string(); - let mut b: Vec = s.clone().into(); - let mut first = [AsciiChar::a, AsciiChar::b]; - let mut second = [AsciiChar::d]; - assert_eq!(s.as_mut_ascii_str(), err!(2)); - assert_eq!(b.as_mut_ascii_str(), err!(2)); - assert_eq!(s.slice_ascii_mut(..), err!(2)); - assert_eq!(b.slice_ascii_mut(..), err!(2)); - assert_eq!(s[..2].as_mut_ascii_str(), Ok((&mut first[..]).into())); - assert_eq!(b[..2].as_mut_ascii_str(), Ok((&mut first[..]).into())); - assert_eq!(s.slice_ascii_mut(0..2), Ok((&mut first[..]).into())); - assert_eq!(b.slice_ascii_mut(0..2), Ok((&mut first[..]).into())); - assert_eq!(s.slice_ascii_mut(4..), Ok((&mut second[..]).into())); - assert_eq!(b.slice_ascii_mut(4..), Ok((&mut second[..]).into())); - assert_eq!(s.slice_ascii_mut(4..=10), err!(5)); - assert_eq!(b.slice_ascii_mut(4..=10), err!(5)); - } - - #[test] - fn default() { - let default: &'static AsciiStr = Default::default(); - assert!(default.is_empty()); - } - - #[test] - #[allow(clippy::redundant_slicing)] - fn index() { - let mut arr = [AsciiChar::A, AsciiChar::B, AsciiChar::C, AsciiChar::D]; - { - let a: &AsciiStr = arr[..].into(); - assert_eq!(a[..].as_slice(), &a.as_slice()[..]); - assert_eq!(a[..4].as_slice(), &a.as_slice()[..4]); - assert_eq!(a[4..].as_slice(), &a.as_slice()[4..]); - assert_eq!(a[2..3].as_slice(), &a.as_slice()[2..3]); - assert_eq!(a[..=3].as_slice(), &a.as_slice()[..=3]); - assert_eq!(a[1..=1].as_slice(), &a.as_slice()[1..=1]); - } - let mut copy = arr; - let a_mut: &mut AsciiStr = { &mut arr[..] }.into(); - assert_eq!(a_mut[..].as_mut_slice(), &mut copy[..]); - assert_eq!(a_mut[..2].as_mut_slice(), &mut copy[..2]); - assert_eq!(a_mut[3..].as_mut_slice(), &mut copy[3..]); - assert_eq!(a_mut[4..4].as_mut_slice(), &mut copy[4..4]); - assert_eq!(a_mut[..=0].as_mut_slice(), &mut copy[..=0]); - assert_eq!(a_mut[0..=2].as_mut_slice(), &mut copy[0..=2]); - } - - #[test] - fn as_str() { - let b = b"( ;"; - let v = AsciiStr::from_ascii(b).unwrap(); - assert_eq!(v.as_str(), "( ;"); - assert_eq!(AsRef::::as_ref(v), "( ;"); - } - - #[test] - fn as_bytes() { - let b = b"( ;"; - let v = AsciiStr::from_ascii(b).unwrap(); - assert_eq!(v.as_bytes(), b"( ;"); - assert_eq!(AsRef::<[u8]>::as_ref(v), b"( ;"); - } - - #[test] - fn make_ascii_case() { - let mut bytes = ([b'a', b'@', b'A'], [b'A', b'@', b'a']); - let a = bytes.0.as_mut_ascii_str().unwrap(); - let b = bytes.1.as_mut_ascii_str().unwrap(); - assert!(a.eq_ignore_ascii_case(b)); - assert!(b.eq_ignore_ascii_case(a)); - a.make_ascii_lowercase(); - b.make_ascii_uppercase(); - assert_eq!(a, "a@a"); - assert_eq!(b, "A@A"); - } - - #[test] - #[cfg(feature = "alloc")] - fn to_ascii_case() { - let bytes = ([b'a', b'@', b'A'], [b'A', b'@', b'a']); - let a = bytes.0.as_ascii_str().unwrap(); - let b = bytes.1.as_ascii_str().unwrap(); - assert_eq!(a.to_ascii_lowercase().as_str(), "a@a"); - assert_eq!(a.to_ascii_uppercase().as_str(), "A@A"); - assert_eq!(b.to_ascii_lowercase().as_str(), "a@a"); - assert_eq!(b.to_ascii_uppercase().as_str(), "A@A"); - } - - #[test] - fn chars_iter() { - let chars = &[ - b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd', b'\0', - ]; - let ascii = AsciiStr::from_ascii(chars).unwrap(); - for (achar, byte) in ascii.chars().zip(chars.iter().copied()) { - assert_eq!(achar, byte); - } - } - - #[test] - fn chars_iter_mut() { - let chars = &mut [ - b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd', b'\0', - ]; - let ascii = chars.as_mut_ascii_str().unwrap(); - *ascii.chars_mut().next().unwrap() = AsciiChar::H; - assert_eq!(ascii[0], b'H'); - } - - #[test] - fn lines_iter() { - use core::iter::Iterator; - - let lines: [&str; 4] = ["foo", "bar", "", "baz"]; - let joined = "foo\r\nbar\n\nbaz\n"; - let ascii = AsciiStr::from_ascii(joined.as_bytes()).unwrap(); - for (asciiline, line) in ascii.lines().zip(&lines) { - assert_eq!(asciiline, *line); - } - assert_eq!(ascii.lines().count(), lines.len()); - - let lines: [&str; 4] = ["foo", "bar", "", "baz"]; - let joined = "foo\r\nbar\n\nbaz"; - let ascii = AsciiStr::from_ascii(joined.as_bytes()).unwrap(); - for (asciiline, line) in ascii.lines().zip(&lines) { - assert_eq!(asciiline, *line); - } - assert_eq!(ascii.lines().count(), lines.len()); - - let trailing_line_break = b"\n"; - let ascii = AsciiStr::from_ascii(&trailing_line_break).unwrap(); - let mut line_iter = ascii.lines(); - assert_eq!(line_iter.next(), Some(AsciiStr::from_ascii("").unwrap())); - assert_eq!(line_iter.next(), None); - - let empty_lines = b"\n\r\n\n\r\n"; - let mut iter_count = 0; - let ascii = AsciiStr::from_ascii(&empty_lines).unwrap(); - for line in ascii.lines() { - iter_count += 1; - assert!(line.is_empty()); - } - assert_eq!(4, iter_count); - } - - #[test] - fn lines_iter_rev() { - let joined = "foo\r\nbar\n\nbaz\n"; - let ascii = AsciiStr::from_ascii(joined.as_bytes()).unwrap(); - assert_eq!(ascii.lines().rev().count(), 4); - assert_eq!(ascii.lines().rev().count(), joined.lines().rev().count()); - for (asciiline, line) in ascii.lines().rev().zip(joined.lines().rev()) { - assert_eq!(asciiline, line); - } - let mut iter = ascii.lines(); - assert_eq!(iter.next(), Some("foo".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), Some("baz".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), Some("".as_ascii_str().unwrap())); - assert_eq!(iter.next(), Some("bar".as_ascii_str().unwrap())); - - let empty_lines = b"\n\r\n\n\r\n"; - let mut iter_count = 0; - let ascii = AsciiStr::from_ascii(&empty_lines).unwrap(); - for line in ascii.lines().rev() { - iter_count += 1; - assert!(line.is_empty()); - } - assert_eq!(4, iter_count); - } - - #[test] - fn lines_iter_empty() { - assert_eq!("".as_ascii_str().unwrap().lines().next(), None); - assert_eq!("".as_ascii_str().unwrap().lines().next_back(), None); - assert_eq!("".lines().next(), None); - } - - #[test] - fn split_str() { - fn split_equals_str(haystack: &str, needle: char) { - let mut strs = haystack.split(needle); - let mut asciis = haystack - .as_ascii_str() - .unwrap() - .split(AsciiChar::from_ascii(needle).unwrap()) - .map(AsciiStr::as_str); - loop { - assert_eq!(asciis.size_hint(), strs.size_hint()); - let (a, s) = (asciis.next(), strs.next()); - assert_eq!(a, s); - if a == None { - break; - } - } - // test fusedness if str's version is fused - if strs.next() == None { - assert_eq!(asciis.next(), None); - } - } - split_equals_str("", '='); - split_equals_str("1,2,3", ','); - split_equals_str("foo;bar;baz;", ';'); - split_equals_str("|||", '|'); - split_equals_str(" a b c ", ' '); - } - - #[test] - fn split_str_rev() { - let words = " foo bar baz "; - let ascii = words.as_ascii_str().unwrap(); - for (word, asciiword) in words - .split(' ') - .rev() - .zip(ascii.split(AsciiChar::Space).rev()) - { - assert_eq!(asciiword, word); - } - let mut iter = ascii.split(AsciiChar::Space); - assert_eq!(iter.next(), Some("".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), Some("".as_ascii_str().unwrap())); - assert_eq!(iter.next(), Some("foo".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), Some("baz".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), Some("bar".as_ascii_str().unwrap())); - assert_eq!(iter.next(), Some("".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), None); - } - - #[test] - fn split_str_empty() { - let empty = <&AsciiStr>::default(); - let mut iter = empty.split(AsciiChar::NAK); - assert_eq!(iter.next(), Some(empty)); - assert_eq!(iter.next(), None); - let mut iter = empty.split(AsciiChar::NAK); - assert_eq!(iter.next_back(), Some(empty)); - assert_eq!(iter.next_back(), None); - assert_eq!("".split('s').next(), Some("")); // str.split() also produces one element - } - - #[test] - #[cfg(feature = "std")] - fn fmt_ascii_str() { - let s = "abc".as_ascii_str().unwrap(); - assert_eq!(format!("{}", s), "abc".to_string()); - assert_eq!(format!("{:?}", s), "\"abc\"".to_string()); - } -} diff --git a/anneal/vendor/ascii/src/ascii_string.rs b/anneal/vendor/ascii/src/ascii_string.rs deleted file mode 100644 index 4cb6a17356..0000000000 --- a/anneal/vendor/ascii/src/ascii_string.rs +++ /dev/null @@ -1,1057 +0,0 @@ -use alloc::borrow::{Borrow, BorrowMut, Cow, ToOwned}; -use alloc::fmt; -use alloc::string::String; -use alloc::vec::Vec; -use alloc::boxed::Box; -use alloc::rc::Rc; -use alloc::sync::Arc; -#[cfg(feature = "std")] -use core::any::Any; -use core::iter::FromIterator; -use core::mem; -use core::ops::{Add, AddAssign, Deref, DerefMut, Index, IndexMut}; -use core::str::FromStr; -#[cfg(feature = "std")] -use std::error::Error; -#[cfg(feature = "std")] -use std::ffi::{CStr, CString}; - -use ascii_char::AsciiChar; -use ascii_str::{AsAsciiStr, AsAsciiStrError, AsciiStr}; - -/// A growable string stored as an ASCII encoded buffer. -#[derive(Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[repr(transparent)] -pub struct AsciiString { - vec: Vec, -} - -impl AsciiString { - /// Creates a new, empty ASCII string buffer without allocating. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::new(); - /// ``` - #[inline] - #[must_use] - pub const fn new() -> Self { - AsciiString { vec: Vec::new() } - } - - /// Creates a new ASCII string buffer with the given capacity. - /// The string will be able to hold exactly `capacity` bytes without reallocating. - /// If `capacity` is 0, the ASCII string will not allocate. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::with_capacity(10); - /// ``` - #[inline] - #[must_use] - pub fn with_capacity(capacity: usize) -> Self { - AsciiString { - vec: Vec::with_capacity(capacity), - } - } - - /// Creates a new `AsciiString` from a length, capacity and pointer. - /// - /// # Safety - /// - /// This is highly unsafe, due to the number of invariants that aren't checked: - /// - /// * The memory at `buf` need to have been previously allocated by the same allocator this - /// library uses, with an alignment of 1. - /// * `length` needs to be less than or equal to `capacity`. - /// * `capacity` needs to be the correct value. - /// * `buf` must have `length` valid ascii elements and contain a total of `capacity` total, - /// possibly, uninitialized, elements. - /// * Nothing else must be using the memory `buf` points to. - /// - /// Violating these may cause problems like corrupting the allocator's internal data structures. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use ascii::AsciiString; - /// use std::mem; - /// - /// unsafe { - /// let mut s = AsciiString::from_ascii("hello").unwrap(); - /// let ptr = s.as_mut_ptr(); - /// let len = s.len(); - /// let capacity = s.capacity(); - /// - /// mem::forget(s); - /// - /// let s = AsciiString::from_raw_parts(ptr, len, capacity); - /// - /// assert_eq!(AsciiString::from_ascii("hello").unwrap(), s); - /// } - /// ``` - #[inline] - #[must_use] - pub unsafe fn from_raw_parts(buf: *mut AsciiChar, length: usize, capacity: usize) -> Self { - AsciiString { - // SAFETY: Caller guarantees that `buf` was previously allocated by this library, - // that `buf` contains `length` valid ascii elements and has a total capacity - // of `capacity` elements, and that nothing else is using the momory. - vec: unsafe { Vec::from_raw_parts(buf, length, capacity) }, - } - } - - /// Converts a vector of bytes to an `AsciiString` without checking for non-ASCII characters. - /// - /// # Safety - /// This function is unsafe because it does not check that the bytes passed to it are valid - /// ASCII characters. If this constraint is violated, it may cause memory unsafety issues with - /// future of the `AsciiString`, as the rest of this library assumes that `AsciiString`s are - /// ASCII encoded. - #[inline] - #[must_use] - pub unsafe fn from_ascii_unchecked(bytes: B) -> Self - where - B: Into>, - { - let mut bytes = bytes.into(); - // SAFETY: The caller guarantees all bytes are valid ascii bytes. - let ptr = bytes.as_mut_ptr().cast::(); - let length = bytes.len(); - let capacity = bytes.capacity(); - mem::forget(bytes); - - // SAFETY: We guarantee all invariants, as we got the - // pointer, length and capacity from a `Vec`, - // and we also guarantee the pointer is valid per - // the `SAFETY` notice above. - let vec = Vec::from_raw_parts(ptr, length, capacity); - - Self { vec } - } - - /// Converts anything that can represent a byte buffer into an `AsciiString`. - /// - /// # Errors - /// Returns the byte buffer if not all of the bytes are ASCII characters. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let foo = AsciiString::from_ascii("foo".to_string()).unwrap(); - /// let err = AsciiString::from_ascii("Ŋ".to_string()).unwrap_err(); - /// assert_eq!(foo.as_str(), "foo"); - /// assert_eq!(err.into_source(), "Ŋ"); - /// ``` - pub fn from_ascii(bytes: B) -> Result> - where - B: Into> + AsRef<[u8]>, - { - match bytes.as_ref().as_ascii_str() { - // SAFETY: `as_ascii_str` guarantees all bytes are valid ascii bytes. - Ok(_) => Ok(unsafe { AsciiString::from_ascii_unchecked(bytes) }), - Err(e) => Err(FromAsciiError { - error: e, - owner: bytes, - }), - } - } - - /// Pushes the given ASCII string onto this ASCII string buffer. - /// - /// # Examples - /// ``` - /// # use ascii::{AsciiString, AsAsciiStr}; - /// use std::str::FromStr; - /// let mut s = AsciiString::from_str("foo").unwrap(); - /// s.push_str("bar".as_ascii_str().unwrap()); - /// assert_eq!(s, "foobar".as_ascii_str().unwrap()); - /// ``` - #[inline] - pub fn push_str(&mut self, string: &AsciiStr) { - self.vec.extend(string.chars()); - } - - /// Inserts the given ASCII string at the given place in this ASCII string buffer. - /// - /// # Panics - /// - /// Panics if `idx` is larger than the `AsciiString`'s length. - /// - /// # Examples - /// ``` - /// # use ascii::{AsciiString, AsAsciiStr}; - /// use std::str::FromStr; - /// let mut s = AsciiString::from_str("abc").unwrap(); - /// s.insert_str(1, "def".as_ascii_str().unwrap()); - /// assert_eq!(&*s, "adefbc"); - #[inline] - pub fn insert_str(&mut self, idx: usize, string: &AsciiStr) { - self.vec.reserve(string.len()); - self.vec.splice(idx..idx, string.into_iter().copied()); - } - - /// Returns the number of bytes that this ASCII string buffer can hold without reallocating. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let s = String::with_capacity(10); - /// assert!(s.capacity() >= 10); - /// ``` - #[inline] - #[must_use] - pub fn capacity(&self) -> usize { - self.vec.capacity() - } - - /// Reserves capacity for at least `additional` more bytes to be inserted in the given - /// `AsciiString`. The collection may reserve more space to avoid frequent reallocations. - /// - /// # Panics - /// Panics if the new capacity overflows `usize`. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::new(); - /// s.reserve(10); - /// assert!(s.capacity() >= 10); - /// ``` - #[inline] - pub fn reserve(&mut self, additional: usize) { - self.vec.reserve(additional); - } - - /// Reserves the minimum capacity for exactly `additional` more bytes to be inserted in the - /// given `AsciiString`. Does nothing if the capacity is already sufficient. - /// - /// Note that the allocator may give the collection more space than it requests. Therefore - /// capacity can not be relied upon to be precisely minimal. Prefer `reserve` if future - /// insertions are expected. - /// - /// # Panics - /// Panics if the new capacity overflows `usize`. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::new(); - /// s.reserve_exact(10); - /// assert!(s.capacity() >= 10); - /// ``` - #[inline] - - pub fn reserve_exact(&mut self, additional: usize) { - self.vec.reserve_exact(additional); - } - - /// Shrinks the capacity of this ASCII string buffer to match it's length. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// use std::str::FromStr; - /// let mut s = AsciiString::from_str("foo").unwrap(); - /// s.reserve(100); - /// assert!(s.capacity() >= 100); - /// s.shrink_to_fit(); - /// assert_eq!(s.capacity(), 3); - /// ``` - #[inline] - - pub fn shrink_to_fit(&mut self) { - self.vec.shrink_to_fit(); - } - - /// Adds the given ASCII character to the end of the ASCII string. - /// - /// # Examples - /// ``` - /// # use ascii::{ AsciiChar, AsciiString}; - /// let mut s = AsciiString::from_ascii("abc").unwrap(); - /// s.push(AsciiChar::from_ascii('1').unwrap()); - /// s.push(AsciiChar::from_ascii('2').unwrap()); - /// s.push(AsciiChar::from_ascii('3').unwrap()); - /// assert_eq!(s, "abc123"); - /// ``` - #[inline] - - pub fn push(&mut self, ch: AsciiChar) { - self.vec.push(ch); - } - - /// Shortens a ASCII string to the specified length. - /// - /// # Panics - /// Panics if `new_len` > current length. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::from_ascii("hello").unwrap(); - /// s.truncate(2); - /// assert_eq!(s, "he"); - /// ``` - #[inline] - - pub fn truncate(&mut self, new_len: usize) { - self.vec.truncate(new_len); - } - - /// Removes the last character from the ASCII string buffer and returns it. - /// Returns `None` if this string buffer is empty. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::from_ascii("foo").unwrap(); - /// assert_eq!(s.pop().map(|c| c.as_char()), Some('o')); - /// assert_eq!(s.pop().map(|c| c.as_char()), Some('o')); - /// assert_eq!(s.pop().map(|c| c.as_char()), Some('f')); - /// assert_eq!(s.pop(), None); - /// ``` - #[inline] - #[must_use] - pub fn pop(&mut self) -> Option { - self.vec.pop() - } - - /// Removes the ASCII character at position `idx` from the buffer and returns it. - /// - /// # Warning - /// This is an O(n) operation as it requires copying every element in the buffer. - /// - /// # Panics - /// If `idx` is out of bounds this function will panic. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::from_ascii("foo").unwrap(); - /// assert_eq!(s.remove(0).as_char(), 'f'); - /// assert_eq!(s.remove(1).as_char(), 'o'); - /// assert_eq!(s.remove(0).as_char(), 'o'); - /// ``` - #[inline] - #[must_use] - pub fn remove(&mut self, idx: usize) -> AsciiChar { - self.vec.remove(idx) - } - - /// Inserts an ASCII character into the buffer at position `idx`. - /// - /// # Warning - /// This is an O(n) operation as it requires copying every element in the buffer. - /// - /// # Panics - /// If `idx` is out of bounds this function will panic. - /// - /// # Examples - /// ``` - /// # use ascii::{AsciiString,AsciiChar}; - /// let mut s = AsciiString::from_ascii("foo").unwrap(); - /// s.insert(2, AsciiChar::b); - /// assert_eq!(s, "fobo"); - /// ``` - #[inline] - - pub fn insert(&mut self, idx: usize, ch: AsciiChar) { - self.vec.insert(idx, ch); - } - - /// Returns the number of bytes in this ASCII string. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let s = AsciiString::from_ascii("foo").unwrap(); - /// assert_eq!(s.len(), 3); - /// ``` - #[inline] - #[must_use] - pub fn len(&self) -> usize { - self.vec.len() - } - - /// Returns true if the ASCII string contains zero bytes. - /// - /// # Examples - /// ``` - /// # use ascii::{AsciiChar, AsciiString}; - /// let mut s = AsciiString::new(); - /// assert!(s.is_empty()); - /// s.push(AsciiChar::from_ascii('a').unwrap()); - /// assert!(!s.is_empty()); - /// ``` - #[inline] - #[must_use] - pub fn is_empty(&self) -> bool { - self.len() == 0 - } - - /// Truncates the ASCII string, setting length (but not capacity) to zero. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::from_ascii("foo").unwrap(); - /// s.clear(); - /// assert!(s.is_empty()); - /// ``` - #[inline] - - pub fn clear(&mut self) { - self.vec.clear(); - } - - /// Converts this [`AsciiString`] into a [`Box`]`<`[`AsciiStr`]`>`. - /// - /// This will drop any excess capacity - #[inline] - #[must_use] - pub fn into_boxed_ascii_str(self) -> Box { - let slice = self.vec.into_boxed_slice(); - Box::from(slice) - } -} - -impl Deref for AsciiString { - type Target = AsciiStr; - - #[inline] - fn deref(&self) -> &AsciiStr { - self.vec.as_slice().as_ref() - } -} - -impl DerefMut for AsciiString { - #[inline] - fn deref_mut(&mut self) -> &mut AsciiStr { - self.vec.as_mut_slice().as_mut() - } -} - -impl PartialEq for AsciiString { - #[inline] - fn eq(&self, other: &str) -> bool { - **self == *other - } -} - -impl PartialEq for str { - #[inline] - fn eq(&self, other: &AsciiString) -> bool { - **other == *self - } -} - -macro_rules! impl_eq { - ($lhs:ty, $rhs:ty) => { - impl PartialEq<$rhs> for $lhs { - #[inline] - fn eq(&self, other: &$rhs) -> bool { - PartialEq::eq(&**self, &**other) - } - } - }; -} - -impl_eq! { AsciiString, String } -impl_eq! { String, AsciiString } -impl_eq! { &AsciiStr, String } -impl_eq! { String, &AsciiStr } -impl_eq! { &AsciiStr, AsciiString } -impl_eq! { AsciiString, &AsciiStr } -impl_eq! { &str, AsciiString } -impl_eq! { AsciiString, &str } - -impl Borrow for AsciiString { - #[inline] - fn borrow(&self) -> &AsciiStr { - &**self - } -} - -impl BorrowMut for AsciiString { - #[inline] - fn borrow_mut(&mut self) -> &mut AsciiStr { - &mut **self - } -} - -impl From> for AsciiString { - #[inline] - fn from(vec: Vec) -> Self { - AsciiString { vec } - } -} - -impl From for AsciiString { - #[inline] - fn from(ch: AsciiChar) -> Self { - AsciiString { vec: vec![ch] } - } -} - -impl From for Vec { - fn from(mut s: AsciiString) -> Vec { - // SAFETY: All ascii bytes are valid `u8`, as we are `repr(u8)`. - // Note: We forget `self` to avoid `self.vec` from being deallocated. - let ptr = s.vec.as_mut_ptr().cast::(); - let length = s.vec.len(); - let capacity = s.vec.capacity(); - mem::forget(s); - - // SAFETY: We guarantee all invariants due to getting `ptr`, `length` - // and `capacity` from a `Vec`. We also guarantee `ptr` is valid - // due to the `SAFETY` block above. - unsafe { Vec::from_raw_parts(ptr, length, capacity) } - } -} - -impl From for Vec { - fn from(s: AsciiString) -> Vec { - s.vec - } -} - -impl<'a> From<&'a AsciiStr> for AsciiString { - #[inline] - fn from(s: &'a AsciiStr) -> Self { - s.to_ascii_string() - } -} - -impl<'a> From<&'a [AsciiChar]> for AsciiString { - #[inline] - fn from(s: &'a [AsciiChar]) -> AsciiString { - s.iter().copied().collect() - } -} - -impl From for String { - #[inline] - fn from(s: AsciiString) -> String { - // SAFETY: All ascii bytes are `utf8`. - unsafe { String::from_utf8_unchecked(s.into()) } - } -} - -impl From> for AsciiString { - #[inline] - fn from(boxed: Box) -> Self { - boxed.into_ascii_string() - } -} - -impl From for Box { - #[inline] - fn from(string: AsciiString) -> Self { - string.into_boxed_ascii_str() - } -} - -impl From for Rc { - fn from(s: AsciiString) -> Rc { - let var: Rc<[AsciiChar]> = s.vec.into(); - // SAFETY: AsciiStr is repr(transparent) and thus has the same layout as [AsciiChar] - unsafe { Rc::from_raw(Rc::into_raw(var) as *const AsciiStr) } - } -} - -impl From for Arc { - fn from(s: AsciiString) -> Arc { - let var: Arc<[AsciiChar]> = s.vec.into(); - // SAFETY: AsciiStr is repr(transparent) and thus has the same layout as [AsciiChar] - unsafe { Arc::from_raw(Arc::into_raw(var) as *const AsciiStr) } - } -} - -impl<'a> From> for AsciiString { - fn from(cow: Cow<'a, AsciiStr>) -> AsciiString { - cow.into_owned() - } -} - -impl From for Cow<'static, AsciiStr> { - fn from(string: AsciiString) -> Cow<'static, AsciiStr> { - Cow::Owned(string) - } -} - -impl<'a> From<&'a AsciiStr> for Cow<'a, AsciiStr> { - fn from(s: &'a AsciiStr) -> Cow<'a, AsciiStr> { - Cow::Borrowed(s) - } -} - -impl AsRef for AsciiString { - #[inline] - fn as_ref(&self) -> &AsciiStr { - &**self - } -} - -impl AsRef<[AsciiChar]> for AsciiString { - #[inline] - fn as_ref(&self) -> &[AsciiChar] { - &self.vec - } -} - -impl AsRef<[u8]> for AsciiString { - #[inline] - fn as_ref(&self) -> &[u8] { - self.as_bytes() - } -} - -impl AsRef for AsciiString { - #[inline] - fn as_ref(&self) -> &str { - self.as_str() - } -} - -impl AsMut for AsciiString { - #[inline] - fn as_mut(&mut self) -> &mut AsciiStr { - &mut *self - } -} - -impl AsMut<[AsciiChar]> for AsciiString { - #[inline] - fn as_mut(&mut self) -> &mut [AsciiChar] { - &mut self.vec - } -} - -impl FromStr for AsciiString { - type Err = AsAsciiStrError; - - fn from_str(s: &str) -> Result { - s.as_ascii_str().map(AsciiStr::to_ascii_string) - } -} - -impl fmt::Display for AsciiString { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&**self, f) - } -} - -impl fmt::Debug for AsciiString { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&**self, f) - } -} - -/// Please note that the `std::fmt::Result` returned by these methods does not support -/// transmission of an error other than that an error occurred. -impl fmt::Write for AsciiString { - fn write_str(&mut self, s: &str) -> fmt::Result { - if let Ok(astr) = AsciiStr::from_ascii(s) { - self.push_str(astr); - Ok(()) - } else { - Err(fmt::Error) - } - } - - fn write_char(&mut self, c: char) -> fmt::Result { - if let Ok(achar) = AsciiChar::from_ascii(c) { - self.push(achar); - Ok(()) - } else { - Err(fmt::Error) - } - } -} - -impl> FromIterator for AsciiString { - fn from_iter>(iter: I) -> AsciiString { - let mut buf = AsciiString::new(); - buf.extend(iter); - buf - } -} - -impl> Extend for AsciiString { - fn extend>(&mut self, iterable: I) { - let iterator = iterable.into_iter(); - let (lower_bound, _) = iterator.size_hint(); - self.reserve(lower_bound); - for item in iterator { - self.push_str(item.as_ref()); - } - } -} - -impl<'a> Add<&'a AsciiStr> for AsciiString { - type Output = AsciiString; - - #[inline] - fn add(mut self, other: &AsciiStr) -> AsciiString { - self.push_str(other); - self - } -} - -impl<'a> AddAssign<&'a AsciiStr> for AsciiString { - #[inline] - fn add_assign(&mut self, other: &AsciiStr) { - self.push_str(other); - } -} - -#[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default -impl Index for AsciiString -where - AsciiStr: Index, -{ - type Output = >::Output; - - #[inline] - fn index(&self, index: T) -> &>::Output { - &(**self)[index] - } -} - -#[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default -impl IndexMut for AsciiString -where - AsciiStr: IndexMut, -{ - #[inline] - fn index_mut(&mut self, index: T) -> &mut >::Output { - &mut (**self)[index] - } -} - -/// A possible error value when converting an `AsciiString` from a byte vector or string. -/// It wraps an `AsAsciiStrError` which you can get through the `ascii_error()` method. -/// -/// This is the error type for `AsciiString::from_ascii()` and -/// `IntoAsciiString::into_ascii_string()`. They will never clone or touch the content of the -/// original type; It can be extracted by the `into_source` method. -/// -/// #Examples -/// ``` -/// # use ascii::IntoAsciiString; -/// let err = "bø!".to_string().into_ascii_string().unwrap_err(); -/// assert_eq!(err.ascii_error().valid_up_to(), 1); -/// assert_eq!(err.into_source(), "bø!".to_string()); -/// ``` -#[derive(Clone, Copy, PartialEq, Eq)] -pub struct FromAsciiError { - error: AsAsciiStrError, - owner: O, -} -impl FromAsciiError { - /// Get the position of the first non-ASCII byte or character. - #[inline] - #[must_use] - pub fn ascii_error(&self) -> AsAsciiStrError { - self.error - } - /// Get back the original, unmodified type. - #[inline] - #[must_use] - pub fn into_source(self) -> O { - self.owner - } -} -impl fmt::Debug for FromAsciiError { - #[inline] - fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&self.error, fmtr) - } -} -impl fmt::Display for FromAsciiError { - #[inline] - fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&self.error, fmtr) - } -} -#[cfg(feature = "std")] -impl Error for FromAsciiError { - #[inline] - #[allow(deprecated)] // TODO: Remove deprecation once the earliest version we support deprecates this method. - fn description(&self) -> &str { - self.error.description() - } - /// Always returns an `AsAsciiStrError` - fn cause(&self) -> Option<&dyn Error> { - Some(&self.error as &dyn Error) - } -} - -/// Convert vectors into `AsciiString`. -pub trait IntoAsciiString: Sized { - /// Convert to `AsciiString` without checking for non-ASCII characters. - /// - /// # Safety - /// If `self` contains non-ascii characters, calling this function is - /// undefined behavior. - unsafe fn into_ascii_string_unchecked(self) -> AsciiString; - - /// Convert to `AsciiString`. - /// - /// # Errors - /// If `self` contains non-ascii characters, this will return `Err` - fn into_ascii_string(self) -> Result>; -} - -impl IntoAsciiString for Vec { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - AsciiString::from(self) - } - #[inline] - fn into_ascii_string(self) -> Result> { - Ok(AsciiString::from(self)) - } -} - -impl<'a> IntoAsciiString for &'a [AsciiChar] { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - AsciiString::from(self) - } - #[inline] - fn into_ascii_string(self) -> Result> { - Ok(AsciiString::from(self)) - } -} - -impl<'a> IntoAsciiString for &'a AsciiStr { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - AsciiString::from(self) - } - #[inline] - fn into_ascii_string(self) -> Result> { - Ok(AsciiString::from(self)) - } -} - -macro_rules! impl_into_ascii_string { - ('a, $wider:ty) => { - impl<'a> IntoAsciiString for $wider { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - // SAFETY: Caller guarantees `self` only has valid ascii bytes - unsafe { AsciiString::from_ascii_unchecked(self) } - } - - #[inline] - fn into_ascii_string(self) -> Result> { - AsciiString::from_ascii(self) - } - } - }; - - ($wider:ty) => { - impl IntoAsciiString for $wider { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - // SAFETY: Caller guarantees `self` only has valid ascii bytes - unsafe { AsciiString::from_ascii_unchecked(self) } - } - - #[inline] - fn into_ascii_string(self) -> Result> { - AsciiString::from_ascii(self) - } - } - }; -} - -impl_into_ascii_string! {AsciiString} -impl_into_ascii_string! {Vec} -impl_into_ascii_string! {'a, &'a [u8]} -impl_into_ascii_string! {String} -impl_into_ascii_string! {'a, &'a str} - -/// # Notes -/// The trailing null byte `CString` has will be removed during this conversion. -#[cfg(feature = "std")] -impl IntoAsciiString for CString { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - // SAFETY: Caller guarantees `self` only has valid ascii bytes - unsafe { AsciiString::from_ascii_unchecked(self.into_bytes()) } - } - - fn into_ascii_string(self) -> Result> { - AsciiString::from_ascii(self.into_bytes_with_nul()) - .map_err(|FromAsciiError { error, owner }| { - FromAsciiError { - // SAFETY: We don't discard the NULL byte from the original - // string, so we ensure that it's null terminated - owner: unsafe { CString::from_vec_unchecked(owner) }, - error, - } - }) - .map(|mut s| { - let nul = s.pop(); - debug_assert_eq!(nul, Some(AsciiChar::Null)); - s - }) - } -} - -/// Note that the trailing null byte will be removed in the conversion. -#[cfg(feature = "std")] -impl<'a> IntoAsciiString for &'a CStr { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - // SAFETY: Caller guarantees `self` only has valid ascii bytes - unsafe { AsciiString::from_ascii_unchecked(self.to_bytes()) } - } - - fn into_ascii_string(self) -> Result> { - AsciiString::from_ascii(self.to_bytes_with_nul()) - .map_err(|FromAsciiError { error, owner }| FromAsciiError { - // SAFETY: We don't discard the NULL byte from the original - // string, so we ensure that it's null terminated - owner: unsafe { CStr::from_ptr(owner.as_ptr().cast()) }, - error, - }) - .map(|mut s| { - let nul = s.pop(); - debug_assert_eq!(nul, Some(AsciiChar::Null)); - s - }) - } -} - -impl<'a, B> IntoAsciiString for Cow<'a, B> -where - B: 'a + ToOwned + ?Sized, - &'a B: IntoAsciiString, - ::Owned: IntoAsciiString, -{ - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - // SAFETY: Caller guarantees `self` only has valid ascii bytes - unsafe { IntoAsciiString::into_ascii_string_unchecked(self.into_owned()) } - } - - fn into_ascii_string(self) -> Result> { - match self { - Cow::Owned(b) => { - IntoAsciiString::into_ascii_string(b).map_err(|FromAsciiError { error, owner }| { - FromAsciiError { - owner: Cow::Owned(owner), - error, - } - }) - } - Cow::Borrowed(b) => { - IntoAsciiString::into_ascii_string(b).map_err(|FromAsciiError { error, owner }| { - FromAsciiError { - owner: Cow::Borrowed(owner), - error, - } - }) - } - } - } -} - -#[cfg(test)] -mod tests { - use super::{AsciiString, IntoAsciiString}; - use alloc::str::FromStr; - use alloc::string::{String, ToString}; - use alloc::vec::Vec; - use alloc::boxed::Box; - #[cfg(feature = "std")] - use std::ffi::CString; - use {AsciiChar, AsciiStr}; - - #[test] - fn into_string() { - let v = AsciiString::from_ascii(&[40_u8, 32, 59][..]).unwrap(); - assert_eq!(Into::::into(v), "( ;".to_string()); - } - - #[test] - fn into_bytes() { - let v = AsciiString::from_ascii(&[40_u8, 32, 59][..]).unwrap(); - assert_eq!(Into::>::into(v), vec![40_u8, 32, 59]); - } - - #[test] - fn from_ascii_vec() { - let vec = vec![ - AsciiChar::from_ascii('A').unwrap(), - AsciiChar::from_ascii('B').unwrap(), - ]; - assert_eq!(AsciiString::from(vec), AsciiString::from_str("AB").unwrap()); - } - - #[test] - #[cfg(feature = "std")] - fn from_cstring() { - let cstring = CString::new("baz").unwrap(); - let ascii_str = cstring.clone().into_ascii_string().unwrap(); - let expected_chars = &[AsciiChar::b, AsciiChar::a, AsciiChar::z]; - assert_eq!(ascii_str.len(), 3); - assert_eq!(ascii_str.as_slice(), expected_chars); - - // SAFETY: "baz" only contains valid ascii characters. - let ascii_str_unchecked = unsafe { cstring.into_ascii_string_unchecked() }; - assert_eq!(ascii_str_unchecked.len(), 3); - assert_eq!(ascii_str_unchecked.as_slice(), expected_chars); - - let sparkle_heart_bytes = vec![240_u8, 159, 146, 150]; - let cstring = CString::new(sparkle_heart_bytes).unwrap(); - let cstr = &*cstring; - let ascii_err = cstr.into_ascii_string().unwrap_err(); - assert_eq!(ascii_err.into_source(), &*cstring); - } - - #[test] - #[cfg(feature = "std")] - fn fmt_ascii_string() { - let s = "abc".to_string().into_ascii_string().unwrap(); - assert_eq!(format!("{}", s), "abc".to_string()); - assert_eq!(format!("{:?}", s), "\"abc\"".to_string()); - } - - #[test] - fn write_fmt() { - use alloc::{fmt, str}; - - let mut s0 = AsciiString::new(); - fmt::write(&mut s0, format_args!("Hello World")).unwrap(); - assert_eq!(s0, "Hello World"); - - let mut s1 = AsciiString::new(); - fmt::write(&mut s1, format_args!("{}", 9)).unwrap(); - assert_eq!(s1, "9"); - - let mut s2 = AsciiString::new(); - let sparkle_heart_bytes = [240, 159, 146, 150]; - let sparkle_heart = str::from_utf8(&sparkle_heart_bytes).unwrap(); - assert!(fmt::write(&mut s2, format_args!("{}", sparkle_heart)).is_err()); - } - - #[test] - fn to_and_from_box() { - let string = "abc".into_ascii_string().unwrap(); - let converted: Box = Box::from(string.clone()); - let converted: AsciiString = converted.into(); - assert_eq!(string, converted); - } -} diff --git a/anneal/vendor/ascii/src/free_functions.rs b/anneal/vendor/ascii/src/free_functions.rs deleted file mode 100644 index 55d97321e4..0000000000 --- a/anneal/vendor/ascii/src/free_functions.rs +++ /dev/null @@ -1,59 +0,0 @@ -use ascii_char::{AsciiChar, ToAsciiChar}; - -/// Terminals use [caret notation](https://en.wikipedia.org/wiki/Caret_notation) -/// to display some typed control codes, such as ^D for EOT and ^Z for SUB. -/// -/// This function returns the caret notation letter for control codes, -/// or `None` for printable characters. -/// -/// # Examples -/// ``` -/// # use ascii::{AsciiChar, caret_encode}; -/// assert_eq!(caret_encode(b'\0'), Some(AsciiChar::At)); -/// assert_eq!(caret_encode(AsciiChar::DEL), Some(AsciiChar::Question)); -/// assert_eq!(caret_encode(b'E'), None); -/// assert_eq!(caret_encode(b'\n'), Some(AsciiChar::J)); -/// ``` -pub fn caret_encode>(c: C) -> Option { - // The formula is explained in the Wikipedia article. - let c = c.into() ^ 0b0100_0000; - if (b'?'..=b'_').contains(&c) { - // SAFETY: All bytes between '?' (0x3F) and '_' (0x5f) are valid ascii characters. - Some(unsafe { c.to_ascii_char_unchecked() }) - } else { - None - } -} - -/// Returns the control code represented by a [caret notation](https://en.wikipedia.org/wiki/Caret_notation) -/// letter, or `None` if the letter is not used in caret notation. -/// -/// This function is the inverse of `caret_encode()`. -/// -/// # Examples -/// -/// Basic usage: -/// -/// ``` -/// # use ascii::{AsciiChar, caret_decode}; -/// assert_eq!(caret_decode(b'?'), Some(AsciiChar::DEL)); -/// assert_eq!(caret_decode(AsciiChar::D), Some(AsciiChar::EOT)); -/// assert_eq!(caret_decode(b'\0'), None); -/// ``` -/// -/// Symmetry: -/// -/// ``` -/// # use ascii::{AsciiChar, caret_encode, caret_decode}; -/// assert_eq!(caret_encode(AsciiChar::US).and_then(caret_decode), Some(AsciiChar::US)); -/// assert_eq!(caret_decode(b'@').and_then(caret_encode), Some(AsciiChar::At)); -/// ``` -pub fn caret_decode>(c: C) -> Option { - // The formula is explained in the Wikipedia article. - match c.into() { - // SAFETY: All bytes between '?' (0x3F) and '_' (0x5f) after `xoring` with `0b0100_0000` are - // valid bytes, as they represent characters between '␀' (0x0) and '␠' (0x1f) + '␡' (0x7f) - b'?'..=b'_' => Some(unsafe { AsciiChar::from_ascii_unchecked(c.into() ^ 0b0100_0000) }), - _ => None, - } -} diff --git a/anneal/vendor/ascii/src/lib.rs b/anneal/vendor/ascii/src/lib.rs deleted file mode 100644 index 5eacc162fb..0000000000 --- a/anneal/vendor/ascii/src/lib.rs +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! A library that provides ASCII-only string and character types, equivalent to the `char`, `str` -//! and `String` types in the standard library. -//! -//! Please refer to the readme file to learn about the different feature modes of this crate. -//! -//! # Minimum supported Rust version -//! -//! The minimum Rust version for 1.1.\* releases is 1.41.1. -//! Later 1.y.0 releases might require newer Rust versions, but the three most -//! recent stable releases at the time of publishing will always be supported. -//! For example this means that if the current stable Rust version is 1.70 when -//! ascii 1.2.0 is released, then ascii 1.2.\* will not require a newer -//! Rust version than 1.68. -//! -//! # History -//! -//! This package included the Ascii types that were removed from the Rust standard library by the -//! 2014-12 [reform of the `std::ascii` module](https://github.com/rust-lang/rfcs/pull/486). The -//! API changed significantly since then. - -#![cfg_attr(not(feature = "std"), no_std)] -// Clippy lints -#![warn( - clippy::pedantic, - clippy::decimal_literal_representation, - clippy::get_unwrap, - clippy::indexing_slicing -)] -// Naming conventions sometimes go against this lint -#![allow(clippy::module_name_repetitions)] -// We need to get literal non-asciis for tests -#![allow(clippy::non_ascii_literal)] -// Sometimes it looks better to invert the order, such as when the `else` block is small -#![allow(clippy::if_not_else)] -// Shadowing is common and doesn't affect understanding -// TODO: Consider removing `shadow_unrelated`, as it can show some actual logic errors -#![allow(clippy::shadow_unrelated, clippy::shadow_reuse, clippy::shadow_same)] -// A `if let` / `else` sometimes looks better than using iterator adaptors -#![allow(clippy::option_if_let_else)] -// In tests, we're fine with indexing, since a panic is a failure. -#![cfg_attr(test, allow(clippy::indexing_slicing))] -// for compatibility with methods on char and u8 -#![allow(clippy::trivially_copy_pass_by_ref)] -// In preparation for feature `unsafe_block_in_unsafe_fn` (https://github.com/rust-lang/rust/issues/71668) -#![allow(unused_unsafe)] - -#[cfg(feature = "alloc")] -#[macro_use] -extern crate alloc; -#[cfg(feature = "std")] -extern crate core; - -#[cfg(feature = "serde")] -extern crate serde; - -#[cfg(all(test, feature = "serde_test"))] -extern crate serde_test; - -mod ascii_char; -mod ascii_str; -#[cfg(feature = "alloc")] -mod ascii_string; -mod free_functions; -#[cfg(feature = "serde")] -mod serialization; - -pub use ascii_char::{AsciiChar, ToAsciiChar, ToAsciiCharError}; -pub use ascii_str::{AsAsciiStr, AsAsciiStrError, AsMutAsciiStr, AsciiStr}; -pub use ascii_str::{Chars, CharsMut, CharsRef}; -#[cfg(feature = "alloc")] -pub use ascii_string::{AsciiString, FromAsciiError, IntoAsciiString}; -pub use free_functions::{caret_decode, caret_encode}; diff --git a/anneal/vendor/ascii/src/serialization/ascii_char.rs b/anneal/vendor/ascii/src/serialization/ascii_char.rs deleted file mode 100644 index 9fd843a149..0000000000 --- a/anneal/vendor/ascii/src/serialization/ascii_char.rs +++ /dev/null @@ -1,89 +0,0 @@ -use std::fmt; - -use serde::de::{Error, Unexpected, Visitor}; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; - -use ascii_char::AsciiChar; - -impl Serialize for AsciiChar { - #[inline] - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_char(self.as_char()) - } -} - -struct AsciiCharVisitor; - -impl<'de> Visitor<'de> for AsciiCharVisitor { - type Value = AsciiChar; - - fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.write_str("an ascii character") - } - - #[inline] - fn visit_char(self, v: char) -> Result { - AsciiChar::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Char(v), &self)) - } - - #[inline] - fn visit_str(self, v: &str) -> Result { - if v.len() == 1 { - let c = v.chars().next().unwrap(); - self.visit_char(c) - } else { - Err(Error::invalid_value(Unexpected::Str(v), &self)) - } - } -} - -impl<'de> Deserialize<'de> for AsciiChar { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - deserializer.deserialize_char(AsciiCharVisitor) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[cfg(feature = "serde_test")] - const ASCII_CHAR: char = 'e'; - #[cfg(feature = "serde_test")] - const ASCII_STR: &str = "e"; - #[cfg(feature = "serde_test")] - const UNICODE_CHAR: char = 'é'; - - #[test] - fn basic() { - fn assert_serialize() {} - fn assert_deserialize<'de, T: Deserialize<'de>>() {} - assert_serialize::(); - assert_deserialize::(); - } - - #[test] - #[cfg(feature = "serde_test")] - fn serialize() { - use serde_test::{assert_tokens, Token}; - let ascii_char = AsciiChar::from_ascii(ASCII_CHAR).unwrap(); - assert_tokens(&ascii_char, &[Token::Char(ASCII_CHAR)]); - } - - #[test] - #[cfg(feature = "serde_test")] - fn deserialize() { - use serde_test::{assert_de_tokens, assert_de_tokens_error, Token}; - let ascii_char = AsciiChar::from_ascii(ASCII_CHAR).unwrap(); - assert_de_tokens(&ascii_char, &[Token::String(ASCII_STR)]); - assert_de_tokens(&ascii_char, &[Token::Str(ASCII_STR)]); - assert_de_tokens(&ascii_char, &[Token::BorrowedStr(ASCII_STR)]); - assert_de_tokens_error::( - &[Token::Char(UNICODE_CHAR)], - "invalid value: character `é`, expected an ascii character", - ); - } -} diff --git a/anneal/vendor/ascii/src/serialization/ascii_str.rs b/anneal/vendor/ascii/src/serialization/ascii_str.rs deleted file mode 100644 index 9aa9353afb..0000000000 --- a/anneal/vendor/ascii/src/serialization/ascii_str.rs +++ /dev/null @@ -1,79 +0,0 @@ -use std::fmt; - -use serde::de::{Error, Unexpected, Visitor}; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; - -use ascii_str::AsciiStr; - -impl Serialize for AsciiStr { - #[inline] - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_str(self.as_str()) - } -} - -struct AsciiStrVisitor; - -impl<'a> Visitor<'a> for AsciiStrVisitor { - type Value = &'a AsciiStr; - - fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.write_str("a borrowed ascii string") - } - - fn visit_borrowed_str(self, v: &'a str) -> Result { - AsciiStr::from_ascii(v.as_bytes()) - .map_err(|_| Error::invalid_value(Unexpected::Str(v), &self)) - } - - fn visit_borrowed_bytes(self, v: &'a [u8]) -> Result { - AsciiStr::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self)) - } -} - -impl<'de: 'a, 'a> Deserialize<'de> for &'a AsciiStr { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - deserializer.deserialize_str(AsciiStrVisitor) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[cfg(feature = "serde_test")] - const ASCII: &str = "Francais"; - #[cfg(feature = "serde_test")] - const UNICODE: &str = "Français"; - - #[test] - fn basic() { - fn assert_serialize() {} - fn assert_deserialize<'de, T: Deserialize<'de>>() {} - assert_serialize::<&AsciiStr>(); - assert_deserialize::<&AsciiStr>(); - } - - #[test] - #[cfg(feature = "serde_test")] - fn serialize() { - use serde_test::{assert_tokens, Token}; - let ascii_str = AsciiStr::from_ascii(ASCII).unwrap(); - assert_tokens(&ascii_str, &[Token::BorrowedStr(ASCII)]); - } - - #[test] - #[cfg(feature = "serde_test")] - fn deserialize() { - use serde_test::{assert_de_tokens, assert_de_tokens_error, Token}; - let ascii_str = AsciiStr::from_ascii(ASCII).unwrap(); - assert_de_tokens(&ascii_str, &[Token::BorrowedBytes(ASCII.as_bytes())]); - assert_de_tokens_error::<&AsciiStr>( - &[Token::BorrowedStr(UNICODE)], - "invalid value: string \"Français\", expected a borrowed ascii string", - ); - } -} diff --git a/anneal/vendor/ascii/src/serialization/ascii_string.rs b/anneal/vendor/ascii/src/serialization/ascii_string.rs deleted file mode 100644 index 1547655f1e..0000000000 --- a/anneal/vendor/ascii/src/serialization/ascii_string.rs +++ /dev/null @@ -1,149 +0,0 @@ -use std::fmt; - -use serde::de::{Error, Unexpected, Visitor}; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; - -use ascii_str::AsciiStr; -use ascii_string::AsciiString; - -impl Serialize for AsciiString { - #[inline] - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_str(self.as_str()) - } -} - -struct AsciiStringVisitor; - -impl<'de> Visitor<'de> for AsciiStringVisitor { - type Value = AsciiString; - - fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.write_str("an ascii string") - } - - fn visit_str(self, v: &str) -> Result { - AsciiString::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Str(v), &self)) - } - - fn visit_string(self, v: String) -> Result { - AsciiString::from_ascii(v.as_bytes()) - .map_err(|_| Error::invalid_value(Unexpected::Str(&v), &self)) - } - - fn visit_bytes(self, v: &[u8]) -> Result { - AsciiString::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self)) - } - - fn visit_byte_buf(self, v: Vec) -> Result { - AsciiString::from_ascii(v.as_slice()) - .map_err(|_| Error::invalid_value(Unexpected::Bytes(&v), &self)) - } -} - -struct AsciiStringInPlaceVisitor<'a>(&'a mut AsciiString); - -impl<'a, 'de> Visitor<'de> for AsciiStringInPlaceVisitor<'a> { - type Value = (); - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("an ascii string") - } - - fn visit_str(self, v: &str) -> Result { - let ascii_str = match AsciiStr::from_ascii(v.as_bytes()) { - Ok(ascii_str) => ascii_str, - Err(_) => return Err(Error::invalid_value(Unexpected::Str(v), &self)), - }; - self.0.clear(); - self.0.push_str(ascii_str); - Ok(()) - } - - fn visit_string(self, v: String) -> Result { - let ascii_string = match AsciiString::from_ascii(v.as_bytes()) { - Ok(ascii_string) => ascii_string, - Err(_) => return Err(Error::invalid_value(Unexpected::Str(&v), &self)), - }; - *self.0 = ascii_string; - Ok(()) - } - - fn visit_bytes(self, v: &[u8]) -> Result { - let ascii_str = match AsciiStr::from_ascii(v) { - Ok(ascii_str) => ascii_str, - Err(_) => return Err(Error::invalid_value(Unexpected::Bytes(v), &self)), - }; - self.0.clear(); - self.0.push_str(ascii_str); - Ok(()) - } - - fn visit_byte_buf(self, v: Vec) -> Result { - let ascii_string = match AsciiString::from_ascii(v.as_slice()) { - Ok(ascii_string) => ascii_string, - Err(_) => return Err(Error::invalid_value(Unexpected::Bytes(&v), &self)), - }; - *self.0 = ascii_string; - Ok(()) - } -} - -impl<'de> Deserialize<'de> for AsciiString { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - deserializer.deserialize_string(AsciiStringVisitor) - } - - fn deserialize_in_place(deserializer: D, place: &mut Self) -> Result<(), D::Error> - where - D: Deserializer<'de>, - { - deserializer.deserialize_string(AsciiStringInPlaceVisitor(place)) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[cfg(feature = "serde_test")] - const ASCII: &str = "Francais"; - #[cfg(feature = "serde_test")] - const UNICODE: &str = "Français"; - - #[test] - fn basic() { - fn assert_serialize() {} - fn assert_deserialize<'de, T: Deserialize<'de>>() {} - assert_serialize::(); - assert_deserialize::(); - } - - #[test] - #[cfg(feature = "serde_test")] - fn serialize() { - use serde_test::{assert_tokens, Token}; - - let ascii_string = AsciiString::from_ascii(ASCII).unwrap(); - assert_tokens(&ascii_string, &[Token::String(ASCII)]); - assert_tokens(&ascii_string, &[Token::Str(ASCII)]); - assert_tokens(&ascii_string, &[Token::BorrowedStr(ASCII)]); - } - - #[test] - #[cfg(feature = "serde_test")] - fn deserialize() { - use serde_test::{assert_de_tokens, assert_de_tokens_error, Token}; - let ascii_string = AsciiString::from_ascii(ASCII).unwrap(); - assert_de_tokens(&ascii_string, &[Token::Bytes(ASCII.as_bytes())]); - assert_de_tokens(&ascii_string, &[Token::BorrowedBytes(ASCII.as_bytes())]); - assert_de_tokens(&ascii_string, &[Token::ByteBuf(ASCII.as_bytes())]); - assert_de_tokens_error::( - &[Token::String(UNICODE)], - "invalid value: string \"Français\", expected an ascii string", - ); - } -} diff --git a/anneal/vendor/ascii/src/serialization/mod.rs b/anneal/vendor/ascii/src/serialization/mod.rs deleted file mode 100644 index 69a4e03a1c..0000000000 --- a/anneal/vendor/ascii/src/serialization/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -mod ascii_char; -mod ascii_str; -mod ascii_string; diff --git a/anneal/vendor/ascii/tests.rs b/anneal/vendor/ascii/tests.rs deleted file mode 100644 index 017a7be781..0000000000 --- a/anneal/vendor/ascii/tests.rs +++ /dev/null @@ -1,143 +0,0 @@ -extern crate ascii; - -use ascii::{AsAsciiStr, AsciiChar, AsciiStr}; -#[cfg(feature = "std")] -use ascii::{AsciiString, IntoAsciiString}; - -#[test] -#[cfg(feature = "std")] -fn ascii_vec() { - let test = b"( ;"; - let a = AsciiStr::from_ascii(test).unwrap(); - assert_eq!(test.as_ascii_str(), Ok(a)); - assert_eq!("( ;".as_ascii_str(), Ok(a)); - let v = test.to_vec(); - assert_eq!(v.as_ascii_str(), Ok(a)); - assert_eq!("( ;".to_string().as_ascii_str(), Ok(a)); -} - -#[test] -fn to_ascii() { - assert!("zoä华".as_ascii_str().is_err()); - assert!([127_u8, 128, 255].as_ascii_str().is_err()); - - let arr = [AsciiChar::ParenOpen, AsciiChar::Space, AsciiChar::Semicolon]; - let a: &AsciiStr = (&arr[..]).into(); - assert_eq!(b"( ;".as_ascii_str(), Ok(a)); - assert_eq!("( ;".as_ascii_str(), Ok(a)); -} - -#[test] -#[cfg(feature = "std")] -fn into_ascii() { - let arr = [AsciiChar::ParenOpen, AsciiChar::Space, AsciiChar::Semicolon]; - let v = AsciiString::from(arr.to_vec()); - assert_eq!(b"( ;".to_vec().into_ascii_string(), Ok(v.clone())); - assert_eq!("( ;".to_string().into_ascii_string(), Ok(v.clone())); - assert_eq!(b"( ;", AsRef::<[u8]>::as_ref(&v)); - - let err = "zoä华".to_string().into_ascii_string().unwrap_err(); - assert_eq!(Err(err.ascii_error()), "zoä华".as_ascii_str()); - assert_eq!(err.into_source(), "zoä华"); - let err = vec![127, 128, 255].into_ascii_string().unwrap_err(); - assert_eq!(Err(err.ascii_error()), [127, 128, 255].as_ascii_str()); - assert_eq!(err.into_source(), &[127, 128, 255]); -} - -#[test] -#[cfg(feature = "std")] -fn compare_ascii_string_ascii_str() { - let v = b"abc"; - let ascii_string = AsciiString::from_ascii(&v[..]).unwrap(); - let ascii_str = AsciiStr::from_ascii(v).unwrap(); - assert!(ascii_string == ascii_str); - assert!(ascii_str == ascii_string); -} - -#[test] -#[cfg(feature = "std")] -fn compare_ascii_string_string() { - let v = b"abc"; - let string = String::from_utf8(v.to_vec()).unwrap(); - let ascii_string = AsciiString::from_ascii(&v[..]).unwrap(); - assert!(string == ascii_string); - assert!(ascii_string == string); -} - -#[test] -#[cfg(feature = "std")] -fn compare_ascii_str_string() { - let v = b"abc"; - let string = String::from_utf8(v.to_vec()).unwrap(); - let ascii_str = AsciiStr::from_ascii(&v[..]).unwrap(); - assert!(string == ascii_str); - assert!(ascii_str == string); -} - -#[test] -#[cfg(feature = "std")] -fn compare_ascii_string_str() { - let v = b"abc"; - let sstr = ::std::str::from_utf8(v).unwrap(); - let ascii_string = AsciiString::from_ascii(&v[..]).unwrap(); - assert!(sstr == ascii_string); - assert!(ascii_string == sstr); -} - -#[test] -fn compare_ascii_str_str() { - let v = b"abc"; - let sstr = ::std::str::from_utf8(v).unwrap(); - let ascii_str = AsciiStr::from_ascii(v).unwrap(); - assert!(sstr == ascii_str); - assert!(ascii_str == sstr); -} - -#[test] -#[allow(clippy::redundant_slicing)] -fn compare_ascii_str_slice() { - let b = b"abc".as_ascii_str().unwrap(); - let c = b"ab".as_ascii_str().unwrap(); - assert_eq!(&b[..2], &c[..]); - assert_eq!(c[1].as_char(), 'b'); -} - -#[test] -#[cfg(feature = "std")] -fn compare_ascii_string_slice() { - let b = AsciiString::from_ascii("abc").unwrap(); - let c = AsciiString::from_ascii("ab").unwrap(); - assert_eq!(&b[..2], &c[..]); - assert_eq!(c[1].as_char(), 'b'); -} - -#[test] -#[cfg(feature = "std")] -fn extend_from_iterator() { - use std::borrow::Cow; - - let abc = "abc".as_ascii_str().unwrap(); - let mut s = abc.chars().collect::(); - assert_eq!(s, abc); - s.extend(abc); - assert_eq!(s, "abcabc"); - - let lines = "one\ntwo\nthree".as_ascii_str().unwrap().lines(); - s.extend(lines); - assert_eq!(s, "abcabconetwothree"); - - let cows = "ASCII Ascii ascii" - .as_ascii_str() - .unwrap() - .split(AsciiChar::Space) - .map(|case| { - if case.chars().all(AsciiChar::is_uppercase) { - Cow::from(case) - } else { - Cow::from(case.to_ascii_uppercase()) - } - }); - s.extend(cows); - s.extend(&[AsciiChar::LineFeed]); - assert_eq!(s, "abcabconetwothreeASCIIASCIIASCII\n"); -} diff --git a/anneal/vendor/chunked_transfer/.cargo-checksum.json b/anneal/vendor/chunked_transfer/.cargo-checksum.json deleted file mode 100644 index 83680bf097..0000000000 --- a/anneal/vendor/chunked_transfer/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{".cargo_vcs_info.json":"6efd477ff120102f1e31ff8f7625366ab64d193a5f0bb5d70882c3413e89e00a",".github/workflows/rust.yml":"6fdda8eaeae4d2e4b64a8497b836e40a244bd8f725ec49f19a9e1095aa62e819","Cargo.toml":"7753964e6adfc969908ea8f54aaad4c4bfed26a05e44bedb0faf588b9961f746","Cargo.toml.orig":"bcc025821244a7c37bf244d24a9116c9c48a0ade225fbcd34c825ff68c8036d7","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"5eda8c6538e7d543efe31ebad3fc0e66a7c4df056ddb901a5bdfbf5ef397e116","README.md":"4c3df261bfbfe8f7ed7bef76b833c606164dc768fe2919d7faf2ad3a3c1cb749","benches/encode.rs":"39e69d513bde63cbc977a4dc70f289c2ff494919ce0b934769039ffa82579312","src/decoder.rs":"e6df82dca0f409e866898464cb83d65cefb8d99b08109b77501444ff0c5ca5ec","src/encoder.rs":"1f645db6731b69d0394cb2e06250ea1de7a07c348aacc50df07b593421846953","src/lib.rs":"b1af36d3dddf7d2f7f45732281fa3fcafb741a60146f6befd33884fab51a6b03"},"package":"6e4de3bc4ea267985becf712dc6d9eed8b04c953b3fcfb339ebc87acd9804901"} \ No newline at end of file diff --git a/anneal/vendor/chunked_transfer/.cargo_vcs_info.json b/anneal/vendor/chunked_transfer/.cargo_vcs_info.json deleted file mode 100644 index 6bade92d3b..0000000000 --- a/anneal/vendor/chunked_transfer/.cargo_vcs_info.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "git": { - "sha1": "d4637cda63ec2da7052bba9d4d37f69cbeae9ab8" - }, - "path_in_vcs": "" -} \ No newline at end of file diff --git a/anneal/vendor/chunked_transfer/.github/workflows/rust.yml b/anneal/vendor/chunked_transfer/.github/workflows/rust.yml deleted file mode 100644 index 31000a2744..0000000000 --- a/anneal/vendor/chunked_transfer/.github/workflows/rust.yml +++ /dev/null @@ -1,22 +0,0 @@ -name: Rust - -on: - push: - branches: [ "main" ] - pull_request: - branches: [ "main" ] - -env: - CARGO_TERM_COLOR: always - -jobs: - build: - - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v3 - - name: Build - run: cargo build --verbose - - name: Run tests - run: cargo test --verbose diff --git a/anneal/vendor/chunked_transfer/Cargo.toml b/anneal/vendor/chunked_transfer/Cargo.toml deleted file mode 100644 index 52bd6cd984..0000000000 --- a/anneal/vendor/chunked_transfer/Cargo.toml +++ /dev/null @@ -1,27 +0,0 @@ -# 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 = "chunked_transfer" -version = "1.5.0" -authors = ["Corey Farwell "] -description = "Encoder and decoder for HTTP chunked transfer coding (RFC 7230 § 4.1)" -readme = "README.md" -license = "MIT OR Apache-2.0" -repository = "https://github.com/frewsxcv/rust-chunked-transfer" - -[[bench]] -name = "encode" -harness = false - -[dev-dependencies.criterion] -version = "0.3" diff --git a/anneal/vendor/chunked_transfer/Cargo.toml.orig b/anneal/vendor/chunked_transfer/Cargo.toml.orig deleted file mode 100644 index e0eaae9dab..0000000000 --- a/anneal/vendor/chunked_transfer/Cargo.toml.orig +++ /dev/null @@ -1,15 +0,0 @@ -[package] -name = "chunked_transfer" -version = "1.5.0" -authors = ["Corey Farwell "] -license = "MIT OR Apache-2.0" -repository = "https://github.com/frewsxcv/rust-chunked-transfer" -description = "Encoder and decoder for HTTP chunked transfer coding (RFC 7230 § 4.1)" -edition = "2018" - -[dev-dependencies] -criterion = "0.3" - -[[bench]] -name = "encode" -harness = false diff --git a/anneal/vendor/chunked_transfer/LICENSE-APACHE b/anneal/vendor/chunked_transfer/LICENSE-APACHE deleted file mode 100644 index 16fe87b06e..0000000000 --- a/anneal/vendor/chunked_transfer/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/anneal/vendor/chunked_transfer/LICENSE-MIT b/anneal/vendor/chunked_transfer/LICENSE-MIT deleted file mode 100644 index 892d6c7c47..0000000000 --- a/anneal/vendor/chunked_transfer/LICENSE-MIT +++ /dev/null @@ -1,22 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2015 The tiny-http Contributors -Copyright (c) 2015 The rust-chunked-transfer Contributors - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/anneal/vendor/chunked_transfer/README.md b/anneal/vendor/chunked_transfer/README.md deleted file mode 100644 index 92cfe05993..0000000000 --- a/anneal/vendor/chunked_transfer/README.md +++ /dev/null @@ -1,59 +0,0 @@ -# rust-chunked-transfer - -[Documentation](https://docs.rs/chunked_transfer/) - -Encoder and decoder for HTTP chunked transfer coding. For more information about chunked transfer encoding: - -* [RFC 7230 § 4.1](https://tools.ietf.org/html/rfc7230#section-4.1) -* [RFC 2616 § 3.6.1](https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.6.1) (deprecated) -* [Wikipedia: Chunked transfer encoding](https://en.wikipedia.org/wiki/Chunked_transfer_encoding) - -## Example - -### Decoding - -```rust -use chunked_transfer::Decoder; -use std::io::Read; - -let encoded = b"3\r\nhel\r\nb\r\nlo world!!!\r\n0\r\n\r\n"; -let mut decoded = String::new(); - -let mut decoder = Decoder::new(encoded as &[u8]); -decoder.read_to_string(&mut decoded); - -assert_eq!(decoded, "hello world!!!"); -``` - -### Encoding - -```rust -use chunked_transfer::Encoder; -use std::io::Write; - -let mut decoded = "hello world"; -let mut encoded: Vec = vec![]; - -{ - let mut encoder = Encoder::with_chunks_size(&mut encoded, 5); - encoder.write_all(decoded.as_bytes()); -} - -assert_eq!(encoded, b"5\r\nhello\r\n5\r\n worl\r\n1\r\nd\r\n0\r\n\r\n"); -``` - -## Authors - -* [tomaka](https://github.com/tomaka) -* [frewsxcv](https://github.com/frewsxcv) - -# License - -Licensed under either of: - - * Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0) - * MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT) - -## Contribution - -Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions. diff --git a/anneal/vendor/chunked_transfer/benches/encode.rs b/anneal/vendor/chunked_transfer/benches/encode.rs deleted file mode 100644 index 76306ff64b..0000000000 --- a/anneal/vendor/chunked_transfer/benches/encode.rs +++ /dev/null @@ -1,22 +0,0 @@ -#![feature(test)] - -use chunked_transfer; -use criterion::{criterion_group, criterion_main, Criterion}; -use std::io::Write; - -extern crate test; - -fn encode_benchmark(c: &mut Criterion) { - c.bench_function("encode", |b| { - let writer = vec![]; - let mut encoder = chunked_transfer::Encoder::new(writer); - let mut to_write = vec![b'a'; 1000]; - - b.iter(|| { - test::black_box(encoder.write_all(&mut to_write)); - }); - }); -} - -criterion_group!(benches, encode_benchmark); -criterion_main!(benches); diff --git a/anneal/vendor/chunked_transfer/src/decoder.rs b/anneal/vendor/chunked_transfer/src/decoder.rs deleted file mode 100644 index 453752fd69..0000000000 --- a/anneal/vendor/chunked_transfer/src/decoder.rs +++ /dev/null @@ -1,300 +0,0 @@ -use std::error::Error; -use std::fmt; -use std::io::Error as IoError; -use std::io::ErrorKind; -use std::io::Read; -use std::io::Result as IoResult; - -/// Reads HTTP chunks and sends back real data. -/// -/// # Example -/// -/// ``` -/// use chunked_transfer::Decoder; -/// use std::io::Read; -/// -/// let encoded = b"3\r\nhel\r\nb\r\nlo world!!!\r\n0\r\n\r\n"; -/// let mut decoded = String::new(); -/// -/// let mut decoder = Decoder::new(encoded as &[u8]); -/// decoder.read_to_string(&mut decoded); -/// -/// assert_eq!(decoded, "hello world!!!"); -/// ``` -pub struct Decoder { - // where the chunks come from - source: R, - - // remaining size of the chunk being read - // none if we are not in a chunk - remaining_chunks_size: Option, -} - -impl Decoder -where - R: Read, -{ - pub fn new(source: R) -> Decoder { - Decoder { - source, - remaining_chunks_size: None, - } - } - - /// Returns the remaining bytes left in the chunk being read. - pub fn remaining_chunks_size(&self) -> Option { - self.remaining_chunks_size - } - - /// Unwraps the Decoder into its inner `Read` source. - pub fn into_inner(self) -> R { - self.source - } - - /// Gets a reference to the underlying value in this decoder. - pub fn get_ref(&self) -> &R { - &self.source - } - - /// Gets a mutable reference to the underlying value in this decoder. - pub fn get_mut(&mut self) -> &mut R { - &mut self.source - } - - fn read_chunk_size(&mut self) -> IoResult { - let mut chunk_size_bytes = Vec::new(); - let mut has_ext = false; - - loop { - let byte = match self.source.by_ref().bytes().next() { - Some(b) => b?, - None => return Err(IoError::new(ErrorKind::InvalidInput, DecoderError)), - }; - - if byte == b'\r' { - break; - } - - if byte == b';' { - has_ext = true; - break; - } - - chunk_size_bytes.push(byte); - } - - // Ignore extensions for now - if has_ext { - loop { - let byte = match self.source.by_ref().bytes().next() { - Some(b) => b?, - None => return Err(IoError::new(ErrorKind::InvalidInput, DecoderError)), - }; - if byte == b'\r' { - break; - } - } - } - - self.read_line_feed()?; - - let chunk_size = String::from_utf8(chunk_size_bytes) - .ok() - .and_then(|c| usize::from_str_radix(c.trim(), 16).ok()) - .ok_or_else(|| IoError::new(ErrorKind::InvalidInput, DecoderError))?; - - Ok(chunk_size) - } - - fn read_carriage_return(&mut self) -> IoResult<()> { - match self.source.by_ref().bytes().next() { - Some(Ok(b'\r')) => Ok(()), - _ => Err(IoError::new(ErrorKind::InvalidInput, DecoderError)), - } - } - - fn read_line_feed(&mut self) -> IoResult<()> { - match self.source.by_ref().bytes().next() { - Some(Ok(b'\n')) => Ok(()), - _ => Err(IoError::new(ErrorKind::InvalidInput, DecoderError)), - } - } -} - -impl Read for Decoder -where - R: Read, -{ - fn read(&mut self, buf: &mut [u8]) -> IoResult { - let remaining_chunks_size = match self.remaining_chunks_size { - Some(c) => c, - None => { - // first possibility: we are not in a chunk, so we'll attempt to determine - // the chunks size - let chunk_size = self.read_chunk_size()?; - - // if the chunk size is 0, we are at EOF - if chunk_size == 0 { - self.read_carriage_return()?; - self.read_line_feed()?; - return Ok(0); - } - - chunk_size - } - }; - - // second possibility: we continue reading from a chunk - if buf.len() < remaining_chunks_size { - let read = self.source.read(buf)?; - self.remaining_chunks_size = Some(remaining_chunks_size - read); - return Ok(read); - } - - // third possibility: the read request goes further than the current chunk - // we simply read until the end of the chunk and return - assert!(buf.len() >= remaining_chunks_size); - - let buf = &mut buf[..remaining_chunks_size]; - let read = self.source.read(buf)?; - - self.remaining_chunks_size = if read == remaining_chunks_size { - self.read_carriage_return()?; - self.read_line_feed()?; - None - } else { - Some(remaining_chunks_size - read) - }; - - Ok(read) - } -} - -#[derive(Debug, Copy, Clone)] -struct DecoderError; - -impl fmt::Display for DecoderError { - fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { - write!(fmt, "Error while decoding chunks") - } -} - -impl Error for DecoderError { - fn description(&self) -> &str { - "Error while decoding chunks" - } -} - -#[cfg(test)] -mod test { - use super::Decoder; - use std::io; - use std::io::Read; - - /// This unit test is taken from from Hyper - /// https://github.com/hyperium/hyper - /// Copyright (c) 2014 Sean McArthur - #[test] - fn test_read_chunk_size() { - fn read(s: &str, expected: usize) { - let mut decoded = Decoder::new(s.as_bytes()); - let actual = decoded.read_chunk_size().unwrap(); - assert_eq!(expected, actual); - } - - fn read_err(s: &str) { - let mut decoded = Decoder::new(s.as_bytes()); - let err_kind = decoded.read_chunk_size().unwrap_err().kind(); - assert_eq!(err_kind, io::ErrorKind::InvalidInput); - } - - read("1\r\n", 1); - read("01\r\n", 1); - read("0\r\n", 0); - read("00\r\n", 0); - read("A\r\n", 10); - read("a\r\n", 10); - read("Ff\r\n", 255); - read("Ff \r\n", 255); - // Missing LF or CRLF - read_err("F\rF"); - read_err("F"); - // Invalid hex digit - read_err("X\r\n"); - read_err("1X\r\n"); - read_err("-\r\n"); - read_err("-1\r\n"); - // Acceptable (if not fully valid) extensions do not influence the size - read("1;extension\r\n", 1); - read("a;ext name=value\r\n", 10); - read("1;extension;extension2\r\n", 1); - read("1;;; ;\r\n", 1); - read("2; extension...\r\n", 2); - read("3 ; extension=123\r\n", 3); - read("3 ;\r\n", 3); - read("3 ; \r\n", 3); - // Invalid extensions cause an error - read_err("1 invalid extension\r\n"); - read_err("1 A\r\n"); - read_err("1;no CRLF"); - } - - #[test] - fn test_valid_chunk_decode() { - let source = io::Cursor::new( - "3\r\nhel\r\nb\r\nlo world!!!\r\n0\r\n\r\n" - .to_string() - .into_bytes(), - ); - let mut decoded = Decoder::new(source); - - let mut string = String::new(); - decoded.read_to_string(&mut string).unwrap(); - - assert_eq!(string, "hello world!!!"); - } - - #[test] - fn test_decode_zero_length() { - let mut decoder = Decoder::new(b"0\r\n\r\n" as &[u8]); - - let mut decoded = String::new(); - decoder.read_to_string(&mut decoded).unwrap(); - - assert_eq!(decoded, ""); - } - - #[test] - fn test_decode_invalid_chunk_length() { - let mut decoder = Decoder::new(b"m\r\n\r\n" as &[u8]); - - let mut decoded = String::new(); - assert!(decoder.read_to_string(&mut decoded).is_err()); - } - - #[test] - fn invalid_input1() { - let source = io::Cursor::new( - "2\r\nhel\r\nb\r\nlo world!!!\r\n0\r\n" - .to_string() - .into_bytes(), - ); - let mut decoded = Decoder::new(source); - - let mut string = String::new(); - assert!(decoded.read_to_string(&mut string).is_err()); - } - - #[test] - fn invalid_input2() { - let source = io::Cursor::new( - "3\rhel\r\nb\r\nlo world!!!\r\n0\r\n" - .to_string() - .into_bytes(), - ); - let mut decoded = Decoder::new(source); - - let mut string = String::new(); - assert!(decoded.read_to_string(&mut string).is_err()); - } -} diff --git a/anneal/vendor/chunked_transfer/src/encoder.rs b/anneal/vendor/chunked_transfer/src/encoder.rs deleted file mode 100644 index f1f45d0cc9..0000000000 --- a/anneal/vendor/chunked_transfer/src/encoder.rs +++ /dev/null @@ -1,207 +0,0 @@ -use std::io::Result as IoResult; -use std::io::Write; - -/// Splits the incoming data into HTTP chunks. -/// -/// # Example -/// -/// ``` -/// use chunked_transfer::Encoder; -/// use std::io::Write; -/// -/// let mut decoded = "hello world"; -/// let mut encoded: Vec = vec![]; -/// -/// { -/// let mut encoder = Encoder::with_chunks_size(&mut encoded, 5); -/// encoder.write_all(decoded.as_bytes()); -/// } -/// -/// assert_eq!(encoded, b"5\r\nhello\r\n5\r\n worl\r\n1\r\nd\r\n0\r\n\r\n"); -/// ``` -pub struct Encoder -where - W: Write, -{ - // where to send the result - output: W, - - // size of each chunk - chunks_size: usize, - - // data waiting to be sent is stored here - // This will always be at least 6 bytes long. The first 6 bytes - // are reserved for the chunk size and \r\n. - buffer: Vec, - - // Flushes the internal buffer after each write. This might be useful - // if data should be sent immediately to downstream consumers - flush_after_write: bool, -} - -const MAX_CHUNK_SIZE: usize = std::u32::MAX as usize; -// This accounts for four hex digits (enough to hold a u32) plus two bytes -// for the \r\n -const MAX_HEADER_SIZE: usize = 6; - -impl Encoder -where - W: Write, -{ - pub fn new(output: W) -> Encoder { - Encoder::with_chunks_size(output, 8192) - } - - /// Gets a reference to the underlying value in this encoder. - pub fn get_ref(&self) -> &W { - &self.output - } - - /// Gets a mutable reference to the underlying value in this encoder. - pub fn get_mut(&mut self) -> &mut W { - &mut self.output - } - - pub fn with_chunks_size(output: W, chunks: usize) -> Encoder { - let chunks_size = chunks.min(MAX_CHUNK_SIZE); - let mut encoder = Encoder { - output, - chunks_size, - buffer: vec![0; MAX_HEADER_SIZE], - flush_after_write: false, - }; - encoder.reset_buffer(); - encoder - } - - pub fn with_flush_after_write(output: W) -> Encoder { - let mut encoder = Encoder { - output, - chunks_size: 8192, - buffer: vec![0; MAX_HEADER_SIZE], - flush_after_write: true, - }; - encoder.reset_buffer(); - encoder - } - - fn reset_buffer(&mut self) { - // Reset buffer, still leaving space for the chunk size. That space - // will be populated once we know the size of the chunk. - self.buffer.truncate(MAX_HEADER_SIZE); - } - - fn is_buffer_empty(&self) -> bool { - self.buffer.len() == MAX_HEADER_SIZE - } - - fn buffer_len(&self) -> usize { - self.buffer.len() - MAX_HEADER_SIZE - } - - fn send(&mut self) -> IoResult<()> { - // Never send an empty buffer, because that would be interpreted - // as the end of the stream, which we indicate explicitly on drop. - if self.is_buffer_empty() { - return Ok(()); - } - // Prepend the length and \r\n to the buffer. - let prelude = format!("{:x}\r\n", self.buffer_len()); - let prelude = prelude.as_bytes(); - - // This should never happen because MAX_CHUNK_SIZE of u32::MAX - // can always be encoded in 4 hex bytes. - assert!( - prelude.len() <= MAX_HEADER_SIZE, - "invariant failed: prelude longer than MAX_HEADER_SIZE" - ); - - // Copy the prelude into the buffer. For small chunks, this won't necessarily - // take up all the space that was reserved for the prelude. - let offset = MAX_HEADER_SIZE - prelude.len(); - self.buffer[offset..MAX_HEADER_SIZE].clone_from_slice(prelude); - - // Append the chunk-finishing \r\n to the buffer. - self.buffer.write_all(b"\r\n")?; - - self.output.write_all(&self.buffer[offset..])?; - self.reset_buffer(); - - Ok(()) - } -} - -impl Write for Encoder -where - W: Write, -{ - fn write(&mut self, data: &[u8]) -> IoResult { - let remaining_buffer_space = self.chunks_size - self.buffer_len(); - let bytes_to_buffer = std::cmp::min(remaining_buffer_space, data.len()); - self.buffer.extend_from_slice(&data[0..bytes_to_buffer]); - let more_to_write: bool = bytes_to_buffer < data.len(); - if self.flush_after_write || more_to_write { - self.send()?; - } - - // If we didn't write the whole thing, keep working on it. - if more_to_write { - self.write_all(&data[bytes_to_buffer..])?; - } - Ok(data.len()) - } - - fn flush(&mut self) -> IoResult<()> { - self.send() - } -} - -impl Drop for Encoder -where - W: Write, -{ - fn drop(&mut self) { - self.flush().ok(); - write!(self.output, "0\r\n\r\n").ok(); - } -} - -#[cfg(test)] -mod test { - use super::Encoder; - use std::io; - use std::io::Write; - use std::str::from_utf8; - - #[test] - fn test() { - let mut source = io::Cursor::new("hello world".to_string().into_bytes()); - let mut dest: Vec = vec![]; - - { - let mut encoder = Encoder::with_chunks_size(dest.by_ref(), 5); - io::copy(&mut source, &mut encoder).unwrap(); - assert!(!encoder.is_buffer_empty()); - } - - let output = from_utf8(&dest).unwrap(); - - assert_eq!(output, "5\r\nhello\r\n5\r\n worl\r\n1\r\nd\r\n0\r\n\r\n"); - } - #[test] - fn flush_after_write() { - let mut source = io::Cursor::new("hello world".to_string().into_bytes()); - let mut dest: Vec = vec![]; - - { - let mut encoder = Encoder::with_flush_after_write(dest.by_ref()); - io::copy(&mut source, &mut encoder).unwrap(); - // The internal buffer has been flushed. - assert!(encoder.is_buffer_empty()); - } - - let output = from_utf8(&dest).unwrap(); - - assert_eq!(output, "b\r\nhello world\r\n0\r\n\r\n"); - } -} diff --git a/anneal/vendor/chunked_transfer/src/lib.rs b/anneal/vendor/chunked_transfer/src/lib.rs deleted file mode 100644 index ba9542b334..0000000000 --- a/anneal/vendor/chunked_transfer/src/lib.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod decoder; -pub use crate::decoder::Decoder; - -mod encoder; -pub use crate::encoder::Encoder; diff --git a/anneal/vendor/fancy-regex/.cargo-checksum.json b/anneal/vendor/fancy-regex/.cargo-checksum.json index f80c5752fc..4991b4963d 100644 --- a/anneal/vendor/fancy-regex/.cargo-checksum.json +++ b/anneal/vendor/fancy-regex/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"cf43644f4417a371f3b570fae27b3a6949dc254c597474a10b7ee23839965437","AUTHORS":"d5fca2653c88ad02d197faead77e22b80c70636b5bec6e02f2805f389a21b86d","CHANGELOG.md":"33e288ac35f2f0045f692c87624de90f10166e3bd0b3b311eeb7d28560a67aa1","CONTRIBUTING.md":"a7e0f3d282301aa5f4b546ed7fc5376159569987a002f24bf57082d49746fde6","Cargo.lock":"8846412681720cb85ae6a79ac3eae84ca145c7cb4a809e0bd52a3cbaed31ee31","Cargo.toml":"fe2d3062136b9c1bdacc09aaf8ad2766a4182de39732498de8bbb21c62f4384a","Cargo.toml.orig":"fc005fab26a48ff9c66f508c538a84b05cb5b5aea0968acf97daf9092687599a","LICENSE":"3bc70e239e91272782006c638fc0452a714d384224f11f0923036b7be07cf9b5","PERFORMANCE.md":"9de4fa787572943e7e350a2688002d571e986190e4869d08587048974bc2fcc6","README.md":"5321b581e5d6bea76875bc3ef93a482184fea9616b45f73781f5ec16542bdf9c","benches/bench.rs":"ec5005c0ec5b5155ae334f9204dffac98b583c377773dbe81e460ecf7404c1d0","codecov.yml":"d6ebfcadb4d940a0f86ab1a99928b673195c7d84cecee17a5eefeaf396c8477b","examples/toy.rs":"33c5f572f2afa1e0d359845708bd984bc95e272b4dcac0eb3ce55668b2a9d03b","src/analyze.rs":"0ea9e0b9661cef8c804a750459d6caf196b298dae1267d52661f1894f88c47d6","src/compile.rs":"54afdafd8004bc3cd27074e949fb1ccf0c81af0992f9c140141bea8f182ed42c","src/error.rs":"931e720cd907f7f62d41c10b69174f286c2944bb4230df8c3c1428aa75056260","src/expand.rs":"6eff8afef144363d8ebbb90922448783cf2ebfc71ef716948bd9da54793663af","src/lib.rs":"5fceb05786b2e860ec2141c8e6bfbb85014c97b4f48cc634d0842b81b0dd6477","src/parse.rs":"8991c0f8b311f404cd63bc8f2beb898055f14c2fd899ccfb86055b396a596229","src/replacer.rs":"5bf1c99d598c27248fd6591dab000e649eedc8f51179f904e00b94ac27919dc3","src/vm.rs":"8442aec0c60680576130f0ebbd6da494bba14d1141e7035f66c68f3849933731","tests/captures.rs":"0b561bbec208af0cdea12c8b10e3c72eab80ef2dbf1a9c1007fdffc7401b4434","tests/common/mod.rs":"b8ab2a7a3a25adad8317c8eb1f4566df6a81978c3a7ab49847ec2f838d77c888","tests/finding.rs":"76e60d370ae71585a304018fe0398e5206fe431fe21bbde6347cc2572afff0e5","tests/matching.rs":"3f8d1e0f6567375866b14610eda6e2dc1e96ed26ba1a451fe0c4bb2bf6f774fb","tests/oniguruma.rs":"78a54ef464d08fa7192959eb50c3de03df7dae0f9d41831b06ecfa170dfcfd65","tests/oniguruma/README.md":"eae6ac089cd32010ffacb4b2f0f8cbac03ad2623e115386af53bfc93e04d1903","tests/oniguruma/test_utf8.c":"1e4813ac64703cfdbcdca359b82856c5c6778abf977e577992f6b34ab26b92de","tests/oniguruma/test_utf8_ignore.c":"88760e1779017c58dfca5b03f382df7b067dceefcb4b52d81aef36f096b918a0","tests/regex_options.rs":"1744e707e8d76f19b999728c6b7de6e0e531342d1cd708af61ffbe74cef84a3f","tests/replace.rs":"689fef80c2cd243a510be212cb8e6a04a30a0b0fa6f1dd6be63b17a9abb158d8","tests/splitting.rs":"55a60e7953e92cf542fff8016c24607d3da4fdf9cbf68712348cc430b2bc0f3f"},"package":"6e24cb5a94bcae1e5408b0effca5cd7172ea3c5755049c5f3af4cd283a165298"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"cf43644f4417a371f3b570fae27b3a6949dc254c597474a10b7ee23839965437","AUTHORS":"d5fca2653c88ad02d197faead77e22b80c70636b5bec6e02f2805f389a21b86d","CHANGELOG.md":"33e288ac35f2f0045f692c87624de90f10166e3bd0b3b311eeb7d28560a67aa1","CONTRIBUTING.md":"a7e0f3d282301aa5f4b546ed7fc5376159569987a002f24bf57082d49746fde6","Cargo.lock":"8846412681720cb85ae6a79ac3eae84ca145c7cb4a809e0bd52a3cbaed31ee31","Cargo.toml":"fe2d3062136b9c1bdacc09aaf8ad2766a4182de39732498de8bbb21c62f4384a","Cargo.toml.orig":"fc005fab26a48ff9c66f508c538a84b05cb5b5aea0968acf97daf9092687599a","LICENSE":"3bc70e239e91272782006c638fc0452a714d384224f11f0923036b7be07cf9b5","PERFORMANCE.md":"9de4fa787572943e7e350a2688002d571e986190e4869d08587048974bc2fcc6","README.md":"5321b581e5d6bea76875bc3ef93a482184fea9616b45f73781f5ec16542bdf9c","benches/bench.rs":"ec5005c0ec5b5155ae334f9204dffac98b583c377773dbe81e460ecf7404c1d0","codecov.yml":"d6ebfcadb4d940a0f86ab1a99928b673195c7d84cecee17a5eefeaf396c8477b","examples/toy.rs":"33c5f572f2afa1e0d359845708bd984bc95e272b4dcac0eb3ce55668b2a9d03b","src/analyze.rs":"0ea9e0b9661cef8c804a750459d6caf196b298dae1267d52661f1894f88c47d6","src/compile.rs":"54afdafd8004bc3cd27074e949fb1ccf0c81af0992f9c140141bea8f182ed42c","src/error.rs":"931e720cd907f7f62d41c10b69174f286c2944bb4230df8c3c1428aa75056260","src/expand.rs":"6eff8afef144363d8ebbb90922448783cf2ebfc71ef716948bd9da54793663af","src/lib.rs":"5fceb05786b2e860ec2141c8e6bfbb85014c97b4f48cc634d0842b81b0dd6477","src/parse.rs":"8991c0f8b311f404cd63bc8f2beb898055f14c2fd899ccfb86055b396a596229","src/replacer.rs":"5bf1c99d598c27248fd6591dab000e649eedc8f51179f904e00b94ac27919dc3","src/vm.rs":"8442aec0c60680576130f0ebbd6da494bba14d1141e7035f66c68f3849933731","tests/captures.rs":"0b561bbec208af0cdea12c8b10e3c72eab80ef2dbf1a9c1007fdffc7401b4434","tests/common/mod.rs":"b8ab2a7a3a25adad8317c8eb1f4566df6a81978c3a7ab49847ec2f838d77c888","tests/finding.rs":"76e60d370ae71585a304018fe0398e5206fe431fe21bbde6347cc2572afff0e5","tests/matching.rs":"3f8d1e0f6567375866b14610eda6e2dc1e96ed26ba1a451fe0c4bb2bf6f774fb","tests/oniguruma.rs":"78a54ef464d08fa7192959eb50c3de03df7dae0f9d41831b06ecfa170dfcfd65","tests/oniguruma/.gitattributes":"b8d35d419a619abf4283b4f1e8a3daeaca142c87df6634b4cd706b726d29a88d","tests/oniguruma/README.md":"eae6ac089cd32010ffacb4b2f0f8cbac03ad2623e115386af53bfc93e04d1903","tests/oniguruma/test_utf8.c":"1e4813ac64703cfdbcdca359b82856c5c6778abf977e577992f6b34ab26b92de","tests/oniguruma/test_utf8_ignore.c":"88760e1779017c58dfca5b03f382df7b067dceefcb4b52d81aef36f096b918a0","tests/regex_options.rs":"1744e707e8d76f19b999728c6b7de6e0e531342d1cd708af61ffbe74cef84a3f","tests/replace.rs":"689fef80c2cd243a510be212cb8e6a04a30a0b0fa6f1dd6be63b17a9abb158d8","tests/splitting.rs":"55a60e7953e92cf542fff8016c24607d3da4fdf9cbf68712348cc430b2bc0f3f"},"package":"6e24cb5a94bcae1e5408b0effca5cd7172ea3c5755049c5f3af4cd283a165298"} \ No newline at end of file diff --git a/anneal/vendor/fancy-regex/tests/oniguruma/.gitattributes b/anneal/vendor/fancy-regex/tests/oniguruma/.gitattributes new file mode 100644 index 0000000000..7d949a450f --- /dev/null +++ b/anneal/vendor/fancy-regex/tests/oniguruma/.gitattributes @@ -0,0 +1,2 @@ +# Imported from oniguruma +*.c linguist-vendored diff --git a/anneal/vendor/httpdate/.cargo-checksum.json b/anneal/vendor/httpdate/.cargo-checksum.json deleted file mode 100644 index 29b7b44f66..0000000000 --- a/anneal/vendor/httpdate/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{".cargo_vcs_info.json":"158299c819b7d96576c47ecdbb6d8a12749ea3f45de887679fe58e3a462cf6fc",".github/workflows/ci.yml":"9a88cd3211399918ee069a77456e6c9317efeddae0848c681d14d08364211814","Cargo.toml":"d1adbc974f706b302bc844ce7b6d6323d30a1689b9e3bf53ab78ba0bb09a9ed9","Cargo.toml.orig":"935ef51333a927e121be199efebd6aa6df22e14682770d1cfd9d32fd2bc931eb","LICENSE-APACHE":"4d10fe5f3aa176b05b229a248866bad70b834c173f1252a814ff4748d8a13837","LICENSE-MIT":"934887691e05d69d7c86ad3f2c360980fa30c15b035e351f3c9865e99da4debc","README.md":"276cab7dac6cc74706b2aec34e649ef09c5b0149dbf15329020781161bb13673","benches/benchmarks.rs":"13f1208dfb86e3c02dcd67a4c08c2bae300c0a153de5df437eac4a136579ec23","src/date.rs":"87e7de1394f6b0d37128bfbf5943e256c886c35ed3f9078d15a08309c2206c69","src/lib.rs":"1c5b99558a8b2fec28d003b58a198cb2aebd232f0a2d162906524c5e6ead162e"},"package":"df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"} \ No newline at end of file diff --git a/anneal/vendor/httpdate/.cargo_vcs_info.json b/anneal/vendor/httpdate/.cargo_vcs_info.json deleted file mode 100644 index f43f4cfa20..0000000000 --- a/anneal/vendor/httpdate/.cargo_vcs_info.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "git": { - "sha1": "638da761065df8b67282b0a1d139c0a7e4a02429" - }, - "path_in_vcs": "" -} \ No newline at end of file diff --git a/anneal/vendor/httpdate/.github/workflows/ci.yml b/anneal/vendor/httpdate/.github/workflows/ci.yml deleted file mode 100644 index 8a9dfcc7de..0000000000 --- a/anneal/vendor/httpdate/.github/workflows/ci.yml +++ /dev/null @@ -1,24 +0,0 @@ -on: [push, pull_request] - -name: Continuous integration - -jobs: - check-test: - name: Check and test crate - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - uses: dtolnay/rust-toolchain@stable - - run: cargo check --all-targets - - run: cargo test - - clippy-fmt: - name: Run Clippy and format code - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - uses: dtolnay/rust-toolchain@stable - with: - components: clippy, rustfmt - - run: cargo clippy --all-targets -- -D warnings - - run: cargo fmt --all --check diff --git a/anneal/vendor/httpdate/Cargo.toml b/anneal/vendor/httpdate/Cargo.toml deleted file mode 100644 index f5049680ff..0000000000 --- a/anneal/vendor/httpdate/Cargo.toml +++ /dev/null @@ -1,35 +0,0 @@ -# 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" -rust-version = "1.56" -name = "httpdate" -version = "1.0.3" -authors = ["Pyfisch "] -description = "HTTP date parsing and formatting" -readme = "README.md" -keywords = [ - "http", - "date", - "time", - "simple", - "timestamp", -] -license = "MIT OR Apache-2.0" -repository = "https://github.com/pyfisch/httpdate" - -[[bench]] -name = "benchmarks" -harness = false - -[dev-dependencies.criterion] -version = "0.5" diff --git a/anneal/vendor/httpdate/Cargo.toml.orig b/anneal/vendor/httpdate/Cargo.toml.orig deleted file mode 100644 index ddc17f1099..0000000000 --- a/anneal/vendor/httpdate/Cargo.toml.orig +++ /dev/null @@ -1,18 +0,0 @@ -[package] -name = "httpdate" -version = "1.0.3" -authors = ["Pyfisch "] -license = "MIT OR Apache-2.0" -description = "HTTP date parsing and formatting" -keywords = ["http", "date", "time", "simple", "timestamp"] -readme = "README.md" -repository = "https://github.com/pyfisch/httpdate" -edition = "2021" -rust-version = "1.56" - -[dev-dependencies] -criterion = "0.5" - -[[bench]] -name = "benchmarks" -harness = false diff --git a/anneal/vendor/httpdate/LICENSE-APACHE b/anneal/vendor/httpdate/LICENSE-APACHE deleted file mode 100644 index cd482d8976..0000000000 --- a/anneal/vendor/httpdate/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ -Apache License -Version 2.0, January 2004 -http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - -"License" shall mean the terms and conditions for use, reproduction, -and distribution as defined by Sections 1 through 9 of this document. - -"Licensor" shall mean the copyright owner or entity authorized by -the copyright owner that is granting the License. - -"Legal Entity" shall mean the union of the acting entity and all -other entities that control, are controlled by, or are under common -control with that entity. For the purposes of this definition, -"control" means (i) the power, direct or indirect, to cause the -direction or management of such entity, whether by contract or -otherwise, or (ii) ownership of fifty percent (50%) or more of the -outstanding shares, or (iii) beneficial ownership of such entity. - -"You" (or "Your") shall mean an individual or Legal Entity -exercising permissions granted by this License. - -"Source" form shall mean the preferred form for making modifications, -including but not limited to software source code, documentation -source, and configuration files. - -"Object" form shall mean any form resulting from mechanical -transformation or translation of a Source form, including but -not limited to compiled object code, generated documentation, -and conversions to other media types. - -"Work" shall mean the work of authorship, whether in Source or -Object form, made available under the License, as indicated by a -copyright notice that is included in or attached to the work -(an example is provided in the Appendix below). - -"Derivative Works" shall mean any work, whether in Source or Object -form, that is based on (or derived from) the Work and for which the -editorial revisions, annotations, elaborations, or other modifications -represent, as a whole, an original work of authorship. For the purposes -of this License, Derivative Works shall not include works that remain -separable from, or merely link (or bind by name) to the interfaces of, -the Work and Derivative Works thereof. - -"Contribution" shall mean any work of authorship, including -the original version of the Work and any modifications or additions -to that Work or Derivative Works thereof, that is intentionally -submitted to Licensor for inclusion in the Work by the copyright owner -or by an individual or Legal Entity authorized to submit on behalf of -the copyright owner. For the purposes of this definition, "submitted" -means any form of electronic, verbal, or written communication sent -to the Licensor or its representatives, including but not limited to -communication on electronic mailing lists, source code control systems, -and issue tracking systems that are managed by, or on behalf of, the -Licensor for the purpose of discussing and improving the Work, but -excluding communication that is conspicuously marked or otherwise -designated in writing by the copyright owner as "Not a Contribution." - -"Contributor" shall mean Licensor and any individual or Legal Entity -on behalf of whom a Contribution has been received by Licensor and -subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of -this License, each Contributor hereby grants to You a perpetual, -worldwide, non-exclusive, no-charge, royalty-free, irrevocable -copyright license to reproduce, prepare Derivative Works of, -publicly display, publicly perform, sublicense, and distribute the -Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of -this License, each Contributor hereby grants to You a perpetual, -worldwide, non-exclusive, no-charge, royalty-free, irrevocable -(except as stated in this section) patent license to make, have made, -use, offer to sell, sell, import, and otherwise transfer the Work, -where such license applies only to those patent claims licensable -by such Contributor that are necessarily infringed by their -Contribution(s) alone or by combination of their Contribution(s) -with the Work to which such Contribution(s) was submitted. If You -institute patent litigation against any entity (including a -cross-claim or counterclaim in a lawsuit) alleging that the Work -or a Contribution incorporated within the Work constitutes direct -or contributory patent infringement, then any patent licenses -granted to You under this License for that Work shall terminate -as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the -Work or Derivative Works thereof in any medium, with or without -modifications, and in Source or Object form, provided that You -meet the following conditions: - -(a) You must give any other recipients of the Work or -Derivative Works a copy of this License; and - -(b) You must cause any modified files to carry prominent notices -stating that You changed the files; and - -(c) You must retain, in the Source form of any Derivative Works -that You distribute, all copyright, patent, trademark, and -attribution notices from the Source form of the Work, -excluding those notices that do not pertain to any part of -the Derivative Works; and - -(d) If the Work includes a "NOTICE" text file as part of its -distribution, then any Derivative Works that You distribute must -include a readable copy of the attribution notices contained -within such NOTICE file, excluding those notices that do not -pertain to any part of the Derivative Works, in at least one -of the following places: within a NOTICE text file distributed -as part of the Derivative Works; within the Source form or -documentation, if provided along with the Derivative Works; or, -within a display generated by the Derivative Works, if and -wherever such third-party notices normally appear. The contents -of the NOTICE file are for informational purposes only and -do not modify the License. You may add Your own attribution -notices within Derivative Works that You distribute, alongside -or as an addendum to the NOTICE text from the Work, provided -that such additional attribution notices cannot be construed -as modifying the License. - -You may add Your own copyright statement to Your modifications and -may provide additional or different license terms and conditions -for use, reproduction, or distribution of Your modifications, or -for any such Derivative Works as a whole, provided Your use, -reproduction, and distribution of the Work otherwise complies with -the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, -any Contribution intentionally submitted for inclusion in the Work -by You to the Licensor shall be under the terms and conditions of -this License, without any additional terms or conditions. -Notwithstanding the above, nothing herein shall supersede or modify -the terms of any separate license agreement you may have executed -with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade -names, trademarks, service marks, or product names of the Licensor, -except as required for reasonable and customary use in describing the -origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or -agreed to in writing, Licensor provides the Work (and each -Contributor provides its Contributions) on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or -implied, including, without limitation, any warranties or conditions -of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A -PARTICULAR PURPOSE. You are solely responsible for determining the -appropriateness of using or redistributing the Work and assume any -risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, -whether in tort (including negligence), contract, or otherwise, -unless required by applicable law (such as deliberate and grossly -negligent acts) or agreed to in writing, shall any Contributor be -liable to You for damages, including any direct, indirect, special, -incidental, or consequential damages of any character arising as a -result of this License or out of the use or inability to use the -Work (including but not limited to damages for loss of goodwill, -work stoppage, computer failure or malfunction, or any and all -other commercial damages or losses), even if such Contributor -has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing -the Work or Derivative Works thereof, You may choose to offer, -and charge a fee for, acceptance of support, warranty, indemnity, -or other liability obligations and/or rights consistent with this -License. However, in accepting such obligations, You may act only -on Your own behalf and on Your sole responsibility, not on behalf -of any other Contributor, and only if You agree to indemnify, -defend, and hold each Contributor harmless for any liability -incurred by, or claims asserted against, such Contributor by reason -of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - -To apply the Apache License to your work, attach the following -boilerplate notice, with the fields enclosed by brackets "[]" -replaced with your own identifying information. (Don't include -the brackets!) The text should be enclosed in the appropriate -comment syntax for the file format. We also recommend that a -file or class name and description of purpose be included on the -same "printed page" as the copyright notice for easier -identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - -http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/anneal/vendor/httpdate/LICENSE-MIT b/anneal/vendor/httpdate/LICENSE-MIT deleted file mode 100644 index 8819964156..0000000000 --- a/anneal/vendor/httpdate/LICENSE-MIT +++ /dev/null @@ -1,19 +0,0 @@ -Copyright (c) 2016 Pyfisch - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. diff --git a/anneal/vendor/httpdate/README.md b/anneal/vendor/httpdate/README.md deleted file mode 100644 index dd436e86e0..0000000000 --- a/anneal/vendor/httpdate/README.md +++ /dev/null @@ -1,27 +0,0 @@ -# Date and time utils for HTTP. - -[![Build Status](https://github.com/pyfisch/httpdate/actions/workflows/ci.yml/badge.svg)](https://github.com/pyfisch/httpdate/actions/workflows/ci.yml) -[![Crates.io](https://img.shields.io/crates/v/httpdate.svg)](https://crates.io/crates/httpdate) -[![Documentation](https://docs.rs/httpdate/badge.svg)](https://docs.rs/httpdate) - -Multiple HTTP header fields store timestamps. -For example a response created on May 15, 2015 may contain the header -`Date: Fri, 15 May 2015 15:34:21 GMT`. Since the timestamp does not -contain any timezone or leap second information it is equvivalent to -writing 1431696861 Unix time. Rust’s `SystemTime` is used to store -these timestamps. - -This crate provides two public functions: - -* `parse_http_date` to parse a HTTP datetime string to a system time -* `fmt_http_date` to format a system time to a IMF-fixdate - -In addition it exposes the `HttpDate` type that can be used to parse -and format timestamps. Convert a sytem time to `HttpDate` and vice versa. -The `HttpDate` (8 bytes) is smaller than `SystemTime` (16 bytes) and -using the display impl avoids a temporary allocation. - -Read the [blog post](https://pyfisch.org/blog/http-datetime-handling/) to learn -more. - -Fuzz it by installing *cargo-fuzz* and running `cargo fuzz run fuzz_target_1`. diff --git a/anneal/vendor/httpdate/benches/benchmarks.rs b/anneal/vendor/httpdate/benches/benchmarks.rs deleted file mode 100644 index 4f82467bdb..0000000000 --- a/anneal/vendor/httpdate/benches/benchmarks.rs +++ /dev/null @@ -1,57 +0,0 @@ -use criterion::{black_box, criterion_group, criterion_main, Criterion}; - -pub fn parse_imf_fixdate(c: &mut Criterion) { - c.bench_function("parse_imf_fixdate", |b| { - b.iter(|| { - let d = black_box("Sun, 06 Nov 1994 08:49:37 GMT"); - black_box(httpdate::parse_http_date(d)).unwrap(); - }) - }); -} - -pub fn parse_rfc850_date(c: &mut Criterion) { - c.bench_function("parse_rfc850_date", |b| { - b.iter(|| { - let d = black_box("Sunday, 06-Nov-94 08:49:37 GMT"); - black_box(httpdate::parse_http_date(d)).unwrap(); - }) - }); -} - -pub fn parse_asctime(c: &mut Criterion) { - c.bench_function("parse_asctime", |b| { - b.iter(|| { - let d = black_box("Sun Nov 6 08:49:37 1994"); - black_box(httpdate::parse_http_date(d)).unwrap(); - }) - }); -} - -struct BlackBoxWrite; - -impl std::fmt::Write for BlackBoxWrite { - fn write_str(&mut self, s: &str) -> Result<(), std::fmt::Error> { - black_box(s); - Ok(()) - } -} - -pub fn encode_date(c: &mut Criterion) { - c.bench_function("encode_date", |b| { - let d = "Wed, 21 Oct 2015 07:28:00 GMT"; - black_box(httpdate::parse_http_date(d)).unwrap(); - b.iter(|| { - use std::fmt::Write; - let _ = write!(BlackBoxWrite, "{}", d); - }) - }); -} - -criterion_group!( - benches, - parse_imf_fixdate, - parse_rfc850_date, - parse_asctime, - encode_date -); -criterion_main!(benches); diff --git a/anneal/vendor/httpdate/src/date.rs b/anneal/vendor/httpdate/src/date.rs deleted file mode 100644 index 8bc0a3b33b..0000000000 --- a/anneal/vendor/httpdate/src/date.rs +++ /dev/null @@ -1,420 +0,0 @@ -use std::cmp; -use std::fmt::{self, Display, Formatter}; -use std::str::FromStr; -use std::time::{Duration, SystemTime, UNIX_EPOCH}; - -use crate::Error; - -/// HTTP timestamp type. -/// -/// Parse using `FromStr` impl. -/// Format using the `Display` trait. -/// Convert timestamp into/from `SytemTime` to use. -/// Supports comparsion and sorting. -#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)] -pub struct HttpDate { - /// 0...59 - sec: u8, - /// 0...59 - min: u8, - /// 0...23 - hour: u8, - /// 1...31 - day: u8, - /// 1...12 - mon: u8, - /// 1970...9999 - year: u16, - /// 1...7 - wday: u8, -} - -impl HttpDate { - fn is_valid(&self) -> bool { - self.sec < 60 - && self.min < 60 - && self.hour < 24 - && self.day > 0 - && self.day < 32 - && self.mon > 0 - && self.mon <= 12 - && self.year >= 1970 - && self.year <= 9999 - && &HttpDate::from(SystemTime::from(*self)) == self - } -} - -impl From for HttpDate { - fn from(v: SystemTime) -> HttpDate { - let dur = v - .duration_since(UNIX_EPOCH) - .expect("all times should be after the epoch"); - let secs_since_epoch = dur.as_secs(); - - if secs_since_epoch >= 253402300800 { - // year 9999 - panic!("date must be before year 9999"); - } - - /* 2000-03-01 (mod 400 year, immediately after feb29 */ - const LEAPOCH: i64 = 11017; - const DAYS_PER_400Y: i64 = 365 * 400 + 97; - const DAYS_PER_100Y: i64 = 365 * 100 + 24; - const DAYS_PER_4Y: i64 = 365 * 4 + 1; - - let days = (secs_since_epoch / 86400) as i64 - LEAPOCH; - let secs_of_day = secs_since_epoch % 86400; - - let mut qc_cycles = days / DAYS_PER_400Y; - let mut remdays = days % DAYS_PER_400Y; - - if remdays < 0 { - remdays += DAYS_PER_400Y; - qc_cycles -= 1; - } - - let mut c_cycles = remdays / DAYS_PER_100Y; - if c_cycles == 4 { - c_cycles -= 1; - } - remdays -= c_cycles * DAYS_PER_100Y; - - let mut q_cycles = remdays / DAYS_PER_4Y; - if q_cycles == 25 { - q_cycles -= 1; - } - remdays -= q_cycles * DAYS_PER_4Y; - - let mut remyears = remdays / 365; - if remyears == 4 { - remyears -= 1; - } - remdays -= remyears * 365; - - let mut year = 2000 + remyears + 4 * q_cycles + 100 * c_cycles + 400 * qc_cycles; - - let months = [31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 29]; - let mut mon = 0; - for mon_len in months.iter() { - mon += 1; - if remdays < *mon_len { - break; - } - remdays -= *mon_len; - } - let mday = remdays + 1; - let mon = if mon + 2 > 12 { - year += 1; - mon - 10 - } else { - mon + 2 - }; - - let mut wday = (3 + days) % 7; - if wday <= 0 { - wday += 7 - }; - - HttpDate { - sec: (secs_of_day % 60) as u8, - min: ((secs_of_day % 3600) / 60) as u8, - hour: (secs_of_day / 3600) as u8, - day: mday as u8, - mon: mon as u8, - year: year as u16, - wday: wday as u8, - } - } -} - -impl From for SystemTime { - fn from(v: HttpDate) -> SystemTime { - let leap_years = - ((v.year - 1) - 1968) / 4 - ((v.year - 1) - 1900) / 100 + ((v.year - 1) - 1600) / 400; - let mut ydays = match v.mon { - 1 => 0, - 2 => 31, - 3 => 59, - 4 => 90, - 5 => 120, - 6 => 151, - 7 => 181, - 8 => 212, - 9 => 243, - 10 => 273, - 11 => 304, - 12 => 334, - _ => unreachable!(), - } + v.day as u64 - - 1; - if is_leap_year(v.year) && v.mon > 2 { - ydays += 1; - } - let days = (v.year as u64 - 1970) * 365 + leap_years as u64 + ydays; - UNIX_EPOCH - + Duration::from_secs( - v.sec as u64 + v.min as u64 * 60 + v.hour as u64 * 3600 + days * 86400, - ) - } -} - -impl FromStr for HttpDate { - type Err = Error; - - fn from_str(s: &str) -> Result { - if !s.is_ascii() { - return Err(Error(())); - } - let x = s.trim().as_bytes(); - let date = parse_imf_fixdate(x) - .or_else(|_| parse_rfc850_date(x)) - .or_else(|_| parse_asctime(x))?; - if !date.is_valid() { - return Err(Error(())); - } - Ok(date) - } -} - -impl Display for HttpDate { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - let wday = match self.wday { - 1 => b"Mon", - 2 => b"Tue", - 3 => b"Wed", - 4 => b"Thu", - 5 => b"Fri", - 6 => b"Sat", - 7 => b"Sun", - _ => unreachable!(), - }; - - let mon = match self.mon { - 1 => b"Jan", - 2 => b"Feb", - 3 => b"Mar", - 4 => b"Apr", - 5 => b"May", - 6 => b"Jun", - 7 => b"Jul", - 8 => b"Aug", - 9 => b"Sep", - 10 => b"Oct", - 11 => b"Nov", - 12 => b"Dec", - _ => unreachable!(), - }; - - let mut buf: [u8; 29] = *b" , 00 0000 00:00:00 GMT"; - buf[0] = wday[0]; - buf[1] = wday[1]; - buf[2] = wday[2]; - buf[5] = b'0' + (self.day / 10); - buf[6] = b'0' + (self.day % 10); - buf[8] = mon[0]; - buf[9] = mon[1]; - buf[10] = mon[2]; - buf[12] = b'0' + (self.year / 1000) as u8; - buf[13] = b'0' + (self.year / 100 % 10) as u8; - buf[14] = b'0' + (self.year / 10 % 10) as u8; - buf[15] = b'0' + (self.year % 10) as u8; - buf[17] = b'0' + (self.hour / 10); - buf[18] = b'0' + (self.hour % 10); - buf[20] = b'0' + (self.min / 10); - buf[21] = b'0' + (self.min % 10); - buf[23] = b'0' + (self.sec / 10); - buf[24] = b'0' + (self.sec % 10); - f.write_str(std::str::from_utf8(&buf[..]).unwrap()) - } -} - -impl Ord for HttpDate { - fn cmp(&self, other: &HttpDate) -> cmp::Ordering { - SystemTime::from(*self).cmp(&SystemTime::from(*other)) - } -} - -impl PartialOrd for HttpDate { - fn partial_cmp(&self, other: &HttpDate) -> Option { - Some(self.cmp(other)) - } -} - -fn toint_1(x: u8) -> Result { - let result = x.wrapping_sub(b'0'); - if result < 10 { - Ok(result) - } else { - Err(Error(())) - } -} - -fn toint_2(s: &[u8]) -> Result { - let high = s[0].wrapping_sub(b'0'); - let low = s[1].wrapping_sub(b'0'); - - if high < 10 && low < 10 { - Ok(high * 10 + low) - } else { - Err(Error(())) - } -} - -#[allow(clippy::many_single_char_names)] -fn toint_4(s: &[u8]) -> Result { - let a = u16::from(s[0].wrapping_sub(b'0')); - let b = u16::from(s[1].wrapping_sub(b'0')); - let c = u16::from(s[2].wrapping_sub(b'0')); - let d = u16::from(s[3].wrapping_sub(b'0')); - - if a < 10 && b < 10 && c < 10 && d < 10 { - Ok(a * 1000 + b * 100 + c * 10 + d) - } else { - Err(Error(())) - } -} - -fn parse_imf_fixdate(s: &[u8]) -> Result { - // Example: `Sun, 06 Nov 1994 08:49:37 GMT` - if s.len() != 29 || &s[25..] != b" GMT" || s[16] != b' ' || s[19] != b':' || s[22] != b':' { - return Err(Error(())); - } - Ok(HttpDate { - sec: toint_2(&s[23..25])?, - min: toint_2(&s[20..22])?, - hour: toint_2(&s[17..19])?, - day: toint_2(&s[5..7])?, - mon: match &s[7..12] { - b" Jan " => 1, - b" Feb " => 2, - b" Mar " => 3, - b" Apr " => 4, - b" May " => 5, - b" Jun " => 6, - b" Jul " => 7, - b" Aug " => 8, - b" Sep " => 9, - b" Oct " => 10, - b" Nov " => 11, - b" Dec " => 12, - _ => return Err(Error(())), - }, - year: toint_4(&s[12..16])?, - wday: match &s[..5] { - b"Mon, " => 1, - b"Tue, " => 2, - b"Wed, " => 3, - b"Thu, " => 4, - b"Fri, " => 5, - b"Sat, " => 6, - b"Sun, " => 7, - _ => return Err(Error(())), - }, - }) -} - -fn parse_rfc850_date(s: &[u8]) -> Result { - // Example: `Sunday, 06-Nov-94 08:49:37 GMT` - if s.len() < 23 { - return Err(Error(())); - } - - fn wday<'a>(s: &'a [u8], wday: u8, name: &'static [u8]) -> Option<(u8, &'a [u8])> { - if &s[0..name.len()] == name { - return Some((wday, &s[name.len()..])); - } - None - } - let (wday, s) = wday(s, 1, b"Monday, ") - .or_else(|| wday(s, 2, b"Tuesday, ")) - .or_else(|| wday(s, 3, b"Wednesday, ")) - .or_else(|| wday(s, 4, b"Thursday, ")) - .or_else(|| wday(s, 5, b"Friday, ")) - .or_else(|| wday(s, 6, b"Saturday, ")) - .or_else(|| wday(s, 7, b"Sunday, ")) - .ok_or(Error(()))?; - if s.len() != 22 || s[12] != b':' || s[15] != b':' || &s[18..22] != b" GMT" { - return Err(Error(())); - } - let mut year = u16::from(toint_2(&s[7..9])?); - if year < 70 { - year += 2000; - } else { - year += 1900; - } - Ok(HttpDate { - sec: toint_2(&s[16..18])?, - min: toint_2(&s[13..15])?, - hour: toint_2(&s[10..12])?, - day: toint_2(&s[0..2])?, - mon: match &s[2..7] { - b"-Jan-" => 1, - b"-Feb-" => 2, - b"-Mar-" => 3, - b"-Apr-" => 4, - b"-May-" => 5, - b"-Jun-" => 6, - b"-Jul-" => 7, - b"-Aug-" => 8, - b"-Sep-" => 9, - b"-Oct-" => 10, - b"-Nov-" => 11, - b"-Dec-" => 12, - _ => return Err(Error(())), - }, - year, - wday, - }) -} - -fn parse_asctime(s: &[u8]) -> Result { - // Example: `Sun Nov 6 08:49:37 1994` - if s.len() != 24 || s[10] != b' ' || s[13] != b':' || s[16] != b':' || s[19] != b' ' { - return Err(Error(())); - } - Ok(HttpDate { - sec: toint_2(&s[17..19])?, - min: toint_2(&s[14..16])?, - hour: toint_2(&s[11..13])?, - day: { - let x = &s[8..10]; - { - if x[0] == b' ' { - toint_1(x[1]) - } else { - toint_2(x) - } - }? - }, - mon: match &s[4..8] { - b"Jan " => 1, - b"Feb " => 2, - b"Mar " => 3, - b"Apr " => 4, - b"May " => 5, - b"Jun " => 6, - b"Jul " => 7, - b"Aug " => 8, - b"Sep " => 9, - b"Oct " => 10, - b"Nov " => 11, - b"Dec " => 12, - _ => return Err(Error(())), - }, - year: toint_4(&s[20..24])?, - wday: match &s[0..4] { - b"Mon " => 1, - b"Tue " => 2, - b"Wed " => 3, - b"Thu " => 4, - b"Fri " => 5, - b"Sat " => 6, - b"Sun " => 7, - _ => return Err(Error(())), - }, - }) -} - -fn is_leap_year(y: u16) -> bool { - y % 4 == 0 && (y % 100 != 0 || y % 400 == 0) -} diff --git a/anneal/vendor/httpdate/src/lib.rs b/anneal/vendor/httpdate/src/lib.rs deleted file mode 100644 index 88cb6fa751..0000000000 --- a/anneal/vendor/httpdate/src/lib.rs +++ /dev/null @@ -1,160 +0,0 @@ -//! Date and time utils for HTTP. -//! -//! Multiple HTTP header fields store timestamps. -//! For example a response created on May 15, 2015 may contain the header -//! `Date: Fri, 15 May 2015 15:34:21 GMT`. Since the timestamp does not -//! contain any timezone or leap second information it is equvivalent to -//! writing 1431696861 Unix time. Rust’s `SystemTime` is used to store -//! these timestamps. -//! -//! This crate provides two public functions: -//! -//! * `parse_http_date` to parse a HTTP datetime string to a system time -//! * `fmt_http_date` to format a system time to a IMF-fixdate -//! -//! In addition it exposes the `HttpDate` type that can be used to parse -//! and format timestamps. Convert a sytem time to `HttpDate` and vice versa. -//! The `HttpDate` (8 bytes) is smaller than `SystemTime` (16 bytes) and -//! using the display impl avoids a temporary allocation. -#![forbid(unsafe_code)] - -use std::error; -use std::fmt::{self, Display, Formatter}; -use std::io; -use std::time::SystemTime; - -pub use date::HttpDate; - -mod date; - -/// An opaque error type for all parsing errors. -#[derive(Debug)] -pub struct Error(()); - -impl error::Error for Error {} - -impl Display for Error { - fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { - f.write_str("string contains no or an invalid date") - } -} - -impl From for io::Error { - fn from(e: Error) -> io::Error { - io::Error::new(io::ErrorKind::Other, e) - } -} - -/// Parse a date from an HTTP header field. -/// -/// Supports the preferred IMF-fixdate and the legacy RFC 805 and -/// ascdate formats. Two digit years are mapped to dates between -/// 1970 and 2069. -pub fn parse_http_date(s: &str) -> Result { - s.parse::().map(|d| d.into()) -} - -/// Format a date to be used in a HTTP header field. -/// -/// Dates are formatted as IMF-fixdate: `Fri, 15 May 2015 15:34:21 GMT`. -pub fn fmt_http_date(d: SystemTime) -> String { - format!("{}", HttpDate::from(d)) -} - -#[cfg(test)] -mod tests { - use std::str; - use std::time::{Duration, UNIX_EPOCH}; - - use super::{fmt_http_date, parse_http_date, HttpDate}; - - #[test] - fn test_rfc_example() { - let d = UNIX_EPOCH + Duration::from_secs(784111777); - assert_eq!( - d, - parse_http_date("Sun, 06 Nov 1994 08:49:37 GMT").expect("#1") - ); - assert_eq!( - d, - parse_http_date("Sunday, 06-Nov-94 08:49:37 GMT").expect("#2") - ); - assert_eq!(d, parse_http_date("Sun Nov 6 08:49:37 1994").expect("#3")); - } - - #[test] - fn test2() { - let d = UNIX_EPOCH + Duration::from_secs(1475419451); - assert_eq!( - d, - parse_http_date("Sun, 02 Oct 2016 14:44:11 GMT").expect("#1") - ); - assert!(parse_http_date("Sun Nov 10 08:00:00 1000").is_err()); - assert!(parse_http_date("Sun Nov 10 08*00:00 2000").is_err()); - assert!(parse_http_date("Sunday, 06-Nov-94 08+49:37 GMT").is_err()); - } - - #[test] - fn test3() { - let mut d = UNIX_EPOCH; - assert_eq!(d, parse_http_date("Thu, 01 Jan 1970 00:00:00 GMT").unwrap()); - d += Duration::from_secs(3600); - assert_eq!(d, parse_http_date("Thu, 01 Jan 1970 01:00:00 GMT").unwrap()); - d += Duration::from_secs(86400); - assert_eq!(d, parse_http_date("Fri, 02 Jan 1970 01:00:00 GMT").unwrap()); - d += Duration::from_secs(2592000); - assert_eq!(d, parse_http_date("Sun, 01 Feb 1970 01:00:00 GMT").unwrap()); - d += Duration::from_secs(2592000); - assert_eq!(d, parse_http_date("Tue, 03 Mar 1970 01:00:00 GMT").unwrap()); - d += Duration::from_secs(31536005); - assert_eq!(d, parse_http_date("Wed, 03 Mar 1971 01:00:05 GMT").unwrap()); - d += Duration::from_secs(15552000); - assert_eq!(d, parse_http_date("Mon, 30 Aug 1971 01:00:05 GMT").unwrap()); - d += Duration::from_secs(6048000); - assert_eq!(d, parse_http_date("Mon, 08 Nov 1971 01:00:05 GMT").unwrap()); - d += Duration::from_secs(864000000); - assert_eq!(d, parse_http_date("Fri, 26 Mar 1999 01:00:05 GMT").unwrap()); - } - - #[test] - fn test_fmt() { - let d = UNIX_EPOCH; - assert_eq!(fmt_http_date(d), "Thu, 01 Jan 1970 00:00:00 GMT"); - let d = UNIX_EPOCH + Duration::from_secs(1475419451); - assert_eq!(fmt_http_date(d), "Sun, 02 Oct 2016 14:44:11 GMT"); - } - - #[allow(dead_code)] - fn testcase(data: &[u8]) { - if let Ok(s) = str::from_utf8(data) { - println!("{:?}", s); - if let Ok(d) = parse_http_date(s) { - let o = fmt_http_date(d); - assert!(!o.is_empty()); - } - } - } - - #[test] - fn size_of() { - assert_eq!(::std::mem::size_of::(), 8); - } - - #[test] - fn test_date_comparison() { - let a = UNIX_EPOCH + Duration::from_secs(784111777); - let b = a + Duration::from_secs(30); - assert!(a < b); - let a_date: HttpDate = a.into(); - let b_date: HttpDate = b.into(); - assert!(a_date < b_date); - assert_eq!(a_date.cmp(&b_date), ::std::cmp::Ordering::Less) - } - - #[test] - fn test_parse_bad_date() { - // 1994-11-07 is actually a Monday - let parsed = "Sun, 07 Nov 1994 08:48:37 GMT".parse::(); - assert!(parsed.is_err()) - } -} diff --git a/anneal/vendor/libtest-mimic/.cargo-checksum.json b/anneal/vendor/libtest-mimic/.cargo-checksum.json index d0f2c6f227..b5348ca941 100644 --- a/anneal/vendor/libtest-mimic/.cargo-checksum.json +++ b/anneal/vendor/libtest-mimic/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"acfce605463c185aad0e2084ddb293f63fe48d2c5ce36754571c0a2d8b760f8b","CHANGELOG.md":"70de837dca41cc79e6a81bc3860ed90d98480d652dfcadb731f3e69848d80264","Cargo.lock":"bb5b27bbbf27e4c6526aa029d96f4cc46f8f6a59359ec50af8201bcfe12b208a","Cargo.toml":"7f11401bf48b216f00015d13c3e5c561cd09b1701fbe3b4105f744ae6a050d16","Cargo.toml.orig":"2f57ab1221c851fab5022bd5fce1c270226a2013d72abb4d8f8d35ae4d4ebbed","LICENSE-APACHE":"8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90","LICENSE-MIT":"6f54826bbf67526f2d41937c1904ae2de63ef5707b80c68deadbf073b5669c40","README.md":"2607b42f3591f387eae97d673b78a70745e6da07abacad0d1290297d59e580a7","examples/README.md":"c75a125e1c76b6e00ef5c23d16517dbde99e8a705d5b126bd9d89a6db5c6ed08","examples/simple.rs":"79b77fff7540cd309d0565696ccb0d1f2b7bbd89292a3f62d065deb9e90791f7","examples/tidy.rs":"145dce4e059083bd75046e05eac69d3f381d3edde01de04cad6f530596ffdd31","src/args.rs":"cf3c467b9a2bbfe2cbd745d14097fd64693b7653721ec456e38fb9297d256acd","src/lib.rs":"e43d1f693dc3a1af207e3c39efe1fba4ff4a4fd81eafb6eadd695e9346cccc6f","src/printer.rs":"35fa28570b64a9c5c9818ddd0682174ace28dc7616fd9f420722c1a4e3fd7e86","tests/all_passing.rs":"3e2fe5d97cf25ef172470770fe5ab28b9ea9c3e5ffb3fcea782c91d66dc917f6","tests/common/mod.rs":"a2891648ffe586825320aae4727912813605f8f3c18303a87a2b5e05a4a5373e","tests/json-output.json":"e09948e21e614d11532a91583be9371224b5df179cf87849d0ab5112a45c0d21","tests/mixed_bag.rs":"7c7a349b5cba2da89a642b13d794362d17124e365a68c7dc2eac28c62ac09903","tests/panic.rs":"378ea05bb0d4bb8f83f58eb52a678943209d9ab98575f9b5481b5c633de9417b","tests/real/README.md":"62d50b8a9576d9af7b1fd6bb9ab88874cf05ed158816594e4cee5d61bfcc715e","tests/real/ignored.rs":"4830deb1b09593d69a5b0398270419637be02c958a0238322d987aba07965e7a","tests/real/mixed_bag.rs":"d16c258e09f869f69e8b19be3f7cf0576b7b79cc24aad700b718f7582475ea7c","tests/threads.rs":"dabbbba7dca27a0e927bd751293d684fc549fb1c8591e85ac0f8a38e8f847889"},"package":"14e6ba06f0ade6e504aff834d7c34298e5155c6baca353cc6a4aaff2f9fd7f33"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"acfce605463c185aad0e2084ddb293f63fe48d2c5ce36754571c0a2d8b760f8b","CHANGELOG.md":"70de837dca41cc79e6a81bc3860ed90d98480d652dfcadb731f3e69848d80264","Cargo.lock":"bb5b27bbbf27e4c6526aa029d96f4cc46f8f6a59359ec50af8201bcfe12b208a","Cargo.toml":"7f11401bf48b216f00015d13c3e5c561cd09b1701fbe3b4105f744ae6a050d16","Cargo.toml.orig":"2f57ab1221c851fab5022bd5fce1c270226a2013d72abb4d8f8d35ae4d4ebbed","LICENSE-APACHE":"8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90","LICENSE-MIT":"6f54826bbf67526f2d41937c1904ae2de63ef5707b80c68deadbf073b5669c40","README.md":"2607b42f3591f387eae97d673b78a70745e6da07abacad0d1290297d59e580a7","examples/README.md":"c75a125e1c76b6e00ef5c23d16517dbde99e8a705d5b126bd9d89a6db5c6ed08","examples/simple.rs":"79b77fff7540cd309d0565696ccb0d1f2b7bbd89292a3f62d065deb9e90791f7","examples/tidy.rs":"145dce4e059083bd75046e05eac69d3f381d3edde01de04cad6f530596ffdd31","src/args.rs":"cf3c467b9a2bbfe2cbd745d14097fd64693b7653721ec456e38fb9297d256acd","src/lib.rs":"e43d1f693dc3a1af207e3c39efe1fba4ff4a4fd81eafb6eadd695e9346cccc6f","src/printer.rs":"35fa28570b64a9c5c9818ddd0682174ace28dc7616fd9f420722c1a4e3fd7e86","tests/all_passing.rs":"3e2fe5d97cf25ef172470770fe5ab28b9ea9c3e5ffb3fcea782c91d66dc917f6","tests/common/mod.rs":"a2891648ffe586825320aae4727912813605f8f3c18303a87a2b5e05a4a5373e","tests/json-output.json":"e09948e21e614d11532a91583be9371224b5df179cf87849d0ab5112a45c0d21","tests/mixed_bag.rs":"7c7a349b5cba2da89a642b13d794362d17124e365a68c7dc2eac28c62ac09903","tests/panic.rs":"378ea05bb0d4bb8f83f58eb52a678943209d9ab98575f9b5481b5c633de9417b","tests/real/.gitignore":"926f9b5cbcdc8336736a2e912c21237bc4740b7dd9c0ad94d7b7fa3d9e0307d4","tests/real/README.md":"62d50b8a9576d9af7b1fd6bb9ab88874cf05ed158816594e4cee5d61bfcc715e","tests/real/ignored.rs":"4830deb1b09593d69a5b0398270419637be02c958a0238322d987aba07965e7a","tests/real/mixed_bag.rs":"d16c258e09f869f69e8b19be3f7cf0576b7b79cc24aad700b718f7582475ea7c","tests/threads.rs":"dabbbba7dca27a0e927bd751293d684fc549fb1c8591e85ac0f8a38e8f847889"},"package":"14e6ba06f0ade6e504aff834d7c34298e5155c6baca353cc6a4aaff2f9fd7f33"} \ No newline at end of file diff --git a/anneal/vendor/libtest-mimic/tests/real/.gitignore b/anneal/vendor/libtest-mimic/tests/real/.gitignore new file mode 100644 index 0000000000..d1211df8df --- /dev/null +++ b/anneal/vendor/libtest-mimic/tests/real/.gitignore @@ -0,0 +1,3 @@ +# Compiled binaries +mixed_bad +ignored diff --git a/anneal/vendor/portable-atomic/.cargo-checksum.json b/anneal/vendor/portable-atomic/.cargo-checksum.json index 737318624a..9a12bb15b0 100644 --- a/anneal/vendor/portable-atomic/.cargo-checksum.json +++ b/anneal/vendor/portable-atomic/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"482f6b3cc06cfb0c7c9bfa8c260c040a02d762fa4603872cc844a975ab24a8f0","CHANGELOG.md":"b2562dcfd04a5c5907eb348296fa1ca57b7c7420b615c4384d1ee6b024741988","Cargo.lock":"4eea6ec59f568f532cac8e3e71029e24d2fa514d668dd4f86da5168c497b8cf6","Cargo.toml":"3366d6ebb1bada583bfdad414effb4776e4d090e22fd5bbd61c5b8a3560fa17b","Cargo.toml.orig":"ec7bbbc631719bf79a109603f496b852c636062776df74235987d74a825dbbcd","LICENSE-APACHE":"0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"f1c6a56dd42e2e1d02f5d7fef3d77dfca493db10d2409edaee7d48cdc1463b45","build.rs":"4bd0a08a8377b9a468a97a98197db80312a802221b1d7421d6efb40e9e447e2a","matrix-old.json":"7e9c4478ef365531a53834130a53da5b9864e786563682b1b9fcf4dd428dcaf3","src/cfgs.rs":"2e7bdfd6ba48957a8760c0cec389c91917bd5965abaa04db32f916e6e75e8aae","src/gen/build.rs":"4ad2fa43f8f725631e9754338f39b80f64a2e61facdb3bd735efc215b95a6597","src/gen/utils.rs":"49dd2efed43772f91e440523e39d7f9974c1a3305eabde4bccf4044a285dd589","src/imp/atomic128/README.md":"240d085f57eff9e5c92cb87498e0d1bb260a4f0fe41cd64eb86cb96e1d686c96","src/imp/atomic128/aarch64.rs":"c6ecab7ffa5c9609ceac0308e12c6ead732a3e246d75f726b5125879090e721e","src/imp/atomic128/intrinsics.rs":"d268e4aa067b25019fd6329d18f0604210d96af3ee6faedb7ec40d8748646d89","src/imp/atomic128/macros.rs":"31f63dd5f6523fdc80d752afdd7b13e90394e7210b8f14bfa38a4feab0822cd5","src/imp/atomic128/mod.rs":"4d12d39ed3c0e5ab46724ac9536598ccc0028147d258b739ed27212c4e4d5e7e","src/imp/atomic128/powerpc64.rs":"3434fc2bd7fa1d4c93205df7c88aea26934bdcbf867282e99cdbb9d1e09b8806","src/imp/atomic128/riscv64.rs":"6f7c2425c9ddaf5c349039b1d341d5f19c1265705fe9df53a677c81dc91bcfb5","src/imp/atomic128/s390x.rs":"1615997158bdad3bf7d16cafe221c8c0885688fa5e074352c31cad242ac98b0a","src/imp/atomic128/x86_64.rs":"dd5e5e05cc5fff506f99b9ece813cf3f113f618a173e2e94249dce077d42ea93","src/imp/atomic64/README.md":"56ef5c1f1750515a6a8a94b9347fd42faa889cddf5a9f77cd7d650008a4a8b7c","src/imp/atomic64/arm_linux.rs":"adfc11193d412e1c89c7ecdefbee81c5278878279a49c461ab0329c6da7522ac","src/imp/atomic64/macros.rs":"5b6f0bfe40064885926cfd57a336f15da92f6964864c50d339d1bb9903802a9d","src/imp/atomic64/mod.rs":"2977468d184134a068179eb8361d73500865b8d1476b87590099d6b503db30e5","src/imp/atomic64/riscv32.rs":"dfc4cf24ea2e02f4838326ccdcdbab81632ef146f8d49f9cc0fcc85ec838962a","src/imp/avr.rs":"fa50cc025a934377ecb7312fe78c519744809c14f1e1d00f73d8613ffc125df8","src/imp/core_atomic.rs":"e17dc0c7498493dea2ee2800b221e23f1d81403dfc4b308c9eff83efe9e0436c","src/imp/detect/README.md":"68db4ae18738636927628c41de5412e784a026f13529dda9cfe4f8407fd5f89c","src/imp/detect/aarch64_aa64reg.rs":"7d1564035c3a5d8ec177ee255860526c7adf5759db4d6380330a490c77d4d494","src/imp/detect/aarch64_apple.rs":"72d77305801b597b3cd30d1204666169aeffa551dfe88efe3f169e10804aaf25","src/imp/detect/aarch64_fuchsia.rs":"cff2f3808bcf30f2b11c7010a8514cc0bda766615a203da87262fec9d918102c","src/imp/detect/aarch64_illumos.rs":"edc9bf24fc43969d36b2d4aaaf45a622d7699c9c06a7cc716c5cbb94b57f10dc","src/imp/detect/aarch64_windows.rs":"4cdf3df6539205800919a6bd8c17eb238b571183bb853a7a4600ab7a7ed7dbe7","src/imp/detect/auxv.rs":"a58e6da2e71c8544f01e3f026591ee2807bf645fb73e2e97911d32bb56d24da7","src/imp/detect/common.rs":"5a9a16421edb7df226d3ab51a20fe6f8cfca1331fc92613583cd0b1e44b19ecb","src/imp/detect/powerpc64_aix.rs":"34f3694a359bd50f18633817528bcffb45bc42db8405a9ab49cefb25fb4af1ee","src/imp/detect/riscv_linux.rs":"aa10f712f6e27cb919cbff03987623f3f21d898fbccadbfc94fffd1f42e5bf80","src/imp/detect/x86_64.rs":"c2849317ab717a5e97b6a72ac048b0139a964c3e85162d7230458de97a7e644b","src/imp/fallback/mod.rs":"e63d984025ae98941e1c2403b2e5e428d4b5aa67a19c465e788aac2a7d18c77b","src/imp/fallback/outline_atomics.rs":"041d872affc4ad0b6b452f695a1373a1f76fe75d1b2377c24c3c0d199d89e383","src/imp/fallback/seq_lock.rs":"71aae56446d9e656037f5b13cc34a15f2ff061db7d4ea2b0a40ff721956dd138","src/imp/fallback/seq_lock_wide.rs":"2b6646e2f737b9253d8c9d143dc0dabbe3d675b9b973a26162b9bc5ab9fb472b","src/imp/fallback/utils.rs":"86f0d521455069988ea33453b1ab9fcf892ea62134686656f4e9875305ba9fdc","src/imp/float/aarch64.rs":"7dfa52d232470a8a0573972d9dde874f5bf03d4d7532174d851010b3686392a7","src/imp/float/int.rs":"8801b336650a039bc6e056857c0f65c2f148a0774c83baa9bd9bf415618107e5","src/imp/float/mod.rs":"2c722182baee05df65f9f6e2b4de5d5474a3b2bf0c24803a65a771de78b76f95","src/imp/interrupt/README.md":"1f4ed0b78b42832800bc8e4db98576f17ef51e8e84b07375fa3e076addbf83e0","src/imp/interrupt/armv4t.rs":"6fb9e7d01f7fb483bc6bec07916fdcba8563b605b53bd87c5310662da04e55a4","src/imp/interrupt/armv6m.rs":"364a38f18ffb2b3cd836700dff6a390d9542f0f2a3eda07bc63bc8868dafaad1","src/imp/interrupt/avr.rs":"17896e2d3e37a03ddc90e884ba09b3e241a8e56ef611fe9790b799c19494b75f","src/imp/interrupt/mod.rs":"27593db509704456fc853f8c6fe28e5dd055b31ddd33a01e4fd6d88d01df4919","src/imp/interrupt/msp430.rs":"bb752aad62bbbddd3b190702ada84bb562e930752eae7de0c96ca0abc620fbe8","src/imp/interrupt/riscv.rs":"f27fe895d55da2ac097fcd1db64cc455a88d0f0d46668cf4ebb61155f8334281","src/imp/interrupt/xtensa.rs":"69e45c6e6a82e06a827967d34268be8c6545138112b46fd7a6610a68f51ba113","src/imp/mod.rs":"2c269d5051f136669cce386cefbe1be90a79e6731f9c42de83091813581a8bea","src/imp/msp430.rs":"16635485eeca1c1c4b866253eefc1f39fa6121c84c16ec389b904c03fa9cdb55","src/imp/riscv.rs":"6a7b7332800141a4da74e1b241e6c04e519b64e4d69ff9b9ef0f9b6a893cb6b0","src/imp/x86.rs":"97c0e1743d7ba7a3dbabd9f49c38ffc71447863ff9c91db53963e003d2b0adf8","src/lib.rs":"5fc1d48545cd2fcd1cba81898657de683f679c6a96b1bd8aea284c19265f167b","src/rustdoc.css":"fb503ec0cf2eb0dacbbdbea63ffb66d538637ddb0a6617cad69906bf58831d7f","src/tests/helper.rs":"08b56889f8fb78efcbd58bb835b66f05dc15672de8cd216d05a12d6a48460563","src/tests/mod.rs":"c1a316f83894a71f1fc870db04d5401774162a277fd7d0b33f955ce35fc05399","src/utils.rs":"3687375efdb580dee21373a9c427030757f640f23b140d4a8d8b47a4085104fa","version.rs":"cc5733c63aeabd7f37c7ae0c47f0be6a7d7a843f911ca181a4d41d9d4fd4c8f0"},"package":"c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"482f6b3cc06cfb0c7c9bfa8c260c040a02d762fa4603872cc844a975ab24a8f0","CHANGELOG.md":"b2562dcfd04a5c5907eb348296fa1ca57b7c7420b615c4384d1ee6b024741988","Cargo.lock":"4eea6ec59f568f532cac8e3e71029e24d2fa514d668dd4f86da5168c497b8cf6","Cargo.toml":"3366d6ebb1bada583bfdad414effb4776e4d090e22fd5bbd61c5b8a3560fa17b","Cargo.toml.orig":"ec7bbbc631719bf79a109603f496b852c636062776df74235987d74a825dbbcd","LICENSE-APACHE":"0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"f1c6a56dd42e2e1d02f5d7fef3d77dfca493db10d2409edaee7d48cdc1463b45","build.rs":"4bd0a08a8377b9a468a97a98197db80312a802221b1d7421d6efb40e9e447e2a","matrix-old.json":"7e9c4478ef365531a53834130a53da5b9864e786563682b1b9fcf4dd428dcaf3","src/cfgs.rs":"2e7bdfd6ba48957a8760c0cec389c91917bd5965abaa04db32f916e6e75e8aae","src/gen/build.rs":"4ad2fa43f8f725631e9754338f39b80f64a2e61facdb3bd735efc215b95a6597","src/gen/utils.rs":"49dd2efed43772f91e440523e39d7f9974c1a3305eabde4bccf4044a285dd589","src/imp/atomic128/README.md":"240d085f57eff9e5c92cb87498e0d1bb260a4f0fe41cd64eb86cb96e1d686c96","src/imp/atomic128/aarch64.rs":"c6ecab7ffa5c9609ceac0308e12c6ead732a3e246d75f726b5125879090e721e","src/imp/atomic128/intrinsics.rs":"d268e4aa067b25019fd6329d18f0604210d96af3ee6faedb7ec40d8748646d89","src/imp/atomic128/macros.rs":"31f63dd5f6523fdc80d752afdd7b13e90394e7210b8f14bfa38a4feab0822cd5","src/imp/atomic128/mod.rs":"4d12d39ed3c0e5ab46724ac9536598ccc0028147d258b739ed27212c4e4d5e7e","src/imp/atomic128/powerpc64.rs":"3434fc2bd7fa1d4c93205df7c88aea26934bdcbf867282e99cdbb9d1e09b8806","src/imp/atomic128/riscv64.rs":"6f7c2425c9ddaf5c349039b1d341d5f19c1265705fe9df53a677c81dc91bcfb5","src/imp/atomic128/s390x.rs":"1615997158bdad3bf7d16cafe221c8c0885688fa5e074352c31cad242ac98b0a","src/imp/atomic128/x86_64.rs":"dd5e5e05cc5fff506f99b9ece813cf3f113f618a173e2e94249dce077d42ea93","src/imp/atomic64/README.md":"56ef5c1f1750515a6a8a94b9347fd42faa889cddf5a9f77cd7d650008a4a8b7c","src/imp/atomic64/arm_linux.rs":"adfc11193d412e1c89c7ecdefbee81c5278878279a49c461ab0329c6da7522ac","src/imp/atomic64/macros.rs":"5b6f0bfe40064885926cfd57a336f15da92f6964864c50d339d1bb9903802a9d","src/imp/atomic64/mod.rs":"2977468d184134a068179eb8361d73500865b8d1476b87590099d6b503db30e5","src/imp/atomic64/riscv32.rs":"dfc4cf24ea2e02f4838326ccdcdbab81632ef146f8d49f9cc0fcc85ec838962a","src/imp/avr.rs":"fa50cc025a934377ecb7312fe78c519744809c14f1e1d00f73d8613ffc125df8","src/imp/core_atomic.rs":"e17dc0c7498493dea2ee2800b221e23f1d81403dfc4b308c9eff83efe9e0436c","src/imp/detect/README.md":"68db4ae18738636927628c41de5412e784a026f13529dda9cfe4f8407fd5f89c","src/imp/detect/aarch64_aa64reg.rs":"7d1564035c3a5d8ec177ee255860526c7adf5759db4d6380330a490c77d4d494","src/imp/detect/aarch64_apple.rs":"72d77305801b597b3cd30d1204666169aeffa551dfe88efe3f169e10804aaf25","src/imp/detect/aarch64_fuchsia.rs":"cff2f3808bcf30f2b11c7010a8514cc0bda766615a203da87262fec9d918102c","src/imp/detect/aarch64_illumos.rs":"edc9bf24fc43969d36b2d4aaaf45a622d7699c9c06a7cc716c5cbb94b57f10dc","src/imp/detect/aarch64_windows.rs":"4cdf3df6539205800919a6bd8c17eb238b571183bb853a7a4600ab7a7ed7dbe7","src/imp/detect/auxv.rs":"a58e6da2e71c8544f01e3f026591ee2807bf645fb73e2e97911d32bb56d24da7","src/imp/detect/common.rs":"5a9a16421edb7df226d3ab51a20fe6f8cfca1331fc92613583cd0b1e44b19ecb","src/imp/detect/powerpc64_aix.rs":"34f3694a359bd50f18633817528bcffb45bc42db8405a9ab49cefb25fb4af1ee","src/imp/detect/riscv_linux.rs":"aa10f712f6e27cb919cbff03987623f3f21d898fbccadbfc94fffd1f42e5bf80","src/imp/detect/x86_64.rs":"c2849317ab717a5e97b6a72ac048b0139a964c3e85162d7230458de97a7e644b","src/imp/fallback/mod.rs":"e63d984025ae98941e1c2403b2e5e428d4b5aa67a19c465e788aac2a7d18c77b","src/imp/fallback/outline_atomics.rs":"041d872affc4ad0b6b452f695a1373a1f76fe75d1b2377c24c3c0d199d89e383","src/imp/fallback/seq_lock.rs":"71aae56446d9e656037f5b13cc34a15f2ff061db7d4ea2b0a40ff721956dd138","src/imp/fallback/seq_lock_wide.rs":"2b6646e2f737b9253d8c9d143dc0dabbe3d675b9b973a26162b9bc5ab9fb472b","src/imp/fallback/utils.rs":"86f0d521455069988ea33453b1ab9fcf892ea62134686656f4e9875305ba9fdc","src/imp/float/aarch64.rs":"7dfa52d232470a8a0573972d9dde874f5bf03d4d7532174d851010b3686392a7","src/imp/float/int.rs":"8801b336650a039bc6e056857c0f65c2f148a0774c83baa9bd9bf415618107e5","src/imp/float/mod.rs":"2c722182baee05df65f9f6e2b4de5d5474a3b2bf0c24803a65a771de78b76f95","src/imp/interrupt/README.md":"1f4ed0b78b42832800bc8e4db98576f17ef51e8e84b07375fa3e076addbf83e0","src/imp/interrupt/armv4t.rs":"6fb9e7d01f7fb483bc6bec07916fdcba8563b605b53bd87c5310662da04e55a4","src/imp/interrupt/armv6m.rs":"364a38f18ffb2b3cd836700dff6a390d9542f0f2a3eda07bc63bc8868dafaad1","src/imp/interrupt/avr.rs":"17896e2d3e37a03ddc90e884ba09b3e241a8e56ef611fe9790b799c19494b75f","src/imp/interrupt/mod.rs":"27593db509704456fc853f8c6fe28e5dd055b31ddd33a01e4fd6d88d01df4919","src/imp/interrupt/msp430.rs":"bb752aad62bbbddd3b190702ada84bb562e930752eae7de0c96ca0abc620fbe8","src/imp/interrupt/riscv.rs":"f27fe895d55da2ac097fcd1db64cc455a88d0f0d46668cf4ebb61155f8334281","src/imp/interrupt/xtensa.rs":"69e45c6e6a82e06a827967d34268be8c6545138112b46fd7a6610a68f51ba113","src/imp/mod.rs":"2c269d5051f136669cce386cefbe1be90a79e6731f9c42de83091813581a8bea","src/imp/msp430.rs":"16635485eeca1c1c4b866253eefc1f39fa6121c84c16ec389b904c03fa9cdb55","src/imp/riscv.rs":"6a7b7332800141a4da74e1b241e6c04e519b64e4d69ff9b9ef0f9b6a893cb6b0","src/imp/x86.rs":"97c0e1743d7ba7a3dbabd9f49c38ffc71447863ff9c91db53963e003d2b0adf8","src/lib.rs":"5fc1d48545cd2fcd1cba81898657de683f679c6a96b1bd8aea284c19265f167b","src/rustdoc.css":"fb503ec0cf2eb0dacbbdbea63ffb66d538637ddb0a6617cad69906bf58831d7f","src/tests/helper.rs":"08b56889f8fb78efcbd58bb835b66f05dc15672de8cd216d05a12d6a48460563","src/tests/mod.rs":"c1a316f83894a71f1fc870db04d5401774162a277fd7d0b33f955ce35fc05399","src/utils.rs":"3687375efdb580dee21373a9c427030757f640f23b140d4a8d8b47a4085104fa","tests/.gitignore":"3c761e8831e160876acdfee9a0f48bc27270d671f58130bc67445897e9e7de81","version.rs":"cc5733c63aeabd7f37c7ae0c47f0be6a7d7a843f911ca181a4d41d9d4fd4c8f0"},"package":"c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"} \ No newline at end of file diff --git a/anneal/vendor/portable-atomic/tests/.gitignore b/anneal/vendor/portable-atomic/tests/.gitignore new file mode 100644 index 0000000000..2ef89d0aa5 --- /dev/null +++ b/anneal/vendor/portable-atomic/tests/.gitignore @@ -0,0 +1 @@ +!rust-toolchain.toml diff --git a/anneal/vendor/tiny_http/.cargo-checksum.json b/anneal/vendor/tiny_http/.cargo-checksum.json deleted file mode 100644 index 15da0bfa8a..0000000000 --- a/anneal/vendor/tiny_http/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{".cargo_vcs_info.json":"d2a5c2966bca9bcb96f1fb22d7839be5e6dc329dd4e3237696b5c0682720faef",".github/workflows/ci.yaml":"862b496fc6c3802d87dc5472252d5ca0c3622ac8d511938e23d0b99b0b3421a7","CHANGELOG.md":"f502b2cccd3ea9e63111b8cecd540a07ed4fedf00c46c6361607d8fbdfabc2ee","Cargo.lock":"7cb7bf8e1832e3a4d1be881a334fbe26cb63d8d1d215c9024da2a2a7defb0f3c","Cargo.toml":"03c7dfc1df0bbf4274890d33e256baddd4c77e0f9eaee1035ef07a250d229db8","Cargo.toml.orig":"43a7c801ff2acd0fd3af6c26bbdd8824bc0cf188fb19e479cd3c58cdc8d56ea6","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"e69bb98ae371fc43e5ef9cb1fc648762faf92edd93a8afd71411fac419b1b550","README.md":"3f8d7fb0101454ba4a3704d7bd4e29b81a142014b66640f3a0cce936214d95c8","benches/bench.rs":"803e8ac58aadee8bf3c037d622e04473b597c4c3399dfe0951065943599254ab","examples/hello-world.rs":"cc095046b2e9ae44dc095032185db2d478e6e556159614e93917f64c60ba3430","examples/php-cgi-example.php":"72b51bbf38c4b60638ea635752fe071c4f329dcf8a615badaf8228078d63030f","examples/php-cgi.rs":"f2650e84a807f11cec6568a9893169bea17dd2eb0013302d7dda38b5da249a55","examples/readme-example.rs":"5b93dd6584c3bea80896391842ceca5f2f350435b2470c7c0a5dd33fb4a46d92","examples/serve-root.rs":"05d84565ef1e38f5782296ae8bc014b621f4e0b9e7827274b5468efbc1aa3921","examples/ssl-cert.pem":"8a171360b51c9bf4fc9b108e263cfe90c689891c56674cea38e4c29e98c9b836","examples/ssl-key.pem":"e345c5c79dba8fd849f31fb06ee871a32d1f1bf1ef4c15b510e70a2524009626","examples/ssl.rs":"1595c78153214ffc5e5724aba903164e61f33fca1083c727f1d5c417aeee85b5","examples/websockets.rs":"69c96aa370a0378f072dab65fa3ab935309032fe2ddf537c523abce6e9662a0f","src/client.rs":"8fcc6344c2259e91677c267cd9e022a316463a1b03bb805c0a2ec692ef94c898","src/common.rs":"5cae33d9517acdf3f559488acbd4fd727b565ac5e10234b060d37f6398ef2c7b","src/connection.rs":"67dbb92f1d7b3edc8b9fb85b6d770bd50250fb08cde0fdc9e75ceacb68125ac0","src/lib.rs":"5545e94107ab9b4474ad8253d6367f0a20a696ad3f647c97136e21c2824b4a90","src/request.rs":"ef8fcf8d36706a0e1a146f3262917b4631ecf8db925408d4b6959a0d7423695a","src/response.rs":"946c4aa551b7a16cc2ea5f86f8ae2ce9b9bda3faecb2f9d1057d5bc17cb2dbdc","src/ssl.rs":"dd38964c51c5d9fe6dbafd383e172f89d0f62f8d52042e94247cc1d67e07c29e","src/ssl/openssl.rs":"7a7317d2d6d5e75b7e57caa282180a21ec0639e71813e5498a75dcba0dab7e7d","src/ssl/rustls.rs":"d39f329d74f611ec992c0a559a8ea32280b66981380f78683142102a0b758268","src/test.rs":"b6a2a4848acb46fbacc7593629cf6d2fac745e852ead9bf57e014e32623ca1b4","src/util/custom_stream.rs":"a6921b2eb16600070647c41a339c57eb2f616f24116b8b7135cf9a26b2e5ceec","src/util/equal_reader.rs":"7d7916b42316d745c12185509fa5719dd9a032fef1c19fe8057b154f48e8db55","src/util/fused_reader.rs":"2c92bf51a069ec7d6aa647fb44709bbb013131c43cd1667a4a0d1784a57eab6b","src/util/messages_queue.rs":"ac283569e0e24d4f5ff7515a4c74ea08a2cc8439152a17dd1121030429ebcb4f","src/util/mod.rs":"107ceae83c9a10672be797a1805e13772f9c25e68b74e02bef6f45af85018293","src/util/refined_tcp_stream.rs":"f1ee3a06ded63843209120d2d9bf94ae113bc781be91daedce7f5ce9e537a6a1","src/util/sequential.rs":"5ad84c87bd412edec8b289639d6d21486201e84f25a7edc1be4284be59c5570c","src/util/task_pool.rs":"08e3cc8139d1512bb751f828e9838579d8848607e7172ae41b4033d8ecc46fdb","tests/input-tests.rs":"591757acb069d74c6f3a36acee1d931ddb13fe9bc06fe8527d23527071c36e35","tests/network.rs":"ccb382c4c2205caa6025ad8c53c8c101f4fb7f2288c6891c6e04ddb6b31882d3","tests/non-chunked-buffering.rs":"66548e609ce52e8b20e557c3cebab465ed276af5246ea60921a3c344507a0a94","tests/promptness.rs":"1a59a54cde25b90d737f1285a5173b560f962bb8ca9e0a6c74477a5b366b431d","tests/simple-test.rs":"0bf6f66c281fb0ac1b59228c6933cfe49ba8423b7c4fb211b72fa0d800153250","tests/support/mod.rs":"2aed60864d0edb33157bfb3da9fe5d373001cf411a2e6b6fcb065dc972cc8887","tests/unblock-test.rs":"f4a474b808bc0832cf6b1c0e1db754d81a2ae2ea6cf1f539838ac23051e5f8f7","tests/unix-test.rs":"9b104a35858ef9b11d8c7e8803c2399d01b01b2faaf75a10d66dc110356f7dca"},"package":"389915df6413a2e74fb181895f933386023c71110878cd0825588928e64cdc82"} \ No newline at end of file diff --git a/anneal/vendor/tiny_http/.cargo_vcs_info.json b/anneal/vendor/tiny_http/.cargo_vcs_info.json deleted file mode 100644 index 1fbb959db3..0000000000 --- a/anneal/vendor/tiny_http/.cargo_vcs_info.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "git": { - "sha1": "212b1c45852fef2093dc1374875a9393c55eb4b9" - }, - "path_in_vcs": "" -} \ No newline at end of file diff --git a/anneal/vendor/tiny_http/.github/workflows/ci.yaml b/anneal/vendor/tiny_http/.github/workflows/ci.yaml deleted file mode 100644 index e4902a57ad..0000000000 --- a/anneal/vendor/tiny_http/.github/workflows/ci.yaml +++ /dev/null @@ -1,64 +0,0 @@ -on: [push, pull_request] -name: CI -jobs: - clippy_rustfmt: - name: Lint & Format - runs-on: ubuntu-latest - strategy: - matrix: - features: - - default - - ssl-openssl - - ssl-rustls - steps: - - uses: actions/checkout@v2 - - name: Install stable toolchain - uses: actions-rs/toolchain@v1 - with: - toolchain: stable - components: rustfmt, clippy - - - name: Clippy - uses: actions-rs/cargo@v1 - with: - command: clippy - args: --features ${{ matrix.features }} - - - name: Format - uses: actions-rs/cargo@v1 - with: - command: fmt - args: -- --check - - test: - name: Build & Test - runs-on: ubuntu-latest - strategy: - matrix: - rust: - - stable - - nightly - - 1.56 - features: - - default - - ssl-openssl - - ssl-rustls - steps: - - uses: actions/checkout@v2 - - name: Install toolchain - uses: actions-rs/toolchain@v1 - with: - toolchain: ${{ matrix.rust }} - override: true - - - name: Build - uses: actions-rs/cargo@v1 - with: - command: build - args: --features ${{ matrix.features }} - - - name: Test - uses: actions-rs/cargo@v1 - with: - command: test - args: --features ${{ matrix.features }} diff --git a/anneal/vendor/tiny_http/CHANGELOG.md b/anneal/vendor/tiny_http/CHANGELOG.md deleted file mode 100644 index 59c5ad9e1c..0000000000 --- a/anneal/vendor/tiny_http/CHANGELOG.md +++ /dev/null @@ -1,172 +0,0 @@ -# Changes - -## 0.12.0 -* Bumped the minimum compiler version tested by CI to 1.56 - this is necessary due to an increasing number of dependencies - introducing Cargo manifest features only supported on newer versions of Rust. - -* [Add support for UNIX sockets](https://github.com/tiny-http/tiny-http/pull/224) - - Thanks to @ColonelThirtyTwo for adding support for binding to UNIX sockets when creating a tiny-http server. This change - makes a few small breaking API modifications, if you are constructing `ServerConfig` manually you will need to use the new `ListenAddr` - type rather than directly supplying a `net::SocketAddr`. Likewise `Server::server_addr()` will now return an enum that can - represent either a TCP socket or a UNIX socket. - - Finally `Request::remote_addr()` now returns an `Option<&SocketAddr>` as UNIX sockets don't ever have a remote host. - -* [Reduce required dependencies by switching to `httpdate`](https://github.com/tiny-http/tiny-http/pull/228) - - @esheppa replaced our internal HTTPDate type with the `httpdate` library (used extensively in the community by Hyper, Tokio and others) - which reduces our baseline dependency tree from 18 crates to 5! - -* `TestRequest::path` no longer has a `'static` bound, allowing for fuzzers to generate test request paths at runtime. - -* Unpinned `zeroize` so it can float around any stable `^1` version. - -## 0.11.0 - -* [Add support for Rustls](https://github.com/tiny-http/tiny-http/pull/218) - - Thanks to @3xmblzj5 and @travispaul for their help in implementing [`Rustls`](https://github.com/rustls/rustls) as a - drop-in replacement for OpenSSL, you can now build `tiny-http` with TLS support without any external dependencies! - OpenSSL will remain the default implementation if you just enable the `ssl` feature, but you are strongly encouraged - to use `ssl-rustls` where possible! - -* [Fix incorrect certificate chain loading](https://github.com/tiny-http/tiny-http/commit/876efd6b752e991c699d27d3d0ad9a47e9d35c29) - - Fix a longstanding bug where we were only loading the first (i.e. the leaf) certificate from any PEM file supplied by - the user. - - -## 0.10.0 - -* [Replace chrono with time-rs](https://github.com/tiny-http/tiny-http/commit/75ac7758fd0ca660c35f58c2a36edb23a42cda32) - - `chrono` was only used to store and format `DateTime` into the slightly odd format required by RFC 7231, so to - avoid the numerous RUSTSEC advisories generated by the `localtime_r` issue, we can just drop it entirely and switch - to `time-rs`. - Unfortunately this means we need to **bump our minimum tested compiler version to 1.51**, and as such this change - requires a full minor release. - -## 0.9.0 - -* [Rust 2018 Refactor](https://github.com/tiny-http/tiny-http/pull/208) -* [Enable prompt responses, before the request has been fully read](https://github.com/tiny-http/tiny-http/pull/207) - - This isn't an API change, but does result in different behaviour to 0.8.2 and so justifies a minor version bump. - - HTTP requests now return a boxed `FusedReader` which drops the underlying - reader once it reaches EOF, such that the reader no longer needs to be - explicitly consumed and the server may now respond with e.g. a "413 Payload - too large" without waiting for the whole reader. - -* Bumped the minimum compiler version tested by CI to 1.48 (the version supported in Debian Bullseye) - -## 0.8.2 - -* [Add TestRequest for writing server tests more easily](https://github.com/tiny-http/tiny-http/pull/203) - -## 0.8.1 - -* [Don't set Transfer-Encoding for 1xx or 204 Responses](https://github.com/tiny-http/tiny-http/pull/198) - -## 0.8.0 - -* [Fix RUSTSEC-2020-0031](https://github.com/tiny-http/tiny-http/pull/190) -* [Filter out the same socket-closing errors on flush as on write](https://github.com/tiny-http/tiny-http/pull/192) -* [response: Drop the use of EqualReader for TransferEncoding::Identity](https://github.com/tiny-http/tiny-http/pull/183) -* [Add unblock method for graceful shutdown](https://github.com/tiny-http/tiny-http/pull/184) -* [Response: Don't forget `chunked_threshold`](https://github.com/tiny-http/tiny-http/pull/177) -* [Response: Allow manual handling of Range requests](https://github.com/tiny-http/tiny-http/pull/175) -* [Feature | Getters for Response Status Code & Data Length Properties](https://github.com/tiny-http/tiny-http/pull/186) - -## 0.7.0 - -* [Fix HTTPS deadlock](https://github.com/tiny-http/tiny-http/pull/151) -* [Relicense to MIT/Apache-2.0](https://github.com/tiny-http/tiny-http/pull/163) -* [Update `ascii` dependency](https://github.com/tiny-http/tiny-http/pull/165) -* [Fix typo in README](https://github.com/tiny-http/tiny-http/pull/171) -* [Fix compilation errors in benchmark](https://github.com/tiny-http/tiny-http/pull/170) -* [Update `url` dependency](https://github.com/tiny-http/tiny-http/pull/168) -* [Update `chunked_transfer` dependency](https://github.com/tiny-http/tiny-http/pull/166) - -## 0.6.2 - -* [Remove AsciiExt usage](https://github.com/tiny-http/tiny-http/pull/152) -* [Remove unused EncodingDecoder](https://github.com/tiny-http/tiny-http/pull/153) - -## 0.6.1 - -* [Fix documentation typo](https://github.com/tiny-http/tiny-http/pull/148) -* [Expose chunked_threshold on Response](https://github.com/tiny-http/tiny-http/pull/150) - -## 0.6.0 - -* [Bump dependencies](https://github.com/tiny-http/tiny-http/pull/142) -* [Fix `next_header_source` alignment](https://github.com/tiny-http/tiny-http/pull/140) - -## 0.5.9 - -* Expanded and changed status code description mapping according to IANA registry: - * https://github.com/tiny-http/tiny-http/pull/138 - -## 0.5.8 - -* Update links to reflect repository ownership change: https://github.com/frewsxcv/tiny-http -> https://github.com/tiny-http/tiny-http - -## 0.5.7 - -* Fix using Transfer-Encoding: identity with no content length - * https://github.com/tiny-http/tiny-http/pull/126 - -## 0.5.6 - -* Update link to documentation - * https://github.com/tiny-http/tiny-http/pull/123 -* Fix websockets - * https://github.com/tiny-http/tiny-http/pull/124 -* Drop the request reader earlier - * https://github.com/tiny-http/tiny-http/pull/125 - -## 0.5.5 - -* Start using the log crate - * https://github.com/tiny-http/tiny-http/pull/121 -* Unblock the accept thread on shutdown - * https://github.com/tiny-http/tiny-http/pull/120 - -## 0.5.4 - -* Fix compilation warnings - * https://github.com/tiny-http/tiny-http/pull/118 - -## 0.5.3 - -* Add try_recv_timeout function to the server - * https://github.com/tiny-http/tiny-http/pull/116 - -## 0.5.2 - -* Update ascii to version 0.7 - * https://github.com/tiny-http/tiny-http/pull/114 - -## 0.5.1 - -* Request::respond now returns an IoResult - * https://github.com/tiny-http/tiny-http/pull/110 - -## 0.5.0 - -* HTTPS support - * https://github.com/tiny-http/tiny-http/pull/107 -* Rework the server creation API - * https://github.com/tiny-http/tiny-http/pull/106 - -## 0.4.1 - -* Allow binding to a nic by specifying the socket address - * https://github.com/tiny-http/tiny-http/pull/103 - -## 0.4.0 - -* Make Method into an enum instead of a character string - * https://github.com/tiny-http/tiny-http/pull/102 diff --git a/anneal/vendor/tiny_http/Cargo.lock b/anneal/vendor/tiny_http/Cargo.lock deleted file mode 100644 index 1784e035ef..0000000000 --- a/anneal/vendor/tiny_http/Cargo.lock +++ /dev/null @@ -1,395 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "ascii" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbf56136a5198c7b01a49e3afcbef6cf84597273d298f54432926024107b0109" - -[[package]] -name = "autocfg" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" - -[[package]] -name = "base64" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd" - -[[package]] -name = "bitflags" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" - -[[package]] -name = "bumpalo" -version = "3.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1ad822118d20d2c234f427000d5acc36eabe1e29a348c89b63dd60b13f28e5d" - -[[package]] -name = "cc" -version = "1.0.73" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11" - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "chunked_transfer" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e" - -[[package]] -name = "fdlimit" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0da54a593b34c71b889ee45f5b5bb900c74148c5f7f8c6a9479ee7899f69603c" -dependencies = [ - "libc", -] - -[[package]] -name = "foreign-types" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" -dependencies = [ - "foreign-types-shared", -] - -[[package]] -name = "foreign-types-shared" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" - -[[package]] -name = "httpdate" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421" - -[[package]] -name = "js-sys" -version = "0.3.59" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "258451ab10b34f8af53416d1fdab72c22e805f0c92a1136d59470ec0b11138b2" -dependencies = [ - "wasm-bindgen", -] - -[[package]] -name = "libc" -version = "0.2.132" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5" - -[[package]] -name = "log" -version = "0.4.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "once_cell" -version = "1.14.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0" - -[[package]] -name = "openssl" -version = "0.10.41" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "618febf65336490dfcf20b73f885f5651a0c89c64c2d4a8c3662585a70bf5bd0" -dependencies = [ - "bitflags", - "cfg-if", - "foreign-types", - "libc", - "once_cell", - "openssl-macros", - "openssl-sys", -] - -[[package]] -name = "openssl-macros" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b501e44f11665960c7e7fcf062c7d96a14ade4aa98116c004b2e37b5be7d736c" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "openssl-sys" -version = "0.9.75" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5f9bd0c2710541a3cda73d6f9ac4f1b240de4ae261065d309dbe73d9dceb42f" -dependencies = [ - "autocfg", - "cc", - "libc", - "pkg-config", - "vcpkg", -] - -[[package]] -name = "pkg-config" -version = "0.3.25" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1df8c4ec4b0627e53bdf214615ad287367e482558cf84b109250b37464dc03ae" - -[[package]] -name = "proc-macro2" -version = "1.0.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "quote" -version = "1.0.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "ring" -version = "0.16.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc" -dependencies = [ - "cc", - "libc", - "once_cell", - "spin", - "untrusted", - "web-sys", - "winapi", -] - -[[package]] -name = "rustc-serialize" -version = "0.3.24" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda" - -[[package]] -name = "rustls" -version = "0.20.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5aab8ee6c7097ed6057f43c187a62418d0c05a4bd5f18b3571db50ee0f9ce033" -dependencies = [ - "log", - "ring", - "sct", - "webpki", -] - -[[package]] -name = "rustls-pemfile" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5eebeaeb360c87bfb72e84abdb3447159c0eaececf1bef2aecd65a8be949d1c9" -dependencies = [ - "base64", -] - -[[package]] -name = "sct" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "sha1" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1da05c97445caa12d05e848c4a4fcbbea29e748ac28f7e80e9b010392063770" -dependencies = [ - "sha1_smol", -] - -[[package]] -name = "sha1_smol" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae1a47186c03a32177042e55dbc5fd5aee900b8e0069a8d70fba96a9375cd012" - -[[package]] -name = "spin" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" - -[[package]] -name = "syn" -version = "1.0.99" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "tiny_http" -version = "0.12.0" -dependencies = [ - "ascii", - "chunked_transfer", - "fdlimit", - "httpdate", - "log", - "openssl", - "rustc-serialize", - "rustls", - "rustls-pemfile", - "sha1", - "zeroize", -] - -[[package]] -name = "unicode-ident" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf" - -[[package]] -name = "untrusted" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a" - -[[package]] -name = "vcpkg" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" - -[[package]] -name = "wasm-bindgen" -version = "0.2.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc7652e3f6c4706c8d9cd54832c4a4ccb9b5336e2c3bd154d5cccfbf1c1f5f7d" -dependencies = [ - "cfg-if", - "wasm-bindgen-macro", -] - -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "662cd44805586bd52971b9586b1df85cdbbd9112e4ef4d8f41559c334dc6ac3f" -dependencies = [ - "bumpalo", - "log", - "once_cell", - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b260f13d3012071dfb1512849c033b1925038373aea48ced3012c09df952c602" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5be8e654bdd9b79216c2929ab90721aa82faf65c48cdf08bdc4e7f51357b80da" -dependencies = [ - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-backend", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6598dd0bd3c7d51095ff6531a5b23e02acdc81804e30d8f07afb77b7215a140a" - -[[package]] -name = "web-sys" -version = "0.3.59" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed055ab27f941423197eb86b2035720b1a3ce40504df082cac2ecc6ed73335a1" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "webpki" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "winapi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "zeroize" -version = "1.5.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c394b5bd0c6f669e7275d9c20aa90ae064cb22e75a1cad54e1b34088034b149f" diff --git a/anneal/vendor/tiny_http/Cargo.toml b/anneal/vendor/tiny_http/Cargo.toml deleted file mode 100644 index 7f25f3a587..0000000000 --- a/anneal/vendor/tiny_http/Cargo.toml +++ /dev/null @@ -1,82 +0,0 @@ -# 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 = "tiny_http" -version = "0.12.0" -authors = [ - "pierre.krieger1708@gmail.com", - "Corey Farwell ", -] -description = "Low level HTTP server library" -documentation = "https://tiny-http.github.io/tiny-http/tiny_http/index.html" -readme = "README.md" -keywords = [ - "http", - "server", - "web", -] -license = "MIT OR Apache-2.0" -repository = "https://github.com/tiny-http/tiny-http" - -[package.metadata.docs.rs] -features = ["ssl-openssl"] - -[dependencies.ascii] -version = "1.0" - -[dependencies.chunked_transfer] -version = "1" - -[dependencies.httpdate] -version = "1.0.2" - -[dependencies.log] -version = "0.4.4" - -[dependencies.openssl] -version = "0.10" -optional = true - -[dependencies.rustls] -version = "0.20" -optional = true - -[dependencies.rustls-pemfile] -version = "0.2.1" -optional = true - -[dependencies.zeroize] -version = "1" -optional = true - -[dev-dependencies.fdlimit] -version = "0.1" - -[dev-dependencies.rustc-serialize] -version = "0.3" - -[dev-dependencies.sha1] -version = "0.6.0" - -[features] -default = [] -ssl = ["ssl-openssl"] -ssl-openssl = [ - "openssl", - "zeroize", -] -ssl-rustls = [ - "rustls", - "rustls-pemfile", - "zeroize", -] diff --git a/anneal/vendor/tiny_http/Cargo.toml.orig b/anneal/vendor/tiny_http/Cargo.toml.orig deleted file mode 100644 index 1bc6851366..0000000000 --- a/anneal/vendor/tiny_http/Cargo.toml.orig +++ /dev/null @@ -1,37 +0,0 @@ -[package] -name = "tiny_http" -version = "0.12.0" -authors = ["pierre.krieger1708@gmail.com", - "Corey Farwell "] -description = "Low level HTTP server library" -documentation = "https://tiny-http.github.io/tiny-http/tiny_http/index.html" -keywords = ["http", "server", "web"] -license = "MIT OR Apache-2.0" -repository = "https://github.com/tiny-http/tiny-http" -edition = "2018" - -[features] -default = [] -ssl = ["ssl-openssl"] -ssl-openssl = ["openssl", "zeroize"] -ssl-rustls = ["rustls", "rustls-pemfile", "zeroize"] - -[dependencies] -ascii = "1.0" -chunked_transfer = "1" -log = "0.4.4" -httpdate = "1.0.2" - -openssl = { version = "0.10", optional = true } -rustls = { version = "0.20", optional = true } -rustls-pemfile = { version = "0.2.1", optional = true } -zeroize = { version = "1", optional = true } - -[dev-dependencies] -rustc-serialize = "0.3" -sha1 = "0.6.0" -fdlimit = "0.1" - -[package.metadata.docs.rs] -# Enable just one SSL implementation -features = ["ssl-openssl"] diff --git a/anneal/vendor/tiny_http/LICENSE-APACHE b/anneal/vendor/tiny_http/LICENSE-APACHE deleted file mode 100644 index 16fe87b06e..0000000000 --- a/anneal/vendor/tiny_http/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/anneal/vendor/tiny_http/LICENSE-MIT b/anneal/vendor/tiny_http/LICENSE-MIT deleted file mode 100644 index 474b78857f..0000000000 --- a/anneal/vendor/tiny_http/LICENSE-MIT +++ /dev/null @@ -1,25 +0,0 @@ -Copyright (c) 2014-2019 The tiny-http contributors - -Permission is hereby granted, free of charge, to any -person obtaining a copy of this software and associated -documentation files (the "Software"), to deal in the -Software without restriction, including without -limitation the rights to use, copy, modify, merge, -publish, distribute, sublicense, and/or sell copies of -the Software, and to permit persons to whom the Software -is furnished to do so, subject to the following -conditions: - -The above copyright notice and this permission notice -shall be included in all copies or substantial portions -of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF -ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED -TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A -PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT -SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR -IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. diff --git a/anneal/vendor/tiny_http/README.md b/anneal/vendor/tiny_http/README.md deleted file mode 100644 index 0d43793793..0000000000 --- a/anneal/vendor/tiny_http/README.md +++ /dev/null @@ -1,108 +0,0 @@ -# tiny-http - -[![Crate][crate_img]][crate] -[![Documentation][docs_img]][docs] -![License][license_img] -[![CI Status][ci_badge]][ci_link] - -[**Documentation**](https://docs.rs/tiny_http) - -Tiny but strong HTTP server in Rust. -Its main objectives are to be 100% compliant with the HTTP standard and to provide an easy way to create an HTTP server. - -What does **tiny-http** handle? - - Accepting and managing connections to the clients - - Parsing requests - - Requests pipelining - - HTTPS (using either OpenSSL or Rustls) - - Transfer-Encoding and Content-Encoding - - Turning user input (eg. POST input) into a contiguous UTF-8 string (**not implemented yet**) - - Ranges (**not implemented yet**) - - `Connection: upgrade` (used by websockets) - -Tiny-http handles everything that is related to client connections and data transfers and encoding. - -Everything else (parsing the values of the headers, multipart data, routing, etags, cache-control, HTML templates, etc.) must be handled by your code. -If you want to create a website in Rust, I strongly recommend using a framework instead of this library. - -### Installation - -Add this to the `Cargo.toml` file of your project: - -```toml -[dependencies] -tiny_http = "0.11" -``` - -### Usage - -```rust -use tiny_http::{Server, Response}; - -let server = Server::http("0.0.0.0:8000").unwrap(); - -for request in server.incoming_requests() { - println!("received request! method: {:?}, url: {:?}, headers: {:?}", - request.method(), - request.url(), - request.headers() - ); - - let response = Response::from_string("hello world"); - request.respond(response); -} -``` - -### Speed - -Tiny-http was designed with speed in mind: - - Each client connection will be dispatched to a thread pool. Each thread will handle one client. - If there is no thread available when a client connects, a new one is created. Threads that are idle - for a long time (currently 5 seconds) will automatically die. - - If multiple requests from the same client are being pipelined (ie. multiple requests - are sent without waiting for the answer), tiny-http will read them all at once and they will - all be available via `server.recv()`. Tiny-http will automatically rearrange the responses - so that they are sent in the right order. - - One exception to the previous statement exists when a request has a large body (currently > 1kB), - in which case the request handler will read the body directly from the stream and tiny-http - will wait for it to be read before processing the next request. Tiny-http will never wait for - a request to be answered to read the next one. - - When a client connection has sent its last request (by sending `Connection: close` header), - the thread will immediately stop reading from this client and can be reclaimed, even when the - request has not yet been answered. The reading part of the socket will also be immediately closed. - - Decoding the client's request is done lazily. If you don't read the request's body, it will not - be decoded. - -### Examples - -Examples of tiny-http in use: - -* [heroku-tiny-http-hello-world](https://github.com/frewsxcv/heroku-tiny-http-hello-world) - A simple web application demonstrating how to deploy tiny-http to Heroku -* [crate-deps](https://github.com/frewsxcv/crate-deps) - A web service that generates images of dependency graphs for crates hosted on crates.io -* [rouille](https://crates.io/crates/rouille) - Web framework built on tiny-http - -### License - -This project is licensed under either of - - * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or - http://www.apache.org/licenses/LICENSE-2.0) - * MIT license ([LICENSE-MIT](LICENSE-MIT) or - http://opensource.org/licenses/MIT) - -at your option. - -#### Contribution - -Unless you explicitly state otherwise, any contribution intentionally submitted -for inclusion in tiny-http by you, as defined in the Apache-2.0 license, shall be -dual licensed as above, without any additional terms or conditions. - - -[crate_img]: https://img.shields.io/crates/v/tiny_http.svg?logo=rust "Crate Page" -[crate]: https://crates.io/crates/tiny_http "Crate Link" -[docs]: https://docs.rs/tiny_http "Documentation" -[docs_img]: https://docs.rs/tiny_http/badge.svg "Documentation" -[license_img]: https://img.shields.io/crates/l/tiny_http.svg "License" -[ci_badge]: https://github.com/tiny-http/tiny-http/actions/workflows/ci.yaml/badge.svg "CI Status" -[ci_link]: https://github.com/tiny-http/tiny-http/actions/workflows/ci.yaml "Workflow Link" diff --git a/anneal/vendor/tiny_http/benches/bench.rs b/anneal/vendor/tiny_http/benches/bench.rs deleted file mode 100644 index f011ad793d..0000000000 --- a/anneal/vendor/tiny_http/benches/bench.rs +++ /dev/null @@ -1,80 +0,0 @@ -#![feature(test)] - -extern crate fdlimit; -extern crate test; -extern crate tiny_http; - -use std::io::Write; -use std::process::Command; -use tiny_http::Method; - -#[test] -#[ignore] -// TODO: obtain time -fn curl_bench() { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - let num_requests = 10usize; - - match Command::new("curl") - .arg("-s") - .arg(format!("http://localhost:{}/?[1-{}]", port, num_requests)) - .output() - { - Ok(p) => p, - Err(_) => return, // ignoring test - }; - - drop(server); -} - -#[bench] -fn sequential_requests(bencher: &mut test::Bencher) { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - - let mut stream = std::net::TcpStream::connect(("127.0.0.1", port)).unwrap(); - - bencher.iter(|| { - (write!(stream, "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")).unwrap(); - - let request = server.recv().unwrap(); - - assert_eq!(request.method(), &Method::Get); - - request.respond(tiny_http::Response::new_empty(tiny_http::StatusCode(204))); - }); -} - -#[bench] -fn parallel_requests(bencher: &mut test::Bencher) { - fdlimit::raise_fd_limit(); - - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - - bencher.iter(|| { - let mut streams = Vec::new(); - - for _ in 0..1000usize { - let mut stream = std::net::TcpStream::connect(("127.0.0.1", port)).unwrap(); - (write!( - stream, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - )) - .unwrap(); - streams.push(stream); - } - - loop { - let request = match server.try_recv().unwrap() { - None => break, - Some(rq) => rq, - }; - - assert_eq!(request.method(), &Method::Get); - - request.respond(tiny_http::Response::new_empty(tiny_http::StatusCode(204))); - } - }); -} diff --git a/anneal/vendor/tiny_http/examples/hello-world.rs b/anneal/vendor/tiny_http/examples/hello-world.rs deleted file mode 100644 index bce1a4b96e..0000000000 --- a/anneal/vendor/tiny_http/examples/hello-world.rs +++ /dev/null @@ -1,26 +0,0 @@ -extern crate tiny_http; - -use std::sync::Arc; -use std::thread; - -fn main() { - let server = Arc::new(tiny_http::Server::http("0.0.0.0:9975").unwrap()); - println!("Now listening on port 9975"); - - let mut handles = Vec::new(); - - for _ in 0..4 { - let server = server.clone(); - - handles.push(thread::spawn(move || { - for rq in server.incoming_requests() { - let response = tiny_http::Response::from_string("hello world".to_string()); - let _ = rq.respond(response); - } - })); - } - - for h in handles { - h.join().unwrap(); - } -} diff --git a/anneal/vendor/tiny_http/examples/php-cgi-example.php b/anneal/vendor/tiny_http/examples/php-cgi-example.php deleted file mode 100644 index b19249f445..0000000000 --- a/anneal/vendor/tiny_http/examples/php-cgi-example.php +++ /dev/null @@ -1,3 +0,0 @@ - - -*/ - -fn handle(rq: tiny_http::Request, script: &str) { - use std::io::Write; - use std::process::Command; - - let php = Command::new("php-cgi") - .arg(script) - //.stdin(Ignored) - //.extra_io(Ignored) - .env("AUTH_TYPE", "") - .env( - "CONTENT_LENGTH", - format!("{}", rq.body_length().unwrap_or(0)), - ) - .env("CONTENT_TYPE", "") - .env("GATEWAY_INTERFACE", "CGI/1.1") - .env("PATH_INFO", "") - .env("PATH_TRANSLATED", "") - .env("QUERY_STRING", format!("{}", rq.url())) - .env("REMOTE_ADDR", format!("{}", rq.remote_addr().unwrap())) - .env("REMOTE_HOST", "") - .env("REMOTE_IDENT", "") - .env("REMOTE_USER", "") - .env("REQUEST_METHOD", format!("{}", rq.method())) - .env("SCRIPT_NAME", script) - .env("SERVER_NAME", "tiny-http php-cgi example") - .env("SERVER_PORT", format!("{}", rq.remote_addr().unwrap())) - .env("SERVER_PROTOCOL", "HTTP/1.1") - .env("SERVER_SOFTWARE", "tiny-http php-cgi example") - .output() - .unwrap(); - - // note: this is not a good implementation - // cgi returns the status code in the headers ; also many headers will be missing - // in the response - match php.status { - status if status.success() => { - let mut writer = rq.into_writer(); - let writer: &mut dyn Write = &mut *writer; - - (write!(writer, "HTTP/1.1 200 OK\r\n")).unwrap(); - (write!(writer, "{}", php.stdout.clone().as_ascii_str().unwrap())).unwrap(); - - writer.flush().unwrap(); - } - _ => { - println!( - "Error in script execution: {}", - php.stderr.clone().as_ascii_str().unwrap() - ); - } - } -} - -fn main() { - use std::env; - use std::sync::Arc; - use std::thread::spawn; - - let php_script = { - let mut args = env::args(); - if args.len() < 2 { - println!("Usage: php-cgi "); - return; - } - args.nth(1).unwrap() - }; - - let server = Arc::new(tiny_http::Server::http("0.0.0.0:9975").unwrap()); - println!("Now listening on port 9975"); - - let num_cpus = 4; // TODO: dynamically generate this value - for _ in 0..num_cpus { - let server = server.clone(); - let php_script = php_script.clone(); - - spawn(move || { - for rq in server.incoming_requests() { - handle(rq, &php_script); - } - }); - } -} diff --git a/anneal/vendor/tiny_http/examples/readme-example.rs b/anneal/vendor/tiny_http/examples/readme-example.rs deleted file mode 100644 index e093827d5a..0000000000 --- a/anneal/vendor/tiny_http/examples/readme-example.rs +++ /dev/null @@ -1,19 +0,0 @@ -extern crate tiny_http; - -fn main() { - use tiny_http::{Response, Server}; - - let server = Server::http("0.0.0.0:8000").unwrap(); - - for request in server.incoming_requests() { - println!( - "received request! method: {:?}, url: {:?}, headers: {:?}", - request.method(), - request.url(), - request.headers() - ); - - let response = Response::from_string("hello world"); - request.respond(response).expect("Responded"); - } -} diff --git a/anneal/vendor/tiny_http/examples/serve-root.rs b/anneal/vendor/tiny_http/examples/serve-root.rs deleted file mode 100644 index 5391c1b09c..0000000000 --- a/anneal/vendor/tiny_http/examples/serve-root.rs +++ /dev/null @@ -1,58 +0,0 @@ -use ascii::AsciiString; -use std::fs; -use std::path::Path; - -extern crate ascii; -extern crate tiny_http; - -fn get_content_type(path: &Path) -> &'static str { - let extension = match path.extension() { - None => return "text/plain", - Some(e) => e, - }; - - match extension.to_str().unwrap() { - "gif" => "image/gif", - "jpg" => "image/jpeg", - "jpeg" => "image/jpeg", - "png" => "image/png", - "pdf" => "application/pdf", - "htm" => "text/html; charset=utf8", - "html" => "text/html; charset=utf8", - "txt" => "text/plain; charset=utf8", - _ => "text/plain; charset=utf8", - } -} - -fn main() { - let server = tiny_http::Server::http("0.0.0.0:8000").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - println!("Now listening on port {}", port); - - loop { - let rq = match server.recv() { - Ok(rq) => rq, - Err(_) => break, - }; - - println!("{:?}", rq); - - let url = rq.url().to_string(); - let path = Path::new(&url); - let file = fs::File::open(&path); - - if file.is_ok() { - let response = tiny_http::Response::from_file(file.unwrap()); - - let response = response.with_header(tiny_http::Header { - field: "Content-Type".parse().unwrap(), - value: AsciiString::from_ascii(get_content_type(&path)).unwrap(), - }); - - let _ = rq.respond(response); - } else { - let rep = tiny_http::Response::new_empty(tiny_http::StatusCode(404)); - let _ = rq.respond(rep); - } - } -} diff --git a/anneal/vendor/tiny_http/examples/ssl-cert.pem b/anneal/vendor/tiny_http/examples/ssl-cert.pem deleted file mode 100644 index 6488a21970..0000000000 --- a/anneal/vendor/tiny_http/examples/ssl-cert.pem +++ /dev/null @@ -1,23 +0,0 @@ ------BEGIN CERTIFICATE----- -MIIDxzCCAq+gAwIBAgIUVB6JBT6sYv0g4IGfZgjelceiqBQwDQYJKoZIhvcNAQEL -BQAwcjELMAkGA1UEBhMCTk8xDTALBgNVBAgMBE5vbmUxDTALBgNVBAcMBE5vbmUx -DTALBgNVBAoMBE5vbmUxDTALBgNVBAsMBE5vbmUxEjAQBgNVBAMMCWxvY2FsaG9z -dDETMBEGCSqGSIb3DQEJARYETm9uZTAgFw0yMjAxMjgyMDQzMjFaGA8yMDcyMDEx -NjIwNDMyMVowcjELMAkGA1UEBhMCTk8xDTALBgNVBAgMBE5vbmUxDTALBgNVBAcM -BE5vbmUxDTALBgNVBAoMBE5vbmUxDTALBgNVBAsMBE5vbmUxEjAQBgNVBAMMCWxv -Y2FsaG9zdDETMBEGCSqGSIb3DQEJARYETm9uZTCCASIwDQYJKoZIhvcNAQEBBQAD -ggEPADCCAQoCggEBANgjc9hZtEwve2usjNrc+2w4bT9fJi2uVQ3eHdtECirBxHrm -rSbSeOyhvTPmonyp81LQv52KzHDLxwVSmFoJkrIKrnqqSzw/ynuqBpykhV3TKPLK -SCZiyqQmGucTIxOXM9ZEB51zCvq+2jL4v2nBueibY2SzXG6MSAjRRC5ezDTYvIMH -12uH0U4a3UMICPTEMluy+mT4S1EGZLTj37+6JQA/1xYzZAifZAGEKRcCd0q5f9IU -V8GnnYjptFFswJJF7EBpExZIlxwTn7c4Un8yjYOTAj9Yw6OiAy6MVv8NSF1DeGmY -wUFHm6eUUmv+YO/T99sdt1dpdf1+807Fa62L1d8CAwEAAaNTMFEwHQYDVR0OBBYE -FCjWLWB1sdWiGdHT/PY4BcuqnJq0MB8GA1UdIwQYMBaAFCjWLWB1sdWiGdHT/PY4 -BcuqnJq0MA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAH+Gafl1 -/yhjg4wVniQRFKqdufMmaEkAgJGaB87/Cjb5dyf1ku3ZvM7SX9MyV2R3tw6hncBQ -E3XbPhOTJXcohGzpZ5hC043eY+/yAjKgbrSH4c0z/g9iSigX1B/F1hfF4Evx1eR6 -WD5CCpA/YLF8Ik09WU2HKFT85sDIygmv0hmuI0dF+9lpqfPguhx6iLOoFyXkbgqF -RDWe8V0/GtEnX4PckdyyYk/uFX5aKMeW5dBY6GL9YDRcZvTLsjJi1wj3OcDsr7n5 -ULkGWiWdQScpkrGWOPoM72r6yyFi5P/RCBI/p0LBseARXAAedgC8tTK6DpfRXe1M -BumieRdjmHDbE+4= ------END CERTIFICATE----- diff --git a/anneal/vendor/tiny_http/examples/ssl-key.pem b/anneal/vendor/tiny_http/examples/ssl-key.pem deleted file mode 100644 index c924759b6e..0000000000 --- a/anneal/vendor/tiny_http/examples/ssl-key.pem +++ /dev/null @@ -1,28 +0,0 @@ ------BEGIN PRIVATE KEY----- -MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDYI3PYWbRML3tr -rIza3PtsOG0/XyYtrlUN3h3bRAoqwcR65q0m0njsob0z5qJ8qfNS0L+disxwy8cF -UphaCZKyCq56qks8P8p7qgacpIVd0yjyykgmYsqkJhrnEyMTlzPWRAedcwr6vtoy -+L9pwbnom2Nks1xujEgI0UQuXsw02LyDB9drh9FOGt1DCAj0xDJbsvpk+EtRBmS0 -49+/uiUAP9cWM2QIn2QBhCkXAndKuX/SFFfBp52I6bRRbMCSRexAaRMWSJccE5+3 -OFJ/Mo2DkwI/WMOjogMujFb/DUhdQ3hpmMFBR5unlFJr/mDv0/fbHbdXaXX9fvNO -xWuti9XfAgMBAAECggEBALRhyiHKo71dd0yigh96g96KrSpRV4SSVOuw7wv6md2b -P0Yu1F1tFHywcz4ogn02PRtlmjV6DCsq9ltL1lh2WtZ6MamwDAApYOyaNtBuQdvP -CgKurU5T7rjWEGe/QevsqddtiUlvJL+lnmch0GYLxwMJBAeb5U1hiBDLzXJBrX1/ -xstCJzYC1MO3zRNuoNudpZyMU18BCbk1E+XMu/yPyJJPm5VSxS3Qe0RIX0nqC3hd -RjwiTGYIqHX/hTFuZta+lNwVSx/8TJY6wTq69r6mGf0hudXz9A0SEhSVdkU77yFE -NLCTRGD8xkF1bJliT57dGofheSrn4+ATR6eMYzsGmYECgYEA/0Ao+dccjMgqiyhR -K3TTaikSSvvTOY/muISvovlpDe1U10+HIPMfGIJUVOE7p4oAbg9W70x8hMox+0hN -yERLp4Pq9skkwxfmGjA0ooKJt0e0Ux1A5LiboLUPGlBsHwNcLqno/vj4WK/TGdZu -51zG1zvBrSIMLtT5QChsy+zTtsECgYEA2MXlkgy8W7/9BRcdzCXj2Uan5L+H6KT3 -fXHYWc5yp0QBl6dqNCtPJ2lIpZ+qrNzJ1QZM56+qPEftOFOmhnz4+U6SAaKc/75n -bAL//ggMQwHzMus6ufhXJC3AYSduq9e1hnOC+K7Hc3dPLPkJGjVZVC2kXhACTwuL -aBbi5EmWVJ8CgYByk3BRRdgQ8cD3Gi/lW9mSq8EEW6njCs88QIM+msoncENHKvGz -Pq7Up5wHRdsrR20N+mDBpgm26bQp4bjYjp+PIE4WXQ/daxrk4oKd+A6tcMhnDpiU -krF5IA0ZeMQv36g/YhGucj+4P6R40qKRxDmVX8N+XewuEXeY7wx3NWWLgQKBgQC4 -DqA0eDfet49AqTYVxv5F2GZqJe5iLOAvVWDcMBzNxUKM4AufLD7TOeQDLSUgDYAa -LnVSK6eh83iKYQx+GNLV7E6wsMAZrjPmVE3EBlVS9+7lhzGgAisLfwVf+LlRk6B/ -/shwGwcjFWTWzMVbyXyFqxNrArDTKPw/b19LcugABQKBgQD8ARwEoZRyl8kuLyLh -33FRUAVTvuCU1KvEl9CU6BcmEDNcI/O/IYOeOUXYeIeNyATNH2L8A++i53EptpMd -wVxEIE2YBHD2t6+OcTjFSey7/6BejBUExxMVyWnUZMq3Xvf30ecfvacSb/DexqAG -yos+VoW4PIphdW3NBfE1hlLDZQ== ------END PRIVATE KEY----- diff --git a/anneal/vendor/tiny_http/examples/ssl.rs b/anneal/vendor/tiny_http/examples/ssl.rs deleted file mode 100644 index eef2c0521c..0000000000 --- a/anneal/vendor/tiny_http/examples/ssl.rs +++ /dev/null @@ -1,42 +0,0 @@ -extern crate tiny_http; - -#[cfg(not(any(feature = "ssl-openssl", feature = "ssl-rustls")))] -fn main() { - println!("This example requires one of the supported `ssl-*` features to be enabled"); -} - -#[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] -fn main() { - use tiny_http::{Response, Server}; - - let server = Server::https( - "0.0.0.0:8000", - tiny_http::SslConfig { - certificate: include_bytes!("ssl-cert.pem").to_vec(), - private_key: include_bytes!("ssl-key.pem").to_vec(), - }, - ) - .unwrap(); - - println!( - "Note: connecting to this server will likely give you a warning from your browser \ - because the connection is unsecure. This is because the certificate used by this \ - example is self-signed. With a real certificate, you wouldn't get this warning." - ); - - for request in server.incoming_requests() { - assert!(request.secure()); - - println!( - "received request! method: {:?}, url: {:?}, headers: {:?}", - request.method(), - request.url(), - request.headers() - ); - - let response = Response::from_string("hello world"); - request - .respond(response) - .unwrap_or(println!("Failed to respond to request")); - } -} diff --git a/anneal/vendor/tiny_http/examples/websockets.rs b/anneal/vendor/tiny_http/examples/websockets.rs deleted file mode 100644 index acea4e4602..0000000000 --- a/anneal/vendor/tiny_http/examples/websockets.rs +++ /dev/null @@ -1,148 +0,0 @@ -extern crate rustc_serialize; -extern crate sha1; -extern crate tiny_http; - -use std::io::Cursor; -use std::io::Read; -use std::thread::spawn; - -use rustc_serialize::base64::{Config, Newline, Standard, ToBase64}; - -fn home_page(port: u16) -> tiny_http::Response>> { - tiny_http::Response::from_string(format!( - " - -

This example will receive "Hello" for each byte in the packet being sent. - Tiny-http doesn't support decoding websocket frames, so we can't do anything better.

-

-

-

Received:

-

- ", - port - )) - .with_header( - "Content-type: text/html" - .parse::() - .unwrap(), - ) -} - -/// Turns a Sec-WebSocket-Key into a Sec-WebSocket-Accept. -/// Feel free to copy-paste this function, but please use a better error handling. -fn convert_key(input: &str) -> String { - use sha1::Sha1; - - let mut input = input.to_string().into_bytes(); - let mut bytes = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" - .to_string() - .into_bytes(); - input.append(&mut bytes); - - let mut sha1 = Sha1::new(); - sha1.update(&input); - - sha1.digest().bytes().to_base64(Config { - char_set: Standard, - pad: true, - line_length: None, - newline: Newline::LF, - }) -} - -fn main() { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - - println!("Server started"); - println!( - "To try this example, open a browser to http://localhost:{}/", - port - ); - - for request in server.incoming_requests() { - // we are handling this websocket connection in a new task - spawn(move || { - // checking the "Upgrade" header to check that it is a websocket - match request - .headers() - .iter() - .find(|h| h.field.equiv(&"Upgrade")) - .and_then(|hdr| { - if hdr.value == "websocket" { - Some(hdr) - } else { - None - } - }) { - None => { - // sending the HTML page - request.respond(home_page(port)).expect("Responded"); - return; - } - _ => (), - }; - - // getting the value of Sec-WebSocket-Key - let key = match request - .headers() - .iter() - .find(|h| h.field.equiv(&"Sec-WebSocket-Key")) - .map(|h| h.value.clone()) - { - None => { - let response = tiny_http::Response::new_empty(tiny_http::StatusCode(400)); - request.respond(response).expect("Responded"); - return; - } - Some(k) => k, - }; - - // building the "101 Switching Protocols" response - let response = tiny_http::Response::new_empty(tiny_http::StatusCode(101)) - .with_header("Upgrade: websocket".parse::().unwrap()) - .with_header("Connection: Upgrade".parse::().unwrap()) - .with_header( - "Sec-WebSocket-Protocol: ping" - .parse::() - .unwrap(), - ) - .with_header( - format!("Sec-WebSocket-Accept: {}", convert_key(key.as_str())) - .parse::() - .unwrap(), - ); - - // - let mut stream = request.upgrade("websocket", response); - - // - loop { - let mut out = Vec::new(); - match Read::by_ref(&mut stream).take(1).read_to_end(&mut out) { - Ok(n) if n >= 1 => { - // "Hello" frame - let data = [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]; - stream.write(&data).ok(); - stream.flush().ok(); - } - Ok(_) => panic!("eof ; should never happen"), - Err(e) => { - println!("closing connection because: {}", e); - return; - } - }; - } - }); - } -} diff --git a/anneal/vendor/tiny_http/src/client.rs b/anneal/vendor/tiny_http/src/client.rs deleted file mode 100644 index 68bbd469a2..0000000000 --- a/anneal/vendor/tiny_http/src/client.rs +++ /dev/null @@ -1,309 +0,0 @@ -use ascii::AsciiString; - -use std::io::Error as IoError; -use std::io::Result as IoResult; -use std::io::{BufReader, BufWriter, ErrorKind, Read}; - -use std::net::SocketAddr; -use std::str::FromStr; - -use crate::common::{HTTPVersion, Method}; -use crate::util::RefinedTcpStream; -use crate::util::{SequentialReader, SequentialReaderBuilder, SequentialWriterBuilder}; -use crate::Request; - -/// A ClientConnection is an object that will store a socket to a client -/// and return Request objects. -pub struct ClientConnection { - // address of the client - remote_addr: IoResult>, - - // sequence of Readers to the stream, so that the data is not read in - // the wrong order - source: SequentialReaderBuilder>, - - // sequence of Writers to the stream, to avoid writing response #2 before - // response #1 - sink: SequentialWriterBuilder>, - - // Reader to read the next header from - next_header_source: SequentialReader>, - - // set to true if we know that the previous request is the last one - no_more_requests: bool, - - // true if the connection goes through SSL - secure: bool, -} - -/// Error that can happen when reading a request. -#[derive(Debug)] -enum ReadError { - WrongRequestLine, - WrongHeader(HTTPVersion), - /// the client sent an unrecognized `Expect` header - ExpectationFailed(HTTPVersion), - ReadIoError(IoError), -} - -impl ClientConnection { - /// Creates a new `ClientConnection` that takes ownership of the `TcpStream`. - pub fn new( - write_socket: RefinedTcpStream, - mut read_socket: RefinedTcpStream, - ) -> ClientConnection { - let remote_addr = read_socket.peer_addr(); - let secure = read_socket.secure(); - - let mut source = SequentialReaderBuilder::new(BufReader::with_capacity(1024, read_socket)); - let first_header = source.next().unwrap(); - - ClientConnection { - source, - sink: SequentialWriterBuilder::new(BufWriter::with_capacity(1024, write_socket)), - remote_addr, - next_header_source: first_header, - no_more_requests: false, - secure, - } - } - - /// true if the connection is HTTPS - pub fn secure(&self) -> bool { - self.secure - } - - /// Reads the next line from self.next_header_source. - /// - /// Reads until `CRLF` is reached. The next read will start - /// at the first byte of the new line. - fn read_next_line(&mut self) -> IoResult { - let mut buf = Vec::new(); - let mut prev_byte_was_cr = false; - - loop { - let byte = self.next_header_source.by_ref().bytes().next(); - - let byte = match byte { - Some(b) => b?, - None => return Err(IoError::new(ErrorKind::ConnectionAborted, "Unexpected EOF")), - }; - - if byte == b'\n' && prev_byte_was_cr { - buf.pop(); // removing the '\r' - return AsciiString::from_ascii(buf) - .map_err(|_| IoError::new(ErrorKind::InvalidInput, "Header is not in ASCII")); - } - - prev_byte_was_cr = byte == b'\r'; - - buf.push(byte); - } - } - - /// Reads a request from the stream. - /// Blocks until the header has been read. - fn read(&mut self) -> Result { - let (method, path, version, headers) = { - // reading the request line - let (method, path, version) = { - let line = self.read_next_line().map_err(ReadError::ReadIoError)?; - - parse_request_line( - line.as_str().trim(), // TODO: remove this conversion - )? - }; - - // getting all headers - let headers = { - let mut headers = Vec::new(); - loop { - let line = self.read_next_line().map_err(ReadError::ReadIoError)?; - - if line.is_empty() { - break; - }; - headers.push(match FromStr::from_str(line.as_str().trim()) { - // TODO: remove this conversion - Ok(h) => h, - _ => return Err(ReadError::WrongHeader(version)), - }); - } - - headers - }; - - (method, path, version, headers) - }; - - // building the writer for the request - let writer = self.sink.next().unwrap(); - - // follow-up for next potential request - let mut data_source = self.source.next().unwrap(); - std::mem::swap(&mut self.next_header_source, &mut data_source); - - // building the next reader - let request = crate::request::new_request( - self.secure, - method, - path, - version.clone(), - headers, - *self.remote_addr.as_ref().unwrap(), - data_source, - writer, - ) - .map_err(|e| { - use crate::request; - match e { - request::RequestCreationError::CreationIoError(e) => ReadError::ReadIoError(e), - request::RequestCreationError::ExpectationFailed => { - ReadError::ExpectationFailed(version) - } - } - })?; - - // return the request - Ok(request) - } -} - -impl Iterator for ClientConnection { - type Item = Request; - - /// Blocks until the next Request is available. - /// Returns None when no new Requests will come from the client. - fn next(&mut self) -> Option { - use crate::{Response, StatusCode}; - - // the client sent a "connection: close" header in this previous request - // or is using HTTP 1.0, meaning that no new request will come - if self.no_more_requests { - return None; - } - - loop { - let rq = match self.read() { - Err(ReadError::WrongRequestLine) => { - let writer = self.sink.next().unwrap(); - let response = Response::new_empty(StatusCode(400)); - response - .raw_print(writer, HTTPVersion(1, 1), &[], false, None) - .ok(); - return None; // we don't know where the next request would start, - // se we have to close - } - - Err(ReadError::WrongHeader(ver)) => { - let writer = self.sink.next().unwrap(); - let response = Response::new_empty(StatusCode(400)); - response.raw_print(writer, ver, &[], false, None).ok(); - return None; // we don't know where the next request would start, - // se we have to close - } - - Err(ReadError::ReadIoError(ref err)) if err.kind() == ErrorKind::TimedOut => { - // request timeout - let writer = self.sink.next().unwrap(); - let response = Response::new_empty(StatusCode(408)); - response - .raw_print(writer, HTTPVersion(1, 1), &[], false, None) - .ok(); - return None; // closing the connection - } - - Err(ReadError::ExpectationFailed(ver)) => { - let writer = self.sink.next().unwrap(); - let response = Response::new_empty(StatusCode(417)); - response.raw_print(writer, ver, &[], true, None).ok(); - return None; // TODO: should be recoverable, but needs handling in case of body - } - - Err(ReadError::ReadIoError(_)) => return None, - - Ok(rq) => rq, - }; - - // checking HTTP version - if *rq.http_version() > (1, 1) { - let writer = self.sink.next().unwrap(); - let response = Response::from_string( - "This server only supports HTTP versions 1.0 and 1.1".to_owned(), - ) - .with_status_code(StatusCode(505)); - response - .raw_print(writer, HTTPVersion(1, 1), &[], false, None) - .ok(); - continue; - } - - // updating the status of the connection - let connection_header = rq - .headers() - .iter() - .find(|h| h.field.equiv("Connection")) - .map(|h| h.value.as_str()); - - let lowercase = connection_header.map(|h| h.to_ascii_lowercase()); - - match lowercase { - Some(ref val) if val.contains("close") => self.no_more_requests = true, - Some(ref val) if val.contains("upgrade") => self.no_more_requests = true, - Some(ref val) - if !val.contains("keep-alive") && *rq.http_version() == HTTPVersion(1, 0) => - { - self.no_more_requests = true - } - None if *rq.http_version() == HTTPVersion(1, 0) => self.no_more_requests = true, - _ => (), - }; - - // returning the request - return Some(rq); - } - } -} - -/// Parses a "HTTP/1.1" string. -fn parse_http_version(version: &str) -> Result { - let (major, minor) = match version { - "HTTP/0.9" => (0, 9), - "HTTP/1.0" => (1, 0), - "HTTP/1.1" => (1, 1), - "HTTP/2.0" => (2, 0), - "HTTP/3.0" => (3, 0), - _ => return Err(ReadError::WrongRequestLine), - }; - - Ok(HTTPVersion(major, minor)) -} - -/// Parses the request line of the request. -/// eg. GET / HTTP/1.1 -fn parse_request_line(line: &str) -> Result<(Method, String, HTTPVersion), ReadError> { - let mut parts = line.split(' '); - - let method = parts.next().and_then(|w| w.parse().ok()); - let path = parts.next().map(ToOwned::to_owned); - let version = parts.next().and_then(|w| parse_http_version(w).ok()); - - method - .and_then(|method| Some((method, path?, version?))) - .ok_or(ReadError::WrongRequestLine) -} - -#[cfg(test)] -mod test { - #[test] - fn test_parse_request_line() { - let (method, path, ver) = super::parse_request_line("GET /hello HTTP/1.1").unwrap(); - - assert!(method == crate::Method::Get); - assert!(path == "/hello"); - assert!(ver == crate::common::HTTPVersion(1, 1)); - - assert!(super::parse_request_line("GET /hello").is_err()); - assert!(super::parse_request_line("qsd qsd qsd").is_err()); - } -} diff --git a/anneal/vendor/tiny_http/src/common.rs b/anneal/vendor/tiny_http/src/common.rs deleted file mode 100644 index 473fd8d488..0000000000 --- a/anneal/vendor/tiny_http/src/common.rs +++ /dev/null @@ -1,440 +0,0 @@ -use ascii::{AsciiStr, AsciiString, FromAsciiError}; -use std::cmp::Ordering; -use std::fmt::{self, Display, Formatter}; -use std::str::FromStr; - -/// Status code of a request or response. -#[derive(Eq, PartialEq, Copy, Clone, Debug, Ord, PartialOrd)] -pub struct StatusCode(pub u16); - -impl StatusCode { - /// Returns the default reason phrase for this status code. - /// For example the status code 404 corresponds to "Not Found". - pub fn default_reason_phrase(&self) -> &'static str { - match self.0 { - 100 => "Continue", - 101 => "Switching Protocols", - 102 => "Processing", - 103 => "Early Hints", - - 200 => "OK", - 201 => "Created", - 202 => "Accepted", - 203 => "Non-Authoritative Information", - 204 => "No Content", - 205 => "Reset Content", - 206 => "Partial Content", - 207 => "Multi-Status", - 208 => "Already Reported", - 226 => "IM Used", - - 300 => "Multiple Choices", - 301 => "Moved Permanently", - 302 => "Found", - 303 => "See Other", - 304 => "Not Modified", - 305 => "Use Proxy", - 307 => "Temporary Redirect", - 308 => "Permanent Redirect", - - 400 => "Bad Request", - 401 => "Unauthorized", - 402 => "Payment Required", - 403 => "Forbidden", - 404 => "Not Found", - 405 => "Method Not Allowed", - 406 => "Not Acceptable", - 407 => "Proxy Authentication Required", - 408 => "Request Timeout", - 409 => "Conflict", - 410 => "Gone", - 411 => "Length Required", - 412 => "Precondition Failed", - 413 => "Payload Too Large", - 414 => "URI Too Long", - 415 => "Unsupported Media Type", - 416 => "Range Not Satisfiable", - 417 => "Expectation Failed", - 421 => "Misdirected Request", - 422 => "Unprocessable Entity", - 423 => "Locked", - 424 => "Failed Dependency", - 426 => "Upgrade Required", - 428 => "Precondition Required", - 429 => "Too Many Requests", - 431 => "Request Header Fields Too Large", - 451 => "Unavailable For Legal Reasons", - - 500 => "Internal Server Error", - 501 => "Not Implemented", - 502 => "Bad Gateway", - 503 => "Service Unavailable", - 504 => "Gateway Timeout", - 505 => "HTTP Version Not Supported", - 506 => "Variant Also Negotiates", - 507 => "Insufficient Storage", - 508 => "Loop Detected", - 510 => "Not Extended", - 511 => "Network Authentication Required", - _ => "Unknown", - } - } -} - -impl From for StatusCode { - fn from(in_code: i8) -> StatusCode { - StatusCode(in_code as u16) - } -} - -impl From for StatusCode { - fn from(in_code: u8) -> StatusCode { - StatusCode(in_code as u16) - } -} - -impl From for StatusCode { - fn from(in_code: i16) -> StatusCode { - StatusCode(in_code as u16) - } -} - -impl From for StatusCode { - fn from(in_code: u16) -> StatusCode { - StatusCode(in_code) - } -} - -impl From for StatusCode { - fn from(in_code: i32) -> StatusCode { - StatusCode(in_code as u16) - } -} - -impl From for StatusCode { - fn from(in_code: u32) -> StatusCode { - StatusCode(in_code as u16) - } -} - -impl AsRef for StatusCode { - fn as_ref(&self) -> &u16 { - &self.0 - } -} - -impl PartialEq for StatusCode { - fn eq(&self, other: &u16) -> bool { - &self.0 == other - } -} - -impl PartialEq for u16 { - fn eq(&self, other: &StatusCode) -> bool { - self == &other.0 - } -} - -impl PartialOrd for StatusCode { - fn partial_cmp(&self, other: &u16) -> Option { - self.0.partial_cmp(other) - } -} - -impl PartialOrd for u16 { - fn partial_cmp(&self, other: &StatusCode) -> Option { - self.partial_cmp(&other.0) - } -} - -/// Represents a HTTP header. -#[derive(Debug, Clone)] -pub struct Header { - pub field: HeaderField, - pub value: AsciiString, -} - -impl Header { - /// Builds a `Header` from two `Vec`s or two `&[u8]`s. - /// - /// Example: - /// - /// ``` - /// let header = tiny_http::Header::from_bytes(&b"Content-Type"[..], &b"text/plain"[..]).unwrap(); - /// ``` - #[allow(clippy::result_unit_err)] - pub fn from_bytes(header: B1, value: B2) -> Result - where - B1: Into> + AsRef<[u8]>, - B2: Into> + AsRef<[u8]>, - { - let header = HeaderField::from_bytes(header).or(Err(()))?; - let value = AsciiString::from_ascii(value).or(Err(()))?; - - Ok(Header { - field: header, - value, - }) - } -} - -impl FromStr for Header { - type Err = (); - - fn from_str(input: &str) -> Result { - let mut elems = input.splitn(2, ':'); - - let field = elems.next().and_then(|f| f.parse().ok()).ok_or(())?; - let value = elems - .next() - .and_then(|v| AsciiString::from_ascii(v.trim()).ok()) - .ok_or(())?; - - Ok(Header { field, value }) - } -} - -impl Display for Header { - fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), fmt::Error> { - write!(formatter, "{}: {}", self.field, self.value.as_str()) - } -} - -/// Field of a header (eg. `Content-Type`, `Content-Length`, etc.) -/// -/// Comparison between two `HeaderField`s ignores case. -#[derive(Debug, Clone, Eq)] -pub struct HeaderField(AsciiString); - -impl HeaderField { - pub fn from_bytes(bytes: B) -> Result> - where - B: Into> + AsRef<[u8]>, - { - AsciiString::from_ascii(bytes).map(HeaderField) - } - - pub fn as_str(&self) -> &AsciiStr { - &self.0 - } - - pub fn equiv(&self, other: &'static str) -> bool { - other.eq_ignore_ascii_case(self.as_str().as_str()) - } -} - -impl FromStr for HeaderField { - type Err = (); - - fn from_str(s: &str) -> Result { - if s.contains(char::is_whitespace) { - Err(()) - } else { - AsciiString::from_ascii(s).map(HeaderField).map_err(|_| ()) - } - } -} - -impl Display for HeaderField { - fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), fmt::Error> { - write!(formatter, "{}", self.0.as_str()) - } -} - -impl PartialEq for HeaderField { - fn eq(&self, other: &HeaderField) -> bool { - let self_str: &str = self.as_str().as_ref(); - let other_str = other.as_str().as_ref(); - self_str.eq_ignore_ascii_case(other_str) - } -} - -/// HTTP request methods -/// -/// As per [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.1) and -/// [RFC 5789](https://tools.ietf.org/html/rfc5789) -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum Method { - /// `GET` - Get, - - /// `HEAD` - Head, - - /// `POST` - Post, - - /// `PUT` - Put, - - /// `DELETE` - Delete, - - /// `CONNECT` - Connect, - - /// `OPTIONS` - Options, - - /// `TRACE` - Trace, - - /// `PATCH` - Patch, - - /// Request methods not standardized by the IETF - NonStandard(AsciiString), -} - -impl Method { - pub fn as_str(&self) -> &str { - match *self { - Method::Get => "GET", - Method::Head => "HEAD", - Method::Post => "POST", - Method::Put => "PUT", - Method::Delete => "DELETE", - Method::Connect => "CONNECT", - Method::Options => "OPTIONS", - Method::Trace => "TRACE", - Method::Patch => "PATCH", - Method::NonStandard(ref s) => s.as_str(), - } - } -} - -impl FromStr for Method { - type Err = (); - - fn from_str(s: &str) -> Result { - Ok(match s { - "GET" => Method::Get, - "HEAD" => Method::Head, - "POST" => Method::Post, - "PUT" => Method::Put, - "DELETE" => Method::Delete, - "CONNECT" => Method::Connect, - "OPTIONS" => Method::Options, - "TRACE" => Method::Trace, - "PATCH" => Method::Patch, - s => { - let ascii_string = AsciiString::from_ascii(s).map_err(|_| ())?; - Method::NonStandard(ascii_string) - } - }) - } -} - -impl Display for Method { - fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), fmt::Error> { - write!(formatter, "{}", self.as_str()) - } -} - -/// HTTP version (usually 1.0 or 1.1). -#[allow(clippy::upper_case_acronyms)] -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct HTTPVersion(pub u8, pub u8); - -impl Display for HTTPVersion { - fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), fmt::Error> { - write!(formatter, "{}.{}", self.0, self.1) - } -} - -impl Ord for HTTPVersion { - fn cmp(&self, other: &Self) -> Ordering { - let HTTPVersion(my_major, my_minor) = *self; - let HTTPVersion(other_major, other_minor) = *other; - - if my_major != other_major { - return my_major.cmp(&other_major); - } - - my_minor.cmp(&other_minor) - } -} - -impl PartialOrd for HTTPVersion { - fn partial_cmp(&self, other: &HTTPVersion) -> Option { - Some(self.cmp(other)) - } -} - -impl PartialEq<(u8, u8)> for HTTPVersion { - fn eq(&self, &(major, minor): &(u8, u8)) -> bool { - self.eq(&HTTPVersion(major, minor)) - } -} - -impl PartialEq for (u8, u8) { - fn eq(&self, other: &HTTPVersion) -> bool { - let &(major, minor) = self; - HTTPVersion(major, minor).eq(other) - } -} - -impl PartialOrd<(u8, u8)> for HTTPVersion { - fn partial_cmp(&self, &(major, minor): &(u8, u8)) -> Option { - self.partial_cmp(&HTTPVersion(major, minor)) - } -} - -impl PartialOrd for (u8, u8) { - fn partial_cmp(&self, other: &HTTPVersion) -> Option { - let &(major, minor) = self; - HTTPVersion(major, minor).partial_cmp(other) - } -} - -impl From<(u8, u8)> for HTTPVersion { - fn from((major, minor): (u8, u8)) -> HTTPVersion { - HTTPVersion(major, minor) - } -} - -#[cfg(test)] -mod test { - use super::Header; - use httpdate::HttpDate; - use std::time::{Duration, SystemTime}; - - #[test] - fn test_parse_header() { - let header: Header = "Content-Type: text/html".parse().unwrap(); - - assert!(header.field.equiv(&"content-type")); - assert!(header.value.as_str() == "text/html"); - - assert!("hello world".parse::
().is_err()); - } - - #[test] - fn formats_date_correctly() { - let http_date = HttpDate::from(SystemTime::UNIX_EPOCH + Duration::from_secs(420895020)); - - assert_eq!(http_date.to_string(), "Wed, 04 May 1983 11:17:00 GMT") - } - - #[test] - fn test_parse_header_with_doublecolon() { - let header: Header = "Time: 20: 34".parse().unwrap(); - - assert!(header.field.equiv(&"time")); - assert!(header.value.as_str() == "20: 34"); - } - - // This tests reslstance to RUSTSEC-2020-0031: "HTTP Request smuggling - // through malformed Transfer Encoding headers" - // (https://rustsec.org/advisories/RUSTSEC-2020-0031.html). - #[test] - fn test_strict_headers() { - assert!("Transfer-Encoding : chunked".parse::
().is_err()); - assert!(" Transfer-Encoding: chunked".parse::
().is_err()); - assert!("Transfer Encoding: chunked".parse::
().is_err()); - assert!(" Transfer\tEncoding : chunked".parse::
().is_err()); - assert!("Transfer-Encoding: chunked".parse::
().is_ok()); - assert!("Transfer-Encoding: chunked ".parse::
().is_ok()); - assert!("Transfer-Encoding: chunked ".parse::
().is_ok()); - } -} diff --git a/anneal/vendor/tiny_http/src/connection.rs b/anneal/vendor/tiny_http/src/connection.rs deleted file mode 100644 index 6d161cd35e..0000000000 --- a/anneal/vendor/tiny_http/src/connection.rs +++ /dev/null @@ -1,194 +0,0 @@ -//! Abstractions of Tcp and Unix socket types - -#[cfg(unix)] -use std::os::unix::net as unix_net; -use std::{ - net::{Shutdown, SocketAddr, TcpListener, TcpStream, ToSocketAddrs}, - path::PathBuf, -}; - -/// Unified listener. Either a [`TcpListener`] or [`std::os::unix::net::UnixListener`] -pub enum Listener { - Tcp(TcpListener), - #[cfg(unix)] - Unix(unix_net::UnixListener), -} -impl Listener { - pub(crate) fn local_addr(&self) -> std::io::Result { - match self { - Self::Tcp(l) => l.local_addr().map(ListenAddr::from), - #[cfg(unix)] - Self::Unix(l) => l.local_addr().map(ListenAddr::from), - } - } - - pub(crate) fn accept(&self) -> std::io::Result<(Connection, Option)> { - match self { - Self::Tcp(l) => l - .accept() - .map(|(conn, addr)| (Connection::from(conn), Some(addr))), - #[cfg(unix)] - Self::Unix(l) => l.accept().map(|(conn, _)| (Connection::from(conn), None)), - } - } -} -impl From for Listener { - fn from(s: TcpListener) -> Self { - Self::Tcp(s) - } -} -#[cfg(unix)] -impl From for Listener { - fn from(s: unix_net::UnixListener) -> Self { - Self::Unix(s) - } -} - -/// Unified connection. Either a [`TcpStream`] or [`std::os::unix::net::UnixStream`]. -#[derive(Debug)] -pub(crate) enum Connection { - Tcp(TcpStream), - #[cfg(unix)] - Unix(unix_net::UnixStream), -} -impl std::io::Read for Connection { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - match self { - Self::Tcp(s) => s.read(buf), - #[cfg(unix)] - Self::Unix(s) => s.read(buf), - } - } -} -impl std::io::Write for Connection { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - match self { - Self::Tcp(s) => s.write(buf), - #[cfg(unix)] - Self::Unix(s) => s.write(buf), - } - } - - fn flush(&mut self) -> std::io::Result<()> { - match self { - Self::Tcp(s) => s.flush(), - #[cfg(unix)] - Self::Unix(s) => s.flush(), - } - } -} -impl Connection { - /// Gets the peer's address. Some for TCP, None for Unix sockets. - pub(crate) fn peer_addr(&mut self) -> std::io::Result> { - match self { - Self::Tcp(s) => s.peer_addr().map(Some), - #[cfg(unix)] - Self::Unix(_) => Ok(None), - } - } - - pub(crate) fn shutdown(&self, how: Shutdown) -> std::io::Result<()> { - match self { - Self::Tcp(s) => s.shutdown(how), - #[cfg(unix)] - Self::Unix(s) => s.shutdown(how), - } - } - - pub(crate) fn try_clone(&self) -> std::io::Result { - match self { - Self::Tcp(s) => s.try_clone().map(Self::from), - #[cfg(unix)] - Self::Unix(s) => s.try_clone().map(Self::from), - } - } -} -impl From for Connection { - fn from(s: TcpStream) -> Self { - Self::Tcp(s) - } -} -#[cfg(unix)] -impl From for Connection { - fn from(s: unix_net::UnixStream) -> Self { - Self::Unix(s) - } -} - -#[derive(Debug, Clone)] -pub enum ConfigListenAddr { - IP(Vec), - #[cfg(unix)] - // TODO: use SocketAddr when bind_addr is stabilized - Unix(std::path::PathBuf), -} -impl ConfigListenAddr { - pub fn from_socket_addrs(addrs: A) -> std::io::Result { - addrs.to_socket_addrs().map(|it| Self::IP(it.collect())) - } - - #[cfg(unix)] - pub fn unix_from_path>(path: P) -> Self { - Self::Unix(path.into()) - } - - pub(crate) fn bind(&self) -> std::io::Result { - match self { - Self::IP(a) => TcpListener::bind(a.as_slice()).map(Listener::from), - #[cfg(unix)] - Self::Unix(a) => unix_net::UnixListener::bind(a).map(Listener::from), - } - } -} - -/// Unified listen socket address. Either a [`SocketAddr`] or [`std::os::unix::net::SocketAddr`]. -#[derive(Debug, Clone)] -pub enum ListenAddr { - IP(SocketAddr), - #[cfg(unix)] - Unix(unix_net::SocketAddr), -} -impl ListenAddr { - pub fn to_ip(self) -> Option { - match self { - Self::IP(s) => Some(s), - #[cfg(unix)] - Self::Unix(_) => None, - } - } - - /// Gets the Unix socket address. - /// - /// This is also available on non-Unix platforms, for ease of use, but always returns `None`. - #[cfg(unix)] - pub fn to_unix(self) -> Option { - match self { - Self::IP(_) => None, - Self::Unix(s) => Some(s), - } - } - #[cfg(not(unix))] - pub fn to_unix(self) -> Option { - None - } -} -impl From for ListenAddr { - fn from(s: SocketAddr) -> Self { - Self::IP(s) - } -} -#[cfg(unix)] -impl From for ListenAddr { - fn from(s: unix_net::SocketAddr) -> Self { - Self::Unix(s) - } -} -impl std::fmt::Display for ListenAddr { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Self::IP(s) => s.fmt(f), - #[cfg(unix)] - Self::Unix(s) => std::fmt::Debug::fmt(s, f), - } - } -} diff --git a/anneal/vendor/tiny_http/src/lib.rs b/anneal/vendor/tiny_http/src/lib.rs deleted file mode 100644 index 5e4568ab8b..0000000000 --- a/anneal/vendor/tiny_http/src/lib.rs +++ /dev/null @@ -1,445 +0,0 @@ -//! # Simple usage -//! -//! ## Creating the server -//! -//! The easiest way to create a server is to call `Server::http()`. -//! -//! The `http()` function returns an `IoResult` which will return an error -//! in the case where the server creation fails (for example if the listening port is already -//! occupied). -//! -//! ```no_run -//! let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); -//! ``` -//! -//! A newly-created `Server` will immediately start listening for incoming connections and HTTP -//! requests. -//! -//! ## Receiving requests -//! -//! Calling `server.recv()` will block until the next request is available. -//! This function returns an `IoResult`, so you need to handle the possible errors. -//! -//! ```no_run -//! # let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); -//! -//! loop { -//! // blocks until the next request is received -//! let request = match server.recv() { -//! Ok(rq) => rq, -//! Err(e) => { println!("error: {}", e); break } -//! }; -//! -//! // do something with the request -//! // ... -//! } -//! ``` -//! -//! In a real-case scenario, you will probably want to spawn multiple worker tasks and call -//! `server.recv()` on all of them. Like this: -//! -//! ```no_run -//! # use std::sync::Arc; -//! # use std::thread; -//! # let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); -//! let server = Arc::new(server); -//! let mut guards = Vec::with_capacity(4); -//! -//! for _ in (0 .. 4) { -//! let server = server.clone(); -//! -//! let guard = thread::spawn(move || { -//! loop { -//! let rq = server.recv().unwrap(); -//! -//! // ... -//! } -//! }); -//! -//! guards.push(guard); -//! } -//! ``` -//! -//! If you don't want to block, you can call `server.try_recv()` instead. -//! -//! ## Handling requests -//! -//! The `Request` object returned by `server.recv()` contains informations about the client's request. -//! The most useful methods are probably `request.method()` and `request.url()` which return -//! the requested method (`GET`, `POST`, etc.) and url. -//! -//! To handle a request, you need to create a `Response` object. See the docs of this object for -//! more infos. Here is an example of creating a `Response` from a file: -//! -//! ```no_run -//! # use std::fs::File; -//! # use std::path::Path; -//! let response = tiny_http::Response::from_file(File::open(&Path::new("image.png")).unwrap()); -//! ``` -//! -//! All that remains to do is call `request.respond()`: -//! -//! ```no_run -//! # use std::fs::File; -//! # use std::path::Path; -//! # let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); -//! # let request = server.recv().unwrap(); -//! # let response = tiny_http::Response::from_file(File::open(&Path::new("image.png")).unwrap()); -//! let _ = request.respond(response); -//! ``` -#![forbid(unsafe_code)] -#![deny(rust_2018_idioms)] -#![allow(clippy::match_like_matches_macro)] - -#[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] -use zeroize::Zeroizing; - -use std::error::Error; -use std::io::Error as IoError; -use std::io::ErrorKind as IoErrorKind; -use std::io::Result as IoResult; -use std::net::{Shutdown, TcpStream, ToSocketAddrs}; -use std::sync::atomic::AtomicBool; -use std::sync::atomic::Ordering::Relaxed; -use std::sync::mpsc; -use std::sync::Arc; -use std::thread; -use std::time::Duration; - -use client::ClientConnection; -use connection::Connection; -use util::MessagesQueue; - -pub use common::{HTTPVersion, Header, HeaderField, Method, StatusCode}; -pub use connection::{ConfigListenAddr, ListenAddr, Listener}; -pub use request::{ReadWrite, Request}; -pub use response::{Response, ResponseBox}; -pub use test::TestRequest; - -mod client; -mod common; -mod connection; -mod request; -mod response; -mod ssl; -mod test; -mod util; - -/// The main class of this library. -/// -/// Destroying this object will immediately close the listening socket and the reading -/// part of all the client's connections. Requests that have already been returned by -/// the `recv()` function will not close and the responses will be transferred to the client. -pub struct Server { - // should be false as long as the server exists - // when set to true, all the subtasks will close within a few hundreds ms - close: Arc, - - // queue for messages received by child threads - messages: Arc>, - - // result of TcpListener::local_addr() - listening_addr: ListenAddr, -} - -enum Message { - Error(IoError), - NewRequest(Request), -} - -impl From for Message { - fn from(e: IoError) -> Message { - Message::Error(e) - } -} - -impl From for Message { - fn from(rq: Request) -> Message { - Message::NewRequest(rq) - } -} - -// this trait is to make sure that Server implements Share and Send -#[doc(hidden)] -trait MustBeShareDummy: Sync + Send {} -#[doc(hidden)] -impl MustBeShareDummy for Server {} - -pub struct IncomingRequests<'a> { - server: &'a Server, -} - -/// Represents the parameters required to create a server. -#[derive(Debug, Clone)] -pub struct ServerConfig { - /// The addresses to try to listen to. - pub addr: ConfigListenAddr, - - /// If `Some`, then the server will use SSL to encode the communications. - pub ssl: Option, -} - -/// Configuration of the server for SSL. -#[derive(Debug, Clone)] -pub struct SslConfig { - /// Contains the public certificate to send to clients. - pub certificate: Vec, - /// Contains the ultra-secret private key used to decode communications. - pub private_key: Vec, -} - -impl Server { - /// Shortcut for a simple server on a specific address. - #[inline] - pub fn http(addr: A) -> Result> - where - A: ToSocketAddrs, - { - Server::new(ServerConfig { - addr: ConfigListenAddr::from_socket_addrs(addr)?, - ssl: None, - }) - } - - /// Shortcut for an HTTPS server on a specific address. - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - #[inline] - pub fn https( - addr: A, - config: SslConfig, - ) -> Result> - where - A: ToSocketAddrs, - { - Server::new(ServerConfig { - addr: ConfigListenAddr::from_socket_addrs(addr)?, - ssl: Some(config), - }) - } - - #[cfg(unix)] - #[inline] - /// Shortcut for a UNIX socket server at a specific path - pub fn http_unix( - path: &std::path::Path, - ) -> Result> { - Server::new(ServerConfig { - addr: ConfigListenAddr::unix_from_path(path), - ssl: None, - }) - } - - /// Builds a new server that listens on the specified address. - pub fn new(config: ServerConfig) -> Result> { - let listener = config.addr.bind()?; - Self::from_listener(listener, config.ssl) - } - - /// Builds a new server using the specified TCP listener. - /// - /// This is useful if you've constructed TcpListener using some less usual method - /// such as from systemd. For other cases, you probably want the `new()` function. - pub fn from_listener>( - listener: L, - ssl_config: Option, - ) -> Result> { - let listener = listener.into(); - // building the "close" variable - let close_trigger = Arc::new(AtomicBool::new(false)); - - // building the TcpListener - let (server, local_addr) = { - let local_addr = listener.local_addr()?; - log::debug!("Server listening on {}", local_addr); - (listener, local_addr) - }; - - // building the SSL capabilities - #[cfg(all(feature = "ssl-openssl", feature = "ssl-rustls"))] - compile_error!( - "Features 'ssl-openssl' and 'ssl-rustls' must not be enabled at the same time" - ); - #[cfg(not(any(feature = "ssl-openssl", feature = "ssl-rustls")))] - type SslContext = (); - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - type SslContext = crate::ssl::SslContextImpl; - let ssl: Option = { - match ssl_config { - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Some(config) => Some(SslContext::from_pem( - config.certificate, - Zeroizing::new(config.private_key), - )?), - #[cfg(not(any(feature = "ssl-openssl", feature = "ssl-rustls")))] - Some(_) => return Err( - "Building a server with SSL requires enabling the `ssl` feature in tiny-http" - .into(), - ), - None => None, - } - }; - - // creating a task where server.accept() is continuously called - // and ClientConnection objects are pushed in the messages queue - let messages = MessagesQueue::with_capacity(8); - - let inside_close_trigger = close_trigger.clone(); - let inside_messages = messages.clone(); - thread::spawn(move || { - // a tasks pool is used to dispatch the connections into threads - let tasks_pool = util::TaskPool::new(); - - log::debug!("Running accept thread"); - while !inside_close_trigger.load(Relaxed) { - let new_client = match server.accept() { - Ok((sock, _)) => { - use util::RefinedTcpStream; - let (read_closable, write_closable) = match ssl { - None => RefinedTcpStream::new(sock), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Some(ref ssl) => { - // trying to apply SSL over the connection - // if an error occurs, we just close the socket and resume listening - let sock = match ssl.accept(sock) { - Ok(s) => s, - Err(_) => continue, - }; - - RefinedTcpStream::new(sock) - } - #[cfg(not(any(feature = "ssl-openssl", feature = "ssl-rustls")))] - Some(ref _ssl) => unreachable!(), - }; - - Ok(ClientConnection::new(write_closable, read_closable)) - } - Err(e) => Err(e), - }; - - match new_client { - Ok(client) => { - let messages = inside_messages.clone(); - let mut client = Some(client); - tasks_pool.spawn(Box::new(move || { - if let Some(client) = client.take() { - // Synchronization is needed for HTTPS requests to avoid a deadlock - if client.secure() { - let (sender, receiver) = mpsc::channel(); - for rq in client { - messages.push(rq.with_notify_sender(sender.clone()).into()); - receiver.recv().unwrap(); - } - } else { - for rq in client { - messages.push(rq.into()); - } - } - } - })); - } - - Err(e) => { - log::error!("Error accepting new client: {}", e); - inside_messages.push(e.into()); - break; - } - } - } - log::debug!("Terminating accept thread"); - }); - - // result - Ok(Server { - messages, - close: close_trigger, - listening_addr: local_addr, - }) - } - - /// Returns an iterator for all the incoming requests. - /// - /// The iterator will return `None` if the server socket is shutdown. - #[inline] - pub fn incoming_requests(&self) -> IncomingRequests<'_> { - IncomingRequests { server: self } - } - - /// Returns the address the server is listening to. - #[inline] - pub fn server_addr(&self) -> ListenAddr { - self.listening_addr.clone() - } - - /// Returns the number of clients currently connected to the server. - pub fn num_connections(&self) -> usize { - unimplemented!() - //self.requests_receiver.lock().len() - } - - /// Blocks until an HTTP request has been submitted and returns it. - pub fn recv(&self) -> IoResult { - match self.messages.pop() { - Some(Message::Error(err)) => Err(err), - Some(Message::NewRequest(rq)) => Ok(rq), - None => Err(IoError::new(IoErrorKind::Other, "thread unblocked")), - } - } - - /// Same as `recv()` but doesn't block longer than timeout - pub fn recv_timeout(&self, timeout: Duration) -> IoResult> { - match self.messages.pop_timeout(timeout) { - Some(Message::Error(err)) => Err(err), - Some(Message::NewRequest(rq)) => Ok(Some(rq)), - None => Ok(None), - } - } - - /// Same as `recv()` but doesn't block. - pub fn try_recv(&self) -> IoResult> { - match self.messages.try_pop() { - Some(Message::Error(err)) => Err(err), - Some(Message::NewRequest(rq)) => Ok(Some(rq)), - None => Ok(None), - } - } - - /// Unblock thread stuck in recv() or incoming_requests(). - /// If there are several such threads, only one is unblocked. - /// This method allows graceful shutdown of server. - pub fn unblock(&self) { - self.messages.unblock(); - } -} - -impl Iterator for IncomingRequests<'_> { - type Item = Request; - fn next(&mut self) -> Option { - self.server.recv().ok() - } -} - -impl Drop for Server { - fn drop(&mut self) { - self.close.store(true, Relaxed); - // Connect briefly to ourselves to unblock the accept thread - let maybe_stream = match &self.listening_addr { - ListenAddr::IP(addr) => TcpStream::connect(addr).map(Connection::from), - #[cfg(unix)] - ListenAddr::Unix(addr) => { - // TODO: use connect_addr when its stabilized. - let path = addr.as_pathname().unwrap(); - std::os::unix::net::UnixStream::connect(path).map(Connection::from) - } - }; - if let Ok(stream) = maybe_stream { - let _ = stream.shutdown(Shutdown::Both); - } - - #[cfg(unix)] - if let ListenAddr::Unix(addr) = &self.listening_addr { - if let Some(path) = addr.as_pathname() { - let _ = std::fs::remove_file(path); - } - } - } -} diff --git a/anneal/vendor/tiny_http/src/request.rs b/anneal/vendor/tiny_http/src/request.rs deleted file mode 100644 index 531d6aa658..0000000000 --- a/anneal/vendor/tiny_http/src/request.rs +++ /dev/null @@ -1,518 +0,0 @@ -use std::io::Error as IoError; -use std::io::{self, Cursor, ErrorKind, Read, Write}; - -use std::fmt; -use std::net::SocketAddr; -use std::str::FromStr; - -use std::sync::mpsc::Sender; - -use crate::util::{EqualReader, FusedReader}; -use crate::{HTTPVersion, Header, Method, Response, StatusCode}; -use chunked_transfer::Decoder; - -/// Represents an HTTP request made by a client. -/// -/// A `Request` object is what is produced by the server, and is your what -/// your code must analyse and answer. -/// -/// This object implements the `Send` trait, therefore you can dispatch your requests to -/// worker threads. -/// -/// # Pipelining -/// -/// If a client sends multiple requests in a row (without waiting for the response), then you will -/// get multiple `Request` objects simultaneously. This is called *requests pipelining*. -/// Tiny-http automatically reorders the responses so that you don't need to worry about the order -/// in which you call `respond` or `into_writer`. -/// -/// This mechanic is disabled if: -/// -/// - The body of a request is large enough (handling requires pipelining requires storing the -/// body of the request in a buffer ; if the body is too big, tiny-http will avoid doing that) -/// - A request sends a `Expect: 100-continue` header (which means that the client waits to -/// know whether its body will be processed before sending it) -/// - A request sends a `Connection: close` header or `Connection: upgrade` header (used for -/// websockets), which indicates that this is the last request that will be received on this -/// connection -/// -/// # Automatic cleanup -/// -/// If a `Request` object is destroyed without `into_writer` or `respond` being called, -/// an empty response with a 500 status code (internal server error) will automatically be -/// sent back to the client. -/// This means that if your code fails during the handling of a request, this "internal server -/// error" response will automatically be sent during the stack unwinding. -/// -/// # Testing -/// -/// If you want to build fake requests to test your server, use [`TestRequest`](crate::test::TestRequest). -pub struct Request { - // where to read the body from - data_reader: Option>, - - // if this writer is empty, then the request has been answered - response_writer: Option>, - - remote_addr: Option, - - // true if HTTPS, false if HTTP - secure: bool, - - method: Method, - - path: String, - - http_version: HTTPVersion, - - headers: Vec
, - - body_length: Option, - - // true if a `100 Continue` response must be sent when `as_reader()` is called - must_send_continue: bool, - - // If Some, a message must be sent after responding - notify_when_responded: Option>, -} - -struct NotifyOnDrop { - sender: Sender<()>, - inner: R, -} - -impl Read for NotifyOnDrop { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.inner.read(buf) - } -} -impl Write for NotifyOnDrop { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.inner.write(buf) - } - fn flush(&mut self) -> io::Result<()> { - self.inner.flush() - } -} -impl Drop for NotifyOnDrop { - fn drop(&mut self) { - self.sender.send(()).unwrap(); - } -} - -/// Error that can happen when building a `Request` object. -#[derive(Debug)] -pub enum RequestCreationError { - /// The client sent an `Expect` header that was not recognized by tiny-http. - ExpectationFailed, - - /// Error while reading data from the socket during the creation of the `Request`. - CreationIoError(IoError), -} - -impl From for RequestCreationError { - fn from(err: IoError) -> RequestCreationError { - RequestCreationError::CreationIoError(err) - } -} - -/// Builds a new request. -/// -/// After the request line and headers have been read from the socket, a new `Request` object -/// is built. -/// -/// You must pass a `Read` that will allow the `Request` object to read from the incoming data. -/// It is the responsibility of the `Request` to read only the data of the request and not further. -/// -/// The `Write` object will be used by the `Request` to write the response. -#[allow(clippy::too_many_arguments)] -pub fn new_request( - secure: bool, - method: Method, - path: String, - version: HTTPVersion, - headers: Vec
, - remote_addr: Option, - mut source_data: R, - writer: W, -) -> Result -where - R: Read + Send + 'static, - W: Write + Send + 'static, -{ - // finding the transfer-encoding header - let transfer_encoding = headers - .iter() - .find(|h: &&Header| h.field.equiv("Transfer-Encoding")) - .map(|h| h.value.clone()); - - // finding the content-length header - let content_length = if transfer_encoding.is_some() { - // if transfer-encoding is specified, the Content-Length - // header must be ignored (RFC2616 #4.4) - None - } else { - headers - .iter() - .find(|h: &&Header| h.field.equiv("Content-Length")) - .and_then(|h| FromStr::from_str(h.value.as_str()).ok()) - }; - - // true if the client sent a `Expect: 100-continue` header - let expects_continue = { - match headers - .iter() - .find(|h: &&Header| h.field.equiv("Expect")) - .map(|h| h.value.as_str()) - { - None => false, - Some(v) if v.eq_ignore_ascii_case("100-continue") => true, - _ => return Err(RequestCreationError::ExpectationFailed), - } - }; - - // true if the client sent a `Connection: upgrade` header - let connection_upgrade = { - match headers - .iter() - .find(|h: &&Header| h.field.equiv("Connection")) - .map(|h| h.value.as_str()) - { - Some(v) if v.to_ascii_lowercase().contains("upgrade") => true, - _ => false, - } - }; - - // we wrap `source_data` around a reading whose nature depends on the transfer-encoding and - // content-length headers - let reader = if connection_upgrade { - // if we have a `Connection: upgrade`, always keeping the whole reader - Box::new(source_data) as Box - } else if let Some(content_length) = content_length { - if content_length == 0 { - Box::new(io::empty()) as Box - } else if content_length <= 1024 && !expects_continue { - // if the content-length is small enough, we just read everything into a buffer - - let mut buffer = vec![0; content_length]; - let mut offset = 0; - - while offset != content_length { - let read = source_data.read(&mut buffer[offset..])?; - if read == 0 { - // the socket returned EOF, but we were before the expected content-length - // aborting - let info = "Connection has been closed before we received enough data"; - let err = IoError::new(ErrorKind::ConnectionAborted, info); - return Err(RequestCreationError::CreationIoError(err)); - } - - offset += read; - } - - Box::new(Cursor::new(buffer)) as Box - } else { - let (data_reader, _) = EqualReader::new(source_data, content_length); // TODO: - Box::new(FusedReader::new(data_reader)) as Box - } - } else if transfer_encoding.is_some() { - // if a transfer-encoding was specified, then "chunked" is ALWAYS applied - // over the message (RFC2616 #3.6) - Box::new(FusedReader::new(Decoder::new(source_data))) as Box - } else { - // if we have neither a Content-Length nor a Transfer-Encoding, - // assuming that we have no data - // TODO: could also be multipart/byteranges - Box::new(io::empty()) as Box - }; - - Ok(Request { - data_reader: Some(reader), - response_writer: Some(Box::new(writer) as Box), - remote_addr, - secure, - method, - path, - http_version: version, - headers, - body_length: content_length, - must_send_continue: expects_continue, - notify_when_responded: None, - }) -} - -impl Request { - /// Returns true if the request was made through HTTPS. - #[inline] - pub fn secure(&self) -> bool { - self.secure - } - - /// Returns the method requested by the client (eg. `GET`, `POST`, etc.). - #[inline] - pub fn method(&self) -> &Method { - &self.method - } - - /// Returns the resource requested by the client. - #[inline] - pub fn url(&self) -> &str { - &self.path - } - - /// Returns a list of all headers sent by the client. - #[inline] - pub fn headers(&self) -> &[Header] { - &self.headers - } - - /// Returns the HTTP version of the request. - #[inline] - pub fn http_version(&self) -> &HTTPVersion { - &self.http_version - } - - /// Returns the length of the body in bytes. - /// - /// Returns `None` if the length is unknown. - #[inline] - pub fn body_length(&self) -> Option { - self.body_length - } - - /// Returns the address of the client that sent this request. - /// - /// The address is always `Some` for TCP listeners, but always `None` for UNIX listeners - /// (as the remote address of a UNIX client is almost always unnamed). - /// - /// Note that this is gathered from the socket. If you receive the request from a proxy, - /// this function will return the address of the proxy and not the address of the actual - /// user. - #[inline] - pub fn remote_addr(&self) -> Option<&SocketAddr> { - self.remote_addr.as_ref() - } - - /// Sends a response with a `Connection: upgrade` header, then turns the `Request` into a `Stream`. - /// - /// The main purpose of this function is to support websockets. - /// If you detect that the request wants to use some kind of protocol upgrade, you can - /// call this function to obtain full control of the socket stream. - /// - /// If you call this on a non-websocket request, tiny-http will wait until this `Stream` object - /// is destroyed before continuing to read or write on the socket. Therefore you should always - /// destroy it as soon as possible. - pub fn upgrade( - mut self, - protocol: &str, - response: Response, - ) -> Box { - use crate::util::CustomStream; - - response - .raw_print( - self.response_writer.as_mut().unwrap().by_ref(), - self.http_version.clone(), - &self.headers, - false, - Some(protocol), - ) - .ok(); // TODO: unused result - - self.response_writer.as_mut().unwrap().flush().ok(); // TODO: unused result - - let stream = CustomStream::new(self.extract_reader_impl(), self.extract_writer_impl()); - if let Some(sender) = self.notify_when_responded.take() { - let stream = NotifyOnDrop { - sender, - inner: stream, - }; - Box::new(stream) as Box - } else { - Box::new(stream) as Box - } - } - - /// Allows to read the body of the request. - /// - /// # Example - /// - /// ```no_run - /// # extern crate rustc_serialize; - /// # extern crate tiny_http; - /// # use rustc_serialize::json::Json; - /// # use std::io::Read; - /// # fn get_content_type(_: &tiny_http::Request) -> &'static str { "" } - /// # fn main() { - /// # let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - /// let mut request = server.recv().unwrap(); - /// - /// if get_content_type(&request) == "application/json" { - /// let mut content = String::new(); - /// request.as_reader().read_to_string(&mut content).unwrap(); - /// let json: Json = content.parse().unwrap(); - /// } - /// # } - /// ``` - /// - /// If the client sent a `Expect: 100-continue` header with the request, calling this - /// function will send back a `100 Continue` response. - #[inline] - pub fn as_reader(&mut self) -> &mut dyn Read { - if self.must_send_continue { - let msg = Response::new_empty(StatusCode(100)); - msg.raw_print( - self.response_writer.as_mut().unwrap().by_ref(), - self.http_version.clone(), - &self.headers, - true, - None, - ) - .ok(); - self.response_writer.as_mut().unwrap().flush().ok(); - self.must_send_continue = false; - } - - self.data_reader.as_mut().unwrap() - } - - /// Turns the `Request` into a writer. - /// - /// The writer has a raw access to the stream to the user. - /// This function is useful for things like CGI. - /// - /// Note that the destruction of the `Writer` object may trigger - /// some events. For exemple if a client has sent multiple requests and the requests - /// have been processed in parallel, the destruction of a writer will trigger - /// the writing of the next response. - /// Therefore you should always destroy the `Writer` as soon as possible. - #[inline] - pub fn into_writer(mut self) -> Box { - let writer = self.extract_writer_impl(); - if let Some(sender) = self.notify_when_responded.take() { - let writer = NotifyOnDrop { - sender, - inner: writer, - }; - Box::new(writer) as Box - } else { - writer - } - } - - /// Extract the response `Writer` object from the Request, dropping this `Writer` has the same side effects - /// as the object returned by `into_writer` above. - /// - /// This may only be called once on a single request. - fn extract_writer_impl(&mut self) -> Box { - use std::mem; - - assert!(self.response_writer.is_some()); - - let mut writer = None; - mem::swap(&mut self.response_writer, &mut writer); - writer.unwrap() - } - - /// Extract the body `Reader` object from the Request. - /// - /// This may only be called once on a single request. - fn extract_reader_impl(&mut self) -> Box { - use std::mem; - - assert!(self.data_reader.is_some()); - - let mut reader = None; - mem::swap(&mut self.data_reader, &mut reader); - reader.unwrap() - } - - /// Sends a response to this request. - #[inline] - pub fn respond(mut self, response: Response) -> Result<(), IoError> - where - R: Read, - { - let res = self.respond_impl(response); - if let Some(sender) = self.notify_when_responded.take() { - sender.send(()).unwrap(); - } - res - } - - fn respond_impl(&mut self, response: Response) -> Result<(), IoError> - where - R: Read, - { - let mut writer = self.extract_writer_impl(); - - let do_not_send_body = self.method == Method::Head; - - Self::ignore_client_closing_errors(response.raw_print( - writer.by_ref(), - self.http_version.clone(), - &self.headers, - do_not_send_body, - None, - ))?; - - Self::ignore_client_closing_errors(writer.flush()) - } - - fn ignore_client_closing_errors(result: io::Result<()>) -> io::Result<()> { - result.or_else(|err| match err.kind() { - ErrorKind::BrokenPipe => Ok(()), - ErrorKind::ConnectionAborted => Ok(()), - ErrorKind::ConnectionRefused => Ok(()), - ErrorKind::ConnectionReset => Ok(()), - _ => Err(err), - }) - } - - pub(crate) fn with_notify_sender(mut self, sender: Sender<()>) -> Self { - self.notify_when_responded = Some(sender); - self - } -} - -impl fmt::Debug for Request { - fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { - write!( - formatter, - "Request({} {} from {:?})", - self.method, self.path, self.remote_addr - ) - } -} - -impl Drop for Request { - fn drop(&mut self) { - if self.response_writer.is_some() { - let response = Response::empty(500); - let _ = self.respond_impl(response); // ignoring any potential error - if let Some(sender) = self.notify_when_responded.take() { - sender.send(()).unwrap(); - } - } - } -} - -/// Dummy trait that regroups the `Read` and `Write` traits. -/// -/// Automatically implemented on all types that implement both `Read` and `Write`. -pub trait ReadWrite: Read + Write {} -impl ReadWrite for T where T: Read + Write {} - -#[cfg(test)] -mod tests { - use super::Request; - - #[test] - fn must_be_send() { - #![allow(dead_code)] - fn f(_: &T) {} - fn bar(rq: &Request) { - f(rq); - } - } -} diff --git a/anneal/vendor/tiny_http/src/response.rs b/anneal/vendor/tiny_http/src/response.rs deleted file mode 100644 index aaedf5c76b..0000000000 --- a/anneal/vendor/tiny_http/src/response.rs +++ /dev/null @@ -1,574 +0,0 @@ -use crate::common::{HTTPVersion, Header, StatusCode}; -use httpdate::HttpDate; -use std::cmp::Ordering; -use std::sync::mpsc::Receiver; - -use std::io::Result as IoResult; -use std::io::{self, Cursor, Read, Write}; - -use std::fs::File; - -use std::str::FromStr; -use std::time::SystemTime; - -/// Object representing an HTTP response whose purpose is to be given to a `Request`. -/// -/// Some headers cannot be changed. Trying to define the value -/// of one of these will have no effect: -/// -/// - `Connection` -/// - `Trailer` -/// - `Transfer-Encoding` -/// - `Upgrade` -/// -/// Some headers have special behaviors: -/// -/// - `Content-Encoding`: If you define this header, the library -/// will assume that the data from the `Read` object has the specified encoding -/// and will just pass-through. -/// -/// - `Content-Length`: The length of the data should be set manually -/// using the `Reponse` object's API. Attempting to set the value of this -/// header will be equivalent to modifying the size of the data but the header -/// itself may not be present in the final result. -/// -/// - `Content-Type`: You may only set this header to one value at a time. If you -/// try to set it more than once, the existing value will be overwritten. This -/// behavior differs from the default for most headers, which is to allow them to -/// be set multiple times in the same response. -/// -pub struct Response { - reader: R, - status_code: StatusCode, - headers: Vec
, - data_length: Option, - chunked_threshold: Option, -} - -/// A `Response` without a template parameter. -pub type ResponseBox = Response>; - -/// Transfer encoding to use when sending the message. -/// Note that only *supported* encoding are listed here. -#[derive(Copy, Clone)] -enum TransferEncoding { - Identity, - Chunked, -} - -impl FromStr for TransferEncoding { - type Err = (); - - fn from_str(input: &str) -> Result { - if input.eq_ignore_ascii_case("identity") { - Ok(TransferEncoding::Identity) - } else if input.eq_ignore_ascii_case("chunked") { - Ok(TransferEncoding::Chunked) - } else { - Err(()) - } - } -} - -/// Builds a Date: header with the current date. -fn build_date_header() -> Header { - let d = HttpDate::from(SystemTime::now()); - Header::from_bytes(&b"Date"[..], &d.to_string().into_bytes()[..]).unwrap() -} - -fn write_message_header( - mut writer: W, - http_version: &HTTPVersion, - status_code: &StatusCode, - headers: &[Header], -) -> IoResult<()> -where - W: Write, -{ - // writing status line - write!( - &mut writer, - "HTTP/{}.{} {} {}\r\n", - http_version.0, - http_version.1, - status_code.0, - status_code.default_reason_phrase() - )?; - - // writing headers - for header in headers.iter() { - writer.write_all(header.field.as_str().as_ref())?; - write!(&mut writer, ": ")?; - writer.write_all(header.value.as_str().as_ref())?; - write!(&mut writer, "\r\n")?; - } - - // separator between header and data - write!(&mut writer, "\r\n")?; - - Ok(()) -} - -fn choose_transfer_encoding( - status_code: StatusCode, - request_headers: &[Header], - http_version: &HTTPVersion, - entity_length: &Option, - has_additional_headers: bool, - chunked_threshold: usize, -) -> TransferEncoding { - use crate::util; - - // HTTP 1.0 doesn't support other encoding - if *http_version <= (1, 0) { - return TransferEncoding::Identity; - } - - // Per section 3.3.1 of RFC7230: - // A server MUST NOT send a Transfer-Encoding header field in any response with a status code - // of 1xx (Informational) or 204 (No Content). - if status_code.0 < 200 || status_code.0 == 204 { - return TransferEncoding::Identity; - } - - // parsing the request's TE header - let user_request = request_headers - .iter() - // finding TE - .find(|h| h.field.equiv("TE")) - // getting its value - .map(|h| h.value.clone()) - // getting the corresponding TransferEncoding - .and_then(|value| { - // getting list of requested elements - let mut parse = util::parse_header_value(value.as_str()); // TODO: remove conversion - - // sorting elements by most priority - parse.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(Ordering::Equal)); - - // trying to parse each requested encoding - for value in parse.iter() { - // q=0 are ignored - if value.1 <= 0.0 { - continue; - } - - if let Ok(te) = TransferEncoding::from_str(value.0) { - return Some(te); - } - } - - // encoding not found - None - }); - - if let Some(user_request) = user_request { - return user_request; - } - - // if we have additional headers, using chunked - if has_additional_headers { - return TransferEncoding::Chunked; - } - - // if we don't have a Content-Length, or if the Content-Length is too big, using chunks writer - if entity_length - .as_ref() - .map_or(true, |val| *val >= chunked_threshold) - { - return TransferEncoding::Chunked; - } - - // Identity by default - TransferEncoding::Identity -} - -impl Response -where - R: Read, -{ - /// Creates a new Response object. - /// - /// The `additional_headers` argument is a receiver that - /// may provide headers even after the response has been sent. - /// - /// All the other arguments are straight-forward. - pub fn new( - status_code: StatusCode, - headers: Vec
, - data: R, - data_length: Option, - additional_headers: Option>, - ) -> Response { - let mut response = Response { - reader: data, - status_code, - headers: Vec::with_capacity(16), - data_length, - chunked_threshold: None, - }; - - for h in headers { - response.add_header(h) - } - - // dummy implementation - if let Some(additional_headers) = additional_headers { - for h in additional_headers.iter() { - response.add_header(h) - } - } - - response - } - - /// Set a threshold for `Content-Length` where we chose chunked - /// transfer. Notice that chunked transfer might happen regardless of - /// this threshold, for instance when the request headers indicate - /// it is wanted or when there is no `Content-Length`. - pub fn with_chunked_threshold(mut self, length: usize) -> Response { - self.chunked_threshold = Some(length); - self - } - - /// Convert the response into the underlying `Read` type. - /// - /// This is mainly useful for testing as it must consume the `Response`. - pub fn into_reader(self) -> R { - self.reader - } - - /// The current `Content-Length` threshold for switching over to - /// chunked transfer. The default is 32768 bytes. Notice that - /// chunked transfer is mutually exclusive with sending a - /// `Content-Length` header as per the HTTP spec. - pub fn chunked_threshold(&self) -> usize { - self.chunked_threshold.unwrap_or(32768) - } - - /// Adds a header to the list. - /// Does all the checks. - pub fn add_header(&mut self, header: H) - where - H: Into
, - { - let header = header.into(); - - // ignoring forbidden headers - if header.field.equiv("Connection") - || header.field.equiv("Trailer") - || header.field.equiv("Transfer-Encoding") - || header.field.equiv("Upgrade") - { - return; - } - - // if the header is Content-Length, setting the data length - if header.field.equiv("Content-Length") { - if let Ok(val) = usize::from_str(header.value.as_str()) { - self.data_length = Some(val) - } - - return; - // if the header is Content-Type and it's already set, overwrite it - } else if header.field.equiv("Content-Type") { - if let Some(content_type_header) = self - .headers - .iter_mut() - .find(|h| h.field.equiv("Content-Type")) - { - content_type_header.value = header.value; - return; - } - } - - self.headers.push(header); - } - - /// Returns the same request, but with an additional header. - /// - /// Some headers cannot be modified and some other have a - /// special behavior. See the documentation above. - #[inline] - pub fn with_header(mut self, header: H) -> Response - where - H: Into
, - { - self.add_header(header.into()); - self - } - - /// Returns the same request, but with a different status code. - #[inline] - pub fn with_status_code(mut self, code: S) -> Response - where - S: Into, - { - self.status_code = code.into(); - self - } - - /// Returns the same request, but with different data. - pub fn with_data(self, reader: S, data_length: Option) -> Response - where - S: Read, - { - Response { - reader, - headers: self.headers, - status_code: self.status_code, - data_length, - chunked_threshold: self.chunked_threshold, - } - } - - /// Prints the HTTP response to a writer. - /// - /// This function is the one used to send the response to the client's socket. - /// Therefore you shouldn't expect anything pretty-printed or even readable. - /// - /// The HTTP version and headers passed as arguments are used to - /// decide which features (most notably, encoding) to use. - /// - /// Note: does not flush the writer. - pub fn raw_print( - mut self, - mut writer: W, - http_version: HTTPVersion, - request_headers: &[Header], - do_not_send_body: bool, - upgrade: Option<&str>, - ) -> IoResult<()> { - let mut transfer_encoding = Some(choose_transfer_encoding( - self.status_code, - request_headers, - &http_version, - &self.data_length, - false, /* TODO */ - self.chunked_threshold(), - )); - - // add `Date` if not in the headers - if !self.headers.iter().any(|h| h.field.equiv("Date")) { - self.headers.insert(0, build_date_header()); - } - - // add `Server` if not in the headers - if !self.headers.iter().any(|h| h.field.equiv("Server")) { - self.headers.insert( - 0, - Header::from_bytes(&b"Server"[..], &b"tiny-http (Rust)"[..]).unwrap(), - ); - } - - // handling upgrade - if let Some(upgrade) = upgrade { - self.headers.insert( - 0, - Header::from_bytes(&b"Upgrade"[..], upgrade.as_bytes()).unwrap(), - ); - self.headers.insert( - 0, - Header::from_bytes(&b"Connection"[..], &b"upgrade"[..]).unwrap(), - ); - transfer_encoding = None; - } - - // if the transfer encoding is identity, the content length must be known ; therefore if - // we don't know it, we buffer the entire response first here - // while this is an expensive operation, it is only ever needed for clients using HTTP 1.0 - let (mut reader, data_length): (Box, _) = - match (self.data_length, transfer_encoding) { - (Some(l), _) => (Box::new(self.reader), Some(l)), - (None, Some(TransferEncoding::Identity)) => { - let mut buf = Vec::new(); - self.reader.read_to_end(&mut buf)?; - let l = buf.len(); - (Box::new(Cursor::new(buf)), Some(l)) - } - _ => (Box::new(self.reader), None), - }; - - // checking whether to ignore the body of the response - let do_not_send_body = do_not_send_body - || match self.status_code.0 { - // status code 1xx, 204 and 304 MUST not include a body - 100..=199 | 204 | 304 => true, - _ => false, - }; - - // preparing headers for transfer - match transfer_encoding { - Some(TransferEncoding::Chunked) => self - .headers - .push(Header::from_bytes(&b"Transfer-Encoding"[..], &b"chunked"[..]).unwrap()), - - Some(TransferEncoding::Identity) => { - assert!(data_length.is_some()); - let data_length = data_length.unwrap(); - - self.headers.push( - Header::from_bytes( - &b"Content-Length"[..], - format!("{}", data_length).as_bytes(), - ) - .unwrap(), - ) - } - - _ => (), - }; - - // sending headers - write_message_header( - writer.by_ref(), - &http_version, - &self.status_code, - &self.headers, - )?; - - // sending the body - if !do_not_send_body { - match transfer_encoding { - Some(TransferEncoding::Chunked) => { - use chunked_transfer::Encoder; - - let mut writer = Encoder::new(writer); - io::copy(&mut reader, &mut writer)?; - } - - Some(TransferEncoding::Identity) => { - assert!(data_length.is_some()); - let data_length = data_length.unwrap(); - - if data_length >= 1 { - io::copy(&mut reader, &mut writer)?; - } - } - - _ => (), - } - } - - Ok(()) - } - - /// Retrieves the current value of the `Response` status code - pub fn status_code(&self) -> StatusCode { - self.status_code - } - - /// Retrieves the current value of the `Response` data length - pub fn data_length(&self) -> Option { - self.data_length - } - - /// Retrieves the current list of `Response` headers - pub fn headers(&self) -> &[Header] { - &self.headers - } -} - -impl Response -where - R: Read + Send + 'static, -{ - /// Turns this response into a `Response>`. - pub fn boxed(self) -> ResponseBox { - Response { - reader: Box::new(self.reader) as Box, - status_code: self.status_code, - headers: self.headers, - data_length: self.data_length, - chunked_threshold: self.chunked_threshold, - } - } -} - -impl Response { - /// Builds a new `Response` from a `File`. - /// - /// The `Content-Type` will **not** be automatically detected, - /// you must set it yourself. - pub fn from_file(file: File) -> Response { - let file_size = file.metadata().ok().map(|v| v.len() as usize); - - Response::new( - StatusCode(200), - Vec::with_capacity(0), - file, - file_size, - None, - ) - } -} - -impl Response>> { - pub fn from_data(data: D) -> Response>> - where - D: Into>, - { - let data = data.into(); - let data_len = data.len(); - - Response::new( - StatusCode(200), - Vec::with_capacity(0), - Cursor::new(data), - Some(data_len), - None, - ) - } - - pub fn from_string(data: S) -> Response>> - where - S: Into, - { - let data = data.into(); - let data_len = data.len(); - - Response::new( - StatusCode(200), - vec![ - Header::from_bytes(&b"Content-Type"[..], &b"text/plain; charset=UTF-8"[..]) - .unwrap(), - ], - Cursor::new(data.into_bytes()), - Some(data_len), - None, - ) - } -} - -impl Response { - /// Builds an empty `Response` with the given status code. - pub fn empty(status_code: S) -> Response - where - S: Into, - { - Response::new( - status_code.into(), - Vec::with_capacity(0), - io::empty(), - Some(0), - None, - ) - } - - /// DEPRECATED. Use `empty` instead. - pub fn new_empty(status_code: StatusCode) -> Response { - Response::empty(status_code) - } -} - -impl Clone for Response { - fn clone(&self) -> Response { - Response { - reader: io::empty(), - status_code: self.status_code, - headers: self.headers.clone(), - data_length: self.data_length, - chunked_threshold: self.chunked_threshold, - } - } -} diff --git a/anneal/vendor/tiny_http/src/ssl.rs b/anneal/vendor/tiny_http/src/ssl.rs deleted file mode 100644 index d4a8f1b914..0000000000 --- a/anneal/vendor/tiny_http/src/ssl.rs +++ /dev/null @@ -1,20 +0,0 @@ -//! Modules providing SSL/TLS implementations. For backwards compatibility, OpenSSL is the default -//! implementation, but Rustls is highly recommended as a pure Rust alternative. -//! -//! In order to simplify the swappable implementations these SSL/TLS modules adhere to an implicit -//! trait contract and specific implementations are re-exported as [`SslContextImpl`] and [`SslStream`]. -//! The concrete type of these aliases will depend on which module you enable in `Cargo.toml`. - -#[cfg(feature = "ssl-openssl")] -pub(crate) mod openssl; -#[cfg(feature = "ssl-openssl")] -pub(crate) use self::openssl::OpenSslContext as SslContextImpl; -#[cfg(feature = "ssl-openssl")] -pub(crate) use self::openssl::SplitOpenSslStream as SslStream; - -#[cfg(feature = "ssl-rustls")] -pub(crate) mod rustls; -#[cfg(feature = "ssl-rustls")] -pub(crate) use self::rustls::RustlsContext as SslContextImpl; -#[cfg(feature = "ssl-rustls")] -pub(crate) use self::rustls::RustlsStream as SslStream; diff --git a/anneal/vendor/tiny_http/src/ssl/openssl.rs b/anneal/vendor/tiny_http/src/ssl/openssl.rs deleted file mode 100644 index 55d4650096..0000000000 --- a/anneal/vendor/tiny_http/src/ssl/openssl.rs +++ /dev/null @@ -1,110 +0,0 @@ -use crate::connection::Connection; -use crate::util::refined_tcp_stream::Stream as RefinedStream; -use std::error::Error; -use std::io::{Read, Write}; -use std::net::{Shutdown, SocketAddr}; -use std::sync::{Arc, Mutex}; -use zeroize::Zeroizing; - -pub(crate) struct OpenSslStream { - inner: openssl::ssl::SslStream, -} - -/// An OpenSSL stream which has been split into two mutually exclusive streams (e.g. for read / write) -pub(crate) struct SplitOpenSslStream(Arc>); - -// These struct methods form the implict contract for swappable TLS implementations -impl SplitOpenSslStream { - pub(crate) fn peer_addr(&mut self) -> std::io::Result> { - self.0.lock().unwrap().inner.get_mut().peer_addr() - } - - pub(crate) fn shutdown(&mut self, how: Shutdown) -> std::io::Result<()> { - self.0.lock().unwrap().inner.get_mut().shutdown(how) - } -} - -impl Clone for SplitOpenSslStream { - fn clone(&self) -> Self { - Self(self.0.clone()) - } -} - -impl Read for SplitOpenSslStream { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - self.0.lock().unwrap().read(buf) - } -} - -impl Write for SplitOpenSslStream { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - self.0.lock().unwrap().write(buf) - } - - fn flush(&mut self) -> std::io::Result<()> { - self.0.lock().unwrap().flush() - } -} - -impl Read for OpenSslStream { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - self.inner.read(buf) - } -} - -impl Write for OpenSslStream { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - self.inner.write(buf) - } - - fn flush(&mut self) -> std::io::Result<()> { - self.inner.flush() - } -} - -pub(crate) struct OpenSslContext(openssl::ssl::SslContext); - -impl OpenSslContext { - pub fn from_pem( - certificates: Vec, - private_key: Zeroizing>, - ) -> Result> { - use openssl::pkey::PKey; - use openssl::ssl::{self, SslVerifyMode}; - use openssl::x509::X509; - - let mut ctx = openssl::ssl::SslContext::builder(ssl::SslMethod::tls())?; - ctx.set_cipher_list("DEFAULT")?; - let certificate_chain = X509::stack_from_pem(&certificates)?; - if certificate_chain.is_empty() { - return Err("Couldn't extract certificate chain from config.".into()); - } - // The leaf certificate must always be first in the PEM file - ctx.set_certificate(&certificate_chain[0])?; - for chain_cert in certificate_chain.into_iter().skip(1) { - ctx.add_extra_chain_cert(chain_cert)?; - } - let key = PKey::private_key_from_pem(&private_key)?; - ctx.set_private_key(&key)?; - ctx.set_verify(SslVerifyMode::NONE); - ctx.check_private_key()?; - - Ok(Self(ctx.build())) - } - - pub fn accept( - &self, - stream: Connection, - ) -> Result> { - use openssl::ssl::Ssl; - let session = Ssl::new(&self.0).expect("Failed to create new OpenSSL session"); - let stream = session.accept(stream)?; - Ok(OpenSslStream { inner: stream }) - } -} - -impl From for RefinedStream { - fn from(stream: OpenSslStream) -> Self { - RefinedStream::Https(SplitOpenSslStream(Arc::new(Mutex::new(stream)))) - } -} diff --git a/anneal/vendor/tiny_http/src/ssl/rustls.rs b/anneal/vendor/tiny_http/src/ssl/rustls.rs deleted file mode 100644 index ccc6fdf466..0000000000 --- a/anneal/vendor/tiny_http/src/ssl/rustls.rs +++ /dev/null @@ -1,120 +0,0 @@ -use crate::connection::Connection; -use crate::util::refined_tcp_stream::Stream as RefinedStream; -use std::error::Error; -use std::io::{Read, Write}; -use std::net::{Shutdown, SocketAddr}; -use std::sync::{Arc, Mutex}; -use zeroize::Zeroizing; - -/// A wrapper around an owned Rustls connection and corresponding stream. -/// -/// Uses an internal Mutex to permit disparate reader & writer threads to access the stream independently. -pub(crate) struct RustlsStream( - Arc>>, -); - -impl RustlsStream { - pub(crate) fn peer_addr(&mut self) -> std::io::Result> { - self.0 - .lock() - .expect("Failed to lock SSL stream mutex") - .sock - .peer_addr() - } - - pub(crate) fn shutdown(&mut self, how: Shutdown) -> std::io::Result<()> { - self.0 - .lock() - .expect("Failed to lock SSL stream mutex") - .sock - .shutdown(how) - } -} - -impl Clone for RustlsStream { - fn clone(&self) -> Self { - Self(self.0.clone()) - } -} - -impl Read for RustlsStream { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - self.0 - .lock() - .expect("Failed to lock SSL stream mutex") - .read(buf) - } -} - -impl Write for RustlsStream { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - self.0 - .lock() - .expect("Failed to lock SSL stream mutex") - .write(buf) - } - - fn flush(&mut self) -> std::io::Result<()> { - self.0 - .lock() - .expect("Failed to lock SSL stream mutex") - .flush() - } -} - -pub(crate) struct RustlsContext(Arc); - -impl RustlsContext { - pub(crate) fn from_pem( - certificates: Vec, - private_key: Zeroizing>, - ) -> Result> { - let certificate_chain: Vec = - rustls_pemfile::certs(&mut certificates.as_slice())? - .into_iter() - .map(|bytes| rustls::Certificate(bytes)) - .collect(); - - if certificate_chain.is_empty() { - return Err("Couldn't extract certificate chain from config.".into()); - } - - let private_key = rustls::PrivateKey({ - let pkcs8_keys = rustls_pemfile::pkcs8_private_keys( - &mut private_key.clone().as_slice(), - ) - .expect("file contains invalid pkcs8 private key (encrypted keys are not supported)"); - - if let Some(pkcs8_key) = pkcs8_keys.first() { - pkcs8_key.clone() - } else { - let rsa_keys = rustls_pemfile::rsa_private_keys(&mut private_key.as_slice()) - .expect("file contains invalid rsa private key"); - rsa_keys[0].clone() - } - }); - - let tls_conf = rustls::ServerConfig::builder() - .with_safe_defaults() - .with_no_client_auth() - .with_single_cert(certificate_chain, private_key)?; - - Ok(Self(Arc::new(tls_conf))) - } - - pub(crate) fn accept( - &self, - stream: Connection, - ) -> Result> { - let connection = rustls::ServerConnection::new(self.0.clone())?; - Ok(RustlsStream(Arc::new(Mutex::new( - rustls::StreamOwned::new(connection, stream), - )))) - } -} - -impl From for RefinedStream { - fn from(stream: RustlsStream) -> Self { - Self::Https(stream) - } -} diff --git a/anneal/vendor/tiny_http/src/test.rs b/anneal/vendor/tiny_http/src/test.rs deleted file mode 100644 index 996f025678..0000000000 --- a/anneal/vendor/tiny_http/src/test.rs +++ /dev/null @@ -1,127 +0,0 @@ -use crate::{request::new_request, HTTPVersion, Header, HeaderField, Method, Request}; -use ascii::AsciiString; -use std::net::SocketAddr; -use std::str::FromStr; - -/// A simpler version of [`Request`] that is useful for testing. No data actually goes anywhere. -/// -/// By default, `TestRequest` pretends to be an insecure GET request for the server root (`/`) -/// with no headers. To create a `TestRequest` with different parameters, use the builder pattern: -/// -/// ``` -/// # use tiny_http::{Method, TestRequest}; -/// let request = TestRequest::new() -/// .with_method(Method::Post) -/// .with_path("/api/widgets") -/// .with_body("42"); -/// ``` -/// -/// Then, convert the `TestRequest` into a real `Request` and pass it to the server under test: -/// -/// ``` -/// # use tiny_http::{Method, Request, Response, Server, StatusCode, TestRequest}; -/// # use std::io::Cursor; -/// # let request = TestRequest::new() -/// # .with_method(Method::Post) -/// # .with_path("/api/widgets") -/// # .with_body("42"); -/// # struct TestServer { -/// # listener: Server, -/// # } -/// # let server = TestServer { -/// # listener: Server::http("0.0.0.0:0").unwrap(), -/// # }; -/// # impl TestServer { -/// # fn handle_request(&self, request: Request) -> Response>> { -/// # Response::from_string("test") -/// # } -/// # } -/// let response = server.handle_request(request.into()); -/// assert_eq!(response.status_code(), StatusCode(200)); -/// ``` -pub struct TestRequest { - body: &'static str, - remote_addr: SocketAddr, - // true if HTTPS, false if HTTP - secure: bool, - method: Method, - path: String, - http_version: HTTPVersion, - headers: Vec
, -} - -impl From for Request { - fn from(mut mock: TestRequest) -> Request { - // if the user didn't set the Content-Length header, then set it for them - // otherwise, leave it alone (it may be under test) - if !mock - .headers - .iter_mut() - .any(|h| h.field.equiv("Content-Length")) - { - mock.headers.push(Header { - field: HeaderField::from_str("Content-Length").unwrap(), - value: AsciiString::from_ascii(mock.body.len().to_string()).unwrap(), - }); - } - new_request( - mock.secure, - mock.method, - mock.path, - mock.http_version, - mock.headers, - Some(mock.remote_addr), - mock.body.as_bytes(), - std::io::sink(), - ) - .unwrap() - } -} - -impl Default for TestRequest { - fn default() -> Self { - TestRequest { - body: "", - remote_addr: "127.0.0.1:23456".parse().unwrap(), - secure: false, - method: Method::Get, - path: "/".to_string(), - http_version: HTTPVersion::from((1, 1)), - headers: Vec::new(), - } - } -} - -impl TestRequest { - pub fn new() -> Self { - TestRequest::default() - } - pub fn with_body(mut self, body: &'static str) -> Self { - self.body = body; - self - } - pub fn with_remote_addr(mut self, remote_addr: SocketAddr) -> Self { - self.remote_addr = remote_addr; - self - } - pub fn with_https(mut self) -> Self { - self.secure = true; - self - } - pub fn with_method(mut self, method: Method) -> Self { - self.method = method; - self - } - pub fn with_path(mut self, path: &str) -> Self { - self.path = path.to_string(); - self - } - pub fn with_http_version(mut self, version: HTTPVersion) -> Self { - self.http_version = version; - self - } - pub fn with_header(mut self, header: Header) -> Self { - self.headers.push(header); - self - } -} diff --git a/anneal/vendor/tiny_http/src/util/custom_stream.rs b/anneal/vendor/tiny_http/src/util/custom_stream.rs deleted file mode 100644 index ac00b9efc7..0000000000 --- a/anneal/vendor/tiny_http/src/util/custom_stream.rs +++ /dev/null @@ -1,39 +0,0 @@ -use std::io::Result as IoResult; -use std::io::{Read, Write}; - -pub struct CustomStream { - reader: R, - writer: W, -} - -impl CustomStream -where - R: Read, - W: Write, -{ - pub fn new(reader: R, writer: W) -> CustomStream { - CustomStream { reader, writer } - } -} - -impl Read for CustomStream -where - R: Read, -{ - fn read(&mut self, buf: &mut [u8]) -> IoResult { - self.reader.read(buf) - } -} - -impl Write for CustomStream -where - W: Write, -{ - fn write(&mut self, buf: &[u8]) -> IoResult { - self.writer.write(buf) - } - - fn flush(&mut self) -> IoResult<()> { - self.writer.flush() - } -} diff --git a/anneal/vendor/tiny_http/src/util/equal_reader.rs b/anneal/vendor/tiny_http/src/util/equal_reader.rs deleted file mode 100644 index 1305bc5fd7..0000000000 --- a/anneal/vendor/tiny_http/src/util/equal_reader.rs +++ /dev/null @@ -1,131 +0,0 @@ -use std::io::Read; -use std::io::Result as IoResult; -use std::sync::mpsc::channel; -use std::sync::mpsc::{Receiver, Sender}; - -/// A `Reader` that reads exactly the number of bytes from a sub-reader. -/// -/// If the limit is reached, it returns EOF. If the limit is not reached -/// when the destructor is called, the remaining bytes will be read and -/// thrown away. -pub struct EqualReader -where - R: Read, -{ - reader: R, - size: usize, - last_read_signal: Sender>, -} - -impl EqualReader -where - R: Read, -{ - pub fn new(reader: R, size: usize) -> (EqualReader, Receiver>) { - let (tx, rx) = channel(); - - let r = EqualReader { - reader, - size, - last_read_signal: tx, - }; - - (r, rx) - } -} - -impl Read for EqualReader -where - R: Read, -{ - fn read(&mut self, buf: &mut [u8]) -> IoResult { - if self.size == 0 { - return Ok(0); - } - - let buf = if buf.len() < self.size { - buf - } else { - &mut buf[..self.size] - }; - - match self.reader.read(buf) { - Ok(len) => { - self.size -= len; - Ok(len) - } - err @ Err(_) => err, - } - } -} - -impl Drop for EqualReader -where - R: Read, -{ - fn drop(&mut self) { - let mut remaining_to_read = self.size; - - while remaining_to_read > 0 { - let mut buf = vec![0; remaining_to_read]; - - match self.reader.read(&mut buf) { - Err(e) => { - self.last_read_signal.send(Err(e)).ok(); - break; - } - Ok(0) => { - self.last_read_signal.send(Ok(())).ok(); - break; - } - Ok(other) => { - remaining_to_read -= other; - } - } - } - } -} - -#[cfg(test)] -mod tests { - use super::EqualReader; - use std::io::Read; - - #[test] - fn test_limit() { - use std::io::Cursor; - - let mut org_reader = Cursor::new("hello world".to_string().into_bytes()); - - { - let (mut equal_reader, _) = EqualReader::new(org_reader.by_ref(), 5); - - let mut string = String::new(); - equal_reader.read_to_string(&mut string).unwrap(); - assert_eq!(string, "hello"); - } - - let mut string = String::new(); - org_reader.read_to_string(&mut string).unwrap(); - assert_eq!(string, " world"); - } - - #[test] - fn test_not_enough() { - use std::io::Cursor; - - let mut org_reader = Cursor::new("hello world".to_string().into_bytes()); - - { - let (mut equal_reader, _) = EqualReader::new(org_reader.by_ref(), 5); - - let mut vec = [0]; - equal_reader.read_exact(&mut vec).unwrap(); - assert_eq!(vec[0], b'h'); - } - - let mut string = String::new(); - org_reader.read_to_string(&mut string).unwrap(); - assert_eq!(string, " world"); - } -} diff --git a/anneal/vendor/tiny_http/src/util/fused_reader.rs b/anneal/vendor/tiny_http/src/util/fused_reader.rs deleted file mode 100644 index 6300387946..0000000000 --- a/anneal/vendor/tiny_http/src/util/fused_reader.rs +++ /dev/null @@ -1,48 +0,0 @@ -use std::io::{IoSliceMut, Read, Result as IoResult}; - -/// Wraps another reader and provides "fused" behavior. -/// When the underlying reader reaches EOF, it is dropped -/// and the fused reader becomes an empty stub. -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct FusedReader { - inner: Option, -} - -impl FusedReader { - pub fn new(inner: R) -> Self { - Self { inner: Some(inner) } - } - - #[allow(dead_code)] - pub fn into_inner(self) -> Option { - self.inner - } -} - -impl Read for FusedReader { - fn read(&mut self, buf: &mut [u8]) -> IoResult { - match &mut self.inner { - Some(r) => { - let l = r.read(buf)?; - if l == 0 { - self.inner = None; - } - Ok(l) - } - None => Ok(0), - } - } - - fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> IoResult { - match &mut self.inner { - Some(r) => { - let l = r.read_vectored(bufs)?; - if l == 0 { - self.inner = None; - } - Ok(l) - } - None => Ok(0), - } - } -} diff --git a/anneal/vendor/tiny_http/src/util/messages_queue.rs b/anneal/vendor/tiny_http/src/util/messages_queue.rs deleted file mode 100644 index d94e7dbb74..0000000000 --- a/anneal/vendor/tiny_http/src/util/messages_queue.rs +++ /dev/null @@ -1,96 +0,0 @@ -use std::collections::VecDeque; -use std::sync::{Arc, Condvar, Mutex}; -use std::time::{Duration, Instant}; - -enum Control { - Elem(T), - Unblock, -} - -pub struct MessagesQueue -where - T: Send, -{ - queue: Mutex>>, - condvar: Condvar, -} - -impl MessagesQueue -where - T: Send, -{ - pub fn with_capacity(capacity: usize) -> Arc> { - Arc::new(MessagesQueue { - queue: Mutex::new(VecDeque::with_capacity(capacity)), - condvar: Condvar::new(), - }) - } - - /// Pushes an element to the queue. - pub fn push(&self, value: T) { - let mut queue = self.queue.lock().unwrap(); - queue.push_back(Control::Elem(value)); - self.condvar.notify_one(); - } - - /// Unblock one thread stuck in pop loop. - pub fn unblock(&self) { - let mut queue = self.queue.lock().unwrap(); - queue.push_back(Control::Unblock); - self.condvar.notify_one(); - } - - /// Pops an element. Blocks until one is available. - /// Returns None in case unblock() was issued. - pub fn pop(&self) -> Option { - let mut queue = self.queue.lock().unwrap(); - - loop { - match queue.pop_front() { - Some(Control::Elem(value)) => return Some(value), - Some(Control::Unblock) => return None, - None => (), - } - - queue = self.condvar.wait(queue).unwrap(); - } - } - - /// Tries to pop an element without blocking. - pub fn try_pop(&self) -> Option { - let mut queue = self.queue.lock().unwrap(); - match queue.pop_front() { - Some(Control::Elem(value)) => Some(value), - Some(Control::Unblock) | None => None, - } - } - - /// Tries to pop an element without blocking - /// more than the specified timeout duration - /// or unblock() was issued - pub fn pop_timeout(&self, timeout: Duration) -> Option { - let mut queue = self.queue.lock().unwrap(); - let mut duration = timeout; - loop { - match queue.pop_front() { - Some(Control::Elem(value)) => return Some(value), - Some(Control::Unblock) => return None, - None => (), - } - let now = Instant::now(); - let (_queue, result) = self.condvar.wait_timeout(queue, timeout).unwrap(); - queue = _queue; - let sleep_time = now.elapsed(); - duration = if duration > sleep_time { - duration - sleep_time - } else { - Duration::from_millis(0) - }; - if result.timed_out() - || (duration.as_secs() == 0 && duration.subsec_nanos() < 1_000_000) - { - return None; - } - } - } -} diff --git a/anneal/vendor/tiny_http/src/util/mod.rs b/anneal/vendor/tiny_http/src/util/mod.rs deleted file mode 100644 index 4fb2aca5c3..0000000000 --- a/anneal/vendor/tiny_http/src/util/mod.rs +++ /dev/null @@ -1,64 +0,0 @@ -pub use self::custom_stream::CustomStream; -pub use self::equal_reader::EqualReader; -pub use self::fused_reader::FusedReader; -pub use self::messages_queue::MessagesQueue; -pub use self::refined_tcp_stream::RefinedTcpStream; -pub use self::sequential::{SequentialReader, SequentialReaderBuilder}; -pub use self::sequential::{SequentialWriter, SequentialWriterBuilder}; -pub use self::task_pool::TaskPool; - -use std::str::FromStr; - -mod custom_stream; -mod equal_reader; -mod fused_reader; -mod messages_queue; -pub(crate) mod refined_tcp_stream; -mod sequential; -mod task_pool; - -/// Parses a the value of a header. -/// Suitable for `Accept-*`, `TE`, etc. -/// -/// For example with `text/plain, image/png; q=1.5` this function would -/// return `[ ("text/plain", 1.0), ("image/png", 1.5) ]` -pub fn parse_header_value(input: &str) -> Vec<(&str, f32)> { - input - .split(',') - .filter_map(|elem| { - let mut params = elem.split(';'); - - let t = params.next()?; - - let mut value = 1.0_f32; - - for p in params { - if p.trim_start().starts_with("q=") { - if let Ok(val) = f32::from_str(p.trim_start()[2..].trim()) { - value = val; - break; - } - } - } - - Some((t.trim(), value)) - }) - .collect() -} - -#[cfg(test)] -mod test { - #[test] - #[allow(clippy::float_cmp)] - fn test_parse_header() { - let result = super::parse_header_value("text/html, text/plain; q=1.5 , image/png ; q=2.0"); - - assert_eq!(result.len(), 3); - assert_eq!(result[0].0, "text/html"); - assert_eq!(result[0].1, 1.0); - assert_eq!(result[1].0, "text/plain"); - assert_eq!(result[1].1, 1.5); - assert_eq!(result[2].0, "image/png"); - assert_eq!(result[2].1, 2.0); - } -} diff --git a/anneal/vendor/tiny_http/src/util/refined_tcp_stream.rs b/anneal/vendor/tiny_http/src/util/refined_tcp_stream.rs deleted file mode 100644 index 875fbe2fba..0000000000 --- a/anneal/vendor/tiny_http/src/util/refined_tcp_stream.rs +++ /dev/null @@ -1,152 +0,0 @@ -use std::io::Result as IoResult; -use std::io::{Read, Write}; -use std::net::{Shutdown, SocketAddr}; - -use crate::connection::Connection; -#[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] -use crate::ssl::SslStream; - -pub(crate) enum Stream { - Http(Connection), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Https(SslStream), -} - -impl Clone for Stream { - fn clone(&self) -> Self { - match self { - Stream::Http(tcp_stream) => Stream::Http(tcp_stream.try_clone().unwrap()), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => Stream::Https(ssl_stream.clone()), - } - } -} - -impl From for Stream { - fn from(tcp_stream: Connection) -> Self { - Stream::Http(tcp_stream) - } -} - -impl Stream { - fn secure(&self) -> bool { - match self { - Stream::Http(_) => false, - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(_) => true, - } - } - - fn peer_addr(&mut self) -> IoResult> { - match self { - Stream::Http(tcp_stream) => tcp_stream.peer_addr(), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => ssl_stream.peer_addr(), - } - } - - fn shutdown(&mut self, how: Shutdown) -> IoResult<()> { - match self { - Stream::Http(tcp_stream) => tcp_stream.shutdown(how), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => ssl_stream.shutdown(how), - } - } -} - -impl Read for Stream { - fn read(&mut self, buf: &mut [u8]) -> IoResult { - match self { - Stream::Http(tcp_stream) => tcp_stream.read(buf), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => ssl_stream.read(buf), - } - } -} - -impl Write for Stream { - fn write(&mut self, buf: &[u8]) -> IoResult { - match self { - Stream::Http(tcp_stream) => tcp_stream.write(buf), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => ssl_stream.write(buf), - } - } - - fn flush(&mut self) -> IoResult<()> { - match self { - Stream::Http(tcp_stream) => tcp_stream.flush(), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => ssl_stream.flush(), - } - } -} - -pub struct RefinedTcpStream { - stream: Stream, - close_read: bool, - close_write: bool, -} - -impl RefinedTcpStream { - pub(crate) fn new(stream: S) -> (RefinedTcpStream, RefinedTcpStream) - where - S: Into, - { - let stream: Stream = stream.into(); - - let (read, write) = (stream.clone(), stream); - - let read = RefinedTcpStream { - stream: read, - close_read: true, - close_write: false, - }; - - let write = RefinedTcpStream { - stream: write, - close_read: false, - close_write: true, - }; - - (read, write) - } - - /// Returns true if this struct wraps around a secure connection. - #[inline] - pub(crate) fn secure(&self) -> bool { - self.stream.secure() - } - - pub(crate) fn peer_addr(&mut self) -> IoResult> { - self.stream.peer_addr() - } -} - -impl Drop for RefinedTcpStream { - fn drop(&mut self) { - if self.close_read { - self.stream.shutdown(Shutdown::Read).ok(); - } - - if self.close_write { - self.stream.shutdown(Shutdown::Write).ok(); - } - } -} - -impl Read for RefinedTcpStream { - fn read(&mut self, buf: &mut [u8]) -> IoResult { - self.stream.read(buf) - } -} - -impl Write for RefinedTcpStream { - fn write(&mut self, buf: &[u8]) -> IoResult { - self.stream.write(buf) - } - - fn flush(&mut self) -> IoResult<()> { - self.stream.flush() - } -} diff --git a/anneal/vendor/tiny_http/src/util/sequential.rs b/anneal/vendor/tiny_http/src/util/sequential.rs deleted file mode 100644 index 8ecc3b93fd..0000000000 --- a/anneal/vendor/tiny_http/src/util/sequential.rs +++ /dev/null @@ -1,174 +0,0 @@ -use std::io::Result as IoResult; -use std::io::{Read, Write}; - -use std::sync::mpsc::channel; -use std::sync::mpsc::{Receiver, Sender}; -use std::sync::{Arc, Mutex}; - -use std::mem; - -pub struct SequentialReaderBuilder -where - R: Read + Send, -{ - inner: SequentialReaderBuilderInner, -} - -enum SequentialReaderBuilderInner -where - R: Read + Send, -{ - First(R), - NotFirst(Receiver), -} - -pub struct SequentialReader -where - R: Read + Send, -{ - inner: SequentialReaderInner, - next: Sender, -} - -enum SequentialReaderInner -where - R: Read + Send, -{ - MyTurn(R), - Waiting(Receiver), - Empty, -} - -pub struct SequentialWriterBuilder -where - W: Write + Send, -{ - writer: Arc>, - next_trigger: Option>, -} - -pub struct SequentialWriter -where - W: Write + Send, -{ - trigger: Option>, - writer: Arc>, - on_finish: Sender<()>, -} - -impl SequentialReaderBuilder { - pub fn new(reader: R) -> SequentialReaderBuilder { - SequentialReaderBuilder { - inner: SequentialReaderBuilderInner::First(reader), - } - } -} - -impl SequentialWriterBuilder { - pub fn new(writer: W) -> SequentialWriterBuilder { - SequentialWriterBuilder { - writer: Arc::new(Mutex::new(writer)), - next_trigger: None, - } - } -} - -impl Iterator for SequentialReaderBuilder { - type Item = SequentialReader; - - fn next(&mut self) -> Option> { - let (tx, rx) = channel(); - - let inner = mem::replace(&mut self.inner, SequentialReaderBuilderInner::NotFirst(rx)); - - match inner { - SequentialReaderBuilderInner::First(reader) => Some(SequentialReader { - inner: SequentialReaderInner::MyTurn(reader), - next: tx, - }), - - SequentialReaderBuilderInner::NotFirst(previous) => Some(SequentialReader { - inner: SequentialReaderInner::Waiting(previous), - next: tx, - }), - } - } -} - -impl Iterator for SequentialWriterBuilder { - type Item = SequentialWriter; - fn next(&mut self) -> Option> { - let (tx, rx) = channel(); - let mut next_next_trigger = Some(rx); - ::std::mem::swap(&mut next_next_trigger, &mut self.next_trigger); - - Some(SequentialWriter { - trigger: next_next_trigger, - writer: self.writer.clone(), - on_finish: tx, - }) - } -} - -impl Read for SequentialReader { - fn read(&mut self, buf: &mut [u8]) -> IoResult { - let mut reader = match self.inner { - SequentialReaderInner::MyTurn(ref mut reader) => return reader.read(buf), - SequentialReaderInner::Waiting(ref mut recv) => recv.recv().unwrap(), - SequentialReaderInner::Empty => unreachable!(), - }; - - let result = reader.read(buf); - self.inner = SequentialReaderInner::MyTurn(reader); - result - } -} - -impl Write for SequentialWriter { - fn write(&mut self, buf: &[u8]) -> IoResult { - if let Some(v) = self.trigger.as_mut() { - v.recv().unwrap() - } - self.trigger = None; - - self.writer.lock().unwrap().write(buf) - } - - fn flush(&mut self) -> IoResult<()> { - if let Some(v) = self.trigger.as_mut() { - v.recv().unwrap() - } - self.trigger = None; - - self.writer.lock().unwrap().flush() - } -} - -impl Drop for SequentialReader -where - R: Read + Send, -{ - fn drop(&mut self) { - let inner = mem::replace(&mut self.inner, SequentialReaderInner::Empty); - - match inner { - SequentialReaderInner::MyTurn(reader) => { - self.next.send(reader).ok(); - } - SequentialReaderInner::Waiting(recv) => { - let reader = recv.recv().unwrap(); - self.next.send(reader).ok(); - } - SequentialReaderInner::Empty => (), - } - } -} - -impl Drop for SequentialWriter -where - W: Write + Send, -{ - fn drop(&mut self) { - self.on_finish.send(()).ok(); - } -} diff --git a/anneal/vendor/tiny_http/src/util/task_pool.rs b/anneal/vendor/tiny_http/src/util/task_pool.rs deleted file mode 100644 index 155a34d9cd..0000000000 --- a/anneal/vendor/tiny_http/src/util/task_pool.rs +++ /dev/null @@ -1,137 +0,0 @@ -use std::collections::VecDeque; -use std::sync::atomic::{AtomicUsize, Ordering}; -use std::sync::{Arc, Condvar, Mutex}; -use std::thread; -use std::time::Duration; - -/// Manages a collection of threads. -/// -/// A new thread is created every time all the existing threads are full. -/// Any idle thread will automatically die after a few seconds. -pub struct TaskPool { - sharing: Arc, -} - -struct Sharing { - // list of the tasks to be done by worker threads - todo: Mutex>>, - - // condvar that will be notified whenever a task is added to `todo` - condvar: Condvar, - - // number of total worker threads running - active_tasks: AtomicUsize, - - // number of idle worker threads - waiting_tasks: AtomicUsize, -} - -/// Minimum number of active threads. -static MIN_THREADS: usize = 4; - -struct Registration<'a> { - nb: &'a AtomicUsize, -} - -impl<'a> Registration<'a> { - fn new(nb: &'a AtomicUsize) -> Registration<'a> { - nb.fetch_add(1, Ordering::Release); - Registration { nb } - } -} - -impl<'a> Drop for Registration<'a> { - fn drop(&mut self) { - self.nb.fetch_sub(1, Ordering::Release); - } -} - -impl TaskPool { - pub fn new() -> TaskPool { - let pool = TaskPool { - sharing: Arc::new(Sharing { - todo: Mutex::new(VecDeque::new()), - condvar: Condvar::new(), - active_tasks: AtomicUsize::new(0), - waiting_tasks: AtomicUsize::new(0), - }), - }; - - for _ in 0..MIN_THREADS { - pool.add_thread(None) - } - - pool - } - - /// Executes a function in a thread. - /// If no thread is available, spawns a new one. - pub fn spawn(&self, code: Box) { - let mut queue = self.sharing.todo.lock().unwrap(); - - if self.sharing.waiting_tasks.load(Ordering::Acquire) == 0 { - self.add_thread(Some(code)); - } else { - queue.push_back(code); - self.sharing.condvar.notify_one(); - } - } - - fn add_thread(&self, initial_fn: Option>) { - let sharing = self.sharing.clone(); - - thread::spawn(move || { - let sharing = sharing; - let _active_guard = Registration::new(&sharing.active_tasks); - - if let Some(mut f) = initial_fn { - f(); - } - - loop { - let mut task: Box = { - let mut todo = sharing.todo.lock().unwrap(); - - let task; - loop { - if let Some(poped_task) = todo.pop_front() { - task = poped_task; - break; - } - let _waiting_guard = Registration::new(&sharing.waiting_tasks); - - let received = - if sharing.active_tasks.load(Ordering::Acquire) <= MIN_THREADS { - todo = sharing.condvar.wait(todo).unwrap(); - true - } else { - let (new_lock, waitres) = sharing - .condvar - .wait_timeout(todo, Duration::from_millis(5000)) - .unwrap(); - todo = new_lock; - !waitres.timed_out() - }; - - if !received && todo.is_empty() { - return; - } - } - - task - }; - - task(); - } - }); - } -} - -impl Drop for TaskPool { - fn drop(&mut self) { - self.sharing - .active_tasks - .store(999_999_999, Ordering::Release); - self.sharing.condvar.notify_all(); - } -} diff --git a/anneal/vendor/tiny_http/tests/input-tests.rs b/anneal/vendor/tiny_http/tests/input-tests.rs deleted file mode 100644 index 10974be78a..0000000000 --- a/anneal/vendor/tiny_http/tests/input-tests.rs +++ /dev/null @@ -1,122 +0,0 @@ -extern crate tiny_http; - -use std::io::{Read, Write}; -use std::net::Shutdown; -use std::sync::mpsc; -use std::thread; - -#[allow(dead_code)] -mod support; - -#[test] -fn basic_string_input() { - let (server, client) = support::new_one_server_one_client(); - - { - let mut client = client; - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\nContent-Type: text/plain; charset=utf8\r\nContent-Length: 5\r\n\r\nhello")).unwrap(); - } - - let mut request = server.recv().unwrap(); - - let mut output = String::new(); - request.as_reader().read_to_string(&mut output).unwrap(); - assert_eq!(output, "hello"); -} - -#[test] -fn wrong_content_length() { - let (server, client) = support::new_one_server_one_client(); - - { - let mut client = client; - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\nContent-Type: text/plain; charset=utf8\r\nContent-Length: 3\r\n\r\nhello")).unwrap(); - } - - let mut request = server.recv().unwrap(); - - let mut output = String::new(); - request.as_reader().read_to_string(&mut output).unwrap(); - assert_eq!(output, "hel"); -} - -#[test] -fn expect_100_continue() { - let (server, client) = support::new_one_server_one_client(); - - let mut client = client; - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nExpect: 100-continue\r\nContent-Type: text/plain; charset=utf8\r\nContent-Length: 5\r\n\r\n")).unwrap(); - client.flush().unwrap(); - - let (tx, rx) = mpsc::channel(); - - thread::spawn(move || { - let mut request = server.recv().unwrap(); - let mut output = String::new(); - request.as_reader().read_to_string(&mut output).unwrap(); - assert_eq!(output, "hello"); - tx.send(()).unwrap(); - }); - - // client.set_keepalive(Some(3)).unwrap(); FIXME: reenable this - let mut content = vec![0; 12]; - client.read_exact(&mut content).unwrap(); - assert!(&content[9..].starts_with(b"100")); // 100 status code - - (write!(client, "hello")).unwrap(); - client.flush().unwrap(); - client.shutdown(Shutdown::Write).unwrap(); - - rx.recv().unwrap(); -} - -#[test] -fn unsupported_expect_header() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nExpect: 189-dummy\r\nContent-Type: text/plain; charset=utf8\r\n\r\n")).unwrap(); - - // client.set_keepalive(Some(3)).unwrap(); FIXME: reenable this - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(&content[9..].starts_with("417")); // 417 status code -} - -#[test] -fn invalid_header_name() { - let mut client = support::new_client_to_hello_world_server(); - - // note the space hidden in the Content-Length, which is invalid - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nContent-Type: text/plain; charset=utf8\r\nContent-Length : 5\r\n\r\nhello")).unwrap(); - - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(&content[9..].starts_with("400 Bad Request")); // 400 status code -} - -#[test] -fn custom_content_type_response_header() { - let (server, mut stream) = support::new_one_server_one_client(); - write!( - stream, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - ) - .unwrap(); - - let request = server.recv().unwrap(); - request - .respond( - tiny_http::Response::from_string("{\"custom\": \"Content-Type\"}").with_header( - "Content-Type: application/json" - .parse::() - .unwrap(), - ), - ) - .unwrap(); - - let mut content = String::new(); - stream.read_to_string(&mut content).unwrap(); - - assert!(content.ends_with("{\"custom\": \"Content-Type\"}")); - assert_ne!(content.find("Content-Type: application/json"), None); -} diff --git a/anneal/vendor/tiny_http/tests/network.rs b/anneal/vendor/tiny_http/tests/network.rs deleted file mode 100644 index d6c6e0540d..0000000000 --- a/anneal/vendor/tiny_http/tests/network.rs +++ /dev/null @@ -1,222 +0,0 @@ -extern crate tiny_http; - -use std::io::{Read, Write}; -use std::net::{Shutdown, TcpStream}; -use std::thread; -use std::time::Duration; - -#[allow(dead_code)] -mod support; - -#[test] -fn connection_close_header() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "GET / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n")).unwrap(); - thread::sleep(Duration::from_millis(1000)); - - (write!(client, "GET / HTTP/1.1\r\nConnection: close\r\n\r\n")).unwrap(); - - // if the connection was not closed, this will err with timeout - // client.set_keepalive(Some(1)).unwrap(); FIXME: reenable this - let mut out = Vec::new(); - client.read_to_end(&mut out).unwrap(); -} - -#[test] -fn http_1_0_connection_close() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "GET / HTTP/1.0\r\nHost: localhost\r\n\r\n")).unwrap(); - - // if the connection was not closed, this will err with timeout - // client.set_keepalive(Some(1)).unwrap(); FIXME: reenable this - let mut out = Vec::new(); - client.read_to_end(&mut out).unwrap(); -} - -#[test] -fn detect_connection_closed() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "GET / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n")).unwrap(); - thread::sleep(Duration::from_millis(1000)); - - client.shutdown(Shutdown::Write).unwrap(); - - // if the connection was not closed, this will err with timeout - // client.set_keepalive(Some(1)).unwrap(); FIXME: reenable this - let mut out = Vec::new(); - client.read_to_end(&mut out).unwrap(); -} - -#[test] -fn poor_network_test() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "G")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "ET /he")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "llo HT")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "TP/1.")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "1\r\nHo")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "st: localho")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "st\r\nConnec")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "tion: close\r")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "\n\r")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (writeln!(client)).unwrap(); - - // client.set_keepalive(Some(2)).unwrap(); FIXME: reenable this - let mut data = String::new(); - client.read_to_string(&mut data).unwrap(); - assert!(data.ends_with("hello world")); -} - -#[test] -fn pipelining_test() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")).unwrap(); - (write!(client, "GET /hello HTTP/1.1\r\nHost: localhost\r\n\r\n")).unwrap(); - (write!( - client, - "GET /world HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - )) - .unwrap(); - - // client.set_keepalive(Some(2)).unwrap(); FIXME: reenable this - let mut data = String::new(); - client.read_to_string(&mut data).unwrap(); - assert_eq!(data.split("hello world").count(), 4); -} - -#[test] -fn server_crash_results_in_response() { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - let mut client = TcpStream::connect(("127.0.0.1", port)).unwrap(); - - thread::spawn(move || { - server.recv().unwrap(); - // oops, server crash - }); - - (write!( - client, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - )) - .unwrap(); - - // client.set_keepalive(Some(2)).unwrap(); FIXME: reenable this - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(&content[9..].starts_with('5')); // 5xx status code -} - -#[test] -fn responses_reordered() { - let (server, mut client) = support::new_one_server_one_client(); - - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")).unwrap(); - (write!( - client, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - )) - .unwrap(); - - thread::spawn(move || { - let rq1 = server.recv().unwrap(); - let rq2 = server.recv().unwrap(); - - thread::spawn(move || { - rq2.respond(tiny_http::Response::from_string( - "second request".to_owned(), - )) - .unwrap(); - }); - - thread::sleep(Duration::from_millis(100)); - - thread::spawn(move || { - rq1.respond(tiny_http::Response::from_string("first request".to_owned())) - .unwrap(); - }); - }); - - // client.set_keepalive(Some(2)).unwrap(); FIXME: reenable this - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(content.ends_with("second request")); -} - -#[test] -fn no_transfer_encoding_on_204() { - let (server, mut client) = support::new_one_server_one_client(); - - (write!( - client, - "GET / HTTP/1.1\r\nHost: localhost\r\nTE: chunked\r\nConnection: close\r\n\r\n" - )) - .unwrap(); - - thread::spawn(move || { - let rq = server.recv().unwrap(); - - let resp = tiny_http::Response::empty(tiny_http::StatusCode(204)); - rq.respond(resp).unwrap(); - }); - - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - - assert!(content.starts_with("HTTP/1.1 204")); - assert!(!content.contains("Transfer-Encoding: chunked")); -} - -/* FIXME: uncomment and fix -#[test] -fn connection_timeout() { - let (server, mut client) = { - let server = tiny_http::ServerBuilder::new() - .with_client_connections_timeout(3000) - .with_random_port().build().unwrap(); - let port = server.server_addr().port(); - let client = TcpStream::connect(("127.0.0.1", port)).unwrap(); - (server, client) - }; - - let (tx_stop, rx_stop) = mpsc::channel(); - - // executing server in parallel - thread::spawn(move || { - loop { - server.try_recv(); - thread::sleep(Duration::from_millis(100)); - if rx_stop.try_recv().is_ok() { break } - } - }); - - // waiting for the 408 response - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(&content[9..].starts_with("408")); - - // stopping server - tx_stop.send(()); -} -*/ - -#[test] -fn chunked_threshold() { - let resp = tiny_http::Response::from_string("test".to_string()); - assert_eq!(resp.chunked_threshold(), 32768); - assert_eq!(resp.with_chunked_threshold(42).chunked_threshold(), 42); -} diff --git a/anneal/vendor/tiny_http/tests/non-chunked-buffering.rs b/anneal/vendor/tiny_http/tests/non-chunked-buffering.rs deleted file mode 100644 index 24a5d68002..0000000000 --- a/anneal/vendor/tiny_http/tests/non-chunked-buffering.rs +++ /dev/null @@ -1,103 +0,0 @@ -extern crate tiny_http; - -use std::io::{Cursor, Read, Write}; -use std::sync::{ - atomic::{ - AtomicUsize, - Ordering::{AcqRel, Acquire}, - }, - Arc, -}; - -#[allow(dead_code)] -mod support; - -struct MeteredReader { - inner: T, - position: Arc, -} - -impl Read for MeteredReader -where - T: Read, -{ - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - match self.inner.read(buf) { - Ok(read) => { - self.position.fetch_add(read, AcqRel); - Ok(read) - } - e => e, - } - } -} - -type Reader = MeteredReader>; - -fn big_response_reader() -> Reader { - let big_body = "ABCDEFGHIJKLMNOPQRSTUVXYZ".repeat(1024 * 1024 * 16); - MeteredReader { - inner: Cursor::new(big_body), - position: Arc::new(AtomicUsize::new(0)), - } -} - -fn identity_served(r: &mut Reader) -> tiny_http::Response<&mut Reader> { - let body_len = r.inner.get_ref().len(); - tiny_http::Response::empty(200) - .with_chunked_threshold(std::usize::MAX) - .with_data(r, Some(body_len)) -} - -/// Checks that a body-Read:er is not called when the client has disconnected -#[test] -fn responding_to_closed_client() { - let (server, mut stream) = support::new_one_server_one_client(); - write!( - stream, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - ) - .unwrap(); - - let request = server.recv().unwrap(); - - // Client already disconnected - drop(stream); - - let mut reader = big_response_reader(); - request - .respond(identity_served(&mut reader)) - .expect("Successful"); - - assert!(reader.position.load(Acquire) < 1024 * 1024); -} - -/// Checks that a slow client does not cause data to be consumed and buffered from a reader -#[test] -fn responding_to_non_consuming_client() { - let (server, mut stream) = support::new_one_server_one_client(); - write!( - stream, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - ) - .unwrap(); - - let request = server.recv().unwrap(); - - let mut reader = big_response_reader(); - let position = reader.position.clone(); - - // Client still connected, but not reading anything - std::thread::spawn(move || { - request - .respond(identity_served(&mut reader)) - .expect("Successful"); - }); - - std::thread::sleep(std::time::Duration::from_millis(100)); - - // It seems the client TCP socket can buffer quite a lot, so we need to be permissive - assert!(position.load(Acquire) < 8 * 1024 * 1024); - - drop(stream); -} diff --git a/anneal/vendor/tiny_http/tests/promptness.rs b/anneal/vendor/tiny_http/tests/promptness.rs deleted file mode 100644 index a621d3e585..0000000000 --- a/anneal/vendor/tiny_http/tests/promptness.rs +++ /dev/null @@ -1,207 +0,0 @@ -extern crate tiny_http; - -use std::io::{copy, Read, Write}; -use std::net::{Shutdown, TcpStream}; -use std::ops::Deref; -use std::sync::mpsc::channel; -use std::sync::Arc; -use std::thread::{sleep, spawn}; -use std::time::Duration; -use tiny_http::{Response, Server}; - -/// Stream that produces bytes very slowly -#[derive(Debug, Copy, Clone, PartialEq, Eq)] -struct SlowByteSrc { - val: u8, - len: usize, -} -impl<'b> Read for SlowByteSrc { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - sleep(Duration::from_millis(100)); - let l = self.len.min(buf.len()).min(1000); - for v in buf[..l].iter_mut() { - *v = self.val; - } - self.len -= l; - Ok(l) - } -} - -/// crude impl of http `Transfer-Encoding: chunked` -fn encode_chunked(data: &mut dyn Read, output: &mut dyn Write) { - let mut buf = [0u8; 4096]; - loop { - let l = data.read(&mut buf).unwrap(); - write!(output, "{:X}\r\n", l).unwrap(); - output.write_all(&buf[..l]).unwrap(); - write!(output, "\r\n").unwrap(); - if l == 0 { - break; - } - } -} - -mod prompt_pipelining { - use super::*; - - /// Check that pipelined requests on the same connection are received promptly. - fn assert_requests_parsed_promptly( - req_cnt: usize, - req_body: &'static [u8], - timeout: Duration, - req_writer: impl FnOnce(&mut dyn Write) + Send + 'static, - ) { - let resp_body = SlowByteSrc { - val: 42, - len: 1000_000, - }; // very slow response body - - let server = Server::http("0.0.0.0:0").unwrap(); - let mut client = TcpStream::connect(server.server_addr().to_ip().unwrap()).unwrap(); - let (svr_send, svr_rcv) = channel(); - - spawn(move || { - for _ in 0..req_cnt { - let mut req = server.recv().unwrap(); - // read the whole body of the request - let mut body = Vec::new(); - req.as_reader().read_to_end(&mut body).unwrap(); - assert_eq!(req_body, body.as_slice()); - // The next pipelined request should now be available for parsing, - // while we send the (possibly slow) response in another thread - spawn(move || { - req.respond(Response::empty(200).with_data(resp_body, Some(resp_body.len))) - }); - } - svr_send.send(()).unwrap(); - }); - - spawn(move || req_writer(&mut client)); - - // requests must be sent and received quickly (before timeout expires) - svr_rcv - .recv_timeout(timeout) - .expect("Server did not finish reading pipelined requests quickly enough"); - } - - #[test] - fn empty() { - assert_requests_parsed_promptly(5, &[], Duration::from_millis(200), move |wr| { - for _ in 0..5 { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Connection: keep-alive\r\n\r\n").unwrap(); - } - }); - } - - #[test] - fn content_length_short() { - let body = &[65u8; 100]; // short but not trivial - assert_requests_parsed_promptly(5, body, Duration::from_millis(200), move |wr| { - for _ in 0..5 { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Connection: keep-alive\r\n").unwrap(); - write!(wr, "Content-Length: {}\r\n\r\n", body.len()).unwrap(); - wr.write_all(body).unwrap(); - } - }); - } - - #[test] - fn content_length_long() { - let body = &[65u8; 10000]; // long enough that it won't be buffered - assert_requests_parsed_promptly(5, body, Duration::from_millis(200), move |wr| { - for _ in 0..5 { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Connection: keep-alive\r\n").unwrap(); - write!(wr, "Content-Length: {}\r\n\r\n", body.len()).unwrap(); - wr.write_all(body).unwrap(); - } - }); - } - - #[test] - fn chunked() { - let body = &[65u8; 10000]; - assert_requests_parsed_promptly(5, body, Duration::from_millis(200), move |wr| { - for _ in 0..5 { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Connection: keep-alive\r\n").unwrap(); - write!(wr, "Transfer-Encoding: chunked\r\n\r\n").unwrap(); - encode_chunked(&mut &body[..], wr); - } - }); - } -} - -mod prompt_responses { - use super::*; - - /// Check that response is sent promptly without waiting for full request body. - fn assert_responds_promptly( - timeout: Duration, - req_writer: impl FnOnce(&mut dyn Write) + Send + 'static, - ) { - let server = Server::http("0.0.0.0:0").unwrap(); - let client = TcpStream::connect(server.server_addr().to_ip().unwrap()).unwrap(); - - spawn(move || loop { - // server attempts to respond immediately - let req = server.recv().unwrap(); - req.respond(Response::empty(400)).unwrap(); - }); - - let client = Arc::new(client); - let client_write = Arc::clone(&client); - // request written (possibly very slowly) in another thread - spawn(move || req_writer(&mut client_write.deref())); - - // response should arrive quickly (before timeout expires) - client.set_read_timeout(Some(timeout)).unwrap(); - let resp = client.deref().read(&mut [0u8; 4096]); - client.shutdown(Shutdown::Both).unwrap(); - assert!(resp.is_ok(), "Server response was not sent promptly"); - } - - static SLOW_BODY: SlowByteSrc = SlowByteSrc { - val: 65, - len: 1000_000, - }; - - #[test] - fn content_length_http11() { - assert_responds_promptly(Duration::from_millis(200), move |wr| { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Content-Length: {}\r\n\r\n", SLOW_BODY.len).unwrap(); - copy(&mut SLOW_BODY.clone(), wr).unwrap(); - }); - } - - #[test] - fn content_length_http10() { - assert_responds_promptly(Duration::from_millis(200), move |wr| { - write!(wr, "GET / HTTP/1.0\r\n").unwrap(); - write!(wr, "Content-Length: {}\r\n\r\n", SLOW_BODY.len).unwrap(); - copy(&mut SLOW_BODY.clone(), wr).unwrap(); - }); - } - - #[test] - fn expect_continue() { - assert_responds_promptly(Duration::from_millis(200), move |wr| { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Expect: 100 continue\r\n").unwrap(); - write!(wr, "Content-Length: {}\r\n\r\n", SLOW_BODY.len).unwrap(); - copy(&mut SLOW_BODY.clone(), wr).unwrap(); - }); - } - - #[test] - fn chunked() { - assert_responds_promptly(Duration::from_millis(200), move |wr| { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Transfer-Encoding: chunked\r\n\r\n").unwrap(); - encode_chunked(&mut SLOW_BODY.clone(), wr); - }); - } -} diff --git a/anneal/vendor/tiny_http/tests/simple-test.rs b/anneal/vendor/tiny_http/tests/simple-test.rs deleted file mode 100644 index 4375109d92..0000000000 --- a/anneal/vendor/tiny_http/tests/simple-test.rs +++ /dev/null @@ -1,29 +0,0 @@ -extern crate tiny_http; - -use std::io::{Read, Write}; - -#[allow(dead_code)] -mod support; - -#[test] -fn basic_handling() { - let (server, mut stream) = support::new_one_server_one_client(); - write!( - stream, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - ) - .unwrap(); - - let request = server.recv().unwrap(); - assert!(*request.method() == tiny_http::Method::Get); - //assert!(request.url() == "/"); - request - .respond(tiny_http::Response::from_string("hello world".to_owned())) - .unwrap(); - - server.try_recv().unwrap(); - - let mut content = String::new(); - stream.read_to_string(&mut content).unwrap(); - assert!(content.ends_with("hello world")); -} diff --git a/anneal/vendor/tiny_http/tests/support/mod.rs b/anneal/vendor/tiny_http/tests/support/mod.rs deleted file mode 100644 index 7a4dc587be..0000000000 --- a/anneal/vendor/tiny_http/tests/support/mod.rs +++ /dev/null @@ -1,40 +0,0 @@ -use std::net::TcpStream; -use std::thread; -use std::time::Duration; - -/// Creates a server and a client connected to the server. -pub fn new_one_server_one_client() -> (tiny_http::Server, TcpStream) { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - let client = TcpStream::connect(("127.0.0.1", port)).unwrap(); - (server, client) -} - -/// Creates a "hello world" server with a client connected to the server. -/// -/// The server will automatically close after 3 seconds. -pub fn new_client_to_hello_world_server() -> TcpStream { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - let client = TcpStream::connect(("127.0.0.1", port)).unwrap(); - - thread::spawn(move || { - let mut cycles = 3 * 1000 / 20; - - loop { - if let Some(rq) = server.try_recv().unwrap() { - let response = tiny_http::Response::from_string("hello world".to_string()); - rq.respond(response).unwrap(); - } - - thread::sleep(Duration::from_millis(20)); - - cycles -= 1; - if cycles == 0 { - break; - } - } - }); - - client -} diff --git a/anneal/vendor/tiny_http/tests/unblock-test.rs b/anneal/vendor/tiny_http/tests/unblock-test.rs deleted file mode 100644 index 001568a480..0000000000 --- a/anneal/vendor/tiny_http/tests/unblock-test.rs +++ /dev/null @@ -1,34 +0,0 @@ -extern crate tiny_http; - -use std::sync::Arc; -use std::thread; - -#[test] -fn unblock_server() { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let s = Arc::new(server); - - let s1 = s.clone(); - thread::spawn(move || s1.unblock()); - - // Without unblock this would hang forever - for _rq in s.incoming_requests() {} -} - -#[test] -fn unblock_threads() { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let s = Arc::new(server); - - let s1 = s.clone(); - let s2 = s.clone(); - let h1 = thread::spawn(move || for _rq in s1.incoming_requests() {}); - let h2 = thread::spawn(move || for _rq in s2.incoming_requests() {}); - - // Graceful shutdown; removing even one of the - // unblock calls prevents termination - s.unblock(); - s.unblock(); - h1.join().unwrap(); - h2.join().unwrap(); -} diff --git a/anneal/vendor/tiny_http/tests/unix-test.rs b/anneal/vendor/tiny_http/tests/unix-test.rs deleted file mode 100644 index 42d9476d05..0000000000 --- a/anneal/vendor/tiny_http/tests/unix-test.rs +++ /dev/null @@ -1,44 +0,0 @@ -#![cfg(unix)] - -extern crate tiny_http; - -use std::{ - io::{Read, Write}, - os::unix::net::UnixStream, - path::{Path, PathBuf}, -}; - -#[allow(dead_code)] -mod support; - -#[test] -fn unix_basic_handling() { - let server = tiny_http::Server::http_unix(Path::new("/tmp/tiny-http-test.sock")).unwrap(); - let path: PathBuf = server - .server_addr() - .to_unix() - .unwrap() - .as_pathname() - .unwrap() - .into(); - let mut client = UnixStream::connect(path).unwrap(); - - write!( - client, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - ) - .unwrap(); - - let request = server.recv().unwrap(); - assert!(*request.method() == tiny_http::Method::Get); - //assert!(request.url() == "/"); - request - .respond(tiny_http::Response::from_string("hello world".to_owned())) - .unwrap(); - - server.try_recv().unwrap(); - - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(content.ends_with("hello world")); -} diff --git a/anneal/vendor/unicode-ident/.cargo-checksum.json b/anneal/vendor/unicode-ident/.cargo-checksum.json index c53c065861..973fb2b696 100644 --- a/anneal/vendor/unicode-ident/.cargo-checksum.json +++ b/anneal/vendor/unicode-ident/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"9900659dcf16d47a600102bbfd47cf554a0d4db40790983e570f9ecac9822c68",".github/FUNDING.yml":"b017158736b3c9751a2d21edfce7fe61c8954e2fced8da8dd3013c2f3e295bd9",".github/workflows/ci.yml":"7cd19596c9178c43f442aeeaf808592bb0c3a118ce291aa2037bd22116045e61","Cargo.lock":"dac9e67ad7272c61e7b197143b696705ce4800ea0e010b3b1f0c8924a0c9701d","Cargo.toml":"0bb9c0e006a21355cb85c7df72e78dd8ba6fffbb7dc3f1e7a4c19af53cd354da","Cargo.toml.orig":"8d0abaf7ce10cb78f26edcd613dfe5a47faa4381e6e251c7d1c123608d2e037a","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","LICENSE-UNICODE":"f7db81051789b729fea528a63ec4c938fdcb93d9d61d97dc8cc2e9df6d47f2a1","README.md":"2fd3a0c6c9abd2c042fb319221f9ef2c95728a6e3725b0f067e4d315c5dbfe5a","benches/xid.rs":"7eb058c1140a253f7177af8868a95aabb1b92c52dc7eee5abbfeadb507d7845d","src/lib.rs":"078912e7c64ba3ea1081b88c2610deba31eeb057c28f9d78e929db4856b7774f","src/tables.rs":"369c476ba91a39fce55563b692a3f598daf7f026cfe0a3796cfed1102fb3b190","tests/compare.rs":"f2311271aa1db7380e5bf153ef83ee99777e14579e4f28c2b1a3e21877ffe715","tests/fst/mod.rs":"69a3aaf59acd8bca962ecc6234be56be8c0934ab79b253162f10eb881523901f","tests/fst/xid_continue.fst":"b58be4f0c498253e7a5ac664046096f15f249da66131347d4b822097623549a2","tests/fst/xid_start.fst":"aec7eecdacfce308d2e6210f47d28ed3aad5c8b048efbfbc11fc22e60fbf435b","tests/roaring/mod.rs":"f5c6d55463a7f53e92a493cf046d717149250fbafc0e0fe94bdb531377bf8b11","tests/static_size.rs":"80c3ca7eeec2660f3f4f2efa8fecd6209b32ec8b547192cbfa37c0e67a5f14a0","tests/tables/mod.rs":"e6949172d10fc4b2431ce7546269bfd4f9146454c8c3e31faf5e5d80c16a8ab6","tests/tables/tables.rs":"302d87306100b6280f8db93e167dc70c47f724045cf1312b7354683656c3f36b","tests/trie/mod.rs":"d4acbb716bcbaf80660039797f45e138ed8bbd66749fa3b19b1a971574679cc9","tests/trie/trie.rs":"f7b9edc1e8a98e3be42b653bba27bb4eb5fc48a559d6d8d1c6a4db4b5425b0d5"},"package":"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"9900659dcf16d47a600102bbfd47cf554a0d4db40790983e570f9ecac9822c68",".github/FUNDING.yml":"b017158736b3c9751a2d21edfce7fe61c8954e2fced8da8dd3013c2f3e295bd9",".github/workflows/ci.yml":"7cd19596c9178c43f442aeeaf808592bb0c3a118ce291aa2037bd22116045e61","Cargo.lock":"dac9e67ad7272c61e7b197143b696705ce4800ea0e010b3b1f0c8924a0c9701d","Cargo.toml":"0bb9c0e006a21355cb85c7df72e78dd8ba6fffbb7dc3f1e7a4c19af53cd354da","Cargo.toml.orig":"8d0abaf7ce10cb78f26edcd613dfe5a47faa4381e6e251c7d1c123608d2e037a","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","LICENSE-UNICODE":"f7db81051789b729fea528a63ec4c938fdcb93d9d61d97dc8cc2e9df6d47f2a1","README.md":"2fd3a0c6c9abd2c042fb319221f9ef2c95728a6e3725b0f067e4d315c5dbfe5a","benches/xid.rs":"7eb058c1140a253f7177af8868a95aabb1b92c52dc7eee5abbfeadb507d7845d","src/lib.rs":"078912e7c64ba3ea1081b88c2610deba31eeb057c28f9d78e929db4856b7774f","src/tables.rs":"369c476ba91a39fce55563b692a3f598daf7f026cfe0a3796cfed1102fb3b190","tests/compare.rs":"f2311271aa1db7380e5bf153ef83ee99777e14579e4f28c2b1a3e21877ffe715","tests/fst/.gitignore":"2cd419079c0a08bb15766520880998651dd1c72c55347a31f43357595b16ac10","tests/fst/mod.rs":"69a3aaf59acd8bca962ecc6234be56be8c0934ab79b253162f10eb881523901f","tests/fst/xid_continue.fst":"b58be4f0c498253e7a5ac664046096f15f249da66131347d4b822097623549a2","tests/fst/xid_start.fst":"aec7eecdacfce308d2e6210f47d28ed3aad5c8b048efbfbc11fc22e60fbf435b","tests/roaring/mod.rs":"f5c6d55463a7f53e92a493cf046d717149250fbafc0e0fe94bdb531377bf8b11","tests/static_size.rs":"80c3ca7eeec2660f3f4f2efa8fecd6209b32ec8b547192cbfa37c0e67a5f14a0","tests/tables/mod.rs":"e6949172d10fc4b2431ce7546269bfd4f9146454c8c3e31faf5e5d80c16a8ab6","tests/tables/tables.rs":"302d87306100b6280f8db93e167dc70c47f724045cf1312b7354683656c3f36b","tests/trie/mod.rs":"d4acbb716bcbaf80660039797f45e138ed8bbd66749fa3b19b1a971574679cc9","tests/trie/trie.rs":"f7b9edc1e8a98e3be42b653bba27bb4eb5fc48a559d6d8d1c6a4db4b5425b0d5"},"package":"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"} \ No newline at end of file diff --git a/anneal/vendor/unicode-ident/tests/fst/.gitignore b/anneal/vendor/unicode-ident/tests/fst/.gitignore new file mode 100644 index 0000000000..0ebd2add95 --- /dev/null +++ b/anneal/vendor/unicode-ident/tests/fst/.gitignore @@ -0,0 +1 @@ +/prop_list.rs diff --git a/anneal/vendor/wasmparser/.cargo-checksum.json b/anneal/vendor/wasmparser/.cargo-checksum.json index e637aeaefa..ef9bd32832 100644 --- a/anneal/vendor/wasmparser/.cargo-checksum.json +++ b/anneal/vendor/wasmparser/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"57f74377f548fbafc63ed431ef9c63fc201cbdb7c8c96b2493d98766d3b12420","Cargo.lock":"5e68724753901d9d61ab1e95bd782fd5cd1d951cf052ee43330bfe43d45f6a8c","Cargo.toml":"44fa0c6cd610439798dadcd0b35cf3ddc05df8f300e3df62713317d4e111c659","Cargo.toml.orig":"6053243b73f71715f393a13873b5b847b43cbd85a705329d17ccc9093bf99ba0","README.md":"aabf3b5930893b2a89d0114d8cd97e9b980f3c6f758b960484e06b69a504b823","benches/benchmark.rs":"c69fd76e74644188f25d03beac288f094b22735db58daf00019f812f9400f604","examples/simple.rs":"dc847c55627d346cee20f1415fde9be36a8e93d0ba0929d3fd8eef9d69e3541f","src/arity.rs":"6f34da680d7d79b1606aceb460bb4b06565904821e992c69aad5bcab271321d1","src/binary_reader.rs":"790835b9439150bdf9047e7040379724d66139ca15d8f5d155f9291c74849364","src/collections/hash.rs":"4146765fe03ff2e3456ad713283713c8614d9605a0f9c22c710b95508de7da89","src/collections/index_map.rs":"70823e5d27ca3abd193e0f18a163e3cbcef6f969b212b870b439b341278f1c32","src/collections/index_map/detail.rs":"2e9c56ff3ebf0473704b8bf304d8cca4dd39fa6c5973e06b5493a45332bb656a","src/collections/index_map/tests.rs":"7761fda67a871bcef24579f0cbe4762e40fb8e7ca5147c67187da510c545c016","src/collections/index_set.rs":"f53bcbfbbeccd9bf62406f08565f5ac57af58cf962484a91d4efcd7431d37310","src/collections/map.rs":"f239038e622dd95eb5ee5dbbfb67cd0e4cafe18c750cc0c46b1013809e0ec643","src/collections/mod.rs":"b80b8f49039ef403b9515c994aa2512db5dc905f083c876a41d8ca705d7add6e","src/collections/set.rs":"b9680f5c2f0cb7c52a935ce80f1ec3f5c6239913c1b621556f289a708e0f373b","src/features.rs":"c0adc66a0ab32d0fe20f6831ac6f40639c5d3333496f1e13da32b0406e1eb9a2","src/lib.rs":"1a3d8c79f116527f3c4dcb4e256758acfe3096e87d96f4ec27bbcbd10b587ddf","src/limits.rs":"ac608007fb4e7c45c99159230230e0ab35739055980259920e3e4ad71b87ed61","src/parser.rs":"8abb0c08909f78418eb8a1a48b96185cdab67817afc5793dd1da7f87e57404ff","src/readers.rs":"bf43b91c1ad97d9d67eaa8fc63381428dc300c97b21ce1ede89ab6b628625da7","src/readers/component.rs":"c259628ca3f09ff904f7e920aeec261b657f7a197c99b520a6a7d3e918b9fb3b","src/readers/component/aliases.rs":"97398d9fdcb7b4227b8bb68a6677ebf09c62f6a43b9aa7591b37a2413848e759","src/readers/component/canonicals.rs":"4cffaf5ba1c4d74900ccefd82db50580057dc8d0651614c66177f69441e70a30","src/readers/component/exports.rs":"de6482715680b63fc0969225b6c634c5f5c2fa5b763511628a313af4748df347","src/readers/component/imports.rs":"8d2947817bd1a91956d33a8e723f5af325f73cc6eb2903264a6dd594b3deeb46","src/readers/component/instances.rs":"8ab1254ce1e66528d37a61bcde4cabb2c7c87ccc2740be03d539c064ed544d29","src/readers/component/names.rs":"1bfdffe04b15760ab573359c864ead0c45a0afe42811d16af535d9e19125daa6","src/readers/component/start.rs":"9c37d1eea486ee951547a328693bcf9f2a27f48e2207478daf23c1cd9e9f95f3","src/readers/component/types.rs":"a9729948af3f9f9e526498a5127788e816ecd179ea2a60f1dc9fcde7ef6175b6","src/readers/core.rs":"f77e1eb46e1d05abeabb9be2bd7bdd66acadfc4c651912f2a67b7e5f7d29d041","src/readers/core/branch_hinting.rs":"29210720e08e3a558fd96ac857038c9b87732a265ff1bfbd7f0bf3312ea3e949","src/readers/core/code.rs":"96b4f12b666576100bfa9807e087792ec96b4d315317475180c086f18fe86b4d","src/readers/core/coredumps.rs":"75c1c5ad6a85cb90bc39eb4b22b22a512f5ee98b363565f7262c1c176a10bbef","src/readers/core/custom.rs":"f3c965fcd044576a2c0f3ee87c78e4f9f345ce87899a76d609e5a8709f5d7d9e","src/readers/core/data.rs":"da78898a19accca90f05ee762cf3388c0f8a40a3d60cb78acaa3f0eb71a0cb3c","src/readers/core/dylink0.rs":"c92d75e417eb444673408c00311da3f59427b6f966009f4830be8b518a8bda21","src/readers/core/elements.rs":"16342061fef1f04b68b99db7767e11608fec2922f07831df60922d6a9500e2dc","src/readers/core/exports.rs":"dd13793edf9edcbb857288c5adb273a8231ead5dbad2e39d0f9abd23ed189151","src/readers/core/functions.rs":"b5bbc7f7b7a429187376f63c695a9f1cbf92e515dba840ac876fa60f7290da34","src/readers/core/globals.rs":"19ea22f5c4ae3c1d6d4c62dbd163c503f05117210fa4b029094a1927e2c30b7a","src/readers/core/imports.rs":"b8c9ad9a48211c4d1a076861a1f8b68905981100379f198e5152e79a294678eb","src/readers/core/init.rs":"53831f0d4b9e6c4de65816363787b863ce49850b32a821bd4b3891889b2e3ba6","src/readers/core/linking.rs":"02b1eb463b516fff4fa9f1ba06c623dd8e6b2ea3e632669415074d9ee4ac9968","src/readers/core/memories.rs":"a36d626d167569ee28feddbbfacd5d4211834bb2c8c3c522251a28ca15d229c0","src/readers/core/names.rs":"722dc47fcd523fb75987ae501fb893002978b207e31b3bc054901e66737540f6","src/readers/core/operators.rs":"8536dc584ce3769e6ac3aaa6ac636d65acb4aa681180f53564774657843a5b4a","src/readers/core/producers.rs":"25bbdd1385d26ba4dbc0814c516834f2ab7c0aad697a576b714d3dbe8dc2d7cc","src/readers/core/reloc.rs":"244f29411a0e4cceb09e0a9b9ec05a64bcc2d2c0f783f23227f33f91d2fbee3f","src/readers/core/tables.rs":"a0b3676cdd7c8a5f56ba7fcc0e5c0b3079755dc932e00caf5c37af176288d602","src/readers/core/tags.rs":"c1dcfeb973195da9708549bcc2df4dd8ff282fe802c15a603bebc8a856f70949","src/readers/core/types.rs":"6083a67298dcd9ab48e76b06a92f694fdb46c91b99433c853e8be6935c3867f6","src/readers/core/types/matches.rs":"0df58b38f94f3281b91d1edbb568b9b1d3484ea717fcbc8e353459447ded2d13","src/resources.rs":"eaf203d9b99e167ead8fc8ed8861851bdc1288bc5fe6c435f1ee7cf69e8f9fa5","src/validator.rs":"8d52d96f8e5dd1020db4e33321703dcac3be7d295d37ad61166dba605863e263","src/validator/component.rs":"4d67ec6921af00f0946287719a6c509ee1f001ca607d93693968d449955c2b98","src/validator/component_types.rs":"acb39090c9f706c8bf79e521b7e6926b02880d097b0ad2c1f68c0281fc935e6f","src/validator/core.rs":"748c9f8a432cb3118229825e59d58d3d4faa7d13679fc79ad7205705c1d0d13e","src/validator/core/canonical.rs":"4316d75a9d730fd631815046a34ab4b97f1bba5161cdca130bb5fb3f865c64a5","src/validator/func.rs":"eb8109fc85295d35d7b30d343404c995c6314600086e533f5b85e6a9c1ad7de4","src/validator/names.rs":"8f75bef3ac6d1a3d025c8a74743b63820e67ae0f6779ca3e5254d1e0f6e9394a","src/validator/operators.rs":"88fec45af8c85404c6f9ff946379e3f90804ff86633a9adc81ac56d4cdb113f1","src/validator/operators/simd.rs":"a338d3f82be1246a14cb96e5d99a99de0c728256703be36e4caf8142042693a2","src/validator/types.rs":"802c04e769e01dd028803a22d0c07e0bca91781036f8cb38c36701841db7f62d","tests/big-module.rs":"114d250505a2a3daf2e778bd4b2c14b7fc6b6be842055fa6b9389167fa430dca"},"package":"47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"57f74377f548fbafc63ed431ef9c63fc201cbdb7c8c96b2493d98766d3b12420","Cargo.lock":"5e68724753901d9d61ab1e95bd782fd5cd1d951cf052ee43330bfe43d45f6a8c","Cargo.toml":"44fa0c6cd610439798dadcd0b35cf3ddc05df8f300e3df62713317d4e111c659","Cargo.toml.orig":"6053243b73f71715f393a13873b5b847b43cbd85a705329d17ccc9093bf99ba0","README.md":"aabf3b5930893b2a89d0114d8cd97e9b980f3c6f758b960484e06b69a504b823","benches/.gitignore":"9207f6d87ac45bb48ebb4d879467485c692985481d0674d56121e2150a1e4671","benches/benchmark.rs":"c69fd76e74644188f25d03beac288f094b22735db58daf00019f812f9400f604","examples/simple.rs":"dc847c55627d346cee20f1415fde9be36a8e93d0ba0929d3fd8eef9d69e3541f","src/arity.rs":"6f34da680d7d79b1606aceb460bb4b06565904821e992c69aad5bcab271321d1","src/binary_reader.rs":"790835b9439150bdf9047e7040379724d66139ca15d8f5d155f9291c74849364","src/collections/hash.rs":"4146765fe03ff2e3456ad713283713c8614d9605a0f9c22c710b95508de7da89","src/collections/index_map.rs":"70823e5d27ca3abd193e0f18a163e3cbcef6f969b212b870b439b341278f1c32","src/collections/index_map/detail.rs":"2e9c56ff3ebf0473704b8bf304d8cca4dd39fa6c5973e06b5493a45332bb656a","src/collections/index_map/tests.rs":"7761fda67a871bcef24579f0cbe4762e40fb8e7ca5147c67187da510c545c016","src/collections/index_set.rs":"f53bcbfbbeccd9bf62406f08565f5ac57af58cf962484a91d4efcd7431d37310","src/collections/map.rs":"f239038e622dd95eb5ee5dbbfb67cd0e4cafe18c750cc0c46b1013809e0ec643","src/collections/mod.rs":"b80b8f49039ef403b9515c994aa2512db5dc905f083c876a41d8ca705d7add6e","src/collections/set.rs":"b9680f5c2f0cb7c52a935ce80f1ec3f5c6239913c1b621556f289a708e0f373b","src/features.rs":"c0adc66a0ab32d0fe20f6831ac6f40639c5d3333496f1e13da32b0406e1eb9a2","src/lib.rs":"1a3d8c79f116527f3c4dcb4e256758acfe3096e87d96f4ec27bbcbd10b587ddf","src/limits.rs":"ac608007fb4e7c45c99159230230e0ab35739055980259920e3e4ad71b87ed61","src/parser.rs":"8abb0c08909f78418eb8a1a48b96185cdab67817afc5793dd1da7f87e57404ff","src/readers.rs":"bf43b91c1ad97d9d67eaa8fc63381428dc300c97b21ce1ede89ab6b628625da7","src/readers/component.rs":"c259628ca3f09ff904f7e920aeec261b657f7a197c99b520a6a7d3e918b9fb3b","src/readers/component/aliases.rs":"97398d9fdcb7b4227b8bb68a6677ebf09c62f6a43b9aa7591b37a2413848e759","src/readers/component/canonicals.rs":"4cffaf5ba1c4d74900ccefd82db50580057dc8d0651614c66177f69441e70a30","src/readers/component/exports.rs":"de6482715680b63fc0969225b6c634c5f5c2fa5b763511628a313af4748df347","src/readers/component/imports.rs":"8d2947817bd1a91956d33a8e723f5af325f73cc6eb2903264a6dd594b3deeb46","src/readers/component/instances.rs":"8ab1254ce1e66528d37a61bcde4cabb2c7c87ccc2740be03d539c064ed544d29","src/readers/component/names.rs":"1bfdffe04b15760ab573359c864ead0c45a0afe42811d16af535d9e19125daa6","src/readers/component/start.rs":"9c37d1eea486ee951547a328693bcf9f2a27f48e2207478daf23c1cd9e9f95f3","src/readers/component/types.rs":"a9729948af3f9f9e526498a5127788e816ecd179ea2a60f1dc9fcde7ef6175b6","src/readers/core.rs":"f77e1eb46e1d05abeabb9be2bd7bdd66acadfc4c651912f2a67b7e5f7d29d041","src/readers/core/branch_hinting.rs":"29210720e08e3a558fd96ac857038c9b87732a265ff1bfbd7f0bf3312ea3e949","src/readers/core/code.rs":"96b4f12b666576100bfa9807e087792ec96b4d315317475180c086f18fe86b4d","src/readers/core/coredumps.rs":"75c1c5ad6a85cb90bc39eb4b22b22a512f5ee98b363565f7262c1c176a10bbef","src/readers/core/custom.rs":"f3c965fcd044576a2c0f3ee87c78e4f9f345ce87899a76d609e5a8709f5d7d9e","src/readers/core/data.rs":"da78898a19accca90f05ee762cf3388c0f8a40a3d60cb78acaa3f0eb71a0cb3c","src/readers/core/dylink0.rs":"c92d75e417eb444673408c00311da3f59427b6f966009f4830be8b518a8bda21","src/readers/core/elements.rs":"16342061fef1f04b68b99db7767e11608fec2922f07831df60922d6a9500e2dc","src/readers/core/exports.rs":"dd13793edf9edcbb857288c5adb273a8231ead5dbad2e39d0f9abd23ed189151","src/readers/core/functions.rs":"b5bbc7f7b7a429187376f63c695a9f1cbf92e515dba840ac876fa60f7290da34","src/readers/core/globals.rs":"19ea22f5c4ae3c1d6d4c62dbd163c503f05117210fa4b029094a1927e2c30b7a","src/readers/core/imports.rs":"b8c9ad9a48211c4d1a076861a1f8b68905981100379f198e5152e79a294678eb","src/readers/core/init.rs":"53831f0d4b9e6c4de65816363787b863ce49850b32a821bd4b3891889b2e3ba6","src/readers/core/linking.rs":"02b1eb463b516fff4fa9f1ba06c623dd8e6b2ea3e632669415074d9ee4ac9968","src/readers/core/memories.rs":"a36d626d167569ee28feddbbfacd5d4211834bb2c8c3c522251a28ca15d229c0","src/readers/core/names.rs":"722dc47fcd523fb75987ae501fb893002978b207e31b3bc054901e66737540f6","src/readers/core/operators.rs":"8536dc584ce3769e6ac3aaa6ac636d65acb4aa681180f53564774657843a5b4a","src/readers/core/producers.rs":"25bbdd1385d26ba4dbc0814c516834f2ab7c0aad697a576b714d3dbe8dc2d7cc","src/readers/core/reloc.rs":"244f29411a0e4cceb09e0a9b9ec05a64bcc2d2c0f783f23227f33f91d2fbee3f","src/readers/core/tables.rs":"a0b3676cdd7c8a5f56ba7fcc0e5c0b3079755dc932e00caf5c37af176288d602","src/readers/core/tags.rs":"c1dcfeb973195da9708549bcc2df4dd8ff282fe802c15a603bebc8a856f70949","src/readers/core/types.rs":"6083a67298dcd9ab48e76b06a92f694fdb46c91b99433c853e8be6935c3867f6","src/readers/core/types/matches.rs":"0df58b38f94f3281b91d1edbb568b9b1d3484ea717fcbc8e353459447ded2d13","src/resources.rs":"eaf203d9b99e167ead8fc8ed8861851bdc1288bc5fe6c435f1ee7cf69e8f9fa5","src/validator.rs":"8d52d96f8e5dd1020db4e33321703dcac3be7d295d37ad61166dba605863e263","src/validator/component.rs":"4d67ec6921af00f0946287719a6c509ee1f001ca607d93693968d449955c2b98","src/validator/component_types.rs":"acb39090c9f706c8bf79e521b7e6926b02880d097b0ad2c1f68c0281fc935e6f","src/validator/core.rs":"748c9f8a432cb3118229825e59d58d3d4faa7d13679fc79ad7205705c1d0d13e","src/validator/core/canonical.rs":"4316d75a9d730fd631815046a34ab4b97f1bba5161cdca130bb5fb3f865c64a5","src/validator/func.rs":"eb8109fc85295d35d7b30d343404c995c6314600086e533f5b85e6a9c1ad7de4","src/validator/names.rs":"8f75bef3ac6d1a3d025c8a74743b63820e67ae0f6779ca3e5254d1e0f6e9394a","src/validator/operators.rs":"88fec45af8c85404c6f9ff946379e3f90804ff86633a9adc81ac56d4cdb113f1","src/validator/operators/simd.rs":"a338d3f82be1246a14cb96e5d99a99de0c728256703be36e4caf8142042693a2","src/validator/types.rs":"802c04e769e01dd028803a22d0c07e0bca91781036f8cb38c36701841db7f62d","tests/big-module.rs":"114d250505a2a3daf2e778bd4b2c14b7fc6b6be842055fa6b9389167fa430dca"},"package":"47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"} \ No newline at end of file diff --git a/anneal/vendor/wasmparser/benches/.gitignore b/anneal/vendor/wasmparser/benches/.gitignore new file mode 100644 index 0000000000..45d4a47279 --- /dev/null +++ b/anneal/vendor/wasmparser/benches/.gitignore @@ -0,0 +1 @@ +!*.wasm diff --git a/anneal/vendor/wit-component/.cargo-checksum.json b/anneal/vendor/wit-component/.cargo-checksum.json index 9ed7ebda17..49f8090847 100644 --- a/anneal/vendor/wit-component/.cargo-checksum.json +++ b/anneal/vendor/wit-component/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"8456162b205395e1ccae297c7bff238bc11090019a7807fee70463494697bffa","Cargo.lock":"5fff8966384cc2e3f5f19866742d4b8fd536e64f4cf37963b965f000f3579440","Cargo.toml":"8142ea1fdeebc373aa1ef74dbf068351b2995b10ae9629a758dc6ece35f2fffd","Cargo.toml.orig":"eda00a1d5a187c31873aee6413503278a16d865a2d25c3872fdd7a4281b1c3ad","README.md":"00d3b7547efc420a28ce22afd6d9f29f996e2a972ee0f753f988ee26e54ac8ea","libdl.so":"6d6ea03a4a671db91be183077b6665866106a61c84739580773a7e5b6bd9f256","src/dummy.rs":"8ff563ef71fd4b090ef65b11d4311386e2d16c08769569ab2809d5c207d42f19","src/encoding.rs":"44026b8332e9fd8db97ccc4e685d8bb224fcbc63cb98e08ddc3928be4dffb901","src/encoding/dedupe.rs":"157abfde68d0c0e610acf399b0bb5efe7dce66197b513922cac85ea28004e9e5","src/encoding/types.rs":"b7f25629759c3786351fda2867409da8043be0ed4bfa8ff17d89ed285c8d2670","src/encoding/wit.rs":"dd8abb983f7a3e2499db41d6aa21733758e2cdae3805af5c058063adedcb4c2e","src/encoding/world.rs":"a8d2bf823a5fadf248cfe13e19ac56ad7a63974334518a1f2634251aa44ae2f9","src/gc.rs":"e731ef0b88c56c9cf99b83ee1a9fe6f085b8744c394f2bfc6503106390e6edb0","src/lib.rs":"25a5d6af36e1f9f6fa405e0c67a3736420b310e73f9eb7c03ed520a81515a2f7","src/linking.rs":"bfe049c0138b647a80cd4dbf1d8a926053e6c4f59a3bda702d82670a4cb62e7e","src/linking/metadata.rs":"33899abdc312ff16ea28f016406c2aae75fc24ccd5ef7b2e4bb62aec3af08102","src/metadata.rs":"ddfa0af7c35a410cd5c64ba81feef28dbcf078aad736508ed69c71d47394617c","src/printing.rs":"92311a35a001157f12212e41f21d3d559b7e8219bf38be4bf595f36777855c7f","src/semver_check.rs":"0f1b26ac481daab44aded3150ecc1d50f38d648ebf9c3221da89072f23a995f6","src/targets.rs":"74531ecd7e1b1afa30ed24bb6340b430f1b2e1679ed80bf61894b018b4eb5f8c","src/validation.rs":"870632e0223dd980669d1d75560962502163745f54d53d086df5b0796e2da2ec","tests/components.rs":"78ba10ec0049026d5aebd72b7f651c258626c5fe25cbde4c0015f16834ce1971","tests/components/adapt-empty-interface/adapt-old.wat":"3a6db296d593ac422b4132714267a678490528f5299e3b263291fdcbd7d35b1c","tests/components/adapt-empty-interface/adapt-old.wit":"c04b693fd79794d910e739efa5d8356cec96e0b68df00b3fc21945f68a57cc4f","tests/components/adapt-empty-interface/component.wat":"fca49ffd58ca913a5d740e2cca9b91028f994682ae89c4e3267c0e624c616316","tests/components/adapt-empty-interface/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-empty-interface/module.wat":"e2f2a12e798371295a81cb05092d9164b37545d89962891759e0bd4728c3866e","tests/components/adapt-empty-interface/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-default/adapt-old.wat":"fe2824af7a5061c880d378a418796db230831b7cf50704a42e15c6dd2c9e6258","tests/components/adapt-export-default/adapt-old.wit":"71084c4ee7c4940876553129fe1b519e8eadacfdd3cdbf1cc640d5f3c5aa8831","tests/components/adapt-export-default/component.wat":"976fe1e9be2de60268d70c31ea15f59fdf9824ed411cb14acf1aeebd09d3390a","tests/components/adapt-export-default/component.wit.print":"7898d8d83177c3b78be309e32203a439946ec2765ec849ba9593c7703efd54dd","tests/components/adapt-export-default/module.wat":"8318fb33e37e0e6272ca8d25175c22db8d8c585cde1eb04210474b72bdb561d9","tests/components/adapt-export-default/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-namespaced/adapt-old.wat":"a5ba577bd703bd03fa961655122b46d2ef4ceb06cf851a3ba05e235b477b3cdd","tests/components/adapt-export-namespaced/adapt-old.wit":"3efacadc9fc5ea5997f0a2b468588100a1af780a6f43f09027b1999b5f04bcc9","tests/components/adapt-export-namespaced/component.wat":"865312e1ef947db62bb1856c19650cb5dc7d36de55e9e0d79263cc68d9bc011d","tests/components/adapt-export-namespaced/component.wit.print":"869261a145f6337aee4fdfdadc22f123784b8cf1839deecebda0607f5883f24d","tests/components/adapt-export-namespaced/module.wat":"8318fb33e37e0e6272ca8d25175c22db8d8c585cde1eb04210474b72bdb561d9","tests/components/adapt-export-namespaced/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-export-reallocs/adapt-old.wat":"9db1b4fbaf190e7e7fdea1caf291ae0e833a687f37b396096c6f4b7735491109","tests/components/adapt-export-reallocs/adapt-old.wit":"9cc7430d32be94c362abe794a4b356c470d23ecb6971de030f9b411c612352c7","tests/components/adapt-export-reallocs/component.wat":"caaf9904ead980403b632431a38bb6e64a461a531d03162961f490890c8430c3","tests/components/adapt-export-reallocs/component.wit.print":"82b6fe5b0953b68beee20d7f31e53712ec76f9f5d7196a2dbc57ac59a68c4096","tests/components/adapt-export-reallocs/module.wat":"53c738018c3b15fc3c7f21f1b8b5443c7afe89c25b08e7c56fc45a81a90627a7","tests/components/adapt-export-reallocs/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-export-save-args/adapt-old.wat":"60a41275befb6be47a8618fed9f3e1cab5b0807864d83e25bd84abe17d7579dd","tests/components/adapt-export-save-args/adapt-old.wit":"ceab954d883cf0c7d8c4cb28ce0bc641b969f8d0fda0bc411bc6fed8e553d220","tests/components/adapt-export-save-args/component.wat":"67f09c119ef670e3d478081704470b057d10a5f7b82016df4870dcf5211b1099","tests/components/adapt-export-save-args/component.wit.print":"6f24d727c36366175e949619aa8655755c6fdea10dda4770a30d0b366c877326","tests/components/adapt-export-save-args/module.wat":"6c7d1c7ded2d891fbbc9b778523905240c63bdc281aa4736c13bc01213d31a8b","tests/components/adapt-export-save-args/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-with-post-return/adapt-old.wat":"86ef0da2b6687532011de1aaac54add6150a43309b3d61a4e31fe37a5df6765c","tests/components/adapt-export-with-post-return/adapt-old.wit":"db342b3d869e263bae40fee459ca55736449430b255e9ef5bf6062a1ae3b0275","tests/components/adapt-export-with-post-return/component.wat":"f5ee8419b25645958d64c78613590418c8704f7663a4858dee0bceee28bca9b1","tests/components/adapt-export-with-post-return/component.wit.print":"869261a145f6337aee4fdfdadc22f123784b8cf1839deecebda0607f5883f24d","tests/components/adapt-export-with-post-return/module.wat":"a4e32bd0b2fbf43172da21f77d747ca1d8bef7779e9f9827429bdc114e62d63f","tests/components/adapt-export-with-post-return/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-import-only-used-in-adapter/adapt-unused.wat":"74d4a3a10e95b0b9a40a5269d3c28cbbc1ea1ef0ba9414497d2b1fed8648e510","tests/components/adapt-import-only-used-in-adapter/adapt-unused.wit":"9202e95a58f5d359c9c4f60dcbc5973fabc19915dcadf1d26e2324dda312f5e5","tests/components/adapt-import-only-used-in-adapter/component.wat":"74313f64cba93d7fe6afcea089730eefc24565976bb9bc9b9d71462ead3377c7","tests/components/adapt-import-only-used-in-adapter/component.wit.print":"9dbf66812387cd9f17ea903de18c0bf6ef6308bac6bd9db747f6cdd962b27497","tests/components/adapt-import-only-used-in-adapter/module.wat":"1920c02ae4d6c6c12ca57665e88ac039bf845e05f9b8628379cada9efff074ed","tests/components/adapt-import-only-used-in-adapter/module.wit":"ec9a35c247c4354e6960e3e8801c9aab4b9b5dd57a77fab348991b016b0f6017","tests/components/adapt-inject-stack-with-adapt-realloc/adapt-old.wat":"d7d78f6a6faa80d753c3652e9f7308691b9865435bb58338cb5479a66531b32c","tests/components/adapt-inject-stack-with-adapt-realloc/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-adapt-realloc/component.wat":"a6ee87c556eac0f3d2c01ee2eb1f621e01e61abafe6b3f073507144ee3c4fa5a","tests/components/adapt-inject-stack-with-adapt-realloc/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-adapt-realloc/module.wat":"623ad5e85f4ad4ea9c3480df598dbf1e8d50d7d8bfee01aa9b425550434b0160","tests/components/adapt-inject-stack-with-adapt-realloc/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-inject-stack-with-realloc-no-state/adapt-old.wat":"2102c5772be78a8a907be569aa0d185f0a1ad767e4d601a27a1b870151f892ba","tests/components/adapt-inject-stack-with-realloc-no-state/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-realloc-no-state/component.wat":"93c7d16960727e35915b81091c79c8f2906bc36a63cd21d64ee42e2a4caa0254","tests/components/adapt-inject-stack-with-realloc-no-state/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-realloc-no-state/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-realloc-no-state/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-inject-stack-with-realloc/adapt-old.wat":"d7d78f6a6faa80d753c3652e9f7308691b9865435bb58338cb5479a66531b32c","tests/components/adapt-inject-stack-with-realloc/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-realloc/component.wat":"5e67becee53a51ae1613af0389c1952b12481b5527fffaed1d6f9ed7b72297bd","tests/components/adapt-inject-stack-with-realloc/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-realloc/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-realloc/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-inject-stack-with-reallocing-adapter/adapt-old.wat":"f45808f40cf534bc765895f472b8f6b9880c8cfa450dfa30d3b9c20cede292e1","tests/components/adapt-inject-stack-with-reallocing-adapter/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-reallocing-adapter/component.wat":"f86cc7688639f35f5c618affe960325a916c0b01e6ef828b44737a03d4d15f81","tests/components/adapt-inject-stack-with-reallocing-adapter/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-reallocing-adapter/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-reallocing-adapter/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-inject-stack/adapt-old.wat":"4e61aa8171cbdbad0049d86bd37dc0c2ef1d983e245eab080b4006e453512e0e","tests/components/adapt-inject-stack/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack/component.wat":"63913d6860e01446c3b5340c6cc2d71b29e6a5e04cae3d38ae75288725382be6","tests/components/adapt-inject-stack/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack/module.wat":"7dd9f65faef528be9924ecdf40f0b05cd63b365f70761a31ff58afbe6629d98a","tests/components/adapt-inject-stack/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-list-return/adapt-old.wat":"d32ce421ec76960c676a09af5dbec9841d3b24d0dc8f8553f2b62d6b010707e0","tests/components/adapt-list-return/adapt-old.wit":"fedd6dc412b5980b85d901a02003239d23a6f5b935266f9e28278b0d09d66947","tests/components/adapt-list-return/component.wat":"1499ffc6fc636fc6560f01050c826a38d26120f9e501771714905143f12de04f","tests/components/adapt-list-return/component.wit.print":"3840662862e417d02278b78c1cee0913e95bec39416e29cf679e2868d8d52528","tests/components/adapt-list-return/module.wat":"73e71115facdc70bccaad35d84b1b7efe3c9ef1c53e554fcbb7cf6a47550621c","tests/components/adapt-list-return/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-memory-simple/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/adapt-memory-simple/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/adapt-memory-simple/component.wat":"d4d9a4ce50eb25fc7da3b9cbf0fcde90b9bfaedef4c184a7539501a1d4e88582","tests/components/adapt-memory-simple/component.wit.print":"a55daf78c190d92eef7b04a67a6115cb15a9aff7afe5f56311eb9463e72edf71","tests/components/adapt-memory-simple/module.wat":"5fc3894c9ed221c7d0059752e6f37610b37dc8452f9d08012cb62c93357d6f66","tests/components/adapt-memory-simple/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-multiple/adapt-foo.wat":"360aac53ba20c06b70ccbb17e6bf0abbd6c4256169e63983e0e16179d1b36645","tests/components/adapt-multiple/adapt-foo.wit":"cd76acb12ae0816ce116c5bf5e58fb6fef2cc3443c9d02fb9f166d71c7012d31","tests/components/adapt-multiple/component.wat":"9b59aabb6c55164d8ae24cb2e53307a2041a287a5bc7c3863ddb03b5243320b5","tests/components/adapt-multiple/component.wit.print":"a692a4e2fad55770689c501f3ee858e0d6a82da6306ce8c1ae67b9384004e819","tests/components/adapt-multiple/module.wat":"09c98f0e426797ca22bac7c8597e2b2299162642a56f9cd11c1791b8990c92c9","tests/components/adapt-multiple/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-preview1/adapt-wasi-snapshot-preview1.wat":"2d13becaad0a248f4b86b740e11c53b25e131c015a058cec83f35f03b1529552","tests/components/adapt-preview1/adapt-wasi-snapshot-preview1.wit":"8b084967d2be4bbf24735fe204fd7a5141f6c8baf4939aa033563fd0643509df","tests/components/adapt-preview1/component.wat":"9dbe467777d360124849e44a6f11899ca69db4aeb155d7fd53f60aa1755bdd1f","tests/components/adapt-preview1/component.wit.print":"5d4f747617d4e49467d7ab1f831a859531f38ba8fdbf7bca6af91f1e3583086e","tests/components/adapt-preview1/module.wat":"6d3d0c452aaefde1fbdcab22b2207c3dfc91cf3b7ce2133414090fc770a16bd0","tests/components/adapt-preview1/module.wit":"0207b70f162393b9976640b7afb83470fc815ef69d58523a43e9ffd4997b0f67","tests/components/adapt-stub-wasip2/adapt-wasip2.wat":"c18d8a24f5c8b2e88b16b50a3104357755b788930ad9a1ce42f2c1fd56539c46","tests/components/adapt-stub-wasip2/adapt-wasip2.wit":"25d97f7ad800690ce2b90446b0c7c953b99ba4546203dc3de6687175b210776d","tests/components/adapt-stub-wasip2/component.wat":"f64740e5a017765e3bc8e791127689aff0b47839eca137910491960dc421199a","tests/components/adapt-stub-wasip2/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-stub-wasip2/deps/cli/environment.wit":"b6350bc0c8d1e916d0ec7ddec44bd702f4419fe6e8fb97878d725d7db55f2937","tests/components/adapt-stub-wasip2/module.wat":"67ef212810041d77c3db6df7fabe3d52dbf063a963433a7a478b02f641f83323","tests/components/adapt-stub-wasip2/module.wit":"6e2cbac25c8c2d1120f26f1c04d01cbf3d7578ef759e0b599c6c23c535ddb20a","tests/components/adapt-unused/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/adapt-unused/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/adapt-unused/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/adapt-unused/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-unused/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/adapt-unused/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/async-builtins/component.wat":"1f480263d84e78f6bbd563eb6ff4469d4869e75f8ec129b3904316d0d662b88f","tests/components/async-builtins/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-builtins/module.wat":"bfd0ce1103f232f0593735b45f069d81ac006c0126ac2f16a970c50c5ee1d383","tests/components/async-builtins/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/async-export-with-callback/component.wat":"58c5f7d4687125e5b0363373f322fa01f81531607fb95e33b493733ed33ee1eb","tests/components/async-export-with-callback/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-export-with-callback/module.wat":"38d85c7293b53c0b6fe33192f048b78ee60251dc63106c9b74e0ea314e75f90a","tests/components/async-export-with-callback/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/async-export/component.wat":"fc439f383bf912477408772aa4a7fe130606921798fc690429ba263b4f63190e","tests/components/async-export/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-export/module.wat":"f239da1438442af8f76ea2067cd25c7abd14af474e304584e92f749eb2c05e17","tests/components/async-export/module.wit":"bdf4e2c172d5eadd8f785e7e467655e3dec8eb98101cb84532c8eaace201b75f","tests/components/async-import-only-intrinsic/component.wat":"661f847e409d1dfd62694ec2c659731ab226078d2490a19f64de4799aa8cc60c","tests/components/async-import-only-intrinsic/component.wit.print":"d72c0077b57005a82a04181f4de5a19d0a13f342e51f8ae39c16df0200ca4e2e","tests/components/async-import-only-intrinsic/module.wat":"d739e805be3be8e4594cf3551c6ab32f2550264047535e0dd00e96ab7303f886","tests/components/async-import-only-intrinsic/module.wit":"a67e614f426d01595a5908748223980e6b71e7ae71e9bb55c7954503a4fa5883","tests/components/async-import-tricky/component.wat":"59139c14308ce67e8b3348d1c77bb7826b1d5e744cb90d495b2e2012ee432dea","tests/components/async-import-tricky/component.wit.print":"d72c0077b57005a82a04181f4de5a19d0a13f342e51f8ae39c16df0200ca4e2e","tests/components/async-import-tricky/module.wat":"6adce7213ac96e7fcae050279d5e7011b92aeb84fb8160565ef904bc167bf205","tests/components/async-import-tricky/module.wit":"a67e614f426d01595a5908748223980e6b71e7ae71e9bb55c7954503a4fa5883","tests/components/async-import/component.wat":"3276ebf1556e6715bceded460db3e4531c0fcaa305d0afcf212b26bdfea5b115","tests/components/async-import/component.wit.print":"f17ba3097a41cc0faefcc85611f316be96d7bfd4f67abbc93963daf2c04cf2d4","tests/components/async-import/module.wat":"5f5894e70f438a461441d85203a948f3e5accaf8cc0470195d5b18f8547129d8","tests/components/async-import/module.wit":"31a71ad2c3142b71c67e87c6149efadca1e9ef6262d79eadc88ee2ddd8407203","tests/components/async-streams-and-futures/component.wat":"40a857b7d40ec7046fe7773319393e8dcbb1f708f6ef7527744a12bde1267b4e","tests/components/async-streams-and-futures/component.wit.print":"fbf4aae8ea7d2c661f42b5508e7617eae0e369092941104e5b33d01df04520a0","tests/components/async-streams-and-futures/module.wat":"bacd5dfec7a79670bc135eeb42bc3da07835686156058e9337f2740ec9658028","tests/components/async-streams-and-futures/module.wit":"21bddc5f549b3886d0f2ba9cbc838e5ecd29b1fe2d6a559bf4f44dd634f6878a","tests/components/async-unit-builtins/component.wat":"a699b5191cb6c6e394e642fd194949fed3a5eec7ab908ab664902fc1d1b24f3a","tests/components/async-unit-builtins/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/async-unit-builtins/module.wat":"c75ea94e991400e50800712542c8655d038ad82f42eb87e8075f58e8d4bd22f6","tests/components/async-unit-builtins/module.wit":"62887f2f27236202880a9116dcb8bb0d082ce1d1842f3c247c437f6bf9f12413","tests/components/bare-funcs/component.wat":"b1e1026a7e45f7944d426823cf162682776459fcbbb42590067fad56723f616e","tests/components/bare-funcs/component.wit.print":"44142a3e54179c58231b1406306664b56e708d091373d4c9d26f8a8836fb19d5","tests/components/bare-funcs/module.wat":"eeacf6a9a06818a3dc1938f3f7e70d49e34aed35b6ff3000194b83b310757bba","tests/components/bare-funcs/module.wit":"cfb306074d962ab1cd345b9146c19593efcab6a033b350f809eb28be53a5b709","tests/components/cm32-names/component.wat":"c4e1443a880ebe01ea12a930726c29f3f8f572cba802b0f849791fb0929876a2","tests/components/cm32-names/component.wit.print":"931313d8c16524f0a195235a8acb74332448679069f426535773aca17354c6e3","tests/components/cm32-names/module.wat":"2377a85fd01e55a6fdb6b91b8074967c86f00a565a4fccb0ae3f463dcafe2c03","tests/components/cm32-names/module.wit":"9512314374f9cbd23730915c09c154e48deaf6741013e8d32e22dedae556aaec","tests/components/custom-page-sizes/component.wat":"3eaa8c9790617a9026c077489ae93022ae6e970577e37ea5d850abe90137f22d","tests/components/custom-page-sizes/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/custom-page-sizes/module.wat":"735787796014137b07df0a6c8a5f07b6f9c202440111456ef4b2224b60583b1a","tests/components/custom-page-sizes/module.wit":"2e6ea2c38b49574cd8f8303204067e2977f695925f161c9e68002cd1fee842a0","tests/components/deduplicate-imports/adapt-wasi-snapshot-preview1.wat":"3d96dada383101358bd8985bcc1ff9956d8a50016607914182f205f777a4ebf2","tests/components/deduplicate-imports/adapt-wasi-snapshot-preview1.wit":"f4d3eef4cc15bc74a4d9d7d045aacc81be1991b4bcb184d587e2048a983035d4","tests/components/deduplicate-imports/component.wat":"41496495e2e28882e71d39822a7e8e798ea636e8b0050296320dd7f84eb497b0","tests/components/deduplicate-imports/component.wit.print":"bfc18ec3026ea7285c88bb8da1b4dd5d77db4e41fff8a8f0f26df9656a18ae8d","tests/components/deduplicate-imports/module.wat":"11693ac57d19f8388286897e8a3b3b4d2d18c9ac92ea9cee5e9559038818ad30","tests/components/deduplicate-imports/module.wit":"ebc9fa1a6bf412c67ce4dc481a1477500a902b56c5f395bf5618c4a14474485e","tests/components/empty/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/empty/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/empty/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/empty/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/ensure-default-type-exports/component.wat":"a7991c6b578b95b41de82514cac59c4aa19b46d6341f244eefb16f4bffc77491","tests/components/ensure-default-type-exports/component.wit.print":"baf9b735b1f9dbf8e247064d5735bb8b37fe53f6f1e9bd1bd154a991177e1b54","tests/components/ensure-default-type-exports/module.wat":"14a179f41e4e06a59b4e34f0815ea34e12ccf1f8500bccd83623deb84c71093a","tests/components/ensure-default-type-exports/module.wit":"36353bc5366252cae33912f215d77dc501384cc9606dbadf5fc831b33376f3de","tests/components/error-adapt-missing-memory/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/error-adapt-missing-memory/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/error-adapt-missing-memory/error.txt":"d8491054cdabd0359c1ece02710db9f5989eb58c43283e73dcd0401231fdeae3","tests/components/error-adapt-missing-memory/module.wat":"a09c5c2e4aea7fabae1df7f54791a87061018325968a3f9379d35e3ce2cc405c","tests/components/error-adapt-missing-memory/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-async-export-missing-callback/error.txt":"53956038fd6dc7921e06b1217ea0bb21ce8fb43f9dc6ca42ef5f069793d6d899","tests/components/error-async-export-missing-callback/module.wat":"89ced8e40f2175f16f59261807e23b05dfaf326231873a6f011fc4b765fa86b6","tests/components/error-async-export-missing-callback/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/error-default-export-sig-mismatch/error.txt":"04dac125afd8c985269ced00b248d43cb7dc96f8a52dac2f3103c260aa86f856","tests/components/error-default-export-sig-mismatch/module.wat":"d61b464c502b1af9fd83b5ff5339ac45d2674c9455163bc7a89a02fb5454f878","tests/components/error-default-export-sig-mismatch/module.wit":"5d093bdde43c050d69d2df8b034d66ffa6c076ac4c83b26ad7e9cc78ef49dd68","tests/components/error-empty-module-import/error.txt":"98053ec5a972463d2c9411c82da5b2fa95e24099f6e6c61d355212d46444e8a4","tests/components/error-empty-module-import/module.wat":"a9e2a33d4affd7e94275daf7dd6475c71135de2359343ab0568a3fbe7204a527","tests/components/error-empty-module-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-export-sig-mismatch/error.txt":"a90a4c7f4f88369d8cd30673fa8cef6628f5eef68bc626a225fab11aef056d5e","tests/components/error-export-sig-mismatch/module.wat":"4d7dcefb19126be4325185e99fbd3f0f964947e8bce9cb4254dd153da60a4e39","tests/components/error-export-sig-mismatch/module.wit":"775d9b931e1644f29c0124edb264af4b6c9ef9417c3abcaa2711ec99b809b85c","tests/components/error-import-resource-rep/error.txt":"19991af81b6006ae5d7f1f92f945a8c4debf1e82069ee4a67420df4fd6de8f5c","tests/components/error-import-resource-rep/module.wat":"01c719d6eb94c6e3243e04425c6eee29f5afa86d7de59e0231412190385b3759","tests/components/error-import-resource-rep/module.wit":"9dbf3ad66ed4cd913521b98dcc1eb51780671de15a1d2f3da86fffcc59a9a906","tests/components/error-import-resource-wrong-signature/error.txt":"3e2a1f3b231bd148cbfec7108af76d5f61d90edd5454c0974f0bc86c6049002c","tests/components/error-import-resource-wrong-signature/module.wat":"9f921559b46bffc7e412984c49395cbef1b723e616cfedb5ceea6784b70471e2","tests/components/error-import-resource-wrong-signature/module.wit":"9dbf3ad66ed4cd913521b98dcc1eb51780671de15a1d2f3da86fffcc59a9a906","tests/components/error-import-sig-mismatch/error.txt":"b3364c1047649d851a0ae1d80332a6df1b34504a8519a132c68fc1855c7443b8","tests/components/error-import-sig-mismatch/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-import-sig-mismatch/module.wit":"d98bced030198058d8c1a6e77161ef9a1e3871f8f2c539a618aeccfd4cc19b1b","tests/components/error-invalid-module-import/error.txt":"f8359fe5bc543bda23293a6f8d40b1d96d9dd6d0d521e538113c0b69ad5a0d6b","tests/components/error-invalid-module-import/module.wat":"20b107a75357922999a6951562cb321ff63926ce1011cf724da12ed1b2c86ac9","tests/components/error-invalid-module-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-link-duplicate-initializers/error.txt":"05be0b8139892df6dac079ba7726fce46909ed661bc4367644c9c6ee7f7c8b3e","tests/components/error-link-duplicate-initializers/lib-bar.wat":"7039053f316ef76c2f5e47e266a950bdab536c90b558f408edc43560f215eed5","tests/components/error-link-duplicate-initializers/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/error-link-duplicate-initializers/lib-foo.wat":"162307ee1bb2ee38b02d94e8dae7d0b367cbc7e66250286141e557db56b9816a","tests/components/error-link-duplicate-initializers/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-link-missing-needed/error.txt":"75506d6c1244cd5d0abc95789f38036415599d737a0e34ea0894b23dc9598bad","tests/components/error-link-missing-needed/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/error-link-missing-needed/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-link-missing-symbols/error.txt":"1b8771b7638f5ed476bbd54c5f613c144b36f74ef4f700940540a913f6960c3b","tests/components/error-link-missing-symbols/lib-foo.wat":"d0b8b5ff95b5b4008cfa306d4af74bbca75bf07bd42ec897b711eb3064b1108d","tests/components/error-link-missing-symbols/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-missing-default-export/error.txt":"5a53be2c03ca12de39b6dd856ba0cb4b61ae41284c8970dd319f92458c3fc8d4","tests/components/error-missing-default-export/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/error-missing-default-export/module.wit":"155bf2d1c7ee9ea2d284964c56c936f94ae987195787235350ced0dc6d6db305","tests/components/error-missing-export/error.txt":"878e7173e57fb0eb0df926bb43e7e0403f88462ea9e67c2412018712e6f9ed56","tests/components/error-missing-export/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/error-missing-export/module.wit":"eb129f25552584be9360310178c70a65029de6b72a1440ed99ddbf38d0916c6b","tests/components/error-missing-import-func/error.txt":"be530862604920bc57c09726e1c33d9b19f998c34d41b0fc92e1da9a21c5b4fe","tests/components/error-missing-import-func/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-missing-import-func/module.wit":"4f0718445438c4dfc08950cdfdaebb4a4c5adf2d724d66bd145ed593c1592c1e","tests/components/error-missing-import/error.txt":"be530862604920bc57c09726e1c33d9b19f998c34d41b0fc92e1da9a21c5b4fe","tests/components/error-missing-import/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-missing-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-missing-module-metadata/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/error-missing-module-metadata/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/error-missing-module-metadata/error.txt":"993083f2635f4875169fbcab22b59bf416eaf09de7708cdb26f47918c615ace5","tests/components/error-missing-module-metadata/module.wat":"66a5907fa8f666c22e3f5cf88cc62a8567a777d750d76374de448e0f8e8ac7e0","tests/components/error-missing-module-metadata/module.wit":"62887f2f27236202880a9116dcb8bb0d082ce1d1842f3c247c437f6bf9f12413","tests/components/export-interface-using-import/component.wat":"7d16e055fab6b2601aec5aa0618462d75106e29ad65a676ba31301403d7b0269","tests/components/export-interface-using-import/component.wit.print":"3cdf7896480bc68b7cb0b9c9ff4dc028eb7d435f58de7bfaaf403e426438fd19","tests/components/export-interface-using-import/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/export-interface-using-import/module.wit":"c6b8fc795e93412e9cc6e2ba335c20c89e0ba442f684bb0ab779ce052e715c32","tests/components/export-name-shuffling/component.wat":"abe1f435743fdd3690dac62d9b60ee7afcae762aa9e8e912fa8556fc83eedb5d","tests/components/export-name-shuffling/component.wit.print":"32e7124b8455a67f63c1071d9a5332dddec63c47472909222b351111e0146817","tests/components/export-name-shuffling/module.wat":"cdec922bed8d252248be323019e3d5fc83e0bfc9777fdc654b59348daeddfd19","tests/components/export-name-shuffling/module.wit":"99d470993cedf025e7c356ea8e5c6a041aba2968419193eea5f1947061b19750","tests/components/export-resource/component.wat":"8ad1eca01f2d26a7135898bbb123391da9827604f6900799894b281dabac3bba","tests/components/export-resource/component.wit.print":"9a6e09d0140a25319041d65333e58adf87a0231b5283c3bc768ccbdce83f9c24","tests/components/export-resource/module.wat":"35cf529d4838d0652bbd322e3498e72d02643a4d105c0b7dd801d3648621316d","tests/components/export-resource/module.wit":"ff43e87ba4fb913e5e239a5282f0f0acc33aed4fa04610be25a706791429b56f","tests/components/export-type-name-conflict/component.wat":"02a9d2e58bb5abeeced1fda8ea356bf2a288d27d8f376b0ef84c353804193b0f","tests/components/export-type-name-conflict/component.wit.print":"0039957ae8e5e8ddba28cb0f8c7831a33864e407c87550f578af5e36b5b9d97c","tests/components/export-type-name-conflict/module.wat":"b8703739f92ca2de5a1483eb2504fc082e690f514fb014c7e09b6e5b0348a3ec","tests/components/export-type-name-conflict/module.wit":"47b93fc6d44cd48c9ba768feef028a5dd9980088ac328ef965038f349a566b46","tests/components/export-with-type-alias/component.wat":"01261b62e3576b58c1105019e610e1377476dab64fa0d29830358ba5efd35906","tests/components/export-with-type-alias/component.wit.print":"35e7687bbeb38e07890e152ab3359c6ecb558ae513b44f41efe60be15d99c5cd","tests/components/export-with-type-alias/module.wat":"d0e73d5437af39f365675b5c516a12ffadd6844ab1a7cb36f63829716a823c10","tests/components/export-with-type-alias/module.wit":"22f298065ce8a2fdaf726cdb347c4bca9e56700fc6475bda9ef5ef8563ff0d89","tests/components/exports/component.wat":"acfce3dd26ac8a4bfdfeaf3b01d6c23773acfbb1674813b26eb0f3e1075d4d45","tests/components/exports/component.wit.print":"761c69439ac16484a2b210ff34d219db4afb2bcffad4f3868a2e76479feb7f19","tests/components/exports/module.wat":"324dbfc38fee5a442e7ce3a13eb2a4d25dc6a074ba81bffd4fb35268608f9d08","tests/components/exports/module.wit":"d41d5f8763da23fceeb773ff18c9960132a1e811ef194a47c900d21f48083d43","tests/components/fallible-constructor/component.wat":"1b42b21f2ffd5de0614188b285517732b0676801b2c9460a54908629722b8386","tests/components/fallible-constructor/component.wit.print":"a486e9bc2d393474b05ab915bf61a573e89ef09e3bf7bed24e16cb95a27df2b2","tests/components/fallible-constructor/module.wat":"9dd3bbf052d233572a70122e34ada7573252fe2e727c918bda87f44d62ac7efc","tests/components/fallible-constructor/module.wit":"310b82945183ab329679be7f832f0d8c11c59360e700f9646f87e881e612d0de","tests/components/import-and-export-resource/component.wat":"7fcd443bafed0b524f49c7fa27b371ceccd6b95249998f5c8787e481d4e7547d","tests/components/import-and-export-resource/component.wit.print":"fdb32e7784b0d908390a0d1b62e077294f5168cb46daa470ac5e078cbe8996c9","tests/components/import-and-export-resource/module.wat":"43b89c3fa07a24663af81eaddbd02778a0d9062ce65efa7f04dd10081cc8aba0","tests/components/import-and-export-resource/module.wit":"a9f3ee298ad42fcef0d80a34b6b58e1d18e438e492400463993508599d02adce","tests/components/import-conflict/component.wat":"f0008f711d6bde4eb701a08fa5c61c021e33c61501fe3fce25535a420be1d63f","tests/components/import-conflict/component.wit.print":"19bae900cafe77b7bacda385e23475154f90f0a8d8f063597496132e149867f0","tests/components/import-conflict/module.wat":"639633c3b575c976831d12d1d7e69826ee23165c8cbb6094940397c8359ddc6a","tests/components/import-conflict/module.wit":"d8fd770eb17db0c5e7adc23c41315cbfd77af9014b4514d65fe2f28a629b7b43","tests/components/import-empty-interface/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/import-empty-interface/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/import-empty-interface/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/import-empty-interface/module.wit":"f570a16495e584b54606fa6a50018cfd1ab21dc85c10deb7f869564db3d7450d","tests/components/import-export-same-iface-name/component.wat":"7e506c2d9bcd48d98b4fa2acfe4a7fa33f6ac8cffc764629d9fce27f2005b3b6","tests/components/import-export-same-iface-name/component.wit.print":"510d7b609e6714e7bfb7cbe9f57c42c9d2318ec17de0ece8522599dcdc7aa22e","tests/components/import-export-same-iface-name/deps/dep/foo.wit":"e53988c57720965219fa842f767cc30e31f3c18ee07ba9833432ca2084ed4fca","tests/components/import-export-same-iface-name/module.wat":"a951a5e947ef899087bbe377a97c06d4f742afdc97ecdb673dc3e0e60019f956","tests/components/import-export-same-iface-name/module.wit":"c9bbae4c071ea7fa7da77e422fcb93d48f14a6faf0adeba4ef94b3949cf1f9a8","tests/components/import-export/component.wat":"bd51d58f13dc0de6ae5b62eef53383064378f62172382b879659dd39c4128a51","tests/components/import-export/component.wit.print":"07735b330c59c0c01e604e0d4cfebf3d513beb24a547c3453f9e804a7f502819","tests/components/import-export/module.wat":"5e42ab263e87ae03d3649d839f86614ff580982033ce7022dbfe1c6c13e886aa","tests/components/import-export/module.wit":"c90a74db6e305afd8c8da8c4b9d1bcdb0e4dc575c28d1cb302e2c3ae1b087c21","tests/components/import-in-adapter-and-main-module/adapt-old.wat":"43d847aa6521beba5a478c3bbede7f255c47ab6ee31b4f34a1524b28dfa25df5","tests/components/import-in-adapter-and-main-module/adapt-old.wit":"3cf2e31d18b76f61c61958cbc7313290ff7fb323719d31e89c054b9f6b41615e","tests/components/import-in-adapter-and-main-module/component.wat":"c9d2c38b30c0731bcc8ffb555a38d501135ce2065de42e8c16020b3b87d2f4f7","tests/components/import-in-adapter-and-main-module/component.wit.print":"fb2791ae3aa119e2ef9aabaa811df8a84a5680bbf26a7cb7697403f8efee705b","tests/components/import-in-adapter-and-main-module/deps/shared-dependency/doc.wit":"ba5a8f346d581ddcab0cddbcb00e976e54327920d4c7f98933a422f03e62339c","tests/components/import-in-adapter-and-main-module/deps/shared-dependency/types.wit":"2aa8bf309a148128bf6ca4ccd86c8fae95e97953a73f2ee7d652613a4eceb5f7","tests/components/import-in-adapter-and-main-module/module.wat":"6995ee3ebbbab471d4b7a7d9973647e5a4b86851ed54fc019b6ce46b39c3849b","tests/components/import-in-adapter-and-main-module/module.wit":"d1e48a09fb9307185b79f5f200b54e906da5ad62eb57e841bea93e239a96b9ed","tests/components/import-only-resource-static-function/component.wat":"1bd74e7edbc1bc26bb6c24508a941b67d8aaa3c2fde5ac2ba3183a930ca917a5","tests/components/import-only-resource-static-function/component.wit.print":"392a1d0c73268c3e20bce45065b5618dc8ec498e280d54c226a7701c2c7d17c2","tests/components/import-only-resource-static-function/module.wat":"cf1e1ed8d03ed537c0cefd5261147933c78b85cd748c92f5f005642cdfb1a01c","tests/components/import-only-resource-static-function/module.wit":"c6cf4995b848915d6c99a90f3b2ff95c32ecc9c3cdc21ece827d0840035d64ba","tests/components/import-partial-export-full/component.wat":"55081ae4598055a3abb4ee4cd3676ba30e99a80a167f87e2226be278b8d59435","tests/components/import-partial-export-full/component.wit.print":"3ab4179ebc8dfa619f72f3b51517dd038ba0b2bb1ada2ab063c2cb8dda844b85","tests/components/import-partial-export-full/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/import-partial-export-full/module.wit":"d37ab68346e073666081684d84a94ce9de6c27fc50ccc3c774b902f13dd77e77","tests/components/import-resource-in-interface/component.wat":"9463d61a86d5eb0c4eeac4caad24e61ee406a8fdce569f4a22c972cebb09b345","tests/components/import-resource-in-interface/component.wit.print":"313207ca455eee8d5649b5901c2e7786b117761cb76626ffed15bdfc6efa743c","tests/components/import-resource-in-interface/module.wat":"dfab4bf8f2d634b2f8db1c452ba1cc9f9aa20da580fb8e5f520d9383d53aa614","tests/components/import-resource-in-interface/module.wit":"72d6d2861b7cef7939fd4af3c615db98cb29a08fde3cbb4e5a4ea6fc463993c2","tests/components/import-resource-simple/component.wat":"0a9a15caf8bc2c69375dd1f1f0fe571a9c139e84132039834c1728ba0a103cbe","tests/components/import-resource-simple/component.wit.print":"7d166ca48287419d030b9cd49cd69150fc3a534f1ffc5569cee934c002f1028d","tests/components/import-resource-simple/module.wat":"76206dd7ed5d0ca30f9db6085cc3d0908fba505bff097e5310e1e7eeb6cd3d7b","tests/components/import-resource-simple/module.wit":"81993bcaeb714767b9f5d040079bc2b71cda292861b5d1705d55010e809907b0","tests/components/imports/component.wat":"1cbf22691c0723e661184424d00c620126db8a338499dde7397f29aa75b028fd","tests/components/imports/component.wit.print":"db03bcc1e409cf7eda8abe72152b697bf2242696c9442480d427033a6ada15fe","tests/components/imports/module.wat":"726b52e97319350b0995edadb347404724f750b451515cca2998d6ea43fbff58","tests/components/imports/module.wit":"ae6f59d5a9862832e4393df2e066ab8bd671a0072922b720bd6a7da703bbce43","tests/components/initialize/component.wat":"55ef7b724f6dce61155262085d7d9f627ad3ef0647049f86d836964664f48eed","tests/components/initialize/component.wit.print":"c621c6ab874ea1463aadf38c9a9499772183c86580381c0af0ddda71379213c9","tests/components/initialize/module.wat":"d6b0dd9b619d3ea4f767cdbaee59abfa5cc429a7fde2dbf30d4b98bc1ca8abc6","tests/components/initialize/module.wit":"2ec1457ceac2774e5c0f8701c08ac63575017bdbf8b2f58551f3f946edbae839","tests/components/lift-options/component.wat":"8e7a0fd9998956377a8c4521c0795698245e5e1f4882ec427fb917e1c078e688","tests/components/lift-options/component.wit.print":"0efa031b0013f70c3c5092f53e40b10c0ae02398403320a28ba7c28533517f2e","tests/components/lift-options/module.wat":"7f74aba6c2e663bc2a7de94bfcdeea21cb9f837952a6b7d5473998ee65d8ae33","tests/components/lift-options/module.wit":"63ab644fd22c7cfcb0b9a6195065f0065abc01eb5545e18437c02e6a68e09bd2","tests/components/link-asyncify/component.wat":"8b989d3709a2dce7d8e8894ea83cf827f9b3eb7caee007eb9b059125ec7e3047","tests/components/link-asyncify/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-asyncify/lib-bar.wat":"159e0a9e578b652915a4a1c525d876ab78c76574edc757eed8f2d898231ef3eb","tests/components/link-asyncify/lib-bar.wit":"2314b69344e6938e980366d4a2f912cceecebedb03783199a1827f641fa8aedc","tests/components/link-asyncify/lib-foo.wat":"d61a8d805cfa025d3be070564e8cd993a21307549af7fba1f2702ca5c4d083b8","tests/components/link-asyncify/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-bare-funcs/component.wat":"72c3bff4be47ed0a7f1bf2754c80665a2d20b292881891c0f5fd28732ba1fd4b","tests/components/link-bare-funcs/component.wit.print":"ffaa54c61b292fd93917c958eb7d4a2d6db224b5a30fbced6f07530c23486aa7","tests/components/link-bare-funcs/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link-bare-funcs/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-bare-funcs/lib-foo.wat":"57eea96d26803de69e0a6a69314006251da4146416f658cc7447e5f4212d0ecb","tests/components/link-bare-funcs/lib-foo.wit":"ce1132f1f5d9df197a0326a2b608df671179d490dc537e9c1f8577bd25c57ddd","tests/components/link-circular/component.wat":"5e1b586bb766e1cf3a2cfa47bee8665e44d0eacd8c9332f08e52ee04da6aa4b0","tests/components/link-circular/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-circular/lib-bar.wat":"7039053f316ef76c2f5e47e266a950bdab536c90b558f408edc43560f215eed5","tests/components/link-circular/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-circular/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/link-circular/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-dl-openable-builtin-libdl-with-unused/component.wat":"4444f536a9a97ea84a3822944ba48ec05e8d045ecb5ff86e67807f2106815bc2","tests/components/link-dl-openable-builtin-libdl-with-unused/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable-builtin-libdl-with-unused/dlopen-lib-foo.wat":"e02d2c79ff11af4334d7cf751750843102a4c2c40e1aa35686fd7d04b273cafc","tests/components/link-dl-openable-builtin-libdl-with-unused/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-c.wat":"ef5b56730b4c79fbe9f9e10f462ae222ff18bfa2a960ae03a86e3152257fbe6a","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-unused.wat":"099904a1539e31d8ddd306553dacd0667ee221a76aea79a3861a269d9edfaedb","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/link-dl-openable-builtin-libdl-with-unused/use-built-in-libdl":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable-builtin-libdl/component.wat":"6dd489bded8be0b711abb6129c927cf4d561979fbfc60dcb2317ac103287f32b","tests/components/link-dl-openable-builtin-libdl/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable-builtin-libdl/dlopen-lib-foo.wat":"1183b069d484eefd7a030c9ab975d4ef5bf24fcb033d922148398bc5ecb0de89","tests/components/link-dl-openable-builtin-libdl/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-dl-openable-builtin-libdl/lib-c.wat":"e1988d4a8ff43aed730375fae50e601b9d3f5c28ffafa56f6be581be1517394e","tests/components/link-dl-openable-builtin-libdl/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-dl-openable-builtin-libdl/stub-missing-functions":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable-builtin-libdl/use-built-in-libdl":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable/component.wat":"f169770d4cc24e8ed2c010810e31d956f29374e029b9f2dfb563a6b2f499d919","tests/components/link-dl-openable/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable/dlopen-lib-foo.wat":"7047914692755e525a4049b7973c8328de2c19fe0f1b65a368228f654d14937d","tests/components/link-dl-openable/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-duplicate-symbols/component.wat":"f015b4fd73d2f0b694d4cf0c18be014a82a1dbfca0bdf92452d295bf8382ccc4","tests/components/link-duplicate-symbols/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-duplicate-symbols/lib-bar.wat":"346743798987c1a403b7e4941791c3dff77e6fbfd83afab14596b3efe81b5808","tests/components/link-duplicate-symbols/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-duplicate-symbols/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/link-duplicate-symbols/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-got-func/component.wat":"28f03634ebea0fe1b7d2b187ec472e806759999e6e338116bebabd45ce366db7","tests/components/link-got-func/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-got-func/lib-bar.wat":"b68db9e5915e6875477363893779792319e68e6c0b23411dec94ceb903f2844c","tests/components/link-got-func/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-got-func/lib-foo.wat":"02179e2a615fa830bf3c7b8d42ba1abc9e922b2cc163bf03f389c19fccd3e8c4","tests/components/link-got-func/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-initialize/component.wat":"dda1f4d706281526a986c2973dc2814d58fcc8d035b61de8547b88d968e74564","tests/components/link-initialize/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-initialize/lib-bar.wat":"acdc5991e4e0bcd1a8d681599326d903b47a8485ecaa341daa95d75a10dbc270","tests/components/link-initialize/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link-initialize/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link-initialize/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-initialize/lib-foo.wat":"230df7123dced23e7ed1e01f8ab4c0564d0784c27fb5f56432a9641bb74cd20f","tests/components/link-initialize/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-lib-with-async-export/component.wat":"2ccfbe257b2318b3de66c8023f9f8c57b41ac2af678ec4ad5ecf0f565aff4f67","tests/components/link-lib-with-async-export/component.wit.print":"0d42f40f1f6c38efc4d7c51660b69bfbc86abcbdec31c6350ca6862202d2fdb1","tests/components/link-lib-with-async-export/lib-c.wat":"b42be22217533ebb066b70b2bb36d0deadd5470e45b6ea272e54ccef6d8ab62c","tests/components/link-lib-with-async-export/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-lib-with-async-export/lib-foo.wat":"b3221090479c8732841d2e57583a49d60c16ac0aa7fe8f6e1205212939ade018","tests/components/link-lib-with-async-export/lib-foo.wit":"358a5c8eeb2eb91489109180f0372fa049ca51b03dc56761bafa8de593e26c78","tests/components/link-resources/component.wat":"a41b479bcebb05a75cd6c29c996f02d65920219c74ee5c3394167dada015014d","tests/components/link-resources/component.wit.print":"7c9bcd7d88669aba18c1ff9979d40fcbca7ed4616db8fdae221e75f49c30e863","tests/components/link-resources/lib-bar.wat":"a19533149c2054deeb209e902be84d472b72b6a69771ff7db7d6c881028e172a","tests/components/link-resources/lib-bar.wit":"c51af5e3a0b53612bd02b9cfcfb509145806703ba7591ae9562a324e261fc805","tests/components/link-resources/lib-foo.wat":"914b197c116ae12a47fd337fd0ef1160778479f619d38f958d8ccf6ec1e92020","tests/components/link-resources/lib-foo.wit":"98733c4a044f7ec1916a604bf4d78f1e0fc7432e9d170479c6d513ce33efb3b8","tests/components/link-stack-high-and-low/component.wat":"3e1c9ae6dbab0ccd91f92c372a9ab50f1d97899d5a8ec9797042ee9ad6422fdd","tests/components/link-stack-high-and-low/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-stack-high-and-low/lib-bar.wat":"3477c2c461c8bb6064072d4b278843906a3b3f513439cb2ee5738562c51dd99f","tests/components/link-stack-high-and-low/lib-bar.wit":"2314b69344e6938e980366d4a2f912cceecebedb03783199a1827f641fa8aedc","tests/components/link-stack-high-and-low/lib-foo.wat":"d94339117228cb4b645b29fb4ce711e24f77aafb83b4579279353cd72d1ae94d","tests/components/link-stack-high-and-low/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-stub-wasip2/adapt-wasip2.wat":"c18d8a24f5c8b2e88b16b50a3104357755b788930ad9a1ce42f2c1fd56539c46","tests/components/link-stub-wasip2/adapt-wasip2.wit":"25d97f7ad800690ce2b90446b0c7c953b99ba4546203dc3de6687175b210776d","tests/components/link-stub-wasip2/component.wat":"dba0ffa80c499bf9a2522d20af4904b3fd50da45afa94726e84bb7d0ba13ae5e","tests/components/link-stub-wasip2/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-stub-wasip2/deps/cli/environment.wit":"b6350bc0c8d1e916d0ec7ddec44bd702f4419fe6e8fb97878d725d7db55f2937","tests/components/link-stub-wasip2/lib-bar.wat":"ac236a5b648468d6b729bbcfac2d8d3c2991125a0652d9a6fb62a7327a3c5fa1","tests/components/link-stub-wasip2/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link-stub-wasip2/lib-c.wat":"ff30ef2aeb8c5503309ca521063086d4401b11d5fa42e787ae52c3ace024e6df","tests/components/link-stub-wasip2/lib-c.wit":"7b97c2b019fd47edcee51bb66c69b71a3124ce4ac77b81af0d40b1edd957e8dd","tests/components/link-stub-wasip2/lib-foo.wat":"f46165ea11b30f70136d932c8a34a7492e03f2f51c694100a9bf35312f5ca502","tests/components/link-stub-wasip2/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-stub-wasip2/lib-unused.wat":"dea738cec100835e590712df21717de33392d74a576957daf170b04efdb970d3","tests/components/link-stub-wasip2/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/link-stubs/component.wat":"58e7f8106945a291b8fd13e0997792248009c0cb7853b0874974c6fa61935f7c","tests/components/link-stubs/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-stubs/lib-foo.wat":"d0b8b5ff95b5b4008cfa306d4af74bbca75bf07bd42ec897b711eb3064b1108d","tests/components/link-stubs/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-stubs/stub-missing-functions":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-tag/component.wat":"4cf16662ecc758a4bf730199fc91b5d2e06a7707ab3779389335bbe22c20bc1d","tests/components/link-tag/component.wit.print":"04b8975105d1093d4fb679d99999f103bf0b6801fae41dcb1fece2219453618c","tests/components/link-tag/lib-bar.wat":"4611125ab396c5d69f036f1b8f2e18a3aaaf81ffd5c44b52995cd712d64be3a1","tests/components/link-tag/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-tag/lib-foo.wat":"fb4e47576ad3d1cba844d7a03dedbcfac323d421108a04107db0863b6f44a519","tests/components/link-tag/lib-foo.wit":"bf62ea838d3ccbfdad20b1a51204262b9bd613c4646346ba7bf8e57a8c6f6052","tests/components/link-weak-cabi-realloc/component.wat":"762f3b5d9550d6a49ecae9e13e6ddb538519d049a7dd3efb5d5df77cc9b70211","tests/components/link-weak-cabi-realloc/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-weak-cabi-realloc/lib-foo.wat":"6357c1189cc178bb27c449d9a833da58aa9ff78c04936d5ad10f21e560ab70fb","tests/components/link-weak-cabi-realloc/lib-foo.wit":"903b843983ea9c9c22cea5383ea3fd607b8c1de49d1addd0197d38fe1aae9a69","tests/components/link-weak-import/component.wat":"8e00021d1f863c95e83fc8ebf5e7559aae4cb891def1b225555507f8da4a3a9a","tests/components/link-weak-import/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-weak-import/lib-foo.wat":"8163164df489b40ad2fe861c7621c60d80173b893f3108983306032f28f52b93","tests/components/link-weak-import/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link/component.wat":"344807b51f4f5267163173e2837b3ca9439650d3a70a0d3624a565fbf2a31809","tests/components/link/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link/lib-bar.wat":"ac236a5b648468d6b729bbcfac2d8d3c2991125a0652d9a6fb62a7327a3c5fa1","tests/components/link/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link/lib-foo.wat":"f46165ea11b30f70136d932c8a34a7492e03f2f51c694100a9bf35312f5ca502","tests/components/link/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link/lib-unused.wat":"dea738cec100835e590712df21717de33392d74a576957daf170b04efdb970d3","tests/components/link/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/live-exports-dead-imports/component.wat":"33a32e651592e2f8499ef51c9bf4489e5c4b87a10f07892110f270c70fcb4a49","tests/components/live-exports-dead-imports/component.wit.print":"58c56bb216d91796f2ff53e2568000eba20cc4ac4a8e7315811fead63044d84c","tests/components/live-exports-dead-imports/module.wat":"82607855264e152a2899ccc7d23f068154e043c3522c205702df4b2a6c03e7f1","tests/components/live-exports-dead-imports/module.wit":"563494c0507f08ab4ed9c17032fa68a13837e3a9ad7eb3953a90136c2075e271","tests/components/lower-options/component.wat":"011a9e6c5bca14333185baefa7a6879413ebff21c952774cd057ae080ea055a5","tests/components/lower-options/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/lower-options/module.wat":"957cbf0c8a6687ecb0c76040480fdcc146ce5c61d01e4bd3ddcd894d395209f1","tests/components/lower-options/module.wit":"141d136241a64268b9f9fe18ca20956164ac9e8f47e2b2bb48cc1adef77be68c","tests/components/many-same-names/component.wat":"4c01d2694a24f39577beb93a2d18a4b37d8e13af76a640004abea902ed8df918","tests/components/many-same-names/component.wit.print":"04eb5ca446120ee977f058357f6d7a9967f34f596e4c0a5055a3ec1f51a49af4","tests/components/many-same-names/module.wat":"7a748bf12c36d8ed53f7e76194120df41102a81b52adbe9e6bb3682fab1333af","tests/components/many-same-names/module.wit":"bdc6c8ddf22997dc6505bab8bed04c2d93e45c21756d036b1b84790bb1e76156","tests/components/merge-import-versions-with-adapter/adapt-old.wat":"3c56d37587ab8193c5d63225ce84ff473c33c8f1bf75d6c4bed75bd7c30775ba","tests/components/merge-import-versions-with-adapter/adapt-old.wit":"ef42f0a58910c4cbb63bd8bd92a6634c511c6141850f6fc0694ed7c4a587a759","tests/components/merge-import-versions-with-adapter/component.wat":"edb6947344fc67b9a37527a25decdf813cffdd9437abe82bc111bacd66246fa5","tests/components/merge-import-versions-with-adapter/component.wit.print":"cd24a288951083401d8b01e0ada1e870c28da544c142d468500147e64c7c6e66","tests/components/merge-import-versions-with-adapter/module.wat":"9bdbdd6a7454dcaa8eaccd33696f0855b6a613cab4228663b547ced3a839d630","tests/components/merge-import-versions-with-adapter/module.wit":"a79e62d6f59e4cd8eed01ee0aa1f1dd7eb6cc4e057eae857e514c1b88c5f0196","tests/components/merge-import-versions/component.wat":"44b673bec8cd8b758921f711c20921833e2e1089e2b910c4c2e575a8f5abc994","tests/components/merge-import-versions/component.wit.print":"cd24a288951083401d8b01e0ada1e870c28da544c142d468500147e64c7c6e66","tests/components/merge-import-versions/module.wat":"abfdd39d50c8a4529af1636e0f6c10a4b4cae7103958480e4006a40573ab47a8","tests/components/merge-import-versions/module.wit":"92850e6dfaecb1d699c235bf43e980b410e002d5e9b49cf43d9102d5cb35703c","tests/components/multi-package/baz/qux/component.wat":"9cde15bcf420c2d39031abb8a802f575a756e52c2266738541f6f15c2613935a","tests/components/multi-package/baz/qux/component.wit.print":"b255c8747f2704e788d61a108eab228a7e6e02437ee665314cac38effbb4da36","tests/components/multi-package/baz/qux/module.wat":"2b1492c9015f1347557088a9bb19e61b79edafaa57aa8712bd911ba3921c5d3e","tests/components/multi-package/component.wat":"8ba4c759f3bee8b944e5a631ac4f8437016348ede8488b678bed671459578ad5","tests/components/multi-package/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/multi-package/foo/bar/component.wat":"134a96e6e491ed2e014a036cb56c9d4a196e4a850619be7ef6666b8ff65cd9e6","tests/components/multi-package/foo/bar/component.wit.print":"6b6f89526fe4793ce9085bedf8eb2c66725a92360dbafe920f8dc8f5147efdc3","tests/components/multi-package/foo/bar/module.wat":"ff8ba654ecd7125d49210c22ef349f37fa54b52badccec69f71fb062fd860f56","tests/components/multi-package/module.wit":"057f5c6f1500ba79cc57fcfb428614de419243c7a224e104d20415e518669da0","tests/components/no-realloc-required/component.wat":"3440a750b0c21813cf577ed5256f8dc46682e41f81594083bc1d25db50714fd9","tests/components/no-realloc-required/component.wit.print":"af82805774e5a261f885b97bd183708e86322bf121ce2528c05bd3ef7c3ffcbe","tests/components/no-realloc-required/module.wat":"d7515c3defbfd7288984e414417b6f9af6b4e9be6835ec5a79770079aaeed542","tests/components/no-realloc-required/module.wit":"d4fff6f58ec0f32157f5c17f0c44c9641dd063b0025972cad18af64f6e2de9b5","tests/components/post-return/component.wat":"f7c4867a341a2f5a1c31465462ae0971424b9be80f891a560681242373dbbb58","tests/components/post-return/component.wit.print":"dda1f7d5e2f6e49f6df046e881a8b5eebe2449c19aaf48a49121f426701a06e8","tests/components/post-return/module.wat":"3bbdd4c09686c2f7f61c6eb7d132345f7d8cb7037b3c259d22d1a8b295e67305","tests/components/post-return/module.wit":"b1fae8d17f70cbefed1036d5a44550473a08cbc2328fe1a923ddac4339d0cd0c","tests/components/rename-import-interface/component.wat":"0e1cdfc198539b6e68413048e9b276f7cc8d1784849583bd0cd85c06b042a625","tests/components/rename-import-interface/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/rename-import-interface/module.wat":"6d42f1ef7a8c3b10cfcd9af2052c8e08f47bf068f554013514f2702d3d714df5","tests/components/rename-import-interface/module.wit":"bfb05c599b4b556e11fcfd94a51090eb311972d9b5643b2fc1a4b786fe886d17","tests/components/rename-interface/component.wat":"8a4534c7b80fc412fa024a343927b53e6b804c489f1877c4ef46ebb65830a7cc","tests/components/rename-interface/component.wit.print":"61e6663c4a3e56091cedb85a6339a01006ab37fdadadd84d855f35c4e547afa9","tests/components/rename-interface/module.wat":"45fba53e30e8279c534f0a60e320f1c6a1422bb82f95460dd2bff27d09272e07","tests/components/rename-interface/module.wit":"d4c0aeb65e8de86ffcf651ffc2937d2dd0c15a394fd27fffb2aebc34337d06a3","tests/components/resource-intrinsics-with-just-import/component.wat":"38b11b9263711d8dc42c84e4c24f3ecf26c2e1a311aee4a40571219288ec0c92","tests/components/resource-intrinsics-with-just-import/component.wit.print":"1d1896462fc3ce15a0f79f753b7ff8b83b1b90fb41850b7a3b05afbf17064aba","tests/components/resource-intrinsics-with-just-import/module.wat":"f892c943bc508e188d746be4b31849792ea70e5b35dbb316a5bbb33b9604239c","tests/components/resource-intrinsics-with-just-import/module.wit":"41d2b456f11bd0005178edd868ad2675fed29c2ef4e36f9604383178a01bc707","tests/components/resource-used-through-import/component.wat":"4ee4514507461c97bddc711005bafc951c1337dfd942880707505d56181f92d8","tests/components/resource-used-through-import/component.wit.print":"016e2d6cad8f4d38f6ae9c64108ee475d9e479466caad186850e3e3e7ad0d4fe","tests/components/resource-used-through-import/module.wat":"5444f7ba822b2864e8ffb92a42b21674dbf6416bbe4c868d311db8a9d2ed5772","tests/components/resource-used-through-import/module.wit":"148d7d1dd61494e67dd1abe605731222be46e9c050a42632af85d65892378a1e","tests/components/resource-using-export/component.wat":"dc1ee332ff13e5361f1b60c8fa53db57137f9ef499288510d65c6f5bb7802672","tests/components/resource-using-export/component.wit.print":"81d2ecd76e78f9835ff0a1c201fc449dac6edb6cbc2390c37b3de7665e9c5e6e","tests/components/resource-using-export/module.wat":"a536f2f3270fc6e218e39b4d16c6a481051023c0aa26c4c2023f9ff90ef410d4","tests/components/resource-using-export/module.wit":"2b82098eea901f65cb65a9a079e470a1975b9192d5b5a227511ea25f8c32af85","tests/components/simple/component.wat":"3c2ce9adab9e033f1386da2143d3cbc38693ae6c277c4b003d3aa793d1e18d59","tests/components/simple/component.wit.print":"bc11e4896f9442ef9415b7f0796da9e22d9b07a2cb27d957c746f3be3142e7f7","tests/components/simple/module.wat":"3688a131da2f16901166d04f7fa0499f755a19f7d479a24a47921e94710ca86e","tests/components/simple/module.wit":"ab54b3883a5838519149b99347ab6ded6f494e0526eb16b774890044acf4a569","tests/components/threading/component.wat":"487085b1ddcdaa5c3d01745abd45d3537ef6bc55e0cd0166152ee0e8a58b5c86","tests/components/threading/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/threading/module.wat":"619203db7bf8392f8c66bab654bb5bc52566344c1d867af1e1b67794c9b6ca8e","tests/components/threading/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/tricky-order/component.wat":"e95a6c6fd66eae7ff0640539258a7b3bb48dc6ee047b51f5d3fabeb21a9d33d4","tests/components/tricky-order/component.wit.print":"3fc16dc48f01ab7dcbf933d5a04443abc22fb1f06800ef02668dd0040879e679","tests/components/tricky-order/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/tricky-order/module.wit":"2c5a879b53f07d5303797086792978783e84baf964e0edb09b0abc12139476f9","tests/components/tricky-resources/component.wat":"61c7f212f183dd1f1cb037100f58f4b4efe99556fcae1a3fe8c8aadacc859b80","tests/components/tricky-resources/component.wit.print":"856955fb41792fc9c38d19de23968f5a4f180f28b73f267808e0305bac5bb9b5","tests/components/tricky-resources/module.wat":"f71be4ce8c2d1fe8c83dc8b58cd7e794132f7cf03995d6ac498256dfca8973dc","tests/components/tricky-resources/module.wit":"50b61106dfef6d7b81671b95230b1adf3ef9ca4c028a5a4f932c84cdda260890","tests/components/tricky-resources2/component.wat":"62edd5121214c3c0247bd0705b1662f06a5cdc758e4a20cf786aeb63fa52ef69","tests/components/tricky-resources2/component.wit.print":"a9cfae01ec4574576148c54c917c0be547c0a9a80ba1c76bb313556b80eff2e1","tests/components/tricky-resources2/module.wat":"63fc3214c3d4e4b36def8417cbc3aac44428046c2f212e14c3ba42acb79e29cc","tests/components/tricky-resources2/module.wit":"24df1dba85c4c71a4b8138b9add9d47a7291a82331f2ed08c3841574c668d36a","tests/components/tricky-resources3/component.wat":"8fc170f04c9417a75735b5829115bcc8567010b11fea765c072b40233463ca8a","tests/components/tricky-resources3/component.wit.print":"acf40dce88c3f0ba8ec1eb7c0058745906af2546808b5f87979050645470b803","tests/components/tricky-resources3/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/tricky-resources3/module.wit":"f00e678465c06ac4fd1ff7dbd473934c796e9251fcc15c604ef8bdc9ac870220","tests/components/tricky-resources4/component.wat":"95772b98420903e117bb87d0fe8e4aef50a57032aad2256b677f8a2fcd0fc9e0","tests/components/tricky-resources4/component.wit.print":"0cf3e863909bbff0ffd80995608d50bac03e716531ebe4b9177997e313ef0cb0","tests/components/tricky-resources4/module.wat":"acf798ec37ef20f52b1ca55a2eee9ea428d8c3a134a8450293c77b8ccdf56a40","tests/components/tricky-resources4/module.wit":"411499bff6c68c79f523d061aea6eb7dd0124dff7f1102dd7fa3561eb1acbb09","tests/components/unused-import/component.wat":"fc5cfba85e31292151061680cd3c04ffb16b946aa0fdba0e922e419865003f66","tests/components/unused-import/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/unused-import/module.wat":"357c1e05f5fcb82e7df5958d9709a75d693f67a8b8d31ab4fe09c413dbe79d46","tests/components/unused-import/module.wit":"ee373cb080a5c563252c18da9928dcf8a835ffc1327a7c1b5db4e15f4c44cf94","tests/components/worlds-with-type-renamings/component.wat":"cfbf49f975bf0c10c58392b1fcc6180934efa6adc44abdfffb5134367f788c25","tests/components/worlds-with-type-renamings/component.wit.print":"9797ffdd1f55149336e49a3f3370ec4b052b0b48d094af34d2e305b1e807033e","tests/components/worlds-with-type-renamings/module.wat":"9e0cfa9735e10a42efa429bdfab4e39791673d26ec574722d3eeadf1ef6e2de9","tests/components/worlds-with-type-renamings/module.wit":"5fa4355c6ec3249c4afc32207a89fde9c10be783a4e259243d9bb7bc4d1b5052","tests/components/worlds-with-types/component.wat":"41f5ce7143555c17ddfe7e612f930c8b6f28cde7c2995ae4a342fd571ab390ea","tests/components/worlds-with-types/component.wit.print":"08ec721da023042af8478fc61bcdb441091ea3b6efd7c26567a497e15cea451c","tests/components/worlds-with-types/module.wat":"b08d3fb1390db5c4ab3dea54eb386708fe25f0e875f5e08c3cc5af387a4e6603","tests/components/worlds-with-types/module.wit":"b86cc880c1cb138a26883b9e1d706b8506ba1c8f39b9b2722c4cbd02154b00e1","tests/interfaces.rs":"78397eaace0ae7501995f51bc261198ce04b1e0a169023acaede831ea3a9d7c1","tests/interfaces/console.wat":"65648a08a3be183053434c19e75ff12d4e8ba7b80d12e15e9daf797a44c33690","tests/interfaces/console.wit":"ae4ecef964695f02aed6412aa33125eb25d667984c24053303c02842c6952d1e","tests/interfaces/console.wit.print":"88664e999c44984e3f6e9a33a3fb1c8455abe5d9486d977e1a3e38cd85cd2d1d","tests/interfaces/diamond-disambiguate.wat":"0aa80803e0ee5aaf9d9410dc03a4f9e12ebfabf287d590c563fa5603589da7b1","tests/interfaces/diamond-disambiguate/foo.wit.print":"8c99834e2dff8e984b07f567555c02e8379d6fe9a9e8903e09c0a71cd3e1c7f4","tests/interfaces/diamond-disambiguate/join.wit":"4d85308aa1fa9445db47274a21ea5305043a5fbd2cfd07bd05018503ab9f2f2f","tests/interfaces/diamond-disambiguate/shared1.wit":"12156cefb18c81870ba266446874354a10871389361810efac7830ea0686f96f","tests/interfaces/diamond-disambiguate/shared2.wit":"fc790ffe2a771a13819976d1c56392e96cfb693e1589c757e0ceb8ae8a360dba","tests/interfaces/diamond.wat":"2996d285b348597d0a6b980167fce74053808e794dd1df9e48cc6efb234ae801","tests/interfaces/diamond.wit":"151c0be378c2ca19cfc97e55d820be7e8451817ee16fbec25feaac1332d25c40","tests/interfaces/diamond.wit.print":"7a6dc57ea3283fa22b6d38e0765f38bdd54f0bad36fb417f632144f073ca66c0","tests/interfaces/doc-comments.wat":"174225e7e66146c2204cdf9503fbc3f8b034599b37fd65904a79bdf7a57ec76c","tests/interfaces/doc-comments/foo.wit":"1e7267a6d075105b613e8ccc9f936a0e3747132e5d53697bb93d6c8978f9f68e","tests/interfaces/doc-comments/foo.wit.print":"93065d74520287e3e25647c005a193808661f5ad0592c5a9c37f05b23cf308a8","tests/interfaces/empty.wat":"d6144d67081f7139868791b76ca9016cdd33e07f8f18a7d02b35675849de1f1b","tests/interfaces/empty.wit":"5b69d726e29aee24abc73e2008107fff6e19c7e91bfb892ce91aeb022447fd33","tests/interfaces/empty.wit.print":"f887bbe0d82c8f23d3fc4d5d7ae44f2f7fd86ccdfbfdb89356c0363767b8ab7e","tests/interfaces/export-other-packages-interface.wat":"2d95d60feafeb9447b9c4117c98206dec84800d22313e8d42c09f80d2df2c2fa","tests/interfaces/export-other-packages-interface/deps/the-dep/the-doc.wit":"4e1596c661a7fac18feaefd556d3c148bba76ef748dc64623ca0e711b9b6cefe","tests/interfaces/export-other-packages-interface/foo.wit":"6039d5381dede8af1fdc2969384f5b8fb96dfb7e14316bcc74bc13f4f4771fb6","tests/interfaces/export-other-packages-interface/foo.wit.print":"6039d5381dede8af1fdc2969384f5b8fb96dfb7e14316bcc74bc13f4f4771fb6","tests/interfaces/exports.wat":"b2b7a63e5b9ef42ca01a586656be4cde48d44a4197c18c034c090801b56a9bd7","tests/interfaces/exports.wit":"c998656f0d5e86df7eeb195c4b8cb7601cb9278acf738547e9aba12cf95b5d32","tests/interfaces/exports.wit.print":"c998656f0d5e86df7eeb195c4b8cb7601cb9278acf738547e9aba12cf95b5d32","tests/interfaces/flags.wat":"1895f39b12260e80d872e28521d37e3ba4ebb2ceb321af83f79d11b5a22dc200","tests/interfaces/flags.wit":"67348d8dfe2215374681dda98530c9049f57b5bf7a57155218256336a39a8ea2","tests/interfaces/flags.wit.print":"67348d8dfe2215374681dda98530c9049f57b5bf7a57155218256336a39a8ea2","tests/interfaces/floats.wat":"c8fb2f689753e1e594f2b08e48b58dec55e4b0001dee3c2a35383d373b782956","tests/interfaces/floats.wit":"d3538bc1ad734434bc4b2ec7c152c5371dd8ea7db11a44cdd15ccec2b650b60c","tests/interfaces/floats.wit.print":"5fd8f9f328b5219350e2e9fd6ec483066b67a62238e4463142def96032fe584a","tests/interfaces/foreign-use-chain.wat":"acae7a8f76a913bdbb646a06bebec8615da6a5bc1dcb047715d5328e1e9a3faf","tests/interfaces/foreign-use-chain/deps/bar/bar.wit":"dffa233e1e0a2b35dcdaca0b62539776dd3bfb9662ee4b8cf9d72f4cddd2b551","tests/interfaces/foreign-use-chain/foo.wit":"51251e98cc66f75464b436f1d838a873e89713deec482480ae13d70458cce288","tests/interfaces/foreign-use-chain/foo.wit.print":"8bfedf3ed5380fa5dd359a9a3896421f67ad49f1c7b8d806eb6064b55092d21e","tests/interfaces/import-and-export.wat":"8ce79bbdbac052ba39e2d2d731f72736f277d3b88e0f763cd9c3db84a7386cdc","tests/interfaces/import-and-export.wit":"1dcbf7c373ca0c352bd45f444037170de7af3435a217b94378694bfd33b608fa","tests/interfaces/import-and-export.wit.print":"a6418b0f7bcda1e6055344cf39a438f7af0f7a5e3e3c067976e81d3dd4dbf961","tests/interfaces/integers.wat":"0c11ca08bc17c757cca9d2e42487c8394dd960a56422dcb62f4989ba93971ae1","tests/interfaces/integers.wit":"37d266e41985507c1c93d6c26a59efbd81893106f6d41b8a311e7c7fbae8dca0","tests/interfaces/integers.wit.print":"ad6949f8c87a60dd7e52028fd4bde7c6e8143ffea368a09820b5546b21408941","tests/interfaces/lists.wat":"090e004df86db95af8724a785ab0e17601d26025ce6cd0ebf089be7665b7a722","tests/interfaces/lists.wit":"2b4022cfda4485cbbd8ed25b78da23d74ac18acf7bc4ef2e0f10a47a4b647a39","tests/interfaces/lists.wit.print":"2b4022cfda4485cbbd8ed25b78da23d74ac18acf7bc4ef2e0f10a47a4b647a39","tests/interfaces/maps.wat":"8a35bc0ba86761018f92ebec8633dd8ee2a6923f85df365ac4808d4e24066c6c","tests/interfaces/maps.wit":"fd4fb91fa11798dc163bf2f1cc287300d678e37c2d027a50887230d906181a14","tests/interfaces/maps.wit.print":"858a732922eeaa6c3479f892bd106256e3ca01e228d63e6c0c67210b4a1f31c6","tests/interfaces/multi-doc.wat":"d963c737bdac1ab843e197d81f27b71c3a5e310a3dc180f54d777dca44a27e57","tests/interfaces/multi-doc/a.wit":"e596872a740320ec0cc907db0a0514f8bd06bba396ccfa6f0fddb5063a6d2295","tests/interfaces/multi-doc/b.wit":"60c98779fc63ee8932956245f4f62a817df1873f73a6d38170481bd2e0933bbf","tests/interfaces/multi-doc/foo.wit.print":"94f244451d55c2bab71e4b3624fd0101afa5169c881580337e7d4af020bb8426","tests/interfaces/multiple-use.wat":"f47557d866df570c5ad02935468f170c4373233f80f0500c054258a724a23e98","tests/interfaces/multiple-use.wit":"7b3a8bc783bb588205ec8a4a4ec6b16786ac11632bd8a8af6989340d454a231c","tests/interfaces/multiple-use.wit.print":"720be46dc70779cb31985c505810dc9324511e6adb33e64cd7d51a6c061ba7f4","tests/interfaces/pkg-use-chain.wat":"d02d6bdd9d2c1bfb2f5897f616fb74e6bb51cd5ead90fd11fab08ededffe4e3b","tests/interfaces/pkg-use-chain/chain.wit.print":"fecf679bf3d5f6170e3752e70e3e6ff31a62c76af934310a8481cae26f826c7e","tests/interfaces/pkg-use-chain/def.wit":"e5926171db9b958a935cf7e6c9dfb19f352734d037371515d17384fd04b89422","tests/interfaces/pkg-use-chain/the-use.wit":"fa84d92dd7d863acca588c216df4825d9735ec521f2c8df2f0088efc43126457","tests/interfaces/pkg-use-chain2.wat":"3003789fb7591388e83f8a3a953b006b9561d2af7e0b033dde2d3152438f9a02","tests/interfaces/pkg-use-chain2/bar.wit":"f070c1a8bd8a278e04b0b774f5f2f4f658c281b139d1cc2a53a38771997f206c","tests/interfaces/pkg-use-chain2/foo.wit":"9cda1f4b74d669259f0d47c0b62aaa866d0fce95a2fa23e7ed01b445092af758","tests/interfaces/pkg-use-chain2/foo.wit.print":"234cbdb61a134682163a460f2d13e70dbed3a21fcbdff211af1bb875e49bb224","tests/interfaces/preserve-dep-type-order.wat":"d02789cfff3c031bc45a4c596be9d42a2925a670072b9b691e94b87404eb59cd","tests/interfaces/preserve-dep-type-order/deps/dep/foo.wit":"07d8a31043f7acbda52d2a81da2747125855fde991e2e81dc0a8090aec1b0824","tests/interfaces/preserve-dep-type-order/foo.wit":"cf4b5e08d9c2e7cc6260c97af2397a0116f1c8b20af7f278b62eac20d7f4d910","tests/interfaces/preserve-dep-type-order/foo.wit.print":"cf4b5e08d9c2e7cc6260c97af2397a0116f1c8b20af7f278b62eac20d7f4d910","tests/interfaces/preserve-foreign-reexport.wat":"80eeae235f01940ca94fec2c1b9c4c0603b9794ff39b486de019f5e4b6250e50","tests/interfaces/preserve-foreign-reexport/deps/my-dep/my-doc.wit":"a9e7687b2213e6432d316100c8f063334ffa91c312bbebf6e7b953a07a38887f","tests/interfaces/preserve-foreign-reexport/foo.wit":"08f924eaf5925d79dea11da53a98fa712462b2693267855f1ba7f8af23976a67","tests/interfaces/preserve-foreign-reexport/foo.wit.print":"08f924eaf5925d79dea11da53a98fa712462b2693267855f1ba7f8af23976a67","tests/interfaces/print-keyword.wat":"e35164a7c713261bac2b9eff4d378d0bbe0eee805ff2acbf109644b7eee32935","tests/interfaces/print-keyword.wit":"e56669492ec53c6bef1cd14561f81c85117fa05199241cc2911f697ad75de606","tests/interfaces/print-keyword.wit.print":"d65ce208703b66a5975194a0937dcbaeaac680ed1531397c19b8a898928c6c2e","tests/interfaces/records.wat":"f9e0d53435c7769248c794ab5020253b9373924502b9c91a57888e6d254e2839","tests/interfaces/records.wit":"f16376667373eebc30923f6ef498cd4c53da0aee19697538d5ce2201aac03726","tests/interfaces/records.wit.print":"ff31d9c044473edec440a84f57be7686ad7e188459e37b2e2a65e0ee66305793","tests/interfaces/reference-out-of-order.wat":"9db73dc664f876c7ecde018eccea5d5a492e625af1426eaadab3f70f2869c8cc","tests/interfaces/reference-out-of-order.wit":"5f0eeaeeb9e1920fadba1b372b213138eaf9847017721dbfbd865c6f6b735ede","tests/interfaces/reference-out-of-order.wit.print":"a030a7125086f47bdd47b0a1342c7f7021d8e1543ef98ed1b2ebe5d10e375369","tests/interfaces/resources.wat":"551e5b1f2a2ff21581828ed33d7363ee578f06765df35040c879dc6c7be933fb","tests/interfaces/resources.wit":"ed38925057e1dba87722675326536f3e6dee6b3e64ef3db98fbe5fa4811150c8","tests/interfaces/resources.wit.print":"531fb60a5000c349d45153e41df87fc75358c71545a883c98eb87658a949cf32","tests/interfaces/simple-deps.wat":"45794a5e6dd232f0bf8599e4630fd13b6e2391bdba3a3fe930cfa692e8545d4b","tests/interfaces/simple-deps/deps/some-dep/types.wit":"e4f4f705091fd22a378aaf25c1a37035fe1dc9e4f29be0783733d8bc091a907f","tests/interfaces/simple-deps/foo.wit":"76fd1d55c5faeba3157ada8be1c83853ae1e72d8360c84b0d1b8f8b96d1e0dc7","tests/interfaces/simple-deps/foo.wit.print":"c2f307fd4af86e70abb51cadaa5e51ac6bfd5f8c9a91eb61f1bbc67c17554a57","tests/interfaces/simple-multi.wat":"6b16a64f1f5555e6da647f290bcfc9153bebdb42b9f609b46f37792c39271a3e","tests/interfaces/simple-multi/bar.wit":"e3f98501dfb46f873022dac93af2c9aeb007ea5bf0235302b072bdf2b1b5aa9c","tests/interfaces/simple-multi/foo.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/interfaces/simple-multi/foo.wit.print":"45cea7bb704ea1aa2251e2da314dc3b931b165b7c84596e16c5b4c12200cb5b7","tests/interfaces/simple-use.wat":"1da6ead3dd378c25b096c2a70d8846da0a1810c68ecfcedf0727bd6c792c0070","tests/interfaces/simple-use.wit":"d4e734dd1a51b2224ea1fa965b48f39433e60ada1c2619c9836b81e061beb0d5","tests/interfaces/simple-use.wit.print":"1c91e72769a7ef72633c3e82bdb2f97babbf51961e3d10d177076340241cd277","tests/interfaces/simple-world.wat":"8f023d1da8b20a605f04bde1587eff63a88e45e0240dbcdd4647a84f1e993a49","tests/interfaces/simple-world.wit":"b8c42bd20d951065611170b28538430c76dbd492ddca5a2b63f6d85b229a62a5","tests/interfaces/simple-world.wit.print":"cb5ea537abb70459959dafd9c6114f35404f3a23219206f6e196e452c3f63e5b","tests/interfaces/single-named-result.wat":"a9d03772334090d597a595f38611a67630bd2c637b1b2cab7a79c3662b3098f3","tests/interfaces/type-alias.wat":"3f041675d23c6859523a79a9911826dd9174bc1e8b7f4633c7d827403b5674a6","tests/interfaces/type-alias.wit":"6cac4692ce0c825afb6d16e51fd9ecb3a7aa19756269b9dbd73d601511b3be38","tests/interfaces/type-alias.wit.print":"ff3093d72793ffc05b9c2f4ea55eaa86d276a869a3897c58f822443cfd299636","tests/interfaces/type-alias2.wat":"c67254788da372381e84a78eab4ef65104a59aec422da51cfd86ef6a67410a18","tests/interfaces/type-alias2.wit":"d0821ab9de64a96f24b90c3fe6d6188e9073444ecba789212c206050b3ae02fb","tests/interfaces/type-alias2.wit.print":"d0821ab9de64a96f24b90c3fe6d6188e9073444ecba789212c206050b3ae02fb","tests/interfaces/upstream-deps-same-name.wat":"86b1ee906d85fcb499c8dd64a03235f3b722b7936d436099f01ed0a60a036077","tests/interfaces/upstream-deps-same-name/deps/a/the-name.wit":"067fd6d1ce097bf27dd260114da6f690f5c54142d7b83fe705b98675e83336aa","tests/interfaces/upstream-deps-same-name/deps/b/the-name.wit":"17db81ac295fdc326bc0960166aeba6d2a86ffe6ae9c493209964098057f4672","tests/interfaces/upstream-deps-same-name/foo.wit":"5634861c80a39d59e3c72e26884487bda2ff6123a5607eb72e6251138f43891d","tests/interfaces/upstream-deps-same-name/foo.wit.print":"76cdc49cd35068d9c6d693550c951db74f588eb0d1bef27b4193093a95a3b802","tests/interfaces/use-chain.wat":"3946c5b08f739f31a9f737480e00a027924723130746b325234693318fb79c96","tests/interfaces/use-chain.wit":"9199d5f59616d83e82aebe22a8652e72c711ec962f6c0b53379c998fe4f64675","tests/interfaces/use-chain.wit.print":"ff129506878efb4f9ec1a441845c645ac63f4006e1e1d641d44c1e5d1667a778","tests/interfaces/use-for-type.wat":"e50dff1dacde278b34144745af52c6337acf001ba393bed4f7f162c913c92e41","tests/interfaces/use-for-type.wit":"86178e6002f460c78b43d9a51ffd13dc5795da4aac54e5f4592dfa11a430b42c","tests/interfaces/use-for-type.wit.print":"c899fc7b4f4fffa41f3abea7c0589f268cd683e6c4c5637393173af949d9b379","tests/interfaces/variants.wat":"3c8f5474ff599463212767650e14e3508d95ae670c6b167cc68026699f27309f","tests/interfaces/variants.wit":"2345402856850aae5db913ac40f01d3bac1ffddd4f2d794d4b92b44850354741","tests/interfaces/variants.wit.print":"63a6847094f8687a7f1cafd8f26a5255272386ae04366b5d247bc893ffe45d73","tests/interfaces/wasi-http.wat":"5442500a42b914985e143ee44dd60dfdf2df949d0d455b731034d604ffbd465e","tests/interfaces/wasi-http/deps/cli/command.wit":"5faadd6c6593aac09a85e8e22b2c842c81b4b3d0a04827195c50e0080ac94a00","tests/interfaces/wasi-http/deps/cli/environment.wit":"8d4f13e628d2e8f029f6d668d8075db5e6c8867238c0436cc966dd9a535148e1","tests/interfaces/wasi-http/deps/cli/exit.wit":"337522eb41c89e660b1dabc1bae362acc462f9cbfdcb9546e790e371580175a2","tests/interfaces/wasi-http/deps/cli/imports.wit":"37f6621e37ad9b15c616ba4289cecb549429cdb25a3b4ee3f80c47a5f04bafa3","tests/interfaces/wasi-http/deps/cli/run.wit":"50815a16aaebae4b99d2e2f9de69ddf30fc27249f41ad3cf477c4e796edf5792","tests/interfaces/wasi-http/deps/cli/stdio.wit":"51ce71cb414d1288b404367b4c05e38ade8b72f54811647aae37d871fadadea1","tests/interfaces/wasi-http/deps/cli/terminal.wit":"ba00efd140adfce72e1368fd92b6fba93a550129d2c8587a9f82bccd96e9100a","tests/interfaces/wasi-http/deps/clocks/monotonic-clock.wit":"3d2605e145081885768e23e1b37f5f065e28f0681cc3764fdaa60c35e74d2984","tests/interfaces/wasi-http/deps/clocks/wall-clock.wit":"35ac466a63c310151c228a313665fb30061c13b1954a7d6dead4c80fbe9f5b1d","tests/interfaces/wasi-http/deps/clocks/world.wit":"e5262f7b911444b28a98cce07a224bc8e7e9c42c175bc4890cf9d458d1d7d638","tests/interfaces/wasi-http/deps/filesystem/preopens.wit":"3374e193f60b3ff89708e56b37871fdfc9bb08bcbd3648a4f7bf20b60fe85169","tests/interfaces/wasi-http/deps/filesystem/types.wit":"9fc998c1251c38ceae23851af0a4f46874b5c456ca3240b1ff6faeec5f101d8d","tests/interfaces/wasi-http/deps/filesystem/world.wit":"45ca19ee54e4a0c9e8eca1d73f1e1e37edf00339b5c3e0f393f444a92733e708","tests/interfaces/wasi-http/deps/io/error.wit":"df792be377ef1ae9dfc186a304ae2cbcc091adb83bfb5fa5b9015fc232a90a9c","tests/interfaces/wasi-http/deps/io/poll.wit":"d3062e06aef89c8a2999067ccbde0c638459a01f30ba2073ac2b6458e0b9ca29","tests/interfaces/wasi-http/deps/io/streams.wit":"2aac4f0b81ca892ef07e9df54125082e266afb9ee2948b3f3f134ef736b8e75f","tests/interfaces/wasi-http/deps/io/world.wit":"1a67af673d0874b5a291a2b86721b1e4c1243127e8b2f6fa4ed954b13cbe87c0","tests/interfaces/wasi-http/deps/random/insecure-seed.wit":"617e58cc9fb5ae0f32cd6db3e72f959ee50f6abb8b9a0e10a5867ca2319b804d","tests/interfaces/wasi-http/deps/random/insecure.wit":"db8c140b96a99ca6e11060e2bd46df3c132f5e16b188f11e2767149b860d46a1","tests/interfaces/wasi-http/deps/random/random.wit":"5319685d7ec484d72660092f8db07c584d361d5ed0abb2893bba6d0724c20f88","tests/interfaces/wasi-http/deps/random/world.wit":"f1cc4028ab9d2ce215122946136a05b14b63225943ed8df86aefd5500bbd3217","tests/interfaces/wasi-http/deps/sockets/instance-network.wit":"ad100127c74b967064cf5d8e1770f6f0d787ef55f07ba9f6b334bc4c98c82282","tests/interfaces/wasi-http/deps/sockets/ip-name-lookup.wit":"aa9d95e64edfb9e954bec156f5ede95560a82ebc9ce80c01d475edc2f371d62a","tests/interfaces/wasi-http/deps/sockets/network.wit":"65c428e7f0d29a4dfb785996e88507ec185ae174a67576d3c09f852683d95f82","tests/interfaces/wasi-http/deps/sockets/tcp-create-socket.wit":"5beb6d1d604227a8e93fa2e63ace7ddee55b4048399046a9fecaee9d4352f684","tests/interfaces/wasi-http/deps/sockets/tcp.wit":"408d55fb8a3cc6971a02ce08a53f2864ec16487ea9f33a3c63b40ad90ee8acc3","tests/interfaces/wasi-http/deps/sockets/udp-create-socket.wit":"1e741a57683f834b12bca49c448cea4080e91b9667d50e28c8a823e2d6ca3829","tests/interfaces/wasi-http/deps/sockets/udp.wit":"01f359eeebb86826ea8f40d885feeb329a3272e439034aafab1e0a1e64ffa813","tests/interfaces/wasi-http/deps/sockets/world.wit":"9944b7b13f9933c0fed0768919ac4c8a8156943d0e82061277a28e0893f761f9","tests/interfaces/wasi-http/handler.wit":"96882590ae9934ca52f031eccc91704d0caf80c6b3227b6e1177e947ce135b24","tests/interfaces/wasi-http/http.wit.print":"c2f9bc786bbd0f91a8e38537df2437aa435867b2b9271808c562dd42b0e5487c","tests/interfaces/wasi-http/proxy.wit":"14f5c16f8c9f82965825fb138c2e317fa87afcfa731f9bfbaa5a02f9f3ebb1dc","tests/interfaces/wasi-http/types.wit":"b48cec546a901b55ed334edad747fb1298121a8e60cddb2e8141ff2187cdcdc8","tests/interfaces/world-inline-interface.wat":"d2c133fe41eca77fae870f5d912c17cad86ab9120419e2beaa7a20fe2c6233f6","tests/interfaces/world-inline-interface.wit":"929f431c2e5e14195de9645d75c79d243e65ee4c55a8e30a5ee1ae4c2e6014a7","tests/interfaces/world-inline-interface.wit.print":"36929a8a8a27296e3a183fa33fe95d243a6d20c4df055d9e5bbdc3bbce85bc0b","tests/interfaces/world-pkg-conflict.wat":"105a5cd5b89df94659c910e7511947c51f49f120f803b665cf69940c5f1c26f0","tests/interfaces/world-pkg-conflict/bar.wit":"4f05ba606e0c32c900fa8e9f9d75b137eedcb80999f454161492f52a452e8dad","tests/interfaces/world-pkg-conflict/foo.wit":"4be2c763fa6801e869aeb8da05cd647931f5f8f7775329555cd9cfd880dfe45d","tests/interfaces/world-pkg-conflict/foo.wit.print":"2ea3a7bc96c6493334d49893bc194a86f9e8fa7d592feac394c20678c5c1b288","tests/interfaces/world-top-level.wat":"80f160c0a98dd0003cf634d9d61899723c71ceda6c7f4ca330f791279154291f","tests/interfaces/world-top-level.wit":"10d04b8d9e0cabf534294ca5987f7523c042f3078048b5ebdf0b20f162ff9194","tests/interfaces/world-top-level.wit.print":"cf23c15ec84ad2c86d7124302c370661d13ab93bbd29e5456677a72148079339","tests/interfaces/worlds-with-types.wat":"e6e4a4527933316268841efe6dff6422212668a79077b43ab476f984ab4c7b19","tests/interfaces/worlds-with-types.wit":"cfa2f8bc82383337e9ae80d2bf7f7c59160642b38137367d8e8bca61d24fad3a","tests/interfaces/worlds-with-types.wit.print":"35a5376b6ad4c17ecee2b99fae6be4ffbddc766e891a4012eabc6a303cb0e1d5","tests/linking.rs":"e23feee175162d6758ba35706e92558546603fa5ed370bbee69cfd76d49c7b5e","tests/merge.rs":"5679426b2585a0b57597d2204c9b46e0b05b8f016dc9f438a7dd3eaa0bc7ba49","tests/merge/bad-interface1/error.txt":"98c2b73a27df07fe64cf3cbee106a82f863ff01c9bd7aab19345d2e33bf9971a","tests/merge/bad-interface1/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-interface1/from/deps/foo/a.wit":"8846a4d47a3a4ea7adec3c75dbfe5f7d95a33f550384d60f5ba57c986cebb0f2","tests/merge/bad-interface1/into/a.wit":"3bdc7af80295ca1761b46d4088bfe63323d87b5ce34ba91a5f86b74dd9daf381","tests/merge/bad-interface1/into/deps/foo/a.wit":"94b2dfe771053f49b3da8acdc65b2e0cd9d6b62c9ace43d7e383f67c3258ccd5","tests/merge/bad-interface2/error.txt":"9bc249e46b3bb5c88cdc9b560b83cd83cd22ef7816fc4f271bdff6627db16b0e","tests/merge/bad-interface2/from/a.wit":"a6647eda48b26b8815a5c96c0d2f492751c50575a61a1b5370f631a1dbd6d6c1","tests/merge/bad-interface2/from/deps/foo/a.wit":"de74c812c40393d061efd768601f8747bd61f7d06d59ed260d9c7da5767eaef5","tests/merge/bad-interface2/into/a.wit":"dfe8e3f49c0e9392a85ce7d852d359728e62465d923e296d4594130110864861","tests/merge/bad-interface2/into/deps/foo/a.wit":"faa98d1f0516dc30b55a1d7c3187a4de73985aac1952d275f21476451310335e","tests/merge/bad-world1/error.txt":"6db444c11f4be2e33e0c2cc6ae98a3d59711e0957c291861eb23908edc65b06a","tests/merge/bad-world1/from/a.wit":"d8ab0c1f6d0a4e566442e4af8ad10d44b033ad928232e3e769862a0091af31ed","tests/merge/bad-world1/from/deps/foo/a.wit":"e49da20e2cfa3484864737126b569e4724fac826ac83e0bb418b801336b37062","tests/merge/bad-world1/into/a.wit":"6f6bd76d039cdc1754c88dcbc57f83cd75ca514481930c013cdb1536add4d78e","tests/merge/bad-world1/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/bad-world2/error.txt":"82ea5309efcff50f4b73843f46c28c45ea17d9f3b74415578fd0449445ee8a4e","tests/merge/bad-world2/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world2/from/deps/foo/a.wit":"548c3bb37a685be2e833e62877d7b453ed05ffcc6c51a5fbdae9ab770d1c1a1a","tests/merge/bad-world2/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world2/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/bad-world3/error.txt":"7ce381053e15ac8978fb690eb0eb9f0d9680e6ecad007b3ae5ac273ae2e2755b","tests/merge/bad-world3/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world3/from/deps/foo/a.wit":"548c3bb37a685be2e833e62877d7b453ed05ffcc6c51a5fbdae9ab770d1c1a1a","tests/merge/bad-world3/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world3/into/deps/foo/a.wit":"f4af2d9b3ea3aeb7d9cd1663e54e526d3dba474a1ae5f66227b7be2433234a3d","tests/merge/bad-world4/error.txt":"b87d169ad53a2cb5de0aaa38e365085d5ba472f3a5593cd448d1d2aba76e2df4","tests/merge/bad-world4/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world4/from/deps/foo/a.wit":"9af9c4ed27a130ce0ea282613888d4bff0a8d6d1c36d91ac45ac9528e2b74284","tests/merge/bad-world4/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world4/into/deps/foo/a.wit":"f4af2d9b3ea3aeb7d9cd1663e54e526d3dba474a1ae5f66227b7be2433234a3d","tests/merge/bad-world5/error.txt":"5cdeb66fda055177c3a3acd8070e891476e12759204cc9288ca89beb0cce1cc8","tests/merge/bad-world5/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world5/from/deps/foo/a.wit":"88c8bdbdcd401558214342070b09bbc8454593d682b43de8d7ba6fec98512d42","tests/merge/bad-world5/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world5/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/success/from/a.wit":"9ba239a15824020109d3b7b1b09ff2463a91ee83f174c85acbf08dacaeeabe90","tests/merge/success/from/deps/foo/only-from.wit":"3cb85cffd8f2060149fc6dd2c42259be0af125602cd1f56ca6aa7b3fe5d101b9","tests/merge/success/from/deps/foo/shared.wit":"d75dcff4825dee46320dc97ae6b005c5b43cca83a48bd9c932d2f662e29793d9","tests/merge/success/from/deps/only-from-dep/a.wit":"013b417cdcf40b3203ad2c4a4b2c3d3fdc0930eb05b5095eb03adda5888c6c12","tests/merge/success/into/b.wit":"d46f59c41f4a1f0deb7ba9dc4a30fd68946e4dd228520d0aa94e53771ac58b2f","tests/merge/success/into/deps/foo/only-into.wit":"afd48df694fd9f6be69f123ef0054ebdf54fe40f9de27d3ebd4829f6d3ce2a4d","tests/merge/success/into/deps/foo/shared.wit":"0a2dc3ef6f40a80c125c88a1ef50f7a29ceafafe0a33e6276fda021b43339557","tests/merge/success/merge/foo.wit":"a31a3fb1eee5ba150eff17968de545939a75cf62216f1e634bc319ab0e5eca69","tests/merge/success/merge/from.wit":"5d4ae81da25de51544367675d0d35447959b9ffd38d1addc71b3de43cec2256b","tests/merge/success/merge/into.wit":"f634f6316a61eb8353062dc590bafbdc382b5b660ff47a2fe57a096d37027aa6","tests/merge/success/merge/only-from-dep.wit":"bb258879aa337563aca3efadef46d4267bcc6a364fab0f7b0c83b1ca40646eef","tests/targets.rs":"817c3fea4f0a13f5a162989daa3e77cfe840c61e23039a66874a413bc17f2d76","tests/targets/error-missing-export/error.txt":"5c4f40d87595312b19585b2aaca07212c99a382228c309684c1911b3599572b6","tests/targets/error-missing-export/test.wat":"ecb067df02eb0320a0fdca517e1ed718449f33d6f374bc0c7663e5f142edc074","tests/targets/error-missing-export/test.wit":"3cc01dbf799565f81074bdb2ed9d274ed682c19baeabed5a5422abad55825fa1","tests/targets/error-missing-import/error.txt":"3a666ba746184ad3a04c2f0b7212b26eb4073ded44e887cbb9afcf4c19ede11d","tests/targets/error-missing-import/test.wat":"ba8745404917b9a0900d70377212510d57d90d700002811a826779acd39cba19","tests/targets/error-missing-import/test.wit":"621baefee52d35a98e0459b53abed57ff75969e0dd95c6e7866949e215503c3e","tests/targets/success-empty/test.wat":"fa69abd0e355ea21aeaf9cd3b36e1bf6a4944ee9df0be50d1c764b43eaa1dce6","tests/targets/success-empty/test.wit":"457c6efac7f9d666c5fbb4111fa91b26cb38548be1da2c7c1c0ea89d33cfd5b1","tests/targets/success/test.wat":"bff481f132e976f3ff757f5816e58c79ba7ffabca76184452e048cf75028896e","tests/targets/success/test.wit":"467f876c7e3b3b698517c2df8076bfd1f27cf4764841ec7b1f91f143c8589da4","tests/wit.rs":"160fc7aa322c26d2e6eb58d2eff8eb06f583f34a5f2c6b101bcea67d200910a7","tests/wit/parse-dir/wit/deps/bar/bar.wit":"2319c45fbe264470daeff5718eb5e6cac02ffbbe59af4c14cb1120e401c9dffe","tests/wit/parse-dir/wit/world.wit":"10cddf5af787eb1d0e67e46cca8cab5c3d407ff9cc75f377641dc831153163e7"},"package":"9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"8456162b205395e1ccae297c7bff238bc11090019a7807fee70463494697bffa","Cargo.lock":"5fff8966384cc2e3f5f19866742d4b8fd536e64f4cf37963b965f000f3579440","Cargo.toml":"8142ea1fdeebc373aa1ef74dbf068351b2995b10ae9629a758dc6ece35f2fffd","Cargo.toml.orig":"eda00a1d5a187c31873aee6413503278a16d865a2d25c3872fdd7a4281b1c3ad","README.md":"00d3b7547efc420a28ce22afd6d9f29f996e2a972ee0f753f988ee26e54ac8ea","libdl.so":"6d6ea03a4a671db91be183077b6665866106a61c84739580773a7e5b6bd9f256","src/dummy.rs":"8ff563ef71fd4b090ef65b11d4311386e2d16c08769569ab2809d5c207d42f19","src/encoding.rs":"44026b8332e9fd8db97ccc4e685d8bb224fcbc63cb98e08ddc3928be4dffb901","src/encoding/dedupe.rs":"157abfde68d0c0e610acf399b0bb5efe7dce66197b513922cac85ea28004e9e5","src/encoding/types.rs":"b7f25629759c3786351fda2867409da8043be0ed4bfa8ff17d89ed285c8d2670","src/encoding/wit.rs":"dd8abb983f7a3e2499db41d6aa21733758e2cdae3805af5c058063adedcb4c2e","src/encoding/world.rs":"a8d2bf823a5fadf248cfe13e19ac56ad7a63974334518a1f2634251aa44ae2f9","src/gc.rs":"e731ef0b88c56c9cf99b83ee1a9fe6f085b8744c394f2bfc6503106390e6edb0","src/lib.rs":"25a5d6af36e1f9f6fa405e0c67a3736420b310e73f9eb7c03ed520a81515a2f7","src/linking.rs":"bfe049c0138b647a80cd4dbf1d8a926053e6c4f59a3bda702d82670a4cb62e7e","src/linking/metadata.rs":"33899abdc312ff16ea28f016406c2aae75fc24ccd5ef7b2e4bb62aec3af08102","src/metadata.rs":"ddfa0af7c35a410cd5c64ba81feef28dbcf078aad736508ed69c71d47394617c","src/printing.rs":"92311a35a001157f12212e41f21d3d559b7e8219bf38be4bf595f36777855c7f","src/semver_check.rs":"0f1b26ac481daab44aded3150ecc1d50f38d648ebf9c3221da89072f23a995f6","src/targets.rs":"74531ecd7e1b1afa30ed24bb6340b430f1b2e1679ed80bf61894b018b4eb5f8c","src/validation.rs":"870632e0223dd980669d1d75560962502163745f54d53d086df5b0796e2da2ec","tests/.gitignore":"56290c87f8681b45f1bc1842ae3943204a6d40e03915268c99359c59c5a5cb5d","tests/components.rs":"78ba10ec0049026d5aebd72b7f651c258626c5fe25cbde4c0015f16834ce1971","tests/components/adapt-empty-interface/adapt-old.wat":"3a6db296d593ac422b4132714267a678490528f5299e3b263291fdcbd7d35b1c","tests/components/adapt-empty-interface/adapt-old.wit":"c04b693fd79794d910e739efa5d8356cec96e0b68df00b3fc21945f68a57cc4f","tests/components/adapt-empty-interface/component.wat":"fca49ffd58ca913a5d740e2cca9b91028f994682ae89c4e3267c0e624c616316","tests/components/adapt-empty-interface/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-empty-interface/module.wat":"e2f2a12e798371295a81cb05092d9164b37545d89962891759e0bd4728c3866e","tests/components/adapt-empty-interface/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-default/adapt-old.wat":"fe2824af7a5061c880d378a418796db230831b7cf50704a42e15c6dd2c9e6258","tests/components/adapt-export-default/adapt-old.wit":"71084c4ee7c4940876553129fe1b519e8eadacfdd3cdbf1cc640d5f3c5aa8831","tests/components/adapt-export-default/component.wat":"976fe1e9be2de60268d70c31ea15f59fdf9824ed411cb14acf1aeebd09d3390a","tests/components/adapt-export-default/component.wit.print":"7898d8d83177c3b78be309e32203a439946ec2765ec849ba9593c7703efd54dd","tests/components/adapt-export-default/module.wat":"8318fb33e37e0e6272ca8d25175c22db8d8c585cde1eb04210474b72bdb561d9","tests/components/adapt-export-default/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-namespaced/adapt-old.wat":"a5ba577bd703bd03fa961655122b46d2ef4ceb06cf851a3ba05e235b477b3cdd","tests/components/adapt-export-namespaced/adapt-old.wit":"3efacadc9fc5ea5997f0a2b468588100a1af780a6f43f09027b1999b5f04bcc9","tests/components/adapt-export-namespaced/component.wat":"865312e1ef947db62bb1856c19650cb5dc7d36de55e9e0d79263cc68d9bc011d","tests/components/adapt-export-namespaced/component.wit.print":"869261a145f6337aee4fdfdadc22f123784b8cf1839deecebda0607f5883f24d","tests/components/adapt-export-namespaced/module.wat":"8318fb33e37e0e6272ca8d25175c22db8d8c585cde1eb04210474b72bdb561d9","tests/components/adapt-export-namespaced/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-export-reallocs/adapt-old.wat":"9db1b4fbaf190e7e7fdea1caf291ae0e833a687f37b396096c6f4b7735491109","tests/components/adapt-export-reallocs/adapt-old.wit":"9cc7430d32be94c362abe794a4b356c470d23ecb6971de030f9b411c612352c7","tests/components/adapt-export-reallocs/component.wat":"caaf9904ead980403b632431a38bb6e64a461a531d03162961f490890c8430c3","tests/components/adapt-export-reallocs/component.wit.print":"82b6fe5b0953b68beee20d7f31e53712ec76f9f5d7196a2dbc57ac59a68c4096","tests/components/adapt-export-reallocs/module.wat":"53c738018c3b15fc3c7f21f1b8b5443c7afe89c25b08e7c56fc45a81a90627a7","tests/components/adapt-export-reallocs/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-export-save-args/adapt-old.wat":"60a41275befb6be47a8618fed9f3e1cab5b0807864d83e25bd84abe17d7579dd","tests/components/adapt-export-save-args/adapt-old.wit":"ceab954d883cf0c7d8c4cb28ce0bc641b969f8d0fda0bc411bc6fed8e553d220","tests/components/adapt-export-save-args/component.wat":"67f09c119ef670e3d478081704470b057d10a5f7b82016df4870dcf5211b1099","tests/components/adapt-export-save-args/component.wit.print":"6f24d727c36366175e949619aa8655755c6fdea10dda4770a30d0b366c877326","tests/components/adapt-export-save-args/module.wat":"6c7d1c7ded2d891fbbc9b778523905240c63bdc281aa4736c13bc01213d31a8b","tests/components/adapt-export-save-args/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-with-post-return/adapt-old.wat":"86ef0da2b6687532011de1aaac54add6150a43309b3d61a4e31fe37a5df6765c","tests/components/adapt-export-with-post-return/adapt-old.wit":"db342b3d869e263bae40fee459ca55736449430b255e9ef5bf6062a1ae3b0275","tests/components/adapt-export-with-post-return/component.wat":"f5ee8419b25645958d64c78613590418c8704f7663a4858dee0bceee28bca9b1","tests/components/adapt-export-with-post-return/component.wit.print":"869261a145f6337aee4fdfdadc22f123784b8cf1839deecebda0607f5883f24d","tests/components/adapt-export-with-post-return/module.wat":"a4e32bd0b2fbf43172da21f77d747ca1d8bef7779e9f9827429bdc114e62d63f","tests/components/adapt-export-with-post-return/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-import-only-used-in-adapter/adapt-unused.wat":"74d4a3a10e95b0b9a40a5269d3c28cbbc1ea1ef0ba9414497d2b1fed8648e510","tests/components/adapt-import-only-used-in-adapter/adapt-unused.wit":"9202e95a58f5d359c9c4f60dcbc5973fabc19915dcadf1d26e2324dda312f5e5","tests/components/adapt-import-only-used-in-adapter/component.wat":"74313f64cba93d7fe6afcea089730eefc24565976bb9bc9b9d71462ead3377c7","tests/components/adapt-import-only-used-in-adapter/component.wit.print":"9dbf66812387cd9f17ea903de18c0bf6ef6308bac6bd9db747f6cdd962b27497","tests/components/adapt-import-only-used-in-adapter/module.wat":"1920c02ae4d6c6c12ca57665e88ac039bf845e05f9b8628379cada9efff074ed","tests/components/adapt-import-only-used-in-adapter/module.wit":"ec9a35c247c4354e6960e3e8801c9aab4b9b5dd57a77fab348991b016b0f6017","tests/components/adapt-inject-stack-with-adapt-realloc/adapt-old.wat":"d7d78f6a6faa80d753c3652e9f7308691b9865435bb58338cb5479a66531b32c","tests/components/adapt-inject-stack-with-adapt-realloc/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-adapt-realloc/component.wat":"a6ee87c556eac0f3d2c01ee2eb1f621e01e61abafe6b3f073507144ee3c4fa5a","tests/components/adapt-inject-stack-with-adapt-realloc/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-adapt-realloc/module.wat":"623ad5e85f4ad4ea9c3480df598dbf1e8d50d7d8bfee01aa9b425550434b0160","tests/components/adapt-inject-stack-with-adapt-realloc/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-inject-stack-with-realloc-no-state/adapt-old.wat":"2102c5772be78a8a907be569aa0d185f0a1ad767e4d601a27a1b870151f892ba","tests/components/adapt-inject-stack-with-realloc-no-state/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-realloc-no-state/component.wat":"93c7d16960727e35915b81091c79c8f2906bc36a63cd21d64ee42e2a4caa0254","tests/components/adapt-inject-stack-with-realloc-no-state/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-realloc-no-state/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-realloc-no-state/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-inject-stack-with-realloc/adapt-old.wat":"d7d78f6a6faa80d753c3652e9f7308691b9865435bb58338cb5479a66531b32c","tests/components/adapt-inject-stack-with-realloc/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-realloc/component.wat":"5e67becee53a51ae1613af0389c1952b12481b5527fffaed1d6f9ed7b72297bd","tests/components/adapt-inject-stack-with-realloc/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-realloc/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-realloc/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-inject-stack-with-reallocing-adapter/adapt-old.wat":"f45808f40cf534bc765895f472b8f6b9880c8cfa450dfa30d3b9c20cede292e1","tests/components/adapt-inject-stack-with-reallocing-adapter/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-reallocing-adapter/component.wat":"f86cc7688639f35f5c618affe960325a916c0b01e6ef828b44737a03d4d15f81","tests/components/adapt-inject-stack-with-reallocing-adapter/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-reallocing-adapter/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-reallocing-adapter/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-inject-stack/adapt-old.wat":"4e61aa8171cbdbad0049d86bd37dc0c2ef1d983e245eab080b4006e453512e0e","tests/components/adapt-inject-stack/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack/component.wat":"63913d6860e01446c3b5340c6cc2d71b29e6a5e04cae3d38ae75288725382be6","tests/components/adapt-inject-stack/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack/module.wat":"7dd9f65faef528be9924ecdf40f0b05cd63b365f70761a31ff58afbe6629d98a","tests/components/adapt-inject-stack/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-list-return/adapt-old.wat":"d32ce421ec76960c676a09af5dbec9841d3b24d0dc8f8553f2b62d6b010707e0","tests/components/adapt-list-return/adapt-old.wit":"fedd6dc412b5980b85d901a02003239d23a6f5b935266f9e28278b0d09d66947","tests/components/adapt-list-return/component.wat":"1499ffc6fc636fc6560f01050c826a38d26120f9e501771714905143f12de04f","tests/components/adapt-list-return/component.wit.print":"3840662862e417d02278b78c1cee0913e95bec39416e29cf679e2868d8d52528","tests/components/adapt-list-return/module.wat":"73e71115facdc70bccaad35d84b1b7efe3c9ef1c53e554fcbb7cf6a47550621c","tests/components/adapt-list-return/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-memory-simple/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/adapt-memory-simple/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/adapt-memory-simple/component.wat":"d4d9a4ce50eb25fc7da3b9cbf0fcde90b9bfaedef4c184a7539501a1d4e88582","tests/components/adapt-memory-simple/component.wit.print":"a55daf78c190d92eef7b04a67a6115cb15a9aff7afe5f56311eb9463e72edf71","tests/components/adapt-memory-simple/module.wat":"5fc3894c9ed221c7d0059752e6f37610b37dc8452f9d08012cb62c93357d6f66","tests/components/adapt-memory-simple/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-multiple/adapt-foo.wat":"360aac53ba20c06b70ccbb17e6bf0abbd6c4256169e63983e0e16179d1b36645","tests/components/adapt-multiple/adapt-foo.wit":"cd76acb12ae0816ce116c5bf5e58fb6fef2cc3443c9d02fb9f166d71c7012d31","tests/components/adapt-multiple/component.wat":"9b59aabb6c55164d8ae24cb2e53307a2041a287a5bc7c3863ddb03b5243320b5","tests/components/adapt-multiple/component.wit.print":"a692a4e2fad55770689c501f3ee858e0d6a82da6306ce8c1ae67b9384004e819","tests/components/adapt-multiple/module.wat":"09c98f0e426797ca22bac7c8597e2b2299162642a56f9cd11c1791b8990c92c9","tests/components/adapt-multiple/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-preview1/adapt-wasi-snapshot-preview1.wat":"2d13becaad0a248f4b86b740e11c53b25e131c015a058cec83f35f03b1529552","tests/components/adapt-preview1/adapt-wasi-snapshot-preview1.wit":"8b084967d2be4bbf24735fe204fd7a5141f6c8baf4939aa033563fd0643509df","tests/components/adapt-preview1/component.wat":"9dbe467777d360124849e44a6f11899ca69db4aeb155d7fd53f60aa1755bdd1f","tests/components/adapt-preview1/component.wit.print":"5d4f747617d4e49467d7ab1f831a859531f38ba8fdbf7bca6af91f1e3583086e","tests/components/adapt-preview1/module.wat":"6d3d0c452aaefde1fbdcab22b2207c3dfc91cf3b7ce2133414090fc770a16bd0","tests/components/adapt-preview1/module.wit":"0207b70f162393b9976640b7afb83470fc815ef69d58523a43e9ffd4997b0f67","tests/components/adapt-stub-wasip2/adapt-wasip2.wat":"c18d8a24f5c8b2e88b16b50a3104357755b788930ad9a1ce42f2c1fd56539c46","tests/components/adapt-stub-wasip2/adapt-wasip2.wit":"25d97f7ad800690ce2b90446b0c7c953b99ba4546203dc3de6687175b210776d","tests/components/adapt-stub-wasip2/component.wat":"f64740e5a017765e3bc8e791127689aff0b47839eca137910491960dc421199a","tests/components/adapt-stub-wasip2/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-stub-wasip2/deps/cli/environment.wit":"b6350bc0c8d1e916d0ec7ddec44bd702f4419fe6e8fb97878d725d7db55f2937","tests/components/adapt-stub-wasip2/module.wat":"67ef212810041d77c3db6df7fabe3d52dbf063a963433a7a478b02f641f83323","tests/components/adapt-stub-wasip2/module.wit":"6e2cbac25c8c2d1120f26f1c04d01cbf3d7578ef759e0b599c6c23c535ddb20a","tests/components/adapt-unused/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/adapt-unused/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/adapt-unused/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/adapt-unused/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-unused/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/adapt-unused/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/async-builtins/component.wat":"1f480263d84e78f6bbd563eb6ff4469d4869e75f8ec129b3904316d0d662b88f","tests/components/async-builtins/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-builtins/module.wat":"bfd0ce1103f232f0593735b45f069d81ac006c0126ac2f16a970c50c5ee1d383","tests/components/async-builtins/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/async-export-with-callback/component.wat":"58c5f7d4687125e5b0363373f322fa01f81531607fb95e33b493733ed33ee1eb","tests/components/async-export-with-callback/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-export-with-callback/module.wat":"38d85c7293b53c0b6fe33192f048b78ee60251dc63106c9b74e0ea314e75f90a","tests/components/async-export-with-callback/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/async-export/component.wat":"fc439f383bf912477408772aa4a7fe130606921798fc690429ba263b4f63190e","tests/components/async-export/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-export/module.wat":"f239da1438442af8f76ea2067cd25c7abd14af474e304584e92f749eb2c05e17","tests/components/async-export/module.wit":"bdf4e2c172d5eadd8f785e7e467655e3dec8eb98101cb84532c8eaace201b75f","tests/components/async-import-only-intrinsic/component.wat":"661f847e409d1dfd62694ec2c659731ab226078d2490a19f64de4799aa8cc60c","tests/components/async-import-only-intrinsic/component.wit.print":"d72c0077b57005a82a04181f4de5a19d0a13f342e51f8ae39c16df0200ca4e2e","tests/components/async-import-only-intrinsic/module.wat":"d739e805be3be8e4594cf3551c6ab32f2550264047535e0dd00e96ab7303f886","tests/components/async-import-only-intrinsic/module.wit":"a67e614f426d01595a5908748223980e6b71e7ae71e9bb55c7954503a4fa5883","tests/components/async-import-tricky/component.wat":"59139c14308ce67e8b3348d1c77bb7826b1d5e744cb90d495b2e2012ee432dea","tests/components/async-import-tricky/component.wit.print":"d72c0077b57005a82a04181f4de5a19d0a13f342e51f8ae39c16df0200ca4e2e","tests/components/async-import-tricky/module.wat":"6adce7213ac96e7fcae050279d5e7011b92aeb84fb8160565ef904bc167bf205","tests/components/async-import-tricky/module.wit":"a67e614f426d01595a5908748223980e6b71e7ae71e9bb55c7954503a4fa5883","tests/components/async-import/component.wat":"3276ebf1556e6715bceded460db3e4531c0fcaa305d0afcf212b26bdfea5b115","tests/components/async-import/component.wit.print":"f17ba3097a41cc0faefcc85611f316be96d7bfd4f67abbc93963daf2c04cf2d4","tests/components/async-import/module.wat":"5f5894e70f438a461441d85203a948f3e5accaf8cc0470195d5b18f8547129d8","tests/components/async-import/module.wit":"31a71ad2c3142b71c67e87c6149efadca1e9ef6262d79eadc88ee2ddd8407203","tests/components/async-streams-and-futures/component.wat":"40a857b7d40ec7046fe7773319393e8dcbb1f708f6ef7527744a12bde1267b4e","tests/components/async-streams-and-futures/component.wit.print":"fbf4aae8ea7d2c661f42b5508e7617eae0e369092941104e5b33d01df04520a0","tests/components/async-streams-and-futures/module.wat":"bacd5dfec7a79670bc135eeb42bc3da07835686156058e9337f2740ec9658028","tests/components/async-streams-and-futures/module.wit":"21bddc5f549b3886d0f2ba9cbc838e5ecd29b1fe2d6a559bf4f44dd634f6878a","tests/components/async-unit-builtins/component.wat":"a699b5191cb6c6e394e642fd194949fed3a5eec7ab908ab664902fc1d1b24f3a","tests/components/async-unit-builtins/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/async-unit-builtins/module.wat":"c75ea94e991400e50800712542c8655d038ad82f42eb87e8075f58e8d4bd22f6","tests/components/async-unit-builtins/module.wit":"62887f2f27236202880a9116dcb8bb0d082ce1d1842f3c247c437f6bf9f12413","tests/components/bare-funcs/component.wat":"b1e1026a7e45f7944d426823cf162682776459fcbbb42590067fad56723f616e","tests/components/bare-funcs/component.wit.print":"44142a3e54179c58231b1406306664b56e708d091373d4c9d26f8a8836fb19d5","tests/components/bare-funcs/module.wat":"eeacf6a9a06818a3dc1938f3f7e70d49e34aed35b6ff3000194b83b310757bba","tests/components/bare-funcs/module.wit":"cfb306074d962ab1cd345b9146c19593efcab6a033b350f809eb28be53a5b709","tests/components/cm32-names/component.wat":"c4e1443a880ebe01ea12a930726c29f3f8f572cba802b0f849791fb0929876a2","tests/components/cm32-names/component.wit.print":"931313d8c16524f0a195235a8acb74332448679069f426535773aca17354c6e3","tests/components/cm32-names/module.wat":"2377a85fd01e55a6fdb6b91b8074967c86f00a565a4fccb0ae3f463dcafe2c03","tests/components/cm32-names/module.wit":"9512314374f9cbd23730915c09c154e48deaf6741013e8d32e22dedae556aaec","tests/components/custom-page-sizes/component.wat":"3eaa8c9790617a9026c077489ae93022ae6e970577e37ea5d850abe90137f22d","tests/components/custom-page-sizes/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/custom-page-sizes/module.wat":"735787796014137b07df0a6c8a5f07b6f9c202440111456ef4b2224b60583b1a","tests/components/custom-page-sizes/module.wit":"2e6ea2c38b49574cd8f8303204067e2977f695925f161c9e68002cd1fee842a0","tests/components/deduplicate-imports/adapt-wasi-snapshot-preview1.wat":"3d96dada383101358bd8985bcc1ff9956d8a50016607914182f205f777a4ebf2","tests/components/deduplicate-imports/adapt-wasi-snapshot-preview1.wit":"f4d3eef4cc15bc74a4d9d7d045aacc81be1991b4bcb184d587e2048a983035d4","tests/components/deduplicate-imports/component.wat":"41496495e2e28882e71d39822a7e8e798ea636e8b0050296320dd7f84eb497b0","tests/components/deduplicate-imports/component.wit.print":"bfc18ec3026ea7285c88bb8da1b4dd5d77db4e41fff8a8f0f26df9656a18ae8d","tests/components/deduplicate-imports/module.wat":"11693ac57d19f8388286897e8a3b3b4d2d18c9ac92ea9cee5e9559038818ad30","tests/components/deduplicate-imports/module.wit":"ebc9fa1a6bf412c67ce4dc481a1477500a902b56c5f395bf5618c4a14474485e","tests/components/empty/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/empty/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/empty/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/empty/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/ensure-default-type-exports/component.wat":"a7991c6b578b95b41de82514cac59c4aa19b46d6341f244eefb16f4bffc77491","tests/components/ensure-default-type-exports/component.wit.print":"baf9b735b1f9dbf8e247064d5735bb8b37fe53f6f1e9bd1bd154a991177e1b54","tests/components/ensure-default-type-exports/module.wat":"14a179f41e4e06a59b4e34f0815ea34e12ccf1f8500bccd83623deb84c71093a","tests/components/ensure-default-type-exports/module.wit":"36353bc5366252cae33912f215d77dc501384cc9606dbadf5fc831b33376f3de","tests/components/error-adapt-missing-memory/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/error-adapt-missing-memory/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/error-adapt-missing-memory/error.txt":"d8491054cdabd0359c1ece02710db9f5989eb58c43283e73dcd0401231fdeae3","tests/components/error-adapt-missing-memory/module.wat":"a09c5c2e4aea7fabae1df7f54791a87061018325968a3f9379d35e3ce2cc405c","tests/components/error-adapt-missing-memory/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-async-export-missing-callback/error.txt":"53956038fd6dc7921e06b1217ea0bb21ce8fb43f9dc6ca42ef5f069793d6d899","tests/components/error-async-export-missing-callback/module.wat":"89ced8e40f2175f16f59261807e23b05dfaf326231873a6f011fc4b765fa86b6","tests/components/error-async-export-missing-callback/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/error-default-export-sig-mismatch/error.txt":"04dac125afd8c985269ced00b248d43cb7dc96f8a52dac2f3103c260aa86f856","tests/components/error-default-export-sig-mismatch/module.wat":"d61b464c502b1af9fd83b5ff5339ac45d2674c9455163bc7a89a02fb5454f878","tests/components/error-default-export-sig-mismatch/module.wit":"5d093bdde43c050d69d2df8b034d66ffa6c076ac4c83b26ad7e9cc78ef49dd68","tests/components/error-empty-module-import/error.txt":"98053ec5a972463d2c9411c82da5b2fa95e24099f6e6c61d355212d46444e8a4","tests/components/error-empty-module-import/module.wat":"a9e2a33d4affd7e94275daf7dd6475c71135de2359343ab0568a3fbe7204a527","tests/components/error-empty-module-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-export-sig-mismatch/error.txt":"a90a4c7f4f88369d8cd30673fa8cef6628f5eef68bc626a225fab11aef056d5e","tests/components/error-export-sig-mismatch/module.wat":"4d7dcefb19126be4325185e99fbd3f0f964947e8bce9cb4254dd153da60a4e39","tests/components/error-export-sig-mismatch/module.wit":"775d9b931e1644f29c0124edb264af4b6c9ef9417c3abcaa2711ec99b809b85c","tests/components/error-import-resource-rep/error.txt":"19991af81b6006ae5d7f1f92f945a8c4debf1e82069ee4a67420df4fd6de8f5c","tests/components/error-import-resource-rep/module.wat":"01c719d6eb94c6e3243e04425c6eee29f5afa86d7de59e0231412190385b3759","tests/components/error-import-resource-rep/module.wit":"9dbf3ad66ed4cd913521b98dcc1eb51780671de15a1d2f3da86fffcc59a9a906","tests/components/error-import-resource-wrong-signature/error.txt":"3e2a1f3b231bd148cbfec7108af76d5f61d90edd5454c0974f0bc86c6049002c","tests/components/error-import-resource-wrong-signature/module.wat":"9f921559b46bffc7e412984c49395cbef1b723e616cfedb5ceea6784b70471e2","tests/components/error-import-resource-wrong-signature/module.wit":"9dbf3ad66ed4cd913521b98dcc1eb51780671de15a1d2f3da86fffcc59a9a906","tests/components/error-import-sig-mismatch/error.txt":"b3364c1047649d851a0ae1d80332a6df1b34504a8519a132c68fc1855c7443b8","tests/components/error-import-sig-mismatch/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-import-sig-mismatch/module.wit":"d98bced030198058d8c1a6e77161ef9a1e3871f8f2c539a618aeccfd4cc19b1b","tests/components/error-invalid-module-import/error.txt":"f8359fe5bc543bda23293a6f8d40b1d96d9dd6d0d521e538113c0b69ad5a0d6b","tests/components/error-invalid-module-import/module.wat":"20b107a75357922999a6951562cb321ff63926ce1011cf724da12ed1b2c86ac9","tests/components/error-invalid-module-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-link-duplicate-initializers/error.txt":"05be0b8139892df6dac079ba7726fce46909ed661bc4367644c9c6ee7f7c8b3e","tests/components/error-link-duplicate-initializers/lib-bar.wat":"7039053f316ef76c2f5e47e266a950bdab536c90b558f408edc43560f215eed5","tests/components/error-link-duplicate-initializers/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/error-link-duplicate-initializers/lib-foo.wat":"162307ee1bb2ee38b02d94e8dae7d0b367cbc7e66250286141e557db56b9816a","tests/components/error-link-duplicate-initializers/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-link-missing-needed/error.txt":"75506d6c1244cd5d0abc95789f38036415599d737a0e34ea0894b23dc9598bad","tests/components/error-link-missing-needed/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/error-link-missing-needed/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-link-missing-symbols/error.txt":"1b8771b7638f5ed476bbd54c5f613c144b36f74ef4f700940540a913f6960c3b","tests/components/error-link-missing-symbols/lib-foo.wat":"d0b8b5ff95b5b4008cfa306d4af74bbca75bf07bd42ec897b711eb3064b1108d","tests/components/error-link-missing-symbols/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-missing-default-export/error.txt":"5a53be2c03ca12de39b6dd856ba0cb4b61ae41284c8970dd319f92458c3fc8d4","tests/components/error-missing-default-export/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/error-missing-default-export/module.wit":"155bf2d1c7ee9ea2d284964c56c936f94ae987195787235350ced0dc6d6db305","tests/components/error-missing-export/error.txt":"878e7173e57fb0eb0df926bb43e7e0403f88462ea9e67c2412018712e6f9ed56","tests/components/error-missing-export/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/error-missing-export/module.wit":"eb129f25552584be9360310178c70a65029de6b72a1440ed99ddbf38d0916c6b","tests/components/error-missing-import-func/error.txt":"be530862604920bc57c09726e1c33d9b19f998c34d41b0fc92e1da9a21c5b4fe","tests/components/error-missing-import-func/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-missing-import-func/module.wit":"4f0718445438c4dfc08950cdfdaebb4a4c5adf2d724d66bd145ed593c1592c1e","tests/components/error-missing-import/error.txt":"be530862604920bc57c09726e1c33d9b19f998c34d41b0fc92e1da9a21c5b4fe","tests/components/error-missing-import/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-missing-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-missing-module-metadata/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/error-missing-module-metadata/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/error-missing-module-metadata/error.txt":"993083f2635f4875169fbcab22b59bf416eaf09de7708cdb26f47918c615ace5","tests/components/error-missing-module-metadata/module.wat":"66a5907fa8f666c22e3f5cf88cc62a8567a777d750d76374de448e0f8e8ac7e0","tests/components/error-missing-module-metadata/module.wit":"62887f2f27236202880a9116dcb8bb0d082ce1d1842f3c247c437f6bf9f12413","tests/components/export-interface-using-import/component.wat":"7d16e055fab6b2601aec5aa0618462d75106e29ad65a676ba31301403d7b0269","tests/components/export-interface-using-import/component.wit.print":"3cdf7896480bc68b7cb0b9c9ff4dc028eb7d435f58de7bfaaf403e426438fd19","tests/components/export-interface-using-import/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/export-interface-using-import/module.wit":"c6b8fc795e93412e9cc6e2ba335c20c89e0ba442f684bb0ab779ce052e715c32","tests/components/export-name-shuffling/component.wat":"abe1f435743fdd3690dac62d9b60ee7afcae762aa9e8e912fa8556fc83eedb5d","tests/components/export-name-shuffling/component.wit.print":"32e7124b8455a67f63c1071d9a5332dddec63c47472909222b351111e0146817","tests/components/export-name-shuffling/module.wat":"cdec922bed8d252248be323019e3d5fc83e0bfc9777fdc654b59348daeddfd19","tests/components/export-name-shuffling/module.wit":"99d470993cedf025e7c356ea8e5c6a041aba2968419193eea5f1947061b19750","tests/components/export-resource/component.wat":"8ad1eca01f2d26a7135898bbb123391da9827604f6900799894b281dabac3bba","tests/components/export-resource/component.wit.print":"9a6e09d0140a25319041d65333e58adf87a0231b5283c3bc768ccbdce83f9c24","tests/components/export-resource/module.wat":"35cf529d4838d0652bbd322e3498e72d02643a4d105c0b7dd801d3648621316d","tests/components/export-resource/module.wit":"ff43e87ba4fb913e5e239a5282f0f0acc33aed4fa04610be25a706791429b56f","tests/components/export-type-name-conflict/component.wat":"02a9d2e58bb5abeeced1fda8ea356bf2a288d27d8f376b0ef84c353804193b0f","tests/components/export-type-name-conflict/component.wit.print":"0039957ae8e5e8ddba28cb0f8c7831a33864e407c87550f578af5e36b5b9d97c","tests/components/export-type-name-conflict/module.wat":"b8703739f92ca2de5a1483eb2504fc082e690f514fb014c7e09b6e5b0348a3ec","tests/components/export-type-name-conflict/module.wit":"47b93fc6d44cd48c9ba768feef028a5dd9980088ac328ef965038f349a566b46","tests/components/export-with-type-alias/component.wat":"01261b62e3576b58c1105019e610e1377476dab64fa0d29830358ba5efd35906","tests/components/export-with-type-alias/component.wit.print":"35e7687bbeb38e07890e152ab3359c6ecb558ae513b44f41efe60be15d99c5cd","tests/components/export-with-type-alias/module.wat":"d0e73d5437af39f365675b5c516a12ffadd6844ab1a7cb36f63829716a823c10","tests/components/export-with-type-alias/module.wit":"22f298065ce8a2fdaf726cdb347c4bca9e56700fc6475bda9ef5ef8563ff0d89","tests/components/exports/component.wat":"acfce3dd26ac8a4bfdfeaf3b01d6c23773acfbb1674813b26eb0f3e1075d4d45","tests/components/exports/component.wit.print":"761c69439ac16484a2b210ff34d219db4afb2bcffad4f3868a2e76479feb7f19","tests/components/exports/module.wat":"324dbfc38fee5a442e7ce3a13eb2a4d25dc6a074ba81bffd4fb35268608f9d08","tests/components/exports/module.wit":"d41d5f8763da23fceeb773ff18c9960132a1e811ef194a47c900d21f48083d43","tests/components/fallible-constructor/component.wat":"1b42b21f2ffd5de0614188b285517732b0676801b2c9460a54908629722b8386","tests/components/fallible-constructor/component.wit.print":"a486e9bc2d393474b05ab915bf61a573e89ef09e3bf7bed24e16cb95a27df2b2","tests/components/fallible-constructor/module.wat":"9dd3bbf052d233572a70122e34ada7573252fe2e727c918bda87f44d62ac7efc","tests/components/fallible-constructor/module.wit":"310b82945183ab329679be7f832f0d8c11c59360e700f9646f87e881e612d0de","tests/components/import-and-export-resource/component.wat":"7fcd443bafed0b524f49c7fa27b371ceccd6b95249998f5c8787e481d4e7547d","tests/components/import-and-export-resource/component.wit.print":"fdb32e7784b0d908390a0d1b62e077294f5168cb46daa470ac5e078cbe8996c9","tests/components/import-and-export-resource/module.wat":"43b89c3fa07a24663af81eaddbd02778a0d9062ce65efa7f04dd10081cc8aba0","tests/components/import-and-export-resource/module.wit":"a9f3ee298ad42fcef0d80a34b6b58e1d18e438e492400463993508599d02adce","tests/components/import-conflict/component.wat":"f0008f711d6bde4eb701a08fa5c61c021e33c61501fe3fce25535a420be1d63f","tests/components/import-conflict/component.wit.print":"19bae900cafe77b7bacda385e23475154f90f0a8d8f063597496132e149867f0","tests/components/import-conflict/module.wat":"639633c3b575c976831d12d1d7e69826ee23165c8cbb6094940397c8359ddc6a","tests/components/import-conflict/module.wit":"d8fd770eb17db0c5e7adc23c41315cbfd77af9014b4514d65fe2f28a629b7b43","tests/components/import-empty-interface/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/import-empty-interface/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/import-empty-interface/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/import-empty-interface/module.wit":"f570a16495e584b54606fa6a50018cfd1ab21dc85c10deb7f869564db3d7450d","tests/components/import-export-same-iface-name/component.wat":"7e506c2d9bcd48d98b4fa2acfe4a7fa33f6ac8cffc764629d9fce27f2005b3b6","tests/components/import-export-same-iface-name/component.wit.print":"510d7b609e6714e7bfb7cbe9f57c42c9d2318ec17de0ece8522599dcdc7aa22e","tests/components/import-export-same-iface-name/deps/dep/foo.wit":"e53988c57720965219fa842f767cc30e31f3c18ee07ba9833432ca2084ed4fca","tests/components/import-export-same-iface-name/module.wat":"a951a5e947ef899087bbe377a97c06d4f742afdc97ecdb673dc3e0e60019f956","tests/components/import-export-same-iface-name/module.wit":"c9bbae4c071ea7fa7da77e422fcb93d48f14a6faf0adeba4ef94b3949cf1f9a8","tests/components/import-export/component.wat":"bd51d58f13dc0de6ae5b62eef53383064378f62172382b879659dd39c4128a51","tests/components/import-export/component.wit.print":"07735b330c59c0c01e604e0d4cfebf3d513beb24a547c3453f9e804a7f502819","tests/components/import-export/module.wat":"5e42ab263e87ae03d3649d839f86614ff580982033ce7022dbfe1c6c13e886aa","tests/components/import-export/module.wit":"c90a74db6e305afd8c8da8c4b9d1bcdb0e4dc575c28d1cb302e2c3ae1b087c21","tests/components/import-in-adapter-and-main-module/adapt-old.wat":"43d847aa6521beba5a478c3bbede7f255c47ab6ee31b4f34a1524b28dfa25df5","tests/components/import-in-adapter-and-main-module/adapt-old.wit":"3cf2e31d18b76f61c61958cbc7313290ff7fb323719d31e89c054b9f6b41615e","tests/components/import-in-adapter-and-main-module/component.wat":"c9d2c38b30c0731bcc8ffb555a38d501135ce2065de42e8c16020b3b87d2f4f7","tests/components/import-in-adapter-and-main-module/component.wit.print":"fb2791ae3aa119e2ef9aabaa811df8a84a5680bbf26a7cb7697403f8efee705b","tests/components/import-in-adapter-and-main-module/deps/shared-dependency/doc.wit":"ba5a8f346d581ddcab0cddbcb00e976e54327920d4c7f98933a422f03e62339c","tests/components/import-in-adapter-and-main-module/deps/shared-dependency/types.wit":"2aa8bf309a148128bf6ca4ccd86c8fae95e97953a73f2ee7d652613a4eceb5f7","tests/components/import-in-adapter-and-main-module/module.wat":"6995ee3ebbbab471d4b7a7d9973647e5a4b86851ed54fc019b6ce46b39c3849b","tests/components/import-in-adapter-and-main-module/module.wit":"d1e48a09fb9307185b79f5f200b54e906da5ad62eb57e841bea93e239a96b9ed","tests/components/import-only-resource-static-function/component.wat":"1bd74e7edbc1bc26bb6c24508a941b67d8aaa3c2fde5ac2ba3183a930ca917a5","tests/components/import-only-resource-static-function/component.wit.print":"392a1d0c73268c3e20bce45065b5618dc8ec498e280d54c226a7701c2c7d17c2","tests/components/import-only-resource-static-function/module.wat":"cf1e1ed8d03ed537c0cefd5261147933c78b85cd748c92f5f005642cdfb1a01c","tests/components/import-only-resource-static-function/module.wit":"c6cf4995b848915d6c99a90f3b2ff95c32ecc9c3cdc21ece827d0840035d64ba","tests/components/import-partial-export-full/component.wat":"55081ae4598055a3abb4ee4cd3676ba30e99a80a167f87e2226be278b8d59435","tests/components/import-partial-export-full/component.wit.print":"3ab4179ebc8dfa619f72f3b51517dd038ba0b2bb1ada2ab063c2cb8dda844b85","tests/components/import-partial-export-full/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/import-partial-export-full/module.wit":"d37ab68346e073666081684d84a94ce9de6c27fc50ccc3c774b902f13dd77e77","tests/components/import-resource-in-interface/component.wat":"9463d61a86d5eb0c4eeac4caad24e61ee406a8fdce569f4a22c972cebb09b345","tests/components/import-resource-in-interface/component.wit.print":"313207ca455eee8d5649b5901c2e7786b117761cb76626ffed15bdfc6efa743c","tests/components/import-resource-in-interface/module.wat":"dfab4bf8f2d634b2f8db1c452ba1cc9f9aa20da580fb8e5f520d9383d53aa614","tests/components/import-resource-in-interface/module.wit":"72d6d2861b7cef7939fd4af3c615db98cb29a08fde3cbb4e5a4ea6fc463993c2","tests/components/import-resource-simple/component.wat":"0a9a15caf8bc2c69375dd1f1f0fe571a9c139e84132039834c1728ba0a103cbe","tests/components/import-resource-simple/component.wit.print":"7d166ca48287419d030b9cd49cd69150fc3a534f1ffc5569cee934c002f1028d","tests/components/import-resource-simple/module.wat":"76206dd7ed5d0ca30f9db6085cc3d0908fba505bff097e5310e1e7eeb6cd3d7b","tests/components/import-resource-simple/module.wit":"81993bcaeb714767b9f5d040079bc2b71cda292861b5d1705d55010e809907b0","tests/components/imports/component.wat":"1cbf22691c0723e661184424d00c620126db8a338499dde7397f29aa75b028fd","tests/components/imports/component.wit.print":"db03bcc1e409cf7eda8abe72152b697bf2242696c9442480d427033a6ada15fe","tests/components/imports/module.wat":"726b52e97319350b0995edadb347404724f750b451515cca2998d6ea43fbff58","tests/components/imports/module.wit":"ae6f59d5a9862832e4393df2e066ab8bd671a0072922b720bd6a7da703bbce43","tests/components/initialize/component.wat":"55ef7b724f6dce61155262085d7d9f627ad3ef0647049f86d836964664f48eed","tests/components/initialize/component.wit.print":"c621c6ab874ea1463aadf38c9a9499772183c86580381c0af0ddda71379213c9","tests/components/initialize/module.wat":"d6b0dd9b619d3ea4f767cdbaee59abfa5cc429a7fde2dbf30d4b98bc1ca8abc6","tests/components/initialize/module.wit":"2ec1457ceac2774e5c0f8701c08ac63575017bdbf8b2f58551f3f946edbae839","tests/components/lift-options/component.wat":"8e7a0fd9998956377a8c4521c0795698245e5e1f4882ec427fb917e1c078e688","tests/components/lift-options/component.wit.print":"0efa031b0013f70c3c5092f53e40b10c0ae02398403320a28ba7c28533517f2e","tests/components/lift-options/module.wat":"7f74aba6c2e663bc2a7de94bfcdeea21cb9f837952a6b7d5473998ee65d8ae33","tests/components/lift-options/module.wit":"63ab644fd22c7cfcb0b9a6195065f0065abc01eb5545e18437c02e6a68e09bd2","tests/components/link-asyncify/component.wat":"8b989d3709a2dce7d8e8894ea83cf827f9b3eb7caee007eb9b059125ec7e3047","tests/components/link-asyncify/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-asyncify/lib-bar.wat":"159e0a9e578b652915a4a1c525d876ab78c76574edc757eed8f2d898231ef3eb","tests/components/link-asyncify/lib-bar.wit":"2314b69344e6938e980366d4a2f912cceecebedb03783199a1827f641fa8aedc","tests/components/link-asyncify/lib-foo.wat":"d61a8d805cfa025d3be070564e8cd993a21307549af7fba1f2702ca5c4d083b8","tests/components/link-asyncify/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-bare-funcs/component.wat":"72c3bff4be47ed0a7f1bf2754c80665a2d20b292881891c0f5fd28732ba1fd4b","tests/components/link-bare-funcs/component.wit.print":"ffaa54c61b292fd93917c958eb7d4a2d6db224b5a30fbced6f07530c23486aa7","tests/components/link-bare-funcs/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link-bare-funcs/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-bare-funcs/lib-foo.wat":"57eea96d26803de69e0a6a69314006251da4146416f658cc7447e5f4212d0ecb","tests/components/link-bare-funcs/lib-foo.wit":"ce1132f1f5d9df197a0326a2b608df671179d490dc537e9c1f8577bd25c57ddd","tests/components/link-circular/component.wat":"5e1b586bb766e1cf3a2cfa47bee8665e44d0eacd8c9332f08e52ee04da6aa4b0","tests/components/link-circular/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-circular/lib-bar.wat":"7039053f316ef76c2f5e47e266a950bdab536c90b558f408edc43560f215eed5","tests/components/link-circular/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-circular/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/link-circular/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-dl-openable-builtin-libdl-with-unused/component.wat":"4444f536a9a97ea84a3822944ba48ec05e8d045ecb5ff86e67807f2106815bc2","tests/components/link-dl-openable-builtin-libdl-with-unused/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable-builtin-libdl-with-unused/dlopen-lib-foo.wat":"e02d2c79ff11af4334d7cf751750843102a4c2c40e1aa35686fd7d04b273cafc","tests/components/link-dl-openable-builtin-libdl-with-unused/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-c.wat":"ef5b56730b4c79fbe9f9e10f462ae222ff18bfa2a960ae03a86e3152257fbe6a","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-unused.wat":"099904a1539e31d8ddd306553dacd0667ee221a76aea79a3861a269d9edfaedb","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/link-dl-openable-builtin-libdl-with-unused/use-built-in-libdl":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable-builtin-libdl/component.wat":"6dd489bded8be0b711abb6129c927cf4d561979fbfc60dcb2317ac103287f32b","tests/components/link-dl-openable-builtin-libdl/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable-builtin-libdl/dlopen-lib-foo.wat":"1183b069d484eefd7a030c9ab975d4ef5bf24fcb033d922148398bc5ecb0de89","tests/components/link-dl-openable-builtin-libdl/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-dl-openable-builtin-libdl/lib-c.wat":"e1988d4a8ff43aed730375fae50e601b9d3f5c28ffafa56f6be581be1517394e","tests/components/link-dl-openable-builtin-libdl/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-dl-openable-builtin-libdl/stub-missing-functions":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable-builtin-libdl/use-built-in-libdl":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable/component.wat":"f169770d4cc24e8ed2c010810e31d956f29374e029b9f2dfb563a6b2f499d919","tests/components/link-dl-openable/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable/dlopen-lib-foo.wat":"7047914692755e525a4049b7973c8328de2c19fe0f1b65a368228f654d14937d","tests/components/link-dl-openable/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-duplicate-symbols/component.wat":"f015b4fd73d2f0b694d4cf0c18be014a82a1dbfca0bdf92452d295bf8382ccc4","tests/components/link-duplicate-symbols/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-duplicate-symbols/lib-bar.wat":"346743798987c1a403b7e4941791c3dff77e6fbfd83afab14596b3efe81b5808","tests/components/link-duplicate-symbols/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-duplicate-symbols/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/link-duplicate-symbols/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-got-func/component.wat":"28f03634ebea0fe1b7d2b187ec472e806759999e6e338116bebabd45ce366db7","tests/components/link-got-func/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-got-func/lib-bar.wat":"b68db9e5915e6875477363893779792319e68e6c0b23411dec94ceb903f2844c","tests/components/link-got-func/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-got-func/lib-foo.wat":"02179e2a615fa830bf3c7b8d42ba1abc9e922b2cc163bf03f389c19fccd3e8c4","tests/components/link-got-func/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-initialize/component.wat":"dda1f4d706281526a986c2973dc2814d58fcc8d035b61de8547b88d968e74564","tests/components/link-initialize/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-initialize/lib-bar.wat":"acdc5991e4e0bcd1a8d681599326d903b47a8485ecaa341daa95d75a10dbc270","tests/components/link-initialize/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link-initialize/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link-initialize/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-initialize/lib-foo.wat":"230df7123dced23e7ed1e01f8ab4c0564d0784c27fb5f56432a9641bb74cd20f","tests/components/link-initialize/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-lib-with-async-export/component.wat":"2ccfbe257b2318b3de66c8023f9f8c57b41ac2af678ec4ad5ecf0f565aff4f67","tests/components/link-lib-with-async-export/component.wit.print":"0d42f40f1f6c38efc4d7c51660b69bfbc86abcbdec31c6350ca6862202d2fdb1","tests/components/link-lib-with-async-export/lib-c.wat":"b42be22217533ebb066b70b2bb36d0deadd5470e45b6ea272e54ccef6d8ab62c","tests/components/link-lib-with-async-export/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-lib-with-async-export/lib-foo.wat":"b3221090479c8732841d2e57583a49d60c16ac0aa7fe8f6e1205212939ade018","tests/components/link-lib-with-async-export/lib-foo.wit":"358a5c8eeb2eb91489109180f0372fa049ca51b03dc56761bafa8de593e26c78","tests/components/link-resources/component.wat":"a41b479bcebb05a75cd6c29c996f02d65920219c74ee5c3394167dada015014d","tests/components/link-resources/component.wit.print":"7c9bcd7d88669aba18c1ff9979d40fcbca7ed4616db8fdae221e75f49c30e863","tests/components/link-resources/lib-bar.wat":"a19533149c2054deeb209e902be84d472b72b6a69771ff7db7d6c881028e172a","tests/components/link-resources/lib-bar.wit":"c51af5e3a0b53612bd02b9cfcfb509145806703ba7591ae9562a324e261fc805","tests/components/link-resources/lib-foo.wat":"914b197c116ae12a47fd337fd0ef1160778479f619d38f958d8ccf6ec1e92020","tests/components/link-resources/lib-foo.wit":"98733c4a044f7ec1916a604bf4d78f1e0fc7432e9d170479c6d513ce33efb3b8","tests/components/link-stack-high-and-low/component.wat":"3e1c9ae6dbab0ccd91f92c372a9ab50f1d97899d5a8ec9797042ee9ad6422fdd","tests/components/link-stack-high-and-low/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-stack-high-and-low/lib-bar.wat":"3477c2c461c8bb6064072d4b278843906a3b3f513439cb2ee5738562c51dd99f","tests/components/link-stack-high-and-low/lib-bar.wit":"2314b69344e6938e980366d4a2f912cceecebedb03783199a1827f641fa8aedc","tests/components/link-stack-high-and-low/lib-foo.wat":"d94339117228cb4b645b29fb4ce711e24f77aafb83b4579279353cd72d1ae94d","tests/components/link-stack-high-and-low/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-stub-wasip2/adapt-wasip2.wat":"c18d8a24f5c8b2e88b16b50a3104357755b788930ad9a1ce42f2c1fd56539c46","tests/components/link-stub-wasip2/adapt-wasip2.wit":"25d97f7ad800690ce2b90446b0c7c953b99ba4546203dc3de6687175b210776d","tests/components/link-stub-wasip2/component.wat":"dba0ffa80c499bf9a2522d20af4904b3fd50da45afa94726e84bb7d0ba13ae5e","tests/components/link-stub-wasip2/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-stub-wasip2/deps/cli/environment.wit":"b6350bc0c8d1e916d0ec7ddec44bd702f4419fe6e8fb97878d725d7db55f2937","tests/components/link-stub-wasip2/lib-bar.wat":"ac236a5b648468d6b729bbcfac2d8d3c2991125a0652d9a6fb62a7327a3c5fa1","tests/components/link-stub-wasip2/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link-stub-wasip2/lib-c.wat":"ff30ef2aeb8c5503309ca521063086d4401b11d5fa42e787ae52c3ace024e6df","tests/components/link-stub-wasip2/lib-c.wit":"7b97c2b019fd47edcee51bb66c69b71a3124ce4ac77b81af0d40b1edd957e8dd","tests/components/link-stub-wasip2/lib-foo.wat":"f46165ea11b30f70136d932c8a34a7492e03f2f51c694100a9bf35312f5ca502","tests/components/link-stub-wasip2/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-stub-wasip2/lib-unused.wat":"dea738cec100835e590712df21717de33392d74a576957daf170b04efdb970d3","tests/components/link-stub-wasip2/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/link-stubs/component.wat":"58e7f8106945a291b8fd13e0997792248009c0cb7853b0874974c6fa61935f7c","tests/components/link-stubs/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-stubs/lib-foo.wat":"d0b8b5ff95b5b4008cfa306d4af74bbca75bf07bd42ec897b711eb3064b1108d","tests/components/link-stubs/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-stubs/stub-missing-functions":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-tag/component.wat":"4cf16662ecc758a4bf730199fc91b5d2e06a7707ab3779389335bbe22c20bc1d","tests/components/link-tag/component.wit.print":"04b8975105d1093d4fb679d99999f103bf0b6801fae41dcb1fece2219453618c","tests/components/link-tag/lib-bar.wat":"4611125ab396c5d69f036f1b8f2e18a3aaaf81ffd5c44b52995cd712d64be3a1","tests/components/link-tag/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-tag/lib-foo.wat":"fb4e47576ad3d1cba844d7a03dedbcfac323d421108a04107db0863b6f44a519","tests/components/link-tag/lib-foo.wit":"bf62ea838d3ccbfdad20b1a51204262b9bd613c4646346ba7bf8e57a8c6f6052","tests/components/link-weak-cabi-realloc/component.wat":"762f3b5d9550d6a49ecae9e13e6ddb538519d049a7dd3efb5d5df77cc9b70211","tests/components/link-weak-cabi-realloc/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-weak-cabi-realloc/lib-foo.wat":"6357c1189cc178bb27c449d9a833da58aa9ff78c04936d5ad10f21e560ab70fb","tests/components/link-weak-cabi-realloc/lib-foo.wit":"903b843983ea9c9c22cea5383ea3fd607b8c1de49d1addd0197d38fe1aae9a69","tests/components/link-weak-import/component.wat":"8e00021d1f863c95e83fc8ebf5e7559aae4cb891def1b225555507f8da4a3a9a","tests/components/link-weak-import/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-weak-import/lib-foo.wat":"8163164df489b40ad2fe861c7621c60d80173b893f3108983306032f28f52b93","tests/components/link-weak-import/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link/component.wat":"344807b51f4f5267163173e2837b3ca9439650d3a70a0d3624a565fbf2a31809","tests/components/link/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link/lib-bar.wat":"ac236a5b648468d6b729bbcfac2d8d3c2991125a0652d9a6fb62a7327a3c5fa1","tests/components/link/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link/lib-foo.wat":"f46165ea11b30f70136d932c8a34a7492e03f2f51c694100a9bf35312f5ca502","tests/components/link/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link/lib-unused.wat":"dea738cec100835e590712df21717de33392d74a576957daf170b04efdb970d3","tests/components/link/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/live-exports-dead-imports/component.wat":"33a32e651592e2f8499ef51c9bf4489e5c4b87a10f07892110f270c70fcb4a49","tests/components/live-exports-dead-imports/component.wit.print":"58c56bb216d91796f2ff53e2568000eba20cc4ac4a8e7315811fead63044d84c","tests/components/live-exports-dead-imports/module.wat":"82607855264e152a2899ccc7d23f068154e043c3522c205702df4b2a6c03e7f1","tests/components/live-exports-dead-imports/module.wit":"563494c0507f08ab4ed9c17032fa68a13837e3a9ad7eb3953a90136c2075e271","tests/components/lower-options/component.wat":"011a9e6c5bca14333185baefa7a6879413ebff21c952774cd057ae080ea055a5","tests/components/lower-options/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/lower-options/module.wat":"957cbf0c8a6687ecb0c76040480fdcc146ce5c61d01e4bd3ddcd894d395209f1","tests/components/lower-options/module.wit":"141d136241a64268b9f9fe18ca20956164ac9e8f47e2b2bb48cc1adef77be68c","tests/components/many-same-names/component.wat":"4c01d2694a24f39577beb93a2d18a4b37d8e13af76a640004abea902ed8df918","tests/components/many-same-names/component.wit.print":"04eb5ca446120ee977f058357f6d7a9967f34f596e4c0a5055a3ec1f51a49af4","tests/components/many-same-names/module.wat":"7a748bf12c36d8ed53f7e76194120df41102a81b52adbe9e6bb3682fab1333af","tests/components/many-same-names/module.wit":"bdc6c8ddf22997dc6505bab8bed04c2d93e45c21756d036b1b84790bb1e76156","tests/components/merge-import-versions-with-adapter/adapt-old.wat":"3c56d37587ab8193c5d63225ce84ff473c33c8f1bf75d6c4bed75bd7c30775ba","tests/components/merge-import-versions-with-adapter/adapt-old.wit":"ef42f0a58910c4cbb63bd8bd92a6634c511c6141850f6fc0694ed7c4a587a759","tests/components/merge-import-versions-with-adapter/component.wat":"edb6947344fc67b9a37527a25decdf813cffdd9437abe82bc111bacd66246fa5","tests/components/merge-import-versions-with-adapter/component.wit.print":"cd24a288951083401d8b01e0ada1e870c28da544c142d468500147e64c7c6e66","tests/components/merge-import-versions-with-adapter/module.wat":"9bdbdd6a7454dcaa8eaccd33696f0855b6a613cab4228663b547ced3a839d630","tests/components/merge-import-versions-with-adapter/module.wit":"a79e62d6f59e4cd8eed01ee0aa1f1dd7eb6cc4e057eae857e514c1b88c5f0196","tests/components/merge-import-versions/component.wat":"44b673bec8cd8b758921f711c20921833e2e1089e2b910c4c2e575a8f5abc994","tests/components/merge-import-versions/component.wit.print":"cd24a288951083401d8b01e0ada1e870c28da544c142d468500147e64c7c6e66","tests/components/merge-import-versions/module.wat":"abfdd39d50c8a4529af1636e0f6c10a4b4cae7103958480e4006a40573ab47a8","tests/components/merge-import-versions/module.wit":"92850e6dfaecb1d699c235bf43e980b410e002d5e9b49cf43d9102d5cb35703c","tests/components/multi-package/baz/qux/component.wat":"9cde15bcf420c2d39031abb8a802f575a756e52c2266738541f6f15c2613935a","tests/components/multi-package/baz/qux/component.wit.print":"b255c8747f2704e788d61a108eab228a7e6e02437ee665314cac38effbb4da36","tests/components/multi-package/baz/qux/module.wat":"2b1492c9015f1347557088a9bb19e61b79edafaa57aa8712bd911ba3921c5d3e","tests/components/multi-package/component.wat":"8ba4c759f3bee8b944e5a631ac4f8437016348ede8488b678bed671459578ad5","tests/components/multi-package/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/multi-package/foo/bar/component.wat":"134a96e6e491ed2e014a036cb56c9d4a196e4a850619be7ef6666b8ff65cd9e6","tests/components/multi-package/foo/bar/component.wit.print":"6b6f89526fe4793ce9085bedf8eb2c66725a92360dbafe920f8dc8f5147efdc3","tests/components/multi-package/foo/bar/module.wat":"ff8ba654ecd7125d49210c22ef349f37fa54b52badccec69f71fb062fd860f56","tests/components/multi-package/module.wit":"057f5c6f1500ba79cc57fcfb428614de419243c7a224e104d20415e518669da0","tests/components/no-realloc-required/component.wat":"3440a750b0c21813cf577ed5256f8dc46682e41f81594083bc1d25db50714fd9","tests/components/no-realloc-required/component.wit.print":"af82805774e5a261f885b97bd183708e86322bf121ce2528c05bd3ef7c3ffcbe","tests/components/no-realloc-required/module.wat":"d7515c3defbfd7288984e414417b6f9af6b4e9be6835ec5a79770079aaeed542","tests/components/no-realloc-required/module.wit":"d4fff6f58ec0f32157f5c17f0c44c9641dd063b0025972cad18af64f6e2de9b5","tests/components/post-return/component.wat":"f7c4867a341a2f5a1c31465462ae0971424b9be80f891a560681242373dbbb58","tests/components/post-return/component.wit.print":"dda1f7d5e2f6e49f6df046e881a8b5eebe2449c19aaf48a49121f426701a06e8","tests/components/post-return/module.wat":"3bbdd4c09686c2f7f61c6eb7d132345f7d8cb7037b3c259d22d1a8b295e67305","tests/components/post-return/module.wit":"b1fae8d17f70cbefed1036d5a44550473a08cbc2328fe1a923ddac4339d0cd0c","tests/components/rename-import-interface/component.wat":"0e1cdfc198539b6e68413048e9b276f7cc8d1784849583bd0cd85c06b042a625","tests/components/rename-import-interface/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/rename-import-interface/module.wat":"6d42f1ef7a8c3b10cfcd9af2052c8e08f47bf068f554013514f2702d3d714df5","tests/components/rename-import-interface/module.wit":"bfb05c599b4b556e11fcfd94a51090eb311972d9b5643b2fc1a4b786fe886d17","tests/components/rename-interface/component.wat":"8a4534c7b80fc412fa024a343927b53e6b804c489f1877c4ef46ebb65830a7cc","tests/components/rename-interface/component.wit.print":"61e6663c4a3e56091cedb85a6339a01006ab37fdadadd84d855f35c4e547afa9","tests/components/rename-interface/module.wat":"45fba53e30e8279c534f0a60e320f1c6a1422bb82f95460dd2bff27d09272e07","tests/components/rename-interface/module.wit":"d4c0aeb65e8de86ffcf651ffc2937d2dd0c15a394fd27fffb2aebc34337d06a3","tests/components/resource-intrinsics-with-just-import/component.wat":"38b11b9263711d8dc42c84e4c24f3ecf26c2e1a311aee4a40571219288ec0c92","tests/components/resource-intrinsics-with-just-import/component.wit.print":"1d1896462fc3ce15a0f79f753b7ff8b83b1b90fb41850b7a3b05afbf17064aba","tests/components/resource-intrinsics-with-just-import/module.wat":"f892c943bc508e188d746be4b31849792ea70e5b35dbb316a5bbb33b9604239c","tests/components/resource-intrinsics-with-just-import/module.wit":"41d2b456f11bd0005178edd868ad2675fed29c2ef4e36f9604383178a01bc707","tests/components/resource-used-through-import/component.wat":"4ee4514507461c97bddc711005bafc951c1337dfd942880707505d56181f92d8","tests/components/resource-used-through-import/component.wit.print":"016e2d6cad8f4d38f6ae9c64108ee475d9e479466caad186850e3e3e7ad0d4fe","tests/components/resource-used-through-import/module.wat":"5444f7ba822b2864e8ffb92a42b21674dbf6416bbe4c868d311db8a9d2ed5772","tests/components/resource-used-through-import/module.wit":"148d7d1dd61494e67dd1abe605731222be46e9c050a42632af85d65892378a1e","tests/components/resource-using-export/component.wat":"dc1ee332ff13e5361f1b60c8fa53db57137f9ef499288510d65c6f5bb7802672","tests/components/resource-using-export/component.wit.print":"81d2ecd76e78f9835ff0a1c201fc449dac6edb6cbc2390c37b3de7665e9c5e6e","tests/components/resource-using-export/module.wat":"a536f2f3270fc6e218e39b4d16c6a481051023c0aa26c4c2023f9ff90ef410d4","tests/components/resource-using-export/module.wit":"2b82098eea901f65cb65a9a079e470a1975b9192d5b5a227511ea25f8c32af85","tests/components/simple/component.wat":"3c2ce9adab9e033f1386da2143d3cbc38693ae6c277c4b003d3aa793d1e18d59","tests/components/simple/component.wit.print":"bc11e4896f9442ef9415b7f0796da9e22d9b07a2cb27d957c746f3be3142e7f7","tests/components/simple/module.wat":"3688a131da2f16901166d04f7fa0499f755a19f7d479a24a47921e94710ca86e","tests/components/simple/module.wit":"ab54b3883a5838519149b99347ab6ded6f494e0526eb16b774890044acf4a569","tests/components/threading/component.wat":"487085b1ddcdaa5c3d01745abd45d3537ef6bc55e0cd0166152ee0e8a58b5c86","tests/components/threading/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/threading/module.wat":"619203db7bf8392f8c66bab654bb5bc52566344c1d867af1e1b67794c9b6ca8e","tests/components/threading/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/tricky-order/component.wat":"e95a6c6fd66eae7ff0640539258a7b3bb48dc6ee047b51f5d3fabeb21a9d33d4","tests/components/tricky-order/component.wit.print":"3fc16dc48f01ab7dcbf933d5a04443abc22fb1f06800ef02668dd0040879e679","tests/components/tricky-order/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/tricky-order/module.wit":"2c5a879b53f07d5303797086792978783e84baf964e0edb09b0abc12139476f9","tests/components/tricky-resources/component.wat":"61c7f212f183dd1f1cb037100f58f4b4efe99556fcae1a3fe8c8aadacc859b80","tests/components/tricky-resources/component.wit.print":"856955fb41792fc9c38d19de23968f5a4f180f28b73f267808e0305bac5bb9b5","tests/components/tricky-resources/module.wat":"f71be4ce8c2d1fe8c83dc8b58cd7e794132f7cf03995d6ac498256dfca8973dc","tests/components/tricky-resources/module.wit":"50b61106dfef6d7b81671b95230b1adf3ef9ca4c028a5a4f932c84cdda260890","tests/components/tricky-resources2/component.wat":"62edd5121214c3c0247bd0705b1662f06a5cdc758e4a20cf786aeb63fa52ef69","tests/components/tricky-resources2/component.wit.print":"a9cfae01ec4574576148c54c917c0be547c0a9a80ba1c76bb313556b80eff2e1","tests/components/tricky-resources2/module.wat":"63fc3214c3d4e4b36def8417cbc3aac44428046c2f212e14c3ba42acb79e29cc","tests/components/tricky-resources2/module.wit":"24df1dba85c4c71a4b8138b9add9d47a7291a82331f2ed08c3841574c668d36a","tests/components/tricky-resources3/component.wat":"8fc170f04c9417a75735b5829115bcc8567010b11fea765c072b40233463ca8a","tests/components/tricky-resources3/component.wit.print":"acf40dce88c3f0ba8ec1eb7c0058745906af2546808b5f87979050645470b803","tests/components/tricky-resources3/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/tricky-resources3/module.wit":"f00e678465c06ac4fd1ff7dbd473934c796e9251fcc15c604ef8bdc9ac870220","tests/components/tricky-resources4/component.wat":"95772b98420903e117bb87d0fe8e4aef50a57032aad2256b677f8a2fcd0fc9e0","tests/components/tricky-resources4/component.wit.print":"0cf3e863909bbff0ffd80995608d50bac03e716531ebe4b9177997e313ef0cb0","tests/components/tricky-resources4/module.wat":"acf798ec37ef20f52b1ca55a2eee9ea428d8c3a134a8450293c77b8ccdf56a40","tests/components/tricky-resources4/module.wit":"411499bff6c68c79f523d061aea6eb7dd0124dff7f1102dd7fa3561eb1acbb09","tests/components/unused-import/component.wat":"fc5cfba85e31292151061680cd3c04ffb16b946aa0fdba0e922e419865003f66","tests/components/unused-import/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/unused-import/module.wat":"357c1e05f5fcb82e7df5958d9709a75d693f67a8b8d31ab4fe09c413dbe79d46","tests/components/unused-import/module.wit":"ee373cb080a5c563252c18da9928dcf8a835ffc1327a7c1b5db4e15f4c44cf94","tests/components/worlds-with-type-renamings/component.wat":"cfbf49f975bf0c10c58392b1fcc6180934efa6adc44abdfffb5134367f788c25","tests/components/worlds-with-type-renamings/component.wit.print":"9797ffdd1f55149336e49a3f3370ec4b052b0b48d094af34d2e305b1e807033e","tests/components/worlds-with-type-renamings/module.wat":"9e0cfa9735e10a42efa429bdfab4e39791673d26ec574722d3eeadf1ef6e2de9","tests/components/worlds-with-type-renamings/module.wit":"5fa4355c6ec3249c4afc32207a89fde9c10be783a4e259243d9bb7bc4d1b5052","tests/components/worlds-with-types/component.wat":"41f5ce7143555c17ddfe7e612f930c8b6f28cde7c2995ae4a342fd571ab390ea","tests/components/worlds-with-types/component.wit.print":"08ec721da023042af8478fc61bcdb441091ea3b6efd7c26567a497e15cea451c","tests/components/worlds-with-types/module.wat":"b08d3fb1390db5c4ab3dea54eb386708fe25f0e875f5e08c3cc5af387a4e6603","tests/components/worlds-with-types/module.wit":"b86cc880c1cb138a26883b9e1d706b8506ba1c8f39b9b2722c4cbd02154b00e1","tests/interfaces.rs":"78397eaace0ae7501995f51bc261198ce04b1e0a169023acaede831ea3a9d7c1","tests/interfaces/console.wat":"65648a08a3be183053434c19e75ff12d4e8ba7b80d12e15e9daf797a44c33690","tests/interfaces/console.wit":"ae4ecef964695f02aed6412aa33125eb25d667984c24053303c02842c6952d1e","tests/interfaces/console.wit.print":"88664e999c44984e3f6e9a33a3fb1c8455abe5d9486d977e1a3e38cd85cd2d1d","tests/interfaces/diamond-disambiguate.wat":"0aa80803e0ee5aaf9d9410dc03a4f9e12ebfabf287d590c563fa5603589da7b1","tests/interfaces/diamond-disambiguate/foo.wit.print":"8c99834e2dff8e984b07f567555c02e8379d6fe9a9e8903e09c0a71cd3e1c7f4","tests/interfaces/diamond-disambiguate/join.wit":"4d85308aa1fa9445db47274a21ea5305043a5fbd2cfd07bd05018503ab9f2f2f","tests/interfaces/diamond-disambiguate/shared1.wit":"12156cefb18c81870ba266446874354a10871389361810efac7830ea0686f96f","tests/interfaces/diamond-disambiguate/shared2.wit":"fc790ffe2a771a13819976d1c56392e96cfb693e1589c757e0ceb8ae8a360dba","tests/interfaces/diamond.wat":"2996d285b348597d0a6b980167fce74053808e794dd1df9e48cc6efb234ae801","tests/interfaces/diamond.wit":"151c0be378c2ca19cfc97e55d820be7e8451817ee16fbec25feaac1332d25c40","tests/interfaces/diamond.wit.print":"7a6dc57ea3283fa22b6d38e0765f38bdd54f0bad36fb417f632144f073ca66c0","tests/interfaces/doc-comments.wat":"174225e7e66146c2204cdf9503fbc3f8b034599b37fd65904a79bdf7a57ec76c","tests/interfaces/doc-comments/foo.wit":"1e7267a6d075105b613e8ccc9f936a0e3747132e5d53697bb93d6c8978f9f68e","tests/interfaces/doc-comments/foo.wit.print":"93065d74520287e3e25647c005a193808661f5ad0592c5a9c37f05b23cf308a8","tests/interfaces/empty.wat":"d6144d67081f7139868791b76ca9016cdd33e07f8f18a7d02b35675849de1f1b","tests/interfaces/empty.wit":"5b69d726e29aee24abc73e2008107fff6e19c7e91bfb892ce91aeb022447fd33","tests/interfaces/empty.wit.print":"f887bbe0d82c8f23d3fc4d5d7ae44f2f7fd86ccdfbfdb89356c0363767b8ab7e","tests/interfaces/export-other-packages-interface.wat":"2d95d60feafeb9447b9c4117c98206dec84800d22313e8d42c09f80d2df2c2fa","tests/interfaces/export-other-packages-interface/deps/the-dep/the-doc.wit":"4e1596c661a7fac18feaefd556d3c148bba76ef748dc64623ca0e711b9b6cefe","tests/interfaces/export-other-packages-interface/foo.wit":"6039d5381dede8af1fdc2969384f5b8fb96dfb7e14316bcc74bc13f4f4771fb6","tests/interfaces/export-other-packages-interface/foo.wit.print":"6039d5381dede8af1fdc2969384f5b8fb96dfb7e14316bcc74bc13f4f4771fb6","tests/interfaces/exports.wat":"b2b7a63e5b9ef42ca01a586656be4cde48d44a4197c18c034c090801b56a9bd7","tests/interfaces/exports.wit":"c998656f0d5e86df7eeb195c4b8cb7601cb9278acf738547e9aba12cf95b5d32","tests/interfaces/exports.wit.print":"c998656f0d5e86df7eeb195c4b8cb7601cb9278acf738547e9aba12cf95b5d32","tests/interfaces/flags.wat":"1895f39b12260e80d872e28521d37e3ba4ebb2ceb321af83f79d11b5a22dc200","tests/interfaces/flags.wit":"67348d8dfe2215374681dda98530c9049f57b5bf7a57155218256336a39a8ea2","tests/interfaces/flags.wit.print":"67348d8dfe2215374681dda98530c9049f57b5bf7a57155218256336a39a8ea2","tests/interfaces/floats.wat":"c8fb2f689753e1e594f2b08e48b58dec55e4b0001dee3c2a35383d373b782956","tests/interfaces/floats.wit":"d3538bc1ad734434bc4b2ec7c152c5371dd8ea7db11a44cdd15ccec2b650b60c","tests/interfaces/floats.wit.print":"5fd8f9f328b5219350e2e9fd6ec483066b67a62238e4463142def96032fe584a","tests/interfaces/foreign-use-chain.wat":"acae7a8f76a913bdbb646a06bebec8615da6a5bc1dcb047715d5328e1e9a3faf","tests/interfaces/foreign-use-chain/deps/bar/bar.wit":"dffa233e1e0a2b35dcdaca0b62539776dd3bfb9662ee4b8cf9d72f4cddd2b551","tests/interfaces/foreign-use-chain/foo.wit":"51251e98cc66f75464b436f1d838a873e89713deec482480ae13d70458cce288","tests/interfaces/foreign-use-chain/foo.wit.print":"8bfedf3ed5380fa5dd359a9a3896421f67ad49f1c7b8d806eb6064b55092d21e","tests/interfaces/import-and-export.wat":"8ce79bbdbac052ba39e2d2d731f72736f277d3b88e0f763cd9c3db84a7386cdc","tests/interfaces/import-and-export.wit":"1dcbf7c373ca0c352bd45f444037170de7af3435a217b94378694bfd33b608fa","tests/interfaces/import-and-export.wit.print":"a6418b0f7bcda1e6055344cf39a438f7af0f7a5e3e3c067976e81d3dd4dbf961","tests/interfaces/integers.wat":"0c11ca08bc17c757cca9d2e42487c8394dd960a56422dcb62f4989ba93971ae1","tests/interfaces/integers.wit":"37d266e41985507c1c93d6c26a59efbd81893106f6d41b8a311e7c7fbae8dca0","tests/interfaces/integers.wit.print":"ad6949f8c87a60dd7e52028fd4bde7c6e8143ffea368a09820b5546b21408941","tests/interfaces/lists.wat":"090e004df86db95af8724a785ab0e17601d26025ce6cd0ebf089be7665b7a722","tests/interfaces/lists.wit":"2b4022cfda4485cbbd8ed25b78da23d74ac18acf7bc4ef2e0f10a47a4b647a39","tests/interfaces/lists.wit.print":"2b4022cfda4485cbbd8ed25b78da23d74ac18acf7bc4ef2e0f10a47a4b647a39","tests/interfaces/maps.wat":"8a35bc0ba86761018f92ebec8633dd8ee2a6923f85df365ac4808d4e24066c6c","tests/interfaces/maps.wit":"fd4fb91fa11798dc163bf2f1cc287300d678e37c2d027a50887230d906181a14","tests/interfaces/maps.wit.print":"858a732922eeaa6c3479f892bd106256e3ca01e228d63e6c0c67210b4a1f31c6","tests/interfaces/multi-doc.wat":"d963c737bdac1ab843e197d81f27b71c3a5e310a3dc180f54d777dca44a27e57","tests/interfaces/multi-doc/a.wit":"e596872a740320ec0cc907db0a0514f8bd06bba396ccfa6f0fddb5063a6d2295","tests/interfaces/multi-doc/b.wit":"60c98779fc63ee8932956245f4f62a817df1873f73a6d38170481bd2e0933bbf","tests/interfaces/multi-doc/foo.wit.print":"94f244451d55c2bab71e4b3624fd0101afa5169c881580337e7d4af020bb8426","tests/interfaces/multiple-use.wat":"f47557d866df570c5ad02935468f170c4373233f80f0500c054258a724a23e98","tests/interfaces/multiple-use.wit":"7b3a8bc783bb588205ec8a4a4ec6b16786ac11632bd8a8af6989340d454a231c","tests/interfaces/multiple-use.wit.print":"720be46dc70779cb31985c505810dc9324511e6adb33e64cd7d51a6c061ba7f4","tests/interfaces/pkg-use-chain.wat":"d02d6bdd9d2c1bfb2f5897f616fb74e6bb51cd5ead90fd11fab08ededffe4e3b","tests/interfaces/pkg-use-chain/chain.wit.print":"fecf679bf3d5f6170e3752e70e3e6ff31a62c76af934310a8481cae26f826c7e","tests/interfaces/pkg-use-chain/def.wit":"e5926171db9b958a935cf7e6c9dfb19f352734d037371515d17384fd04b89422","tests/interfaces/pkg-use-chain/the-use.wit":"fa84d92dd7d863acca588c216df4825d9735ec521f2c8df2f0088efc43126457","tests/interfaces/pkg-use-chain2.wat":"3003789fb7591388e83f8a3a953b006b9561d2af7e0b033dde2d3152438f9a02","tests/interfaces/pkg-use-chain2/bar.wit":"f070c1a8bd8a278e04b0b774f5f2f4f658c281b139d1cc2a53a38771997f206c","tests/interfaces/pkg-use-chain2/foo.wit":"9cda1f4b74d669259f0d47c0b62aaa866d0fce95a2fa23e7ed01b445092af758","tests/interfaces/pkg-use-chain2/foo.wit.print":"234cbdb61a134682163a460f2d13e70dbed3a21fcbdff211af1bb875e49bb224","tests/interfaces/preserve-dep-type-order.wat":"d02789cfff3c031bc45a4c596be9d42a2925a670072b9b691e94b87404eb59cd","tests/interfaces/preserve-dep-type-order/deps/dep/foo.wit":"07d8a31043f7acbda52d2a81da2747125855fde991e2e81dc0a8090aec1b0824","tests/interfaces/preserve-dep-type-order/foo.wit":"cf4b5e08d9c2e7cc6260c97af2397a0116f1c8b20af7f278b62eac20d7f4d910","tests/interfaces/preserve-dep-type-order/foo.wit.print":"cf4b5e08d9c2e7cc6260c97af2397a0116f1c8b20af7f278b62eac20d7f4d910","tests/interfaces/preserve-foreign-reexport.wat":"80eeae235f01940ca94fec2c1b9c4c0603b9794ff39b486de019f5e4b6250e50","tests/interfaces/preserve-foreign-reexport/deps/my-dep/my-doc.wit":"a9e7687b2213e6432d316100c8f063334ffa91c312bbebf6e7b953a07a38887f","tests/interfaces/preserve-foreign-reexport/foo.wit":"08f924eaf5925d79dea11da53a98fa712462b2693267855f1ba7f8af23976a67","tests/interfaces/preserve-foreign-reexport/foo.wit.print":"08f924eaf5925d79dea11da53a98fa712462b2693267855f1ba7f8af23976a67","tests/interfaces/print-keyword.wat":"e35164a7c713261bac2b9eff4d378d0bbe0eee805ff2acbf109644b7eee32935","tests/interfaces/print-keyword.wit":"e56669492ec53c6bef1cd14561f81c85117fa05199241cc2911f697ad75de606","tests/interfaces/print-keyword.wit.print":"d65ce208703b66a5975194a0937dcbaeaac680ed1531397c19b8a898928c6c2e","tests/interfaces/records.wat":"f9e0d53435c7769248c794ab5020253b9373924502b9c91a57888e6d254e2839","tests/interfaces/records.wit":"f16376667373eebc30923f6ef498cd4c53da0aee19697538d5ce2201aac03726","tests/interfaces/records.wit.print":"ff31d9c044473edec440a84f57be7686ad7e188459e37b2e2a65e0ee66305793","tests/interfaces/reference-out-of-order.wat":"9db73dc664f876c7ecde018eccea5d5a492e625af1426eaadab3f70f2869c8cc","tests/interfaces/reference-out-of-order.wit":"5f0eeaeeb9e1920fadba1b372b213138eaf9847017721dbfbd865c6f6b735ede","tests/interfaces/reference-out-of-order.wit.print":"a030a7125086f47bdd47b0a1342c7f7021d8e1543ef98ed1b2ebe5d10e375369","tests/interfaces/resources.wat":"551e5b1f2a2ff21581828ed33d7363ee578f06765df35040c879dc6c7be933fb","tests/interfaces/resources.wit":"ed38925057e1dba87722675326536f3e6dee6b3e64ef3db98fbe5fa4811150c8","tests/interfaces/resources.wit.print":"531fb60a5000c349d45153e41df87fc75358c71545a883c98eb87658a949cf32","tests/interfaces/simple-deps.wat":"45794a5e6dd232f0bf8599e4630fd13b6e2391bdba3a3fe930cfa692e8545d4b","tests/interfaces/simple-deps/deps/some-dep/types.wit":"e4f4f705091fd22a378aaf25c1a37035fe1dc9e4f29be0783733d8bc091a907f","tests/interfaces/simple-deps/foo.wit":"76fd1d55c5faeba3157ada8be1c83853ae1e72d8360c84b0d1b8f8b96d1e0dc7","tests/interfaces/simple-deps/foo.wit.print":"c2f307fd4af86e70abb51cadaa5e51ac6bfd5f8c9a91eb61f1bbc67c17554a57","tests/interfaces/simple-multi.wat":"6b16a64f1f5555e6da647f290bcfc9153bebdb42b9f609b46f37792c39271a3e","tests/interfaces/simple-multi/bar.wit":"e3f98501dfb46f873022dac93af2c9aeb007ea5bf0235302b072bdf2b1b5aa9c","tests/interfaces/simple-multi/foo.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/interfaces/simple-multi/foo.wit.print":"45cea7bb704ea1aa2251e2da314dc3b931b165b7c84596e16c5b4c12200cb5b7","tests/interfaces/simple-use.wat":"1da6ead3dd378c25b096c2a70d8846da0a1810c68ecfcedf0727bd6c792c0070","tests/interfaces/simple-use.wit":"d4e734dd1a51b2224ea1fa965b48f39433e60ada1c2619c9836b81e061beb0d5","tests/interfaces/simple-use.wit.print":"1c91e72769a7ef72633c3e82bdb2f97babbf51961e3d10d177076340241cd277","tests/interfaces/simple-world.wat":"8f023d1da8b20a605f04bde1587eff63a88e45e0240dbcdd4647a84f1e993a49","tests/interfaces/simple-world.wit":"b8c42bd20d951065611170b28538430c76dbd492ddca5a2b63f6d85b229a62a5","tests/interfaces/simple-world.wit.print":"cb5ea537abb70459959dafd9c6114f35404f3a23219206f6e196e452c3f63e5b","tests/interfaces/single-named-result.wat":"a9d03772334090d597a595f38611a67630bd2c637b1b2cab7a79c3662b3098f3","tests/interfaces/type-alias.wat":"3f041675d23c6859523a79a9911826dd9174bc1e8b7f4633c7d827403b5674a6","tests/interfaces/type-alias.wit":"6cac4692ce0c825afb6d16e51fd9ecb3a7aa19756269b9dbd73d601511b3be38","tests/interfaces/type-alias.wit.print":"ff3093d72793ffc05b9c2f4ea55eaa86d276a869a3897c58f822443cfd299636","tests/interfaces/type-alias2.wat":"c67254788da372381e84a78eab4ef65104a59aec422da51cfd86ef6a67410a18","tests/interfaces/type-alias2.wit":"d0821ab9de64a96f24b90c3fe6d6188e9073444ecba789212c206050b3ae02fb","tests/interfaces/type-alias2.wit.print":"d0821ab9de64a96f24b90c3fe6d6188e9073444ecba789212c206050b3ae02fb","tests/interfaces/upstream-deps-same-name.wat":"86b1ee906d85fcb499c8dd64a03235f3b722b7936d436099f01ed0a60a036077","tests/interfaces/upstream-deps-same-name/deps/a/the-name.wit":"067fd6d1ce097bf27dd260114da6f690f5c54142d7b83fe705b98675e83336aa","tests/interfaces/upstream-deps-same-name/deps/b/the-name.wit":"17db81ac295fdc326bc0960166aeba6d2a86ffe6ae9c493209964098057f4672","tests/interfaces/upstream-deps-same-name/foo.wit":"5634861c80a39d59e3c72e26884487bda2ff6123a5607eb72e6251138f43891d","tests/interfaces/upstream-deps-same-name/foo.wit.print":"76cdc49cd35068d9c6d693550c951db74f588eb0d1bef27b4193093a95a3b802","tests/interfaces/use-chain.wat":"3946c5b08f739f31a9f737480e00a027924723130746b325234693318fb79c96","tests/interfaces/use-chain.wit":"9199d5f59616d83e82aebe22a8652e72c711ec962f6c0b53379c998fe4f64675","tests/interfaces/use-chain.wit.print":"ff129506878efb4f9ec1a441845c645ac63f4006e1e1d641d44c1e5d1667a778","tests/interfaces/use-for-type.wat":"e50dff1dacde278b34144745af52c6337acf001ba393bed4f7f162c913c92e41","tests/interfaces/use-for-type.wit":"86178e6002f460c78b43d9a51ffd13dc5795da4aac54e5f4592dfa11a430b42c","tests/interfaces/use-for-type.wit.print":"c899fc7b4f4fffa41f3abea7c0589f268cd683e6c4c5637393173af949d9b379","tests/interfaces/variants.wat":"3c8f5474ff599463212767650e14e3508d95ae670c6b167cc68026699f27309f","tests/interfaces/variants.wit":"2345402856850aae5db913ac40f01d3bac1ffddd4f2d794d4b92b44850354741","tests/interfaces/variants.wit.print":"63a6847094f8687a7f1cafd8f26a5255272386ae04366b5d247bc893ffe45d73","tests/interfaces/wasi-http.wat":"5442500a42b914985e143ee44dd60dfdf2df949d0d455b731034d604ffbd465e","tests/interfaces/wasi-http/deps/cli/command.wit":"5faadd6c6593aac09a85e8e22b2c842c81b4b3d0a04827195c50e0080ac94a00","tests/interfaces/wasi-http/deps/cli/environment.wit":"8d4f13e628d2e8f029f6d668d8075db5e6c8867238c0436cc966dd9a535148e1","tests/interfaces/wasi-http/deps/cli/exit.wit":"337522eb41c89e660b1dabc1bae362acc462f9cbfdcb9546e790e371580175a2","tests/interfaces/wasi-http/deps/cli/imports.wit":"37f6621e37ad9b15c616ba4289cecb549429cdb25a3b4ee3f80c47a5f04bafa3","tests/interfaces/wasi-http/deps/cli/run.wit":"50815a16aaebae4b99d2e2f9de69ddf30fc27249f41ad3cf477c4e796edf5792","tests/interfaces/wasi-http/deps/cli/stdio.wit":"51ce71cb414d1288b404367b4c05e38ade8b72f54811647aae37d871fadadea1","tests/interfaces/wasi-http/deps/cli/terminal.wit":"ba00efd140adfce72e1368fd92b6fba93a550129d2c8587a9f82bccd96e9100a","tests/interfaces/wasi-http/deps/clocks/monotonic-clock.wit":"3d2605e145081885768e23e1b37f5f065e28f0681cc3764fdaa60c35e74d2984","tests/interfaces/wasi-http/deps/clocks/wall-clock.wit":"35ac466a63c310151c228a313665fb30061c13b1954a7d6dead4c80fbe9f5b1d","tests/interfaces/wasi-http/deps/clocks/world.wit":"e5262f7b911444b28a98cce07a224bc8e7e9c42c175bc4890cf9d458d1d7d638","tests/interfaces/wasi-http/deps/filesystem/preopens.wit":"3374e193f60b3ff89708e56b37871fdfc9bb08bcbd3648a4f7bf20b60fe85169","tests/interfaces/wasi-http/deps/filesystem/types.wit":"9fc998c1251c38ceae23851af0a4f46874b5c456ca3240b1ff6faeec5f101d8d","tests/interfaces/wasi-http/deps/filesystem/world.wit":"45ca19ee54e4a0c9e8eca1d73f1e1e37edf00339b5c3e0f393f444a92733e708","tests/interfaces/wasi-http/deps/io/error.wit":"df792be377ef1ae9dfc186a304ae2cbcc091adb83bfb5fa5b9015fc232a90a9c","tests/interfaces/wasi-http/deps/io/poll.wit":"d3062e06aef89c8a2999067ccbde0c638459a01f30ba2073ac2b6458e0b9ca29","tests/interfaces/wasi-http/deps/io/streams.wit":"2aac4f0b81ca892ef07e9df54125082e266afb9ee2948b3f3f134ef736b8e75f","tests/interfaces/wasi-http/deps/io/world.wit":"1a67af673d0874b5a291a2b86721b1e4c1243127e8b2f6fa4ed954b13cbe87c0","tests/interfaces/wasi-http/deps/random/insecure-seed.wit":"617e58cc9fb5ae0f32cd6db3e72f959ee50f6abb8b9a0e10a5867ca2319b804d","tests/interfaces/wasi-http/deps/random/insecure.wit":"db8c140b96a99ca6e11060e2bd46df3c132f5e16b188f11e2767149b860d46a1","tests/interfaces/wasi-http/deps/random/random.wit":"5319685d7ec484d72660092f8db07c584d361d5ed0abb2893bba6d0724c20f88","tests/interfaces/wasi-http/deps/random/world.wit":"f1cc4028ab9d2ce215122946136a05b14b63225943ed8df86aefd5500bbd3217","tests/interfaces/wasi-http/deps/sockets/instance-network.wit":"ad100127c74b967064cf5d8e1770f6f0d787ef55f07ba9f6b334bc4c98c82282","tests/interfaces/wasi-http/deps/sockets/ip-name-lookup.wit":"aa9d95e64edfb9e954bec156f5ede95560a82ebc9ce80c01d475edc2f371d62a","tests/interfaces/wasi-http/deps/sockets/network.wit":"65c428e7f0d29a4dfb785996e88507ec185ae174a67576d3c09f852683d95f82","tests/interfaces/wasi-http/deps/sockets/tcp-create-socket.wit":"5beb6d1d604227a8e93fa2e63ace7ddee55b4048399046a9fecaee9d4352f684","tests/interfaces/wasi-http/deps/sockets/tcp.wit":"408d55fb8a3cc6971a02ce08a53f2864ec16487ea9f33a3c63b40ad90ee8acc3","tests/interfaces/wasi-http/deps/sockets/udp-create-socket.wit":"1e741a57683f834b12bca49c448cea4080e91b9667d50e28c8a823e2d6ca3829","tests/interfaces/wasi-http/deps/sockets/udp.wit":"01f359eeebb86826ea8f40d885feeb329a3272e439034aafab1e0a1e64ffa813","tests/interfaces/wasi-http/deps/sockets/world.wit":"9944b7b13f9933c0fed0768919ac4c8a8156943d0e82061277a28e0893f761f9","tests/interfaces/wasi-http/handler.wit":"96882590ae9934ca52f031eccc91704d0caf80c6b3227b6e1177e947ce135b24","tests/interfaces/wasi-http/http.wit.print":"c2f9bc786bbd0f91a8e38537df2437aa435867b2b9271808c562dd42b0e5487c","tests/interfaces/wasi-http/proxy.wit":"14f5c16f8c9f82965825fb138c2e317fa87afcfa731f9bfbaa5a02f9f3ebb1dc","tests/interfaces/wasi-http/types.wit":"b48cec546a901b55ed334edad747fb1298121a8e60cddb2e8141ff2187cdcdc8","tests/interfaces/world-inline-interface.wat":"d2c133fe41eca77fae870f5d912c17cad86ab9120419e2beaa7a20fe2c6233f6","tests/interfaces/world-inline-interface.wit":"929f431c2e5e14195de9645d75c79d243e65ee4c55a8e30a5ee1ae4c2e6014a7","tests/interfaces/world-inline-interface.wit.print":"36929a8a8a27296e3a183fa33fe95d243a6d20c4df055d9e5bbdc3bbce85bc0b","tests/interfaces/world-pkg-conflict.wat":"105a5cd5b89df94659c910e7511947c51f49f120f803b665cf69940c5f1c26f0","tests/interfaces/world-pkg-conflict/bar.wit":"4f05ba606e0c32c900fa8e9f9d75b137eedcb80999f454161492f52a452e8dad","tests/interfaces/world-pkg-conflict/foo.wit":"4be2c763fa6801e869aeb8da05cd647931f5f8f7775329555cd9cfd880dfe45d","tests/interfaces/world-pkg-conflict/foo.wit.print":"2ea3a7bc96c6493334d49893bc194a86f9e8fa7d592feac394c20678c5c1b288","tests/interfaces/world-top-level.wat":"80f160c0a98dd0003cf634d9d61899723c71ceda6c7f4ca330f791279154291f","tests/interfaces/world-top-level.wit":"10d04b8d9e0cabf534294ca5987f7523c042f3078048b5ebdf0b20f162ff9194","tests/interfaces/world-top-level.wit.print":"cf23c15ec84ad2c86d7124302c370661d13ab93bbd29e5456677a72148079339","tests/interfaces/worlds-with-types.wat":"e6e4a4527933316268841efe6dff6422212668a79077b43ab476f984ab4c7b19","tests/interfaces/worlds-with-types.wit":"cfa2f8bc82383337e9ae80d2bf7f7c59160642b38137367d8e8bca61d24fad3a","tests/interfaces/worlds-with-types.wit.print":"35a5376b6ad4c17ecee2b99fae6be4ffbddc766e891a4012eabc6a303cb0e1d5","tests/linking.rs":"e23feee175162d6758ba35706e92558546603fa5ed370bbee69cfd76d49c7b5e","tests/merge.rs":"5679426b2585a0b57597d2204c9b46e0b05b8f016dc9f438a7dd3eaa0bc7ba49","tests/merge/bad-interface1/error.txt":"98c2b73a27df07fe64cf3cbee106a82f863ff01c9bd7aab19345d2e33bf9971a","tests/merge/bad-interface1/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-interface1/from/deps/foo/a.wit":"8846a4d47a3a4ea7adec3c75dbfe5f7d95a33f550384d60f5ba57c986cebb0f2","tests/merge/bad-interface1/into/a.wit":"3bdc7af80295ca1761b46d4088bfe63323d87b5ce34ba91a5f86b74dd9daf381","tests/merge/bad-interface1/into/deps/foo/a.wit":"94b2dfe771053f49b3da8acdc65b2e0cd9d6b62c9ace43d7e383f67c3258ccd5","tests/merge/bad-interface2/error.txt":"9bc249e46b3bb5c88cdc9b560b83cd83cd22ef7816fc4f271bdff6627db16b0e","tests/merge/bad-interface2/from/a.wit":"a6647eda48b26b8815a5c96c0d2f492751c50575a61a1b5370f631a1dbd6d6c1","tests/merge/bad-interface2/from/deps/foo/a.wit":"de74c812c40393d061efd768601f8747bd61f7d06d59ed260d9c7da5767eaef5","tests/merge/bad-interface2/into/a.wit":"dfe8e3f49c0e9392a85ce7d852d359728e62465d923e296d4594130110864861","tests/merge/bad-interface2/into/deps/foo/a.wit":"faa98d1f0516dc30b55a1d7c3187a4de73985aac1952d275f21476451310335e","tests/merge/bad-world1/error.txt":"6db444c11f4be2e33e0c2cc6ae98a3d59711e0957c291861eb23908edc65b06a","tests/merge/bad-world1/from/a.wit":"d8ab0c1f6d0a4e566442e4af8ad10d44b033ad928232e3e769862a0091af31ed","tests/merge/bad-world1/from/deps/foo/a.wit":"e49da20e2cfa3484864737126b569e4724fac826ac83e0bb418b801336b37062","tests/merge/bad-world1/into/a.wit":"6f6bd76d039cdc1754c88dcbc57f83cd75ca514481930c013cdb1536add4d78e","tests/merge/bad-world1/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/bad-world2/error.txt":"82ea5309efcff50f4b73843f46c28c45ea17d9f3b74415578fd0449445ee8a4e","tests/merge/bad-world2/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world2/from/deps/foo/a.wit":"548c3bb37a685be2e833e62877d7b453ed05ffcc6c51a5fbdae9ab770d1c1a1a","tests/merge/bad-world2/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world2/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/bad-world3/error.txt":"7ce381053e15ac8978fb690eb0eb9f0d9680e6ecad007b3ae5ac273ae2e2755b","tests/merge/bad-world3/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world3/from/deps/foo/a.wit":"548c3bb37a685be2e833e62877d7b453ed05ffcc6c51a5fbdae9ab770d1c1a1a","tests/merge/bad-world3/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world3/into/deps/foo/a.wit":"f4af2d9b3ea3aeb7d9cd1663e54e526d3dba474a1ae5f66227b7be2433234a3d","tests/merge/bad-world4/error.txt":"b87d169ad53a2cb5de0aaa38e365085d5ba472f3a5593cd448d1d2aba76e2df4","tests/merge/bad-world4/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world4/from/deps/foo/a.wit":"9af9c4ed27a130ce0ea282613888d4bff0a8d6d1c36d91ac45ac9528e2b74284","tests/merge/bad-world4/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world4/into/deps/foo/a.wit":"f4af2d9b3ea3aeb7d9cd1663e54e526d3dba474a1ae5f66227b7be2433234a3d","tests/merge/bad-world5/error.txt":"5cdeb66fda055177c3a3acd8070e891476e12759204cc9288ca89beb0cce1cc8","tests/merge/bad-world5/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world5/from/deps/foo/a.wit":"88c8bdbdcd401558214342070b09bbc8454593d682b43de8d7ba6fec98512d42","tests/merge/bad-world5/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world5/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/success/from/a.wit":"9ba239a15824020109d3b7b1b09ff2463a91ee83f174c85acbf08dacaeeabe90","tests/merge/success/from/deps/foo/only-from.wit":"3cb85cffd8f2060149fc6dd2c42259be0af125602cd1f56ca6aa7b3fe5d101b9","tests/merge/success/from/deps/foo/shared.wit":"d75dcff4825dee46320dc97ae6b005c5b43cca83a48bd9c932d2f662e29793d9","tests/merge/success/from/deps/only-from-dep/a.wit":"013b417cdcf40b3203ad2c4a4b2c3d3fdc0930eb05b5095eb03adda5888c6c12","tests/merge/success/into/b.wit":"d46f59c41f4a1f0deb7ba9dc4a30fd68946e4dd228520d0aa94e53771ac58b2f","tests/merge/success/into/deps/foo/only-into.wit":"afd48df694fd9f6be69f123ef0054ebdf54fe40f9de27d3ebd4829f6d3ce2a4d","tests/merge/success/into/deps/foo/shared.wit":"0a2dc3ef6f40a80c125c88a1ef50f7a29ceafafe0a33e6276fda021b43339557","tests/merge/success/merge/foo.wit":"a31a3fb1eee5ba150eff17968de545939a75cf62216f1e634bc319ab0e5eca69","tests/merge/success/merge/from.wit":"5d4ae81da25de51544367675d0d35447959b9ffd38d1addc71b3de43cec2256b","tests/merge/success/merge/into.wit":"f634f6316a61eb8353062dc590bafbdc382b5b660ff47a2fe57a096d37027aa6","tests/merge/success/merge/only-from-dep.wit":"bb258879aa337563aca3efadef46d4267bcc6a364fab0f7b0c83b1ca40646eef","tests/targets.rs":"817c3fea4f0a13f5a162989daa3e77cfe840c61e23039a66874a413bc17f2d76","tests/targets/error-missing-export/error.txt":"5c4f40d87595312b19585b2aaca07212c99a382228c309684c1911b3599572b6","tests/targets/error-missing-export/test.wat":"ecb067df02eb0320a0fdca517e1ed718449f33d6f374bc0c7663e5f142edc074","tests/targets/error-missing-export/test.wit":"3cc01dbf799565f81074bdb2ed9d274ed682c19baeabed5a5422abad55825fa1","tests/targets/error-missing-import/error.txt":"3a666ba746184ad3a04c2f0b7212b26eb4073ded44e887cbb9afcf4c19ede11d","tests/targets/error-missing-import/test.wat":"ba8745404917b9a0900d70377212510d57d90d700002811a826779acd39cba19","tests/targets/error-missing-import/test.wit":"621baefee52d35a98e0459b53abed57ff75969e0dd95c6e7866949e215503c3e","tests/targets/success-empty/test.wat":"fa69abd0e355ea21aeaf9cd3b36e1bf6a4944ee9df0be50d1c764b43eaa1dce6","tests/targets/success-empty/test.wit":"457c6efac7f9d666c5fbb4111fa91b26cb38548be1da2c7c1c0ea89d33cfd5b1","tests/targets/success/test.wat":"bff481f132e976f3ff757f5816e58c79ba7ffabca76184452e048cf75028896e","tests/targets/success/test.wit":"467f876c7e3b3b698517c2df8076bfd1f27cf4764841ec7b1f91f143c8589da4","tests/wit.rs":"160fc7aa322c26d2e6eb58d2eff8eb06f583f34a5f2c6b101bcea67d200910a7","tests/wit/parse-dir/wit/deps/bar/bar.wit":"2319c45fbe264470daeff5718eb5e6cac02ffbbe59af4c14cb1120e401c9dffe","tests/wit/parse-dir/wit/world.wit":"10cddf5af787eb1d0e67e46cca8cab5c3d407ff9cc75f377641dc831153163e7"},"package":"9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"} \ No newline at end of file diff --git a/anneal/vendor/wit-component/tests/.gitignore b/anneal/vendor/wit-component/tests/.gitignore new file mode 100644 index 0000000000..9365962f41 --- /dev/null +++ b/anneal/vendor/wit-component/tests/.gitignore @@ -0,0 +1,2 @@ +!*.wasm +!*.wat diff --git a/anneal/vendor/wit-parser/.cargo-checksum.json b/anneal/vendor/wit-parser/.cargo-checksum.json index e616aedbc7..b888eb8e66 100644 --- a/anneal/vendor/wit-parser/.cargo-checksum.json +++ b/anneal/vendor/wit-parser/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"e701d7ace82ec8996103713a5ba11137b8188a7084ce2200d5250f7180c21c4a","Cargo.lock":"4d9db2a27e3e642d9ab03ecc1927e06ae2b88fa5900fb424a990bce136e86ed1","Cargo.toml":"d7bcbbfa75bb0ee12fb76a45b75af7f4f92af9c3ed6046866a2315efb65773fe","Cargo.toml.orig":"57732a62b5239a8d7bc42c142b2dd6b332850cf91d9e039203a3272d7a41bdc9","README.md":"fb3e25cd96468cb3ca6b40dfa684504b316ea5b261f14109eb229c4f82442ef1","src/abi.rs":"3b441a5d5ffc5bca83e5c5fcdf808da6d0bf8cbf31b159013b3e063c35489554","src/ast.rs":"834c8c865f35002e2346549903e3f64563e9aed2530f0eda3e1ee4f8e9a35031","src/ast/lex.rs":"6ccd888e92b36d4404142f55e494d1388f06ef0c6875de5d79f2f300f6ee6a27","src/ast/resolve.rs":"4b3bd0a7ed7340b341e90556ee27a9e5b230be481fc68b6347e4e4f75840c15e","src/ast/toposort.rs":"a71e3fe53836645b71b1eb8152314418bfe7ddaa19e1dba259b1534f55711739","src/decoding.rs":"472d64a3688d2910689f51db6e9da1c39796b0af9e33f17b6b39c9a8ca4d2c12","src/lib.rs":"a5fc6f547d5b65696892622604085974bec2cf47fa95aa49afd242a14d447375","src/live.rs":"12d789a63367f4a9b3581a475e854b36ca0592c95cb5f0404dab11bd9ef92232","src/metadata.rs":"fb580e48681dd88c66b7bb915d90383cb4f1a99df8d2a6654aa97a95d1f5435d","src/resolve.rs":"dee35ee2a393239f8089cf7a2fa8c237a9091b29834750b607d34e55b7aedb32","src/resolve/clone.rs":"9c30b89ecdd03f5269590bc628ffdc698f555c7f3627e4d6ec988b939153ae9c","src/serde_.rs":"619855c4049e83b9dfeac2fdc373e72c7b7eab66e39a06ff643b319b2e442de1","src/sizealign.rs":"8d690ade0227f358682b908abb4309060959cc71e29d3deab8d4563e4c47ee17","tests/all.rs":"6545772c9541c29c66c24b316b1c9e2e01f3fda7ae2e5e6e30dd8f3b6a111ffc","tests/ui/async.wit":"e02dcde5e58db33f6a4cba9ef56d2e23f25ff66becd438bea4a3e44a3b708982","tests/ui/async.wit.json":"ada678ed4ef39e8a15a653da9f327327702e00c84aaec49cb6ae2293bc072430","tests/ui/comments.wit":"475f3c841e96ff3d5b845c889382eb65501ed5937e1cafde2fb1cca22eb6af76","tests/ui/comments.wit.json":"8f1b6361031a0d6d462f64e0a0e5d982e758459388b38cd91d2e20d4c40c95da","tests/ui/complex-include.wit.json":"3fe8649db3e11c4fd377534af39930670e7f56ddac550edf30b38d9b796b71ad","tests/ui/complex-include/deps/bar/root.wit":"847bfc51da81c575d28a11c87ba4d1a4c7af4ef4797bff569df1ba7180186cfa","tests/ui/complex-include/deps/baz/root.wit":"f698fdb5d167e91c5c200b72d590ca6efc47b252340ea686a6a6c5b68b32850b","tests/ui/complex-include/root.wit":"1ccb363347433a31d1e72408a7e2581ad428a602dd77c19d2c38a4bdb3011cad","tests/ui/cross-package-resource.wit.json":"88cd432a64f97b22ce3ce0d947236b7c6dab05710746e99117f7d78dfcd73107","tests/ui/cross-package-resource/deps/foo/foo.wit":"a17fa1d030e1e136d0a78e72f1236f945676bf95a6ac269f1c8279fc5891c7d0","tests/ui/cross-package-resource/foo.wit":"92a38c0eef30ffdb5a314889e127532289afc03d5c6a66d38fc6763869285a80","tests/ui/diamond1.wit.json":"65ca1157767b651d093ff7e0578adc71f384f0eb10f6c5f0df7d9d6c7a65a714","tests/ui/diamond1/deps/dep1/types.wit":"0e88c7dea0e75ee462e9580bcab9f95cea6d47ce465b8e3686c579c871fac70a","tests/ui/diamond1/deps/dep2/types.wit":"a0550fd230ae08e270008582a58e369dfa2959d64e35b47b3267c5e66d5dfd9d","tests/ui/diamond1/join.wit":"9dbe89b4a1db3f48c7fddc35bb0f5624d5a7993b9045110e273483eada067037","tests/ui/disambiguate-diamond.wit.json":"e67b1ef121406dafe3e700c7b26542b089b836a5b8b4c0f88e85b59001297d8d","tests/ui/disambiguate-diamond/shared1.wit":"29c7b86eb0b325007093ddc5cd6bac442f2770222552c2578b3df92b27141ffc","tests/ui/disambiguate-diamond/shared2.wit":"9cb9d0ccffc9d0400da97af00f0c6ca65c0b71bf7eba152ce4c17a94befa04f0","tests/ui/disambiguate-diamond/world.wit":"dc44c49f1f8a1831e183efab5705a9b24d1e03d57b24c59d70eb404ed5783ab7","tests/ui/empty.wit":"180aebeccf365462475063f210fc0e2fffd16d415b40c710112daa478fc05d2c","tests/ui/empty.wit.json":"f6e88371fc423cf186127ced701cef2e6a2d1408554be53bea33fc96b50c660a","tests/ui/error-context.wit":"bc6f8bf716ccd78f58d35ce867b3c516b7b9a00129a8e42a3b4284070081ec12","tests/ui/error-context.wit.json":"62d25fc35388148abf493577414247b90d3285c2f1f6a0d5b97f314afdbc4de7","tests/ui/feature-gates.wit":"6421b98446ab4de927677a37455163faafb8ccbe039c9dec9ea3edf601f62c3e","tests/ui/feature-gates.wit.json":"815eae0d8923390b821fdddbe1ba1492b9fc058a8f36f43c4645a84fc775b542","tests/ui/feature-types.wit":"42907c1e0228a5f5046cc977c0cf9fed6bdd2c7aa3df78ff8ed77fb4db9e96e1","tests/ui/feature-types.wit.json":"c44485247c77e2025c24b01acdb5b3b560fa2d6fc18deeac0242ad0ca1ab5797","tests/ui/foreign-deps-union.wit.json":"5d1400e9c28a3180dc934857151408b4d1bc0819b3d76b40690531834c40b608","tests/ui/foreign-deps-union/deps/another-pkg/other-doc.wit":"c9423fbe1a1122a74d7bade1ba92f768e402a815ebb6b904b8a10ad45fd1c98f","tests/ui/foreign-deps-union/deps/corp/saas.wit":"386928373ef82518259896404073bbc78efd0682c87e84db7946ee2cae9a6a25","tests/ui/foreign-deps-union/deps/different-pkg/the-doc.wit":"f13b9d7a0bb19e2d01b6376d4d24f62a5f1fd0383b28425c1aad8b2d3edba20a","tests/ui/foreign-deps-union/deps/foreign-pkg/the-doc.wit":"beb4afb21df52eeaa553260af4eec19caa91f17125943e220c53f38f53e815a7","tests/ui/foreign-deps-union/deps/some-pkg/some-doc.wit":"999d52ebb0be65f4bc181e98a396579fe58e084c11eeafb354bea9469c1a9119","tests/ui/foreign-deps-union/deps/wasi/clocks.wit":"105e3f217725547b1d4097003d4d4793f7b8b5233f10126078d3b78e6f73373f","tests/ui/foreign-deps-union/deps/wasi/filesystem.wit":"f3591626529a6ca7ede789909090cb6d59377f0374d7a474e94f47fab80bdd2b","tests/ui/foreign-deps-union/deps/wasi/wasi.wit":"992be12ee11207ddefc2ac531016a9e9519af214341af718972fb653924ce231","tests/ui/foreign-deps-union/root.wit":"4856bf403caea6403cd98b73c44a6277c9af52b7e3c16c756f6cc0e4711e3c3f","tests/ui/foreign-deps.wit.json":"e894a9c94e877c2f92592aaf5e51d71541d7c1d36dcf8d6db27d435ffc0126c2","tests/ui/foreign-deps/deps/another-pkg/other-doc.wit":"c9423fbe1a1122a74d7bade1ba92f768e402a815ebb6b904b8a10ad45fd1c98f","tests/ui/foreign-deps/deps/corp/saas.wit":"386928373ef82518259896404073bbc78efd0682c87e84db7946ee2cae9a6a25","tests/ui/foreign-deps/deps/different-pkg/the-doc.wit":"f13b9d7a0bb19e2d01b6376d4d24f62a5f1fd0383b28425c1aad8b2d3edba20a","tests/ui/foreign-deps/deps/foreign-pkg/the-doc.wit":"beb4afb21df52eeaa553260af4eec19caa91f17125943e220c53f38f53e815a7","tests/ui/foreign-deps/deps/some-pkg/some-doc.wit":"999d52ebb0be65f4bc181e98a396579fe58e084c11eeafb354bea9469c1a9119","tests/ui/foreign-deps/deps/wasi/clocks.wit":"105e3f217725547b1d4097003d4d4793f7b8b5233f10126078d3b78e6f73373f","tests/ui/foreign-deps/deps/wasi/filesystem.wit":"f3591626529a6ca7ede789909090cb6d59377f0374d7a474e94f47fab80bdd2b","tests/ui/foreign-deps/root.wit":"532f52d31c706b5ce3dea9869b0aa8fa0c0353309ab2fa9752d29a2aecd7aef0","tests/ui/foreign-interface-dep-gated.wit":"a4e2e64a17b2d145897ddf3280a47df60c80101124c13323bc25485a9cd9057b","tests/ui/foreign-interface-dep-gated.wit.json":"bc2ef7bf9cdbc2ca1ba1c446a2d57714d65faa155b8f126816ed8c8370bb39e6","tests/ui/foreign-world-dep-gated.wit":"b1f4c36d604270c079a645242690e60083bc39ad9d9a507cef89243fd848f579","tests/ui/foreign-world-dep-gated.wit.json":"bc2ef7bf9cdbc2ca1ba1c446a2d57714d65faa155b8f126816ed8c8370bb39e6","tests/ui/functions.wit":"909502792a27bcd571e1e4344fb6f0d03412d44a4afa1468f67896cc9ff479a6","tests/ui/functions.wit.json":"4e374a1fb01d7537a76c781e42bf59435babdbd3c3d3f323f886652707688fe6","tests/ui/gated-include.wit":"292d684e8413242ab91efded4e21ad779f3d11c4c48cf42ec2f37a17ce881f2d","tests/ui/gated-include.wit.json":"12139e81b9b0aee7f1f2a8263ec2ce05d8b3b9cf273e53337b67dcc36ee26e63","tests/ui/gated-use.wit":"792fbc77feeed4544311df936c0068335658d3b28b62880ee0f2c4b9027123bc","tests/ui/gated-use.wit.json":"da18c6d1e6902846e17f42c4b3c21c0bbdb4127f0d7ab965e5051ff847fbe9a5","tests/ui/ignore-files-deps.wit.json":"0a65f0ec2fc58a7429f6ef6d45276726e0900c989628bb3c390219db906d6f01","tests/ui/ignore-files-deps/deps/bar/types.wit":"3f6c58f614a5eb6e92dad08c37faf9a7a0ee3ca6bf0fccfa286b94d768375a60","tests/ui/ignore-files-deps/deps/ignore-me.txt":"4636723dbfd9d2967060094fb248e8121fe1620ec8e0e5ea505e66cf1e2781c2","tests/ui/ignore-files-deps/world.wit":"1e3baa2b60d49e5607534fa3d3069e1e2fe6d5084c8c83ca7e5135927ea9f53f","tests/ui/import-export-overlap1.wit":"1228074dc8caf72beecb3c6281e183769b8367d7162832cb9d0647d314a9b2ac","tests/ui/import-export-overlap1.wit.json":"67d8028378a4dc9365242b2b7f1f8bfea1bfec71a2c5df22ce87a62c3d75122a","tests/ui/import-export-overlap2.wit":"23f35f40aaf4b13e2745d201394add251746d523eb553b246f801715d9d79705","tests/ui/import-export-overlap2.wit.json":"087e6e1dd2d2901ed0c4ba31b61d6032859754ecd0abefb947fb2be314ffc9f3","tests/ui/include-reps.wit":"18b45384f26dd1660e721f00fa25bb45fcae247f91925b37b68b96c95d5a1983","tests/ui/include-reps.wit.json":"7fc06783fa6eefc29be483732ff0a07c2cdaee4028640d1c8d194e9d3d2fdf2c","tests/ui/kebab-name-include-with.wit":"e3018a921e3767a5f546713d8dd56801667d69b18353eff2f057b2e10c820273","tests/ui/kebab-name-include-with.wit.json":"eb626e1a2584eb5402ef71241fdc9be07f15a2502fd46dc45c2a03e1252358ab","tests/ui/kinds-of-deps.wit.json":"1b1ca68b2442b696d5afe8bc64094dd101ffe60729b67e9fd0d01fc873357c7c","tests/ui/kinds-of-deps/a.wit":"55532d4e836d80efd73ebda0d942adead4d6caec33076fe54a30edfc337a7703","tests/ui/kinds-of-deps/deps/b/root.wit":"10e833b051706c4882d451f7f66c7152880b5a4e60d75233a4709177cd45ddfb","tests/ui/kinds-of-deps/deps/c.wit":"4d6a716fabf7fe56efdd3de95afc2f520efa6592b10921d8b177b3640ff90d94","tests/ui/kinds-of-deps/deps/d.wat":"91deb49abbe77e312305d6e14ca746ebeeeed99207f099df49e26956add260ed","tests/ui/kinds-of-deps/deps/e.wasm":"33fc738466bf4d6e8dde7ff530a23831e3a42519d30e6f5d63269c292cd7255f","tests/ui/many-names.wit.json":"a15ab09ba624a77d24173f4e3cd2c7044e406e72eb128afa41933964e455bac7","tests/ui/many-names/a.wit":"9381b4e20f448e02d7cb27fe5db24c3f5f37e9ec1425561172edffc6c79f0a93","tests/ui/many-names/b.wit":"e5a20aa53d8673e38465e74f739a5c8cc4789da211fa43490222433c6131e43d","tests/ui/maps.wit":"245328c5953648a8068d0cd1b84cdd342590fd7ea066d650f40dfd7e5fd381a7","tests/ui/maps.wit.json":"6cd99c802177790f07f6708469b0db44f1e7478afdfa963dade9ccc96a1d489d","tests/ui/multi-file-multi-package.wit.json":"5fdfa45865f31de3c648614277721d86539c3e4c34d0c1ab0ff6ef79ddb3d1f2","tests/ui/multi-file-multi-package/a.wit":"4a996c8b1920aeb34f441d44131b3a7870f9769da5579bcbfd4b608e4a675fb5","tests/ui/multi-file-multi-package/b.wit":"b3f940591bd7adbcd1f61cc1606149c4019666efaf8dc76344bf8df89d138e90","tests/ui/multi-file.wit.json":"c64b219ea422ef8d73648ac2485079a7e1a9002ce5e35e2d67b8fe20590a0dc4","tests/ui/multi-file/bar.wit":"5e8d03741204f1e40e7a0f5bd2c043f31a3356c8de296762e2ddb38cfa89cfb4","tests/ui/multi-file/cycle-a.wit":"90612ed5fa9d552068c9c32a0b179355dc92d475c2d1b6521fec494bd9434738","tests/ui/multi-file/cycle-b.wit":"eecc7ed7ce638740ff1cf9fe20914f03b8c3920ddd247c2d80902914c7a4f8c7","tests/ui/multi-file/foo.wit":"ce81ee2316a34b064e2a37e01fa94ac982a663b1c3fc5be55b4723b6643b2970","tests/ui/multi-package-deps.wit.json":"f5d632858f6d4fc02a7c0713daa3555ffb88eed4d8a424dbcac9516291eb07a8","tests/ui/multi-package-deps/deps/dep.wit":"9d66626b787cd5d12b74354bf47e8d5b7e811f208cc512a4b985304ab7856dde","tests/ui/multi-package-deps/root.wit":"62338e53a74a0ca51e6fe81b8fe001a2fda456e64d1779e398525fbec8f236aa","tests/ui/multi-package-gated-include.wit":"109631bf21f46c17c146927e70579661934c28b0e42484378ccb07f65ffc084a","tests/ui/multi-package-gated-include.wit.json":"b5b5c7c2ce63ac25223a5d01ae42f69e6cbb326fb54073d3f58a1b4c904deffa","tests/ui/multi-package-shared-deps.wit.json":"a5a0cdd60e4b8ae10f5b9feff728faef8a81224880af5cc06f73b30757c733c1","tests/ui/multi-package-shared-deps/deps/dep1/types.wit":"b9cbbfcc38f90cd09b1ba9c9b474db0f858f596c054dda59d0de35fbabb26fa9","tests/ui/multi-package-shared-deps/deps/dep2/types.wit":"4f3bd8ecb0e14c6ff670192145dc4b24e20648176634338f7d9aa93ff5863db3","tests/ui/multi-package-shared-deps/packages.wit":"fb9a1bee65922b9d6372e07717899521a129919a23d6700f49b9f953f32df581","tests/ui/multi-package-transitive-deps.wit.json":"466bebe32e6a390148f4b6c9697148f87bacf65454a4825b8c48e565b217d4fa","tests/ui/multi-package-transitive-deps/deps/dep1/types.wit":"58a8ed5ed904dc9d04b7d0f84c400beeb262b79dd63258e66473ce4f36420b4e","tests/ui/multi-package-transitive-deps/deps/dep2/types.wit":"c2b7e5747fba9fbd25ce19b2a8b4fe7fc96831138f68c96e4af4ccc424cb1efe","tests/ui/multi-package-transitive-deps/packages.wit":"d5adbb7f4c6a9f182ee42155475aba911ddc21aea0ef619dfd68f7d4c7ff006c","tests/ui/name-both-resource-and-type.wit.json":"2345a2b52803a70dc14c3a97c5574b49ff23451c10a4036ed2bf6d682fadfb1f","tests/ui/name-both-resource-and-type/deps/dep/foo.wit":"1ff8e2a03e86e0676ed0459b6400b1f92957ce9e88424c91ef20dc2ce98414e3","tests/ui/name-both-resource-and-type/foo.wit":"b8338da8c7e942580d0654de494d68977f459f9e0fef2ffffc164380ea3293b9","tests/ui/package-syntax1.wit":"090709e7f0f85fb60f6a104c7b0ec325d11fc58fcc69a6c20b02f454a0636eee","tests/ui/package-syntax1.wit.json":"dcf5bf4334dc9ca156dc0a9a62d3dccf27ea1ebbe9525ab0b1b992599513fdb2","tests/ui/package-syntax3.wit":"ccadb54a828f5e200f6f2ca40d3e5bfca9431ab59b375e7dfde91a149b34fa7b","tests/ui/package-syntax3.wit.json":"e517e1ddee9cc8e123729f3e36cb85fba4328828421415150c99f6dc851c9e00","tests/ui/package-syntax4.wit":"516e3e21f7768a4ee479c0b52b68d3947b6983d0a0c04bba6044c05d784a2f41","tests/ui/package-syntax4.wit.json":"b7b65aeb4a33616707bbffc952e8b94b4d3f32e98a2cd3bcc2bf219db4a41850","tests/ui/packages-multiple-nested.wit":"feedd1dc072442d0183ff04562e5107c3081612e60939c1475a25dcb09c0d448","tests/ui/packages-multiple-nested.wit.json":"7ea283985310c900b7009e6c0c6f68be3d370cf71c831e68d5238dc1bb7ff637","tests/ui/packages-nested-colliding-decl-names.wit":"0875563840447d685523542c20262fb6b181bd0c77f56d4460a56211ce79fcac","tests/ui/packages-nested-colliding-decl-names.wit.json":"eab533e2b31ad4c86dc49ba98ae03e7f74730b01ff97296039b315517c4999e8","tests/ui/packages-nested-internal-references.wit":"8d60a92f19097442d2c17de549d41ca48b1d58025714ec9886153d636747ec30","tests/ui/packages-nested-internal-references.wit.json":"e2537174d20e50c7ce041dca4f1e4ac7a9c08ae16779141f6e9bc16db3b17c62","tests/ui/packages-nested-with-semver.wit":"bded1bf70c7d27493eb53571cecace850bf7e05b559f72b010d431c4a812900e","tests/ui/packages-nested-with-semver.wit.json":"d88a57595b4b70e3365dc3dfe8a387900d68663942b2a27c79b3c56403e314e9","tests/ui/packages-single-nested.wit":"b3c438ef0c0f467ec0dd15202d8b48636860921ce1c313968bbd0fdf4451c746","tests/ui/packages-single-nested.wit.json":"5341b377d4eae34b6acd116ca4d60ccc40aeac5da79d0b47d9c7fdb4cf94ad36","tests/ui/parse-fail/alias-no-type.wit":"6d717f638138d6536c634773058484f26bf1696630ccee86cbd98f20ef000185","tests/ui/parse-fail/alias-no-type.wit.result":"149e701639f259bc16082e7fd84542ac20a11480b8ebe6909788c78f42c9e6a6","tests/ui/parse-fail/async-bad-world.wit":"a5f91bfd0e6eb3d67392ba0be97fa037d73b6193f8014df64313d08e8d8dd233","tests/ui/parse-fail/async-bad-world.wit.result":"c326e18dd5737be4718a428cedbcc2dd177a3603fd91ba3b1bee8578bc65f3b0","tests/ui/parse-fail/async-bad-world2.wit":"110a4409ee12bbf9f1ba2e8264a694220ddc52cf6d236940cd6989d8a907b925","tests/ui/parse-fail/async-bad-world2.wit.result":"8fe7d414eb32a321b3e9b48b3f3ac269a9fa9f186e8cad87fe0fc6f1fd058e02","tests/ui/parse-fail/async-bad-world3.wit":"6f30f04652ab9a126f264540db6b63172e959fc1a189fcd0381605a7f4f103a4","tests/ui/parse-fail/async-bad-world3.wit.result":"ac9b153a9eb50546f14c22b737e45176a1dfdd70514fd53b3c0d277b529b1b00","tests/ui/parse-fail/async-bad-world4.wit":"d607651508ad944f22338e86b9226dfa58b83e7796e4c6af1c5fb65683640997","tests/ui/parse-fail/async-bad-world4.wit.result":"e320b3b7d91e7defab11693f6d316bf6b0d6ed5d7ba58d81cae79e5fa900305c","tests/ui/parse-fail/async-bad1.wit":"8c11bac371904041a93d4f04489e1f0fc2e731a1950a1f4a69d1d6a56fadcdea","tests/ui/parse-fail/async-bad1.wit.result":"55b81beea66b26a65c87e2c779f6b80f9fbc6a53a5f53c325e4bd9e5fb9e8a44","tests/ui/parse-fail/async-bad2.wit":"b779614996ac1c6ce2d5d3867e4c8772c66b093e5274807a83d0bb385b09a0d5","tests/ui/parse-fail/async-bad2.wit.result":"d20e721a50d13841ecc069795026e8ded6cd22735a4007a1748e2e3bf231042c","tests/ui/parse-fail/async.wit.result":"67ccac26d7fe73e8410404092b30398a778aa5bc2b460409c9de50d83f721c33","tests/ui/parse-fail/async1.wit.result":"3a04ed56850e4e60e05f72bd1a7d7646fa14bfa81b049e2d8d6a9dfd4837b3ad","tests/ui/parse-fail/bad-deprecated1.wit":"d792904a2c146aa5f247c23fd420e85565431b6f7975616de32bf78cabb78582","tests/ui/parse-fail/bad-deprecated1.wit.result":"0fa750df748b21c74a9ba10a318c21dd6fdd2f25497abbbda4fb36c2a25b82c3","tests/ui/parse-fail/bad-deprecated2.wit":"d333c32a598d23e0decad6f1f5d9278296bfca1320aca4e12291bc113d6e567c","tests/ui/parse-fail/bad-deprecated2.wit.result":"b808b7fe316cccbb96718b7f1f73ea0746af074d0305b6bd47f762e70732ba6c","tests/ui/parse-fail/bad-deprecated3.wit":"f72813a037e8718a7315fee317a080dbe73f3e44df0bc42408c0b9ccab1041f1","tests/ui/parse-fail/bad-deprecated3.wit.result":"e96dcb21216a1a2ae5e0ff3d063ba88dfbb610f5ae09b51853fe69ebdc44f96e","tests/ui/parse-fail/bad-deprecated4.wit":"96ad0d172b69432598acd101e2de83a6b36ef6c6980075d994d3961becc7ffe8","tests/ui/parse-fail/bad-deprecated4.wit.result":"443b255aed5611c14cf1751cd4da2dcde6d875c93599a5ae1bf999e913eb5a4c","tests/ui/parse-fail/bad-function.wit":"ebdaa7b0c3fb7713bd869b510c222e10e0fbe6b5e3c93b3ba8f077b59a9cdee2","tests/ui/parse-fail/bad-function.wit.result":"3480be5e024671f00c1a1d49b0b394dbe145b58d8100f89dff0912d7c39545d1","tests/ui/parse-fail/bad-function2.wit":"e501d5d676b0647999c3e508c4a494ba652cbd16c275be17583ae5fa02bf5e7f","tests/ui/parse-fail/bad-function2.wit.result":"a1c0b324816fd854dd85e9b2f29f9d3e09ad6a7f670244851032a734c96ed67e","tests/ui/parse-fail/bad-gate1.wit":"d427d68abe2e93f488569af3fecd08d5c6bb984ec461fac4f184a2b977d903a5","tests/ui/parse-fail/bad-gate1.wit.result":"21393b47dc8d07dd405941a137f55d94e6598efd449404aa3c42b57a3665b147","tests/ui/parse-fail/bad-gate2.wit":"dd536d413c6b7a0a59a15d39fdd1a52d7a4810d3900c59f8132fbf14d32da3e4","tests/ui/parse-fail/bad-gate2.wit.result":"ba82c990dbd4fa001d4ecfa46bd8730ccfc49a6c873265b0b81cc8454c9a58ab","tests/ui/parse-fail/bad-gate3.wit":"5e0d76a3029a0520b121f2ec6823ca39c3d3adfc57556c849898f69240f83a44","tests/ui/parse-fail/bad-gate3.wit.result":"b70ac740092d59b2d1e56c00e20c5bcaa9843f7a3072cd9f3c0a769818c15b78","tests/ui/parse-fail/bad-gate4.wit":"f5fbb50ad5087d0bb5401d290f05e733ee425bbffc514db3a2ed4d0a0dd366db","tests/ui/parse-fail/bad-gate4.wit.result":"8cc9f8a27b97f5861bacea7462002f3d351ea2038f54632d245385b0e9b95b68","tests/ui/parse-fail/bad-gate5.wit":"52b068c1f00f38174f53927cd7729b78648be636e2a7e2544397a8ea9ea8569e","tests/ui/parse-fail/bad-gate5.wit.result":"5fd577243fad4e78350484c79126566649b25a3744ede72e522baa138dca5034","tests/ui/parse-fail/bad-include1.wit":"05ec00177052bacfe2eef6ee2631abfd373a822d100f8d38d7178845cf3d2908","tests/ui/parse-fail/bad-include1.wit.result":"454bef60e7a0eb813b80b9e31187cef96bdbb389389b4238cc1ed45788eaa351","tests/ui/parse-fail/bad-include2.wit":"32d2bfa14dd78c78aecd93b31b28ba7013701411abd8d67e8c5277f1b8efd1a9","tests/ui/parse-fail/bad-include2.wit.result":"70e86e41d76100601131e14ce54df803ea699f4f7941a84e4a56ccd6c2f28d2b","tests/ui/parse-fail/bad-include3.wit":"44995ec365758dc52f7dc6824587df97777dd874f5d010c62222881a5b3ed929","tests/ui/parse-fail/bad-include3.wit.result":"fbe950700e42783b2126d0dddeb08a2fef837b76de2aa62e8f70c62fda7359f0","tests/ui/parse-fail/bad-list.wit":"20255af34f429589b311fd29367e4f7679eb8f1667538522b048ec5d9e5886e0","tests/ui/parse-fail/bad-list.wit.result":"b8323d11bf88203feee59ae6cb0f67a017ee75183e635269cec9a37b4518e38c","tests/ui/parse-fail/bad-list2.wit":"8325a40a06f2c29c0f106e39652b2519ff40a11f0829da3d32e2c91fd05dee81","tests/ui/parse-fail/bad-list2.wit.result":"7dd98a2e45abaa0fc1c97133df251aa57f855c112f46cd99f2c948e9a425b8c8","tests/ui/parse-fail/bad-list3.wit":"070c1d4580008679e693d5748069c67738620f36958bd71533aaa0813516edd1","tests/ui/parse-fail/bad-list3.wit.result":"460b21d80f73f1d518ae7723c436092bcae56d036c84cc6aee9c6cb616e4e3d3","tests/ui/parse-fail/bad-list4.wit":"474d295829f1303800b0e52ad5e9ff1f997c8f6db5a33028cc0a8502310e310d","tests/ui/parse-fail/bad-list4.wit.result":"74df59ff1e7058f1be49457c7eb8b77dcdf5fa06c007b6e5e7167990fad30b0b","tests/ui/parse-fail/bad-pkg1.wit.result":"8a63ad8c4e708640df5a2a7a064bc26d4ed64a3338215c5cae52518dc0a0f3a7","tests/ui/parse-fail/bad-pkg1/root.wit":"45df62dc512d8f9ead7982c32ea95318253fc243db73cf3b25aaefbe05778c4d","tests/ui/parse-fail/bad-pkg2.wit.result":"9423d8216ca764758513f53bef83fa053e49835f0bdb5b8bb77136b1d391a50f","tests/ui/parse-fail/bad-pkg2/deps/bar/empty.wit":"ccadb54a828f5e200f6f2ca40d3e5bfca9431ab59b375e7dfde91a149b34fa7b","tests/ui/parse-fail/bad-pkg2/root.wit":"3f04dc4f6d4c4adcf178cfeccba312f75439c3bf6a14f9f4d0bbc7d83e259582","tests/ui/parse-fail/bad-pkg3.wit.result":"444c65ff4abf7fa1c37a5403461539013c139ce49dc3ba0cf098683e4870d373","tests/ui/parse-fail/bad-pkg3/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg3/deps/bar/baz.wit":"f521c75f8fea0201278adcba4457115de7eb856a3338ec03dd4df223febe7409","tests/ui/parse-fail/bad-pkg3/root.wit":"3c1725bb749c1ace117e290e0085358bc6cceb4aaf9a6fc1e29c82c5a581ad24","tests/ui/parse-fail/bad-pkg4.wit.result":"cfa526440ae834e59214dfa67f92b0a1f013b4e54d705ec56a4f5341fe9853d3","tests/ui/parse-fail/bad-pkg4/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg4/deps/bar/baz.wit":"f0d7f373a2981f747ff15f994d10abdb7c5d9dc7181daf8e4b4610f98807658d","tests/ui/parse-fail/bad-pkg4/root.wit":"2b060a7ce9da4b0cd8960a28f069f046902633fdcd5dbac2f827658ab674f5d7","tests/ui/parse-fail/bad-pkg5.wit.result":"63d5877b3bf734e1900472a219ef4f20411bdf4d6608eb582ee342a0de5ce8fd","tests/ui/parse-fail/bad-pkg5/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg5/deps/bar/baz.wit":"43ba055c268fbdd4686b141395ce8582e1cddb6699b9564b10793a603abbcd37","tests/ui/parse-fail/bad-pkg5/root.wit":"8fe9c00d8a56e994c9914997d926013e43e01f6b610b27bb3311a9c89566bfbe","tests/ui/parse-fail/bad-pkg6.wit.result":"4c3238fe2df05329d6475277d73dc1731affa5b62717904b536f0609ac9c7341","tests/ui/parse-fail/bad-pkg6/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg6/deps/bar/baz.wit":"e0417499e5a97b2a5dedf83f881eb85830bdad3a2f2724cb07bf3bcd13e4a01e","tests/ui/parse-fail/bad-pkg6/root.wit":"62abc0d5005b2bc46c039978a056e3525c165c29449bf617ca2f4afdb6ebaa98","tests/ui/parse-fail/bad-resource1.wit":"d3783f455c501334f2ae8d132490afffee5142ad1e94ceb3fb0e576299419147","tests/ui/parse-fail/bad-resource1.wit.result":"63fe0c9f4045c9d1643a328d007807f34e495ed8b25c429b65f5721147e842cf","tests/ui/parse-fail/bad-resource10.wit":"4158f1b360360ea4e4429720b34e91b9d259eada8e574733af3c83393552fd38","tests/ui/parse-fail/bad-resource10.wit.result":"f4ed54d9da0802ab22cd25f00f300f8d9bfd1a34820b610ddb37336e210cc40b","tests/ui/parse-fail/bad-resource11.wit":"24459fbe029d94febe36a6823d5992a59732bc8b5436c4bedf2c5192e2c20be2","tests/ui/parse-fail/bad-resource11.wit.result":"54cd069d5119f632d36c4167a7ea9032ac9daa3564691aefd25473d474ab32fb","tests/ui/parse-fail/bad-resource12.wit":"da12b00ae70ece5df5faf295a75b484e89ef3bd5edb07bd7b76bf7dadb04dc45","tests/ui/parse-fail/bad-resource12.wit.result":"0fbb864a5ebb00a53afb87524a534a77de5fa5122d95bf33b7f92e217326fc44","tests/ui/parse-fail/bad-resource13.wit":"e01ae82c5dc83a1f201fb9942b01f469eddd63741a12e14c4b97510cd0b74daa","tests/ui/parse-fail/bad-resource13.wit.result":"f937ab865f5cf26b0302bb94126c2482323fb31d3c4ce606cd10d5750600f8c4","tests/ui/parse-fail/bad-resource14.wit":"ed4450c13763dbe83921828ae23f8900ed88de70ca0bf989874c31e88e929cba","tests/ui/parse-fail/bad-resource14.wit.result":"ac54d2dae60e13d89f6f1532ee4629a9dff3d410be0e9bcb37025d77da8d9176","tests/ui/parse-fail/bad-resource15.wit.result":"8234ca2888cd2ca50708c41de82461bbf64997269032e9a221b6b66ebcbeaa30","tests/ui/parse-fail/bad-resource15/deps/foo/foo.wit":"19b517ce45a205776724b53a0296780751b757e80b4836a0c1230f1238ec2f69","tests/ui/parse-fail/bad-resource15/foo.wit":"92a38c0eef30ffdb5a314889e127532289afc03d5c6a66d38fc6763869285a80","tests/ui/parse-fail/bad-resource16.wit":"c1b3724b5a2d0689db57521fb35f0e8f47302fff277e5fac4e077712b8d06ed5","tests/ui/parse-fail/bad-resource16.wit.result":"6684499b5f7745fbdefd81ae2b9507125364adc3799650f1ed9acb551daad264","tests/ui/parse-fail/bad-resource17.wit":"e3da1cf497d48033f3a91d25ae2f7129de54c004c9b448e5e810ceb2304364c9","tests/ui/parse-fail/bad-resource17.wit.result":"03cf4d36938c5ab1b0656e3ee0e0c0de66707cb0791cb7fb969723d042c40dc9","tests/ui/parse-fail/bad-resource2.wit":"78f8e65877b7254aaf8f448f7f5f4e50774d797fc3eb64ca2793532ff16a62ff","tests/ui/parse-fail/bad-resource2.wit.result":"d0d968ebf8a06cda2946fd4b30595826a6db0ffa40f71ba5472884e75601313e","tests/ui/parse-fail/bad-resource3.wit":"e8620477d3cc02bc3b130d2fc14f2431fffac0cf516cbc05aff2dda37740f2fb","tests/ui/parse-fail/bad-resource3.wit.result":"b19b0a6f8ba99e738504c433afb19e7f17081db14d10dc01506ade5c31b11cb9","tests/ui/parse-fail/bad-resource4.wit":"31537bd0d09e58dee09ea9b93054c8cbb3cfd39bc4a1fa9330bd7b945bd81681","tests/ui/parse-fail/bad-resource4.wit.result":"bca647b5172c6c0bceea3de7ac2dfc7426b68e55468d081beade9b4ff2b0b0fc","tests/ui/parse-fail/bad-resource5.wit":"854fac37c2b7c8edae5276aa1c7c6cc726a348ae757c0f9cc5cd4103d75dc640","tests/ui/parse-fail/bad-resource5.wit.result":"db20186fc1b39c832acedadcaebf2d1f7f803253a2df5eb57b7fd6f66f8d7b38","tests/ui/parse-fail/bad-resource6.wit":"a5f798328cbf777cce00069a637f1dc7d79423c685ebe11a21f7f8ead1bccef4","tests/ui/parse-fail/bad-resource6.wit.result":"1955db627b4a2db9dd86d37974567454572b222bcb33e70664393b31e244a0a9","tests/ui/parse-fail/bad-resource7.wit":"7d09275525b419858d26533211b6a9d3a7b67639e8aa1fc28eabd713dfff4eb1","tests/ui/parse-fail/bad-resource7.wit.result":"c62958d5564b25268b662677cd35b24c4131d985d906c2d61a80bc61ba11267d","tests/ui/parse-fail/bad-resource8.wit":"da8489525fe75a197731293d384c151da204fbb2a278b9ab7a6c30fee45efcdb","tests/ui/parse-fail/bad-resource8.wit.result":"eb657e7afedd3fd1b849780564c5b0350888531fb19092961181d11e31659499","tests/ui/parse-fail/bad-resource9.wit":"5bdde3d51bf8f3e86752a21a31d93776a6b390e41ae9aeedaf7b829e7afd8f19","tests/ui/parse-fail/bad-resource9.wit.result":"d2e74db311d6ddb2796837e9426a58b7a02e8140d72a6a681eea6f54a8731f9d","tests/ui/parse-fail/bad-since1.wit":"8180c2632f6d75ee675528f4e9fad184ea5c9675ba09f34f61d7bca5ced38344","tests/ui/parse-fail/bad-since1.wit.result":"b6023204b3da7c1f58491609dfe5016b05bb8b8cd61b5b38114591c01b24e1f4","tests/ui/parse-fail/bad-since3.wit":"477408c0e355c1383103aecbd4bd4769df5ce251bae1ae5405183dac9a920c6d","tests/ui/parse-fail/bad-since3.wit.result":"07a4d9d40e6fb85da01062a72e6dc0e3cab81fc6a9b5223796957fff492ded90","tests/ui/parse-fail/bad-world-type1.wit":"c04002fdb48270e72f804642932b84f8a0a6acdf03d335e7b809c61b9e5efe64","tests/ui/parse-fail/bad-world-type1.wit.result":"2073c4406bba9ab314d172840c8b43f2e505bee7f823a21abb0f7c649d81a504","tests/ui/parse-fail/case-insensitive-duplicates.wit":"0517099b9586ef9a1a22e4a340e00b3f9088891e5203906ee2303e5e47cf9a49","tests/ui/parse-fail/case-insensitive-duplicates.wit.result":"6404ed765277711fe927b011daf90c20a69942ed2578458a0df285424e6d0cf8","tests/ui/parse-fail/conflicting-package.wit.result":"7577d7f04ab4ecd2401b2b546d46cf42f3951d30f8a118ab843c043194599b33","tests/ui/parse-fail/conflicting-package/a.wit":"20fd778f4594d89d4b3282ed2b4e005cd3e7a377eedbd9a05ba9b96468f53d55","tests/ui/parse-fail/conflicting-package/b.wit":"05ce70a45e9d19c833579bdd20a4fbbc98cc2f2ce737e1030e41f35cab4f0066","tests/ui/parse-fail/cycle.wit":"6940cebea92951af95a7a352f76ec8c79326005a0698e977ec362923ddbddb8e","tests/ui/parse-fail/cycle.wit.result":"09ab288a56c511e8cea5cae9b72f474a4f2cc6ad4bf2840ee10d10e45a144d0b","tests/ui/parse-fail/cycle2.wit":"5c7d28994b1fd872236a03238d9d1b757eefed741a1e540a4bc55e0c2ad0fde2","tests/ui/parse-fail/cycle2.wit.result":"eba74322800b7476a356ad73d8eb40aa5165389624c555d58616144e11b7672c","tests/ui/parse-fail/cycle3.wit":"0f4c613e93478afad6065642b60b5979a8df4ec1e13359f0c9824a218c966de6","tests/ui/parse-fail/cycle3.wit.result":"d98f5432924f5feee6f1a60ace1c0dd82b555a260502b166ab51bad0312e82ec","tests/ui/parse-fail/cycle4.wit":"74fab6b8fff3e176bc1499f3e0acc46f1746e8664a7b0307389645e7ef03b696","tests/ui/parse-fail/cycle4.wit.result":"4b4c4b912e4363eae23b6ae92cb4e499f0582d24299912aedcc0ab78b6ba0e67","tests/ui/parse-fail/cycle5.wit":"c21c064e42ec81544a0ae5cfa0081313b8023fc4cc6725b27a8307ea0acc43cb","tests/ui/parse-fail/cycle5.wit.result":"155993cd465deceded417e0eeac9c04a50adadd6a521786e3a0d3b33b352c062","tests/ui/parse-fail/dangling-type.wit":"61ab6f89a622be1f4003dd4c6841d780646b78f314c0759b77dcf6b2bb91e355","tests/ui/parse-fail/dangling-type.wit.result":"d5d60bd20198bf6fee5066f0bb1bd1a6129a7b23ee28fd623a540f6830267e13","tests/ui/parse-fail/duplicate-function-params.wit":"7c86f5515793538b821a4797f4a8456930329a0fcd054d29e1b7b1117a29d295","tests/ui/parse-fail/duplicate-function-params.wit.result":"614f85899af13a69cf98d762c61d3e607dcfb3d3ed7e4ada211ed1eb7af8a9c9","tests/ui/parse-fail/duplicate-functions.wit":"9ff1bc0093dbe55b961e8a5f4b528c145c1d975bea619b2936cd6cf839edf0e6","tests/ui/parse-fail/duplicate-functions.wit.result":"aff563662f466c0bdaaec5bb197f0aeba8b31c7e962f84a6a1a26c3944601ffc","tests/ui/parse-fail/duplicate-interface.wit":"3acb5212bebafe8eb10e0176f74ffe999b20d9cdb7ce82f09672584a043f90eb","tests/ui/parse-fail/duplicate-interface.wit.result":"8ae55ae32e250a01caca352d9ab03e4a062060095f6e728011b8677fdff86de2","tests/ui/parse-fail/duplicate-interface2.wit.result":"f4f24a6a163cbe68f74613708cdd1b409fd55c775967c0983e466c5b1542a25a","tests/ui/parse-fail/duplicate-interface2/foo.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/ui/parse-fail/duplicate-interface2/foo2.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/ui/parse-fail/duplicate-type.wit":"0d1623865f9cb358f8344fa954becf249e948ee37bb22004c1405602c2f083b4","tests/ui/parse-fail/duplicate-type.wit.result":"de1f41c3125a8ef52719b845bb685b1e735c504b3c7b63e39374f826d7315055","tests/ui/parse-fail/empty-enum.wit":"4d345214cf0ee46c4b4108fc0e9f7b8aaeb7eff82171400aaf45c1fb283e558b","tests/ui/parse-fail/empty-enum.wit.result":"6338ac28789456fe02aa133185e8c3d9896812df9377d2211da2dc0f23076c67","tests/ui/parse-fail/empty-variant1.wit":"1f56da64ab09a7f282b1785241dae5bfd8ecb4bbd055a22dcdebed33971f1522","tests/ui/parse-fail/empty-variant1.wit.result":"d67d08b7b070a59b0f803d3e118dfad4ae0cfbdc404965a5cfc5c5198fde5fa9","tests/ui/parse-fail/export-twice.wit":"a3a7cf6e7cbbe513c5561a93e32f030364c622b5123118392e9e2aa6ae44dfef","tests/ui/parse-fail/export-twice.wit.result":"01bed0e73b437ccbc213a389a512a7dafb9a336eeb38d151cdfc8e14e98f450e","tests/ui/parse-fail/import-and-export1.wit":"626f705beb7506cd30d2adea9b339199f9e6d8ac6f62f5f7778e2e2d683b0230","tests/ui/parse-fail/import-and-export1.wit.result":"330a6ed19e4c4e0e89358e599110f5d62bed823e6e5982f576a23e0b25034ee8","tests/ui/parse-fail/import-and-export2.wit":"617a1b3d8e0b227eb4fbf74101133deb537ab5723811e9cc658d8bcb942425a1","tests/ui/parse-fail/import-and-export2.wit.result":"ec0b14b07e21bb21157155e9d056e1cc303affe16fc1536aaae5c948021ce6fd","tests/ui/parse-fail/import-and-export3.wit":"adc857f5752dbf55460be01bbdd19fb54dffedeb1781ea8f842a05041ae6bab5","tests/ui/parse-fail/import-and-export3.wit.result":"9a99411b891ffe302d8070cc8ad280cfb815a17c1d0cd4b72bba3e65df20dd6a","tests/ui/parse-fail/import-and-export4.wit":"9fd002997b30219720270a8c5399bfe45d55737d9052306c992f6eec30c4aad1","tests/ui/parse-fail/import-and-export4.wit.result":"6cd95a14a1eca775006c558013ef3179e715dc913f5d6a95e23cfd3f4bf4cfd9","tests/ui/parse-fail/import-and-export5.wit":"343bf3eeb13507dc168f1478ca452cf36964f002aad051f0283ff8a95ea40747","tests/ui/parse-fail/import-and-export5.wit.result":"ac812b21785e1f0244bd8ab5b59e94b57e29c5fac5db56c2fe339c92362e324a","tests/ui/parse-fail/import-twice.wit":"ba1975d057920962bf325b034b4ca2cfa7587e2fa79ff0b2bca4a0f950e0806e","tests/ui/parse-fail/import-twice.wit.result":"cfc3f8da5f3e65c73992dd7d39f5e3ef9b9154a883183bb7f3cae7339cef7c65","tests/ui/parse-fail/include-cycle.wit":"0c51410fa39f6afa1465696c4ff97b1496c6870dc8fc5a2a2f3c2a4826c24685","tests/ui/parse-fail/include-cycle.wit.result":"95e03934ed9695bbd1856fdbf4b588a429ee41ade3447e664edadda5c8c01256","tests/ui/parse-fail/include-foreign.wit.result":"5662f77092ae988280c0c1eb1f76a81297fcd2c23823f1cfe0904584bf1a36e8","tests/ui/parse-fail/include-foreign/deps/bar/empty.wit":"348f61ad0f69954f7438ebde4cd03acf45ee8a83fe7ac53f9f52576de2fbb30c","tests/ui/parse-fail/include-foreign/root.wit":"d436297400495dd1236cbf0b6268f3663722660e140f1ae68b3ba600399adcef","tests/ui/parse-fail/include-with-id.wit":"3f50cfcbeb23cf182941e6b273136d83b57531224230f47edf4ba6dc16ce40ce","tests/ui/parse-fail/include-with-id.wit.result":"03fa45329b179073500e002fbe014ea48e564ae7a274dbcbb0bc3b5d39959c89","tests/ui/parse-fail/include-with-on-id.wit":"64dcce8aef4c9fcc30376218696070d8f6a3d0d767fd00abb8c2f6672a99cc60","tests/ui/parse-fail/include-with-on-id.wit.result":"cd893a62379128b37045d0c81364e43c8c8fdf372811183c6aa95c6d17a7ad3d","tests/ui/parse-fail/invalid-toplevel.wit":"c292a6cf02880d580b76ebcb0aafbab2bf6c6f8545299016f9a0bc55dab16624","tests/ui/parse-fail/invalid-toplevel.wit.result":"23c34234dd7ba5af3c135487c7607442c6b45b9a328973ddd1bb3bf841ec2148","tests/ui/parse-fail/invalid-type-reference.wit":"61f8a73ee71a39489ff37a41967cdfe011889c25c1623af939cce809562b1915","tests/ui/parse-fail/invalid-type-reference.wit.result":"d0169e51f599096c65186211656e9b007f01698d2004d4ddc9ae26cbc78bcb57","tests/ui/parse-fail/invalid-type-reference2.wit":"9e1b00da3e1d7d39720c41cda330c3ffa338eeb6ab2faa25ab64332108a0e06f","tests/ui/parse-fail/invalid-type-reference2.wit.result":"a9b2a4a2b69b966e3a3d2ffa4a7f94abd775a02fba877f7c7ddb9ebc76a136ab","tests/ui/parse-fail/kebab-name-include-not-found.wit":"ac48583cf9bf4716cbbf22d6356dd897bbdc657530b9e02168b920da2928bd72","tests/ui/parse-fail/kebab-name-include-not-found.wit.result":"f56ed9f900ad4371561fc149bd0429261e10bb26ee76cff57c527febc502cd25","tests/ui/parse-fail/kebab-name-include.wit":"f81884221b5f20a69015ba9f94915785f9a7fbb5eaf8a02883ddabca510b7961","tests/ui/parse-fail/kebab-name-include.wit.result":"4c48c8a2b849e53ead974720172a4de0881a426a8717a024202a2329cdf74a3f","tests/ui/parse-fail/keyword.wit":"cd46fd9b045e79e0f5f8ace13a6327ae83e26951f699b25d6e0a872fcac71010","tests/ui/parse-fail/keyword.wit.result":"ef1b6510fb56e899c6bb38592a1953d165e01c5a46bc02249c33b73f99f28740","tests/ui/parse-fail/map-invalid-key.wit":"612eba223b7882277f74826312dd61958dea73443dc95ef1f6ddd8b5f4680c91","tests/ui/parse-fail/map-invalid-key.wit.result":"51555d75fa2b8b8897be3a7136829c35513a896344992d7543986a5ec4fa021b","tests/ui/parse-fail/missing-main-declaration-initial-main.wit":"208a8e0aea83d0aaf50edb322181a1b35728ee972bc7929b63f881ab3a923cfa","tests/ui/parse-fail/missing-main-declaration-initial-main.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/missing-main-declaration-initial-nested.wit":"eafc130098a084cebb71ed07c84432bbe8269d92e5c999728136cd90b99e3bb1","tests/ui/parse-fail/missing-main-declaration-initial-nested.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/missing-package.wit":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/missing-package.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/multi-file-missing-delimiter.wit.result":"0d5af4fc565143f116b46ab61e6a4b5fe4d74325af8c6b6180c3ee6a44516ea8","tests/ui/parse-fail/multi-file-missing-delimiter/observe.wit":"bea33af0bfc096aa7058a5d670322f67688b2927d0fcb1eed856593cb5c93b97","tests/ui/parse-fail/multi-file-missing-delimiter/world.wit":"d78271de8c919905008fb0192328770738f31cf2edf9310e7824bad487492c3d","tests/ui/parse-fail/multi-package-deps-share-nest.wit.result":"f4c43b6c9abefe4e13b6224c057276f30a8355363936e0c1c2b1292808f61147","tests/ui/parse-fail/multi-package-deps-share-nest/deps/dep1/types.wit":"dccf32826372acf61a4132d118d1759874c83b5e3032dcedb91fb283489bbf28","tests/ui/parse-fail/multi-package-deps-share-nest/deps/dep2/types.wit":"ccb04fe89839748a7cd9c09d333acd549c4900d84ea1d57cb8890d12ec4303c8","tests/ui/parse-fail/multi-package-deps-share-nest/root.wit":"7b874fb105af381d5361283b115d7d38885e6a055fa5af6867a85f03207ae7f6","tests/ui/parse-fail/multiple-package-docs.wit.result":"db1231691632699274fbdf8a94cbb52a3ddfd429870ddeb8eb15b11ebea0def5","tests/ui/parse-fail/multiple-package-docs/a.wit":"456ace15e375131385fa74f93d676b80ff9179a77b2a8c4cdf01e4cfeca80527","tests/ui/parse-fail/multiple-package-docs/b.wit":"9ad7758e29c6b08f0f072c8ab7ecedde3718abd161b2e05c284d46f95e68b208","tests/ui/parse-fail/multiple-package-inline-cycle.wit":"4c993b0b8a83f68090b85db4d95872145069d5bcd946dcab8a878770726e0b24","tests/ui/parse-fail/multiple-package-inline-cycle.wit.result":"a624984751c8f0674b50c4e297720b104658b5d9ebb15098717fe443ca3d0197","tests/ui/parse-fail/multiple-packages-no-scope-blocks.wit":"a45426e4136e28663f40278e268a390a7562027d6cb6f27168576e3853d66b25","tests/ui/parse-fail/multiple-packages-no-scope-blocks.wit.result":"1a416a1576e387ecc0d34b9a922ba7e5f536b6c48c46a881950e0100c1f569f6","tests/ui/parse-fail/nested-packages-colliding-names.wit":"a528b3e1dacab79c7aa2c7ad6ed42da2f0061c242f178d42152c25f45ead1baa","tests/ui/parse-fail/nested-packages-colliding-names.wit.result":"f2d637675a851babb091b4f6dfe8410bc48b5505499b65ef3519f714cc5d9ba6","tests/ui/parse-fail/nested-packages-with-error.wit":"f8d310644b61d2b0eb4641a003d8c1dbbbf8ec3f98752b3b5ec791d2a0fa7f58","tests/ui/parse-fail/nested-packages-with-error.wit.result":"973d5a905fa8c6149d03978458a2c63a4646a37b9541c5f045abfb1742ece093","tests/ui/parse-fail/no-access-to-sibling-use.wit.result":"3b640ef3569ac8602f155fdbbaa503203dd9f9d01c53c7b6c693787dea408d2f","tests/ui/parse-fail/no-access-to-sibling-use/bar.wit":"e52d3b5ce50a6c3260a367256406d67401d9a48c3aa9bdbb5c9dde30712951cd","tests/ui/parse-fail/no-access-to-sibling-use/foo.wit":"5c4d88f6af280b678722f265775abec5c577eae47e5be275d9bb2ae2b3092a99","tests/ui/parse-fail/non-existance-world-include.wit.result":"8179176b5d30fa1d472cf7269277753ae8f28d2337fd3d4d9409256df24391f7","tests/ui/parse-fail/non-existance-world-include/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/non-existance-world-include/deps/bar/baz.wit":"e0417499e5a97b2a5dedf83f881eb85830bdad3a2f2724cb07bf3bcd13e4a01e","tests/ui/parse-fail/non-existance-world-include/root.wit":"758be0657b943a7718ea8b8f6b68e39a71264f6ea55ae1602ea993352b7ca939","tests/ui/parse-fail/old-float-types.wit":"a331d50c87423e3ff6683e2a43b514d404e7c7920a4951e99bf7dd60b9a8e53a","tests/ui/parse-fail/old-float-types.wit.result":"1131f9caaf4efbe23923c836b71621c3a8c3b3b3293a1e4c6e1a8c589fd34ce2","tests/ui/parse-fail/pkg-cycle.wit.result":"9331660c2b320ad8e2b8477b1797769ed119137df99db9482c2ead7ad18dc573","tests/ui/parse-fail/pkg-cycle/deps/a1/root.wit":"a401664c52777f3542a756eb79a2344ef4d569908df54e15a0243c31aa77b58b","tests/ui/parse-fail/pkg-cycle/root.wit":"4d42e9e04ba377787b944aec6cb44e3ead0088d7130647db5ca67b4cca7be490","tests/ui/parse-fail/pkg-cycle2.wit.result":"048547c47dd0e85ae7df58f3492090c699b271b326f632900ae1e20ef81db276","tests/ui/parse-fail/pkg-cycle2/deps/a1/root.wit":"122dd6e3f2f3f4569b44533ed967b5facd458c38116bdcce3f936f3642005180","tests/ui/parse-fail/pkg-cycle2/deps/a2/root.wit":"b16a1b33f2525e49d3f3691fd1d43598a0e4cf0015bdc7a9979b73737085a830","tests/ui/parse-fail/pkg-cycle2/root.wit":"60bf50dbc32c8b2e702e042358884c293372689fb0a8a34866897fe995ccccd9","tests/ui/parse-fail/resources-multiple-returns-borrow.wit":"79b3bcb55c4df39cd2037e547aaa2200f920591722517db34652e7ad4e766b50","tests/ui/parse-fail/resources-multiple-returns-borrow.wit.result":"d4c6f5075e50d48dc277c5940d34f58640e8d78b2dad6f9a2f5827d975a11328","tests/ui/parse-fail/resources-return-borrow.wit":"7be90d00f626f87b85990a97d26862f5a00352d67acf4a89045c197cb555e6b8","tests/ui/parse-fail/resources-return-borrow.wit.result":"e43f5d3e7c577d8162b255cb0ec3ea0731634dc63801996fc9f7c328cbb36942","tests/ui/parse-fail/return-borrow1.wit":"1e76d092f4919748bac9db9907a638c26a6ca92ab599f026261511f8c2a662cf","tests/ui/parse-fail/return-borrow1.wit.result":"ff77a7717f0baa3b440edf0f9ab5d2a515c99d19a7f159db6f0d11dce06f18bb","tests/ui/parse-fail/return-borrow2.wit":"f707a3ae6de39ed0db7746410506040dcaa2621324b996708d54aba02c9c49bf","tests/ui/parse-fail/return-borrow2.wit.result":"f64b3af5d0c3e7ff1e8f8f773950aac6d4d5ba2169de1a6e998d3dd05f72dfe0","tests/ui/parse-fail/return-borrow3.wit":"5a5760e399143ba937e5d3d773fbf8920ef826397d63175c794488960c602256","tests/ui/parse-fail/return-borrow3.wit.result":"87e650418893bc64d7712873ff8ef86e32bb0337d73c5c87dcdf78ebbad2ae03","tests/ui/parse-fail/return-borrow4.wit":"3e26cf4beedfb48ef6cb449cfefb4977a9ce0e56afbbef96b01c9279eed9c7ba","tests/ui/parse-fail/return-borrow4.wit.result":"45dc8b37c04ff614222096a1060b84c837947d3e7598daa241706c00b55c8d88","tests/ui/parse-fail/return-borrow5.wit":"fc0883c45f58f9febce715c622cdacc4c7a30d8e7acf16e7862969910a621cd3","tests/ui/parse-fail/return-borrow5.wit.result":"73afcb04f4f80c7d8a30928f47843f6524e15e0c0f1a9d3ebe74b4a9a32a5003","tests/ui/parse-fail/return-borrow6.wit":"f7b0b935f130bf810cb4fd21b96ecdf95993d20da8b8d82522d18e5051633726","tests/ui/parse-fail/return-borrow6.wit.result":"a32b28110a8fff2f999491ffcc7aa6d918094abd361be6d2ba4aa0da73c82921","tests/ui/parse-fail/return-borrow7.wit":"63626a382d1213cae263363950c9a64d6d54099b9ac535c594ab6926cb1233bf","tests/ui/parse-fail/return-borrow7.wit.result":"f13777e7b0536fd025f84e6bd8d8a01d47d85d8fa94fa428537213541ae691b2","tests/ui/parse-fail/return-borrow8.wit.result":"9fb553cd5e9541f8624c06204f79ab75c8840c7dcb38a356615f105bc73a9b93","tests/ui/parse-fail/return-borrow8/deps/baz.wit":"62b2638655b890dcc9d7be49bac7ff4689a3ca553293ba1b577f197c6fc91afc","tests/ui/parse-fail/return-borrow8/foo.wit":"f7915c3b37ce20432539b9e7a0662cc773f00a24dd8c5f8e9924392e522c940b","tests/ui/parse-fail/type-and-resource-same-name.wit.result":"28f2c298385dd152ad21a5be43ee86518368fb003ca79985c301b22774e3a778","tests/ui/parse-fail/type-and-resource-same-name/deps/dep/foo.wit":"e209e375ac3c8a02332abadf1112b6ee88a36c0b78bec82141927b8209aeb793","tests/ui/parse-fail/type-and-resource-same-name/foo.wit":"1edf7997100c89b9e299693ef9d0021ffe43d041a39540e193b11d616bbfab35","tests/ui/parse-fail/undefined-typed.wit":"a5c783ac0da51d15526b0104a0d468bd72e6726706ecef1fbbd5cf6aa413e53d","tests/ui/parse-fail/undefined-typed.wit.result":"794055fa5bd2101d289b55236dd813ea1428bbac89133020bbf2270d2c707c30","tests/ui/parse-fail/unknown-interface.wit":"4813d741cead7412e6f453e728627407069ab17922445dd67acfb80cdf463deb","tests/ui/parse-fail/unknown-interface.wit.result":"545c3a6eee6e89b51a46145bd6609cae3f03ac65df0ebc735e439cef0541bacc","tests/ui/parse-fail/unresolved-interface1.wit":"aa48ae74e1dc3165f05a0d216fcc02b5a22e2cd8cab1c1d3fd9b4ec09da5a47f","tests/ui/parse-fail/unresolved-interface1.wit.result":"b4adf53a899553e08ed1e76457970a15753cad66147c39d40a2f2397734238d5","tests/ui/parse-fail/unresolved-interface2.wit":"0fea9d7ff4592d723e4a9c3dbf341357a4902509996d8eb30a6f520735d0a41e","tests/ui/parse-fail/unresolved-interface2.wit.result":"66b21536fd06f55c737bea8d783e11f707003f988d23764cab478eda8afa6555","tests/ui/parse-fail/unresolved-interface3.wit":"ca7dbd14ec8ee5d01ab2bb7c28b7a3713f31db8c092511b3233b46bc5c353c10","tests/ui/parse-fail/unresolved-interface3.wit.result":"6cd94000e5678a2fde3234638b510ce3bed9f0a2f1cfe589527ba0cfa4e9ba14","tests/ui/parse-fail/unresolved-interface4.wit":"cbb042a9274076b17b7e0c42fc971da6fecfe2e6707a1d7026dd4f647ce5426f","tests/ui/parse-fail/unresolved-interface4.wit.result":"4093b50bcb7aeb9d776139290c723a5979cd5c9b5240c3d4fff127755740675c","tests/ui/parse-fail/unresolved-use1.wit":"f6b32002e7060026cd91e879d11d5f55d1fd0abcd8cb89a37325f8816bde9a9a","tests/ui/parse-fail/unresolved-use1.wit.result":"c5347149bf31d2dae55360c12b266292e4e96a49bb1a3494877cc7c031841f8d","tests/ui/parse-fail/unresolved-use10.wit.result":"551a761df6989b52b2e042924bb1b3b0055f3ec7f451d1b0c70dd4b49e2e5f2c","tests/ui/parse-fail/unresolved-use10/bar.wit":"7dad62091e741838831396f8fd31846a26ef6de0fbcadc350ade8fff0bf575ee","tests/ui/parse-fail/unresolved-use10/foo.wit":"feecb9606feec3ea7f499a1e9d97a86185c861eeef81c6e31c4d3805752d099b","tests/ui/parse-fail/unresolved-use2.wit":"b57684da212586ce720cf3161f9a659d3abaec989a4081172a5cd05425777a9a","tests/ui/parse-fail/unresolved-use2.wit.result":"a62b50fe39176b748df8fcfbcc28c099e801762f1e099d65f751e95c92afabbf","tests/ui/parse-fail/unresolved-use3.wit":"47fd4331dd9f76416230f2b4236a1837d1fba2e17603b25376306d2afb72bf24","tests/ui/parse-fail/unresolved-use3.wit.result":"ebf46f8ec011c0a98a0593ad217c1fb90ad142898b76385ca6c02d01a34d883f","tests/ui/parse-fail/unresolved-use7.wit":"b57684da212586ce720cf3161f9a659d3abaec989a4081172a5cd05425777a9a","tests/ui/parse-fail/unresolved-use7.wit.result":"7be5ab3f67d7b0df5ef2d0df1f66c2f2995bf247042bc89ea90089c05d254f84","tests/ui/parse-fail/unresolved-use8.wit":"9208e402aa194d8d0fd3c04f5c3a63e070a6fba35aeb3ee6deb620bdbe825be6","tests/ui/parse-fail/unresolved-use8.wit.result":"0f326c857f8ef05ed3687fc35816318931e9a189a5d3730b8437a0d967f354ba","tests/ui/parse-fail/unresolved-use9.wit":"a55be65d32510b790f687a8cd1a17cc78d66fc348a73c202786ccfc73ef80cda","tests/ui/parse-fail/unresolved-use9.wit.result":"a2479c0725a0e882c20999e0f194d4054777292b5fd3e08115b28d87b6d1217d","tests/ui/parse-fail/unterminated-string.wit.result":"ad1667fb37e169ae458c86c87154fcc2c25c1194578812dfb83c8a941c2ed002","tests/ui/parse-fail/use-and-include-world.wit.result":"5817300629cfa4fc8275c63f2012f2328f27375b771d2da2a14a76d520dcc4e8","tests/ui/parse-fail/use-and-include-world/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/use-and-include-world/deps/bar/baz.wit":"a3bdbdbec31db5c6ae2d898c5d82e1513e39bec7d887b199e648595ed7845102","tests/ui/parse-fail/use-and-include-world/root.wit":"78da4438e0a957af1421dc8c503593f3e675c5179eda0e1671c856b3cdcb6af2","tests/ui/parse-fail/use-conflict.wit":"034cccb48e6d9a80967c432bb1590c753c12d483aec6fa6d0da96eb6dd95636d","tests/ui/parse-fail/use-conflict.wit.result":"27bbdcde0151687d6a785e785824b458eb8f3393266e16146641a0c6062fb6ac","tests/ui/parse-fail/use-conflict2.wit":"fae3ffc85bea2e71f6427442516a93346a1c078db321ff1d9c79f3aa803a8a80","tests/ui/parse-fail/use-conflict2.wit.result":"a10548056049674ab161e6c63bd34aa17388ccd01ed7afdf765d98a40cf42cac","tests/ui/parse-fail/use-conflict3.wit":"c7d3fec48232c0fac946535509b6da609454b8d167040c2545ac3a21f88d9daa","tests/ui/parse-fail/use-conflict3.wit.result":"fed3b72eeee230b2d7866e9eb8feca2481006ee1847ca52df1c535ca34314f97","tests/ui/parse-fail/use-cycle1.wit":"221c299f701cb74b83aca20e869d2c0aefb813fe24cabdc2e911a2c957eb7852","tests/ui/parse-fail/use-cycle1.wit.result":"33d47e1ea89d5fb0bae32e036c98b3d5399196207207c208f195bf509c186ffb","tests/ui/parse-fail/use-cycle4.wit":"e2be0e1404e32463030ca188fbc73e33b0742890b15dcfb49d958aefebd2c3f4","tests/ui/parse-fail/use-cycle4.wit.result":"382267390c78b50f7f88145e5d14535d2cf63bc666770e6bd059fa7354340671","tests/ui/parse-fail/use-shadow1.wit":"0aaecccbbb79cf9472ba313e2d46c05bf3880c45f653fae7b0c78f4b22a295df","tests/ui/parse-fail/use-shadow1.wit.result":"a773e07251372341385395796eadb1fed6c9874ad24da54695556189162a18cf","tests/ui/parse-fail/use-world.wit.result":"15bed7cfaa1a4f59221761ddf8aa7eac1663e17c24951cff8f6d4e18d90954a5","tests/ui/parse-fail/use-world/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/use-world/deps/bar/baz.wit":"a3bdbdbec31db5c6ae2d898c5d82e1513e39bec7d887b199e648595ed7845102","tests/ui/parse-fail/use-world/root.wit":"8acc2f7d198aac787e288e81bdfb1a088014f4a4d1afac464e2cf3f42845d6bd","tests/ui/parse-fail/very-nested-packages.wit":"634d9ea887eb80da7207f942d5ddc53fe6d2b06e7098e6766e4430dc8ead7742","tests/ui/parse-fail/very-nested-packages.wit.result":"ca58759135852a95265d4d55ddde1d43098c307de3423288462932451a5b3e89","tests/ui/parse-fail/world-interface-clash.wit":"6584c79206067af3dc3647f38deb9e5bbd7ea030b7a26f267e10db0b3243bb5b","tests/ui/parse-fail/world-interface-clash.wit.result":"a75d15d2d1eee8078553abbbadacc665c08de9a2a7ab098cf6916ff6bb2b9092","tests/ui/parse-fail/world-same-fields2.wit":"99e6297c3566e8d0df7d4a953b2d816303999fe040776956a8215de6f86a4c0a","tests/ui/parse-fail/world-same-fields2.wit.result":"421bff8bef32cec8f401c7c769c41775db49f10d31497eb66dd573503d342239","tests/ui/parse-fail/world-same-fields3.wit":"179e96948f1bd9b85b3fd53ccd932e1a5828c2ff6ce20f3f69a40295c9d3142c","tests/ui/parse-fail/world-same-fields3.wit.result":"6ae7d531dd1e711f54c3f367424a834da4834f7b1d0d1f0b851b8fdb36def6aa","tests/ui/parse-fail/world-top-level-func.wit":"25198b3e596b399f6724288ec81e7cb5a2b138db575ff2854e3263e4c1d345ea","tests/ui/parse-fail/world-top-level-func.wit.result":"3842657363ed9453b394f6cce0278a6b8cd0b7fb9c4c7044060b2a5a5a6ef093","tests/ui/parse-fail/world-top-level-func2.wit":"05ac462fe2731f3b4b3e0b16cfee74457302d376d14df35f22337016ba49df43","tests/ui/parse-fail/world-top-level-func2.wit.result":"da74d6cadafbea0711f432d1a0813615d8779784337d440f56391d77ebc66ef3","tests/ui/random.wit":"a308df65c57e4848930795bc110f1b2dde102c6e9963570a404c648b2b0be33a","tests/ui/random.wit.json":"7469b9e378f13f111e78657feeb3ef9873c6bcc3099260ae4e6090bdab28d85b","tests/ui/resources-empty.wit":"a7ad4630c28f52b6ed054520613feb8b11d632fcaa80c21ef5b84343cf649659","tests/ui/resources-empty.wit.json":"088c997de81f3366ef77ae83190d6d530810eabdd7f8c7aac4e4014cad90b5e0","tests/ui/resources-multiple-returns-own.wit":"7c665e511dbd2992fb6efcb6412241d1bda0074da78d394ead1070cf6be7f187","tests/ui/resources-multiple-returns-own.wit.json":"95a404930f7eb64112f9a661dcd0f047b6eb33d12f2e1de500e196c9d5b51edf","tests/ui/resources-multiple.wit":"98724d3b6a1d0d192970d9ae149e31694bd9c3f86bfe2e89c520e1a063724921","tests/ui/resources-multiple.wit.json":"265d1bd3914243d782d5c9b0fda62d285655ab5f43196ceeb32fba791909f116","tests/ui/resources-return-own.wit":"29d9f53bd39d0c2263c7260508a1f954e59b28923994f94bda0184cf037c4210","tests/ui/resources-return-own.wit.json":"8b60ee12530bab3e0643ddc7ed4e757b57f395e397b834a53eac2958c95824c7","tests/ui/resources.wit":"3535fc8c8381779d33082f54384362c0e3ab23cfe675562333e6840682d71ebe","tests/ui/resources.wit.json":"ba8fff6d19dcb72e277c925e52646f68b0e6e0b15eff6334de9d770a6f04465f","tests/ui/resources1.wit":"9eb5d63717f20c6801c6c71f6306ae3e2c37790bfe8a89659c11cce85797d128","tests/ui/resources1.wit.json":"090fa9e402168d2a157e7abdda3d450c48b90e2cc325bcc0be30447682ace656","tests/ui/same-name-import-export.wit":"95ba4578908c29d2af14fcdd8970362c8bafb2174916c0f0772b09437e8d57a4","tests/ui/same-name-import-export.wit.json":"c3d2c9fd7a219ffe2fe094233c369916ce0fee0a2efcebfac008a45bc7c5f8dd","tests/ui/shared-types.wit":"d145c035d916f453a7eeb034bf2a59c2e24f14061d8385ab39cc1f076c9265ae","tests/ui/shared-types.wit.json":"70be131e2e80cdf62ba7a2a20418f71f7480428e2e05e1c387dc1a24667dd652","tests/ui/simple-wasm-text.wat":"10e7380158502c5ca3a1ac9d4195b0455cc02438fed0fb3f7188674354c25c2c","tests/ui/simple-wasm-text.wit.json":"0f91dec1e13fb9e0c30b4e1ad6b4335ea22fdc435ff526e3549dc19a8af97443","tests/ui/since-and-unstable.wit":"312fe8ecc9f22c083f3e59ea306731c198b4d1dd8e2bc1b3d868e90b184163a6","tests/ui/since-and-unstable.wit.json":"6147a7d1ef4dd8dcd8572ade33e7423ace0eea398586cbd75bab5be2cd361e60","tests/ui/streams-and-futures.wit":"2d4d378de4dab66aebc90d4dcfec58b3afccc646f83491801d51999fb612cbe4","tests/ui/streams-and-futures.wit.json":"3e180d6002e03e72797e45bfd4003c4dbebcfbecfded930c646cd8837054a6b1","tests/ui/stress-export-elaborate.wit":"7d62775daf1c0e35c7576abd726077e45cde2f693cc21d8cadd542e88271590c","tests/ui/stress-export-elaborate.wit.json":"6930a623e84d06da7fbd49ec1e6d10b43f3821ee191cb7ff56902597210b4c06","tests/ui/type-then-eof.wit":"79610cbf6fe3e2d13ce1fd8c06e53fee6c81d42469ef56e1dd61c46bf5f57ca3","tests/ui/type-then-eof.wit.json":"bcffeaf61ef6ae2ad4752ef83fd5057ff5eeb649d00e797138aefeaedcf39d06","tests/ui/types.wit":"1da7140aa66c3de1867313e5071f18d6814e44d90ae650be25b86dbf58214afa","tests/ui/types.wit.json":"c981cdc0a58a7e500915497eb856a32f37015ca1bfb09b453e3e0bc3fd5b3edf","tests/ui/union-fuzz-1.wit":"c4f60248204707f8dfe134bf4d6ec3385ae343abc4dfa39239798dc9f3991753","tests/ui/union-fuzz-1.wit.json":"5599236aaea5ab475ce9c224bbba3a40de45d5d5a20f75eec23b09e723d14a01","tests/ui/union-fuzz-2.wit":"5e00d73b1b562fb3cb24067fb0b8ba4edf28b6cd71d914dd6b8716f58272f266","tests/ui/union-fuzz-2.wit.json":"5593decd80a12ef08a0937b429ce3414964cadd2eb9138ebd6961a87f0eaa6c8","tests/ui/unstable-resource.wit":"304a4e8cf205f6f7afdc9af0f2756931c1e2875ab7bb70323cd6f1414fb462e8","tests/ui/unstable-resource.wit.json":"98da87f01953568427e36b6676a527cd5b9d54d3a1d5838b65772a58c6ff34cb","tests/ui/use-chain.wit":"3daee8a895e3bfb7c0bd0252f095554a85d07baed2c569c1b7fba5592a1fb675","tests/ui/use-chain.wit.json":"8098e7e6cafb3b22d117a31b1b721d5bda895fd984fa415fdd5cb4490364166f","tests/ui/use.wit":"4c920ba13211fdeeabdb53341c983f002263c464f4bae2829b0dadae3308cbe8","tests/ui/use.wit.json":"0ca15c4eb705f51f0b499f78ce40a45e243f6af040878f9be9697589fb62b99c","tests/ui/version-syntax.wit":"18e83b2246c0271bc3da0bfe004e69ee7699fcfcb6a986ec970dfaab7ec315bb","tests/ui/version-syntax.wit.json":"1722a38926d815646f64ab37ab3181d3cb70d937665a416112bcb7ac50ce31b1","tests/ui/versions.wit.json":"6a2b4f5d9b1cea003a2c3d25cb91116249c02ff307a04109e554457cca2f139e","tests/ui/versions/deps/a1/foo.wit":"407bd32b2274c8b5c0cac5582097d797e1455926c069496a6d5964ebc571b291","tests/ui/versions/deps/a2/foo.wit":"b32843bb65739073b450cef6fd528b2a72bc7fe92fa0953883663a1bf7ced1c4","tests/ui/versions/foo.wit":"4da61a67927a401e08adecd5c1f0d7eb7894982d3beb356184149da458a9f553","tests/ui/wasi.wit":"7227877525a5b0e2fc9ebd6e312d29d110e398126e4706a7fdb07e2d3fa05ff6","tests/ui/wasi.wit.json":"96631c1e2b029e2e15cbc51d2649a8be20e53c0666e8a9a3debed7fffa95bbe4","tests/ui/with-resource-as.wit":"bfc965bbeee53ff610639bef7f6e70057771812395f4328b7025dc6005a5d334","tests/ui/with-resource-as.wit.json":"f230c8a309a799c31759e1e8bc69aa3692e1a8b9fc8eb167f8b5df177b5594f4","tests/ui/world-diamond.wit":"82ca9865f586a5839adee9d8d90a519aead5ead715c2607125e878286f0ce847","tests/ui/world-diamond.wit.json":"5d92d94856aeaca6f73a185c242cfeaadd7afd59a285b6c47ac8997ab5b8db72","tests/ui/world-iface-no-collide.wit":"f1bb804dc568a94c6aa467c8d720a26c4a47a00f3374f4fe045502686eea3d7b","tests/ui/world-iface-no-collide.wit.json":"9c26c5fc05be082e85d37cf928f0bf45750f020a6c1176c92ce8dcdd56cb1d2e","tests/ui/world-implicit-import1.wit":"59515a6a268a6329bcf4e0a6e74b8ed1f77a61638ba8fad5fae935eb0ab59a50","tests/ui/world-implicit-import1.wit.json":"ae22442a9da3bee72efca9bc3adb49df3af510aadf3eda999d6d7b0a21f65a8b","tests/ui/world-implicit-import2.wit":"14bb046b3bf18a2b02ab47ed8be2947f3f911ded88dd2410225ac08e02df8ede","tests/ui/world-implicit-import2.wit.json":"c8a5023cd0159301ac3b415a00a0c349149606f349a7447778f2478f3292182f","tests/ui/world-implicit-import3.wit":"0faf9a3afa61ffab3d3d5e2f869d35d92a39406d65b228865f4871035b93f2d7","tests/ui/world-implicit-import3.wit.json":"488978218df83a17c18274591777d89b8ad18f6958692e50d87483d0d2cd3f5f","tests/ui/world-same-fields4.wit":"8686e463450b6880f1572b0fcb9ac78dfa78c1bf7c1124e255aa79959a49ef7e","tests/ui/world-same-fields4.wit.json":"831f2370d2c565a9f5b9bce32cd05769cb8b1034967051e57d883055157a95c3","tests/ui/world-top-level-funcs.wit":"1ef7498d5c9cae3e8da77bf4af98b2fec439f56387d130b54109b0f16d156d0d","tests/ui/world-top-level-funcs.wit.json":"f3b894996007ca6c370a3f383947ad16c920446a8ea84a32b2082750616d6117","tests/ui/world-top-level-resources.wit":"61267d096998b68bfd72845854f6a2d5391d68f6a0094887fc05cf97cb54410e","tests/ui/world-top-level-resources.wit.json":"35e2342c86841c2b861b5547c6d0cde83bf6ac7af35f7e09af99b209887d19e1","tests/ui/worlds-union-dedup.wit":"1f9ac2813774c0fe1676734bd6e1779f4870091d0d6a8aa061643e865528be10","tests/ui/worlds-union-dedup.wit.json":"254ef09ce95718b658d109cacda832c7dfdc5b7e0420ce1da8fe56589e400dfd","tests/ui/worlds-with-types.wit":"a2e6d00eafed8d6c6278dc9cddbc2ab2542f836869f564cf449625fddc9476e8","tests/ui/worlds-with-types.wit.json":"6d3afdfc4192bc6b6cf8b3507a942d5e63dc5adae26fafed62d5ced0889f6f69"},"package":"ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"e701d7ace82ec8996103713a5ba11137b8188a7084ce2200d5250f7180c21c4a","Cargo.lock":"4d9db2a27e3e642d9ab03ecc1927e06ae2b88fa5900fb424a990bce136e86ed1","Cargo.toml":"d7bcbbfa75bb0ee12fb76a45b75af7f4f92af9c3ed6046866a2315efb65773fe","Cargo.toml.orig":"57732a62b5239a8d7bc42c142b2dd6b332850cf91d9e039203a3272d7a41bdc9","README.md":"fb3e25cd96468cb3ca6b40dfa684504b316ea5b261f14109eb229c4f82442ef1","src/abi.rs":"3b441a5d5ffc5bca83e5c5fcdf808da6d0bf8cbf31b159013b3e063c35489554","src/ast.rs":"834c8c865f35002e2346549903e3f64563e9aed2530f0eda3e1ee4f8e9a35031","src/ast/lex.rs":"6ccd888e92b36d4404142f55e494d1388f06ef0c6875de5d79f2f300f6ee6a27","src/ast/resolve.rs":"4b3bd0a7ed7340b341e90556ee27a9e5b230be481fc68b6347e4e4f75840c15e","src/ast/toposort.rs":"a71e3fe53836645b71b1eb8152314418bfe7ddaa19e1dba259b1534f55711739","src/decoding.rs":"472d64a3688d2910689f51db6e9da1c39796b0af9e33f17b6b39c9a8ca4d2c12","src/lib.rs":"a5fc6f547d5b65696892622604085974bec2cf47fa95aa49afd242a14d447375","src/live.rs":"12d789a63367f4a9b3581a475e854b36ca0592c95cb5f0404dab11bd9ef92232","src/metadata.rs":"fb580e48681dd88c66b7bb915d90383cb4f1a99df8d2a6654aa97a95d1f5435d","src/resolve.rs":"dee35ee2a393239f8089cf7a2fa8c237a9091b29834750b607d34e55b7aedb32","src/resolve/clone.rs":"9c30b89ecdd03f5269590bc628ffdc698f555c7f3627e4d6ec988b939153ae9c","src/serde_.rs":"619855c4049e83b9dfeac2fdc373e72c7b7eab66e39a06ff643b319b2e442de1","src/sizealign.rs":"8d690ade0227f358682b908abb4309060959cc71e29d3deab8d4563e4c47ee17","tests/.gitignore":"56290c87f8681b45f1bc1842ae3943204a6d40e03915268c99359c59c5a5cb5d","tests/all.rs":"6545772c9541c29c66c24b316b1c9e2e01f3fda7ae2e5e6e30dd8f3b6a111ffc","tests/ui/async.wit":"e02dcde5e58db33f6a4cba9ef56d2e23f25ff66becd438bea4a3e44a3b708982","tests/ui/async.wit.json":"ada678ed4ef39e8a15a653da9f327327702e00c84aaec49cb6ae2293bc072430","tests/ui/comments.wit":"475f3c841e96ff3d5b845c889382eb65501ed5937e1cafde2fb1cca22eb6af76","tests/ui/comments.wit.json":"8f1b6361031a0d6d462f64e0a0e5d982e758459388b38cd91d2e20d4c40c95da","tests/ui/complex-include.wit.json":"3fe8649db3e11c4fd377534af39930670e7f56ddac550edf30b38d9b796b71ad","tests/ui/complex-include/deps/bar/root.wit":"847bfc51da81c575d28a11c87ba4d1a4c7af4ef4797bff569df1ba7180186cfa","tests/ui/complex-include/deps/baz/root.wit":"f698fdb5d167e91c5c200b72d590ca6efc47b252340ea686a6a6c5b68b32850b","tests/ui/complex-include/root.wit":"1ccb363347433a31d1e72408a7e2581ad428a602dd77c19d2c38a4bdb3011cad","tests/ui/cross-package-resource.wit.json":"88cd432a64f97b22ce3ce0d947236b7c6dab05710746e99117f7d78dfcd73107","tests/ui/cross-package-resource/deps/foo/foo.wit":"a17fa1d030e1e136d0a78e72f1236f945676bf95a6ac269f1c8279fc5891c7d0","tests/ui/cross-package-resource/foo.wit":"92a38c0eef30ffdb5a314889e127532289afc03d5c6a66d38fc6763869285a80","tests/ui/diamond1.wit.json":"65ca1157767b651d093ff7e0578adc71f384f0eb10f6c5f0df7d9d6c7a65a714","tests/ui/diamond1/deps/dep1/types.wit":"0e88c7dea0e75ee462e9580bcab9f95cea6d47ce465b8e3686c579c871fac70a","tests/ui/diamond1/deps/dep2/types.wit":"a0550fd230ae08e270008582a58e369dfa2959d64e35b47b3267c5e66d5dfd9d","tests/ui/diamond1/join.wit":"9dbe89b4a1db3f48c7fddc35bb0f5624d5a7993b9045110e273483eada067037","tests/ui/disambiguate-diamond.wit.json":"e67b1ef121406dafe3e700c7b26542b089b836a5b8b4c0f88e85b59001297d8d","tests/ui/disambiguate-diamond/shared1.wit":"29c7b86eb0b325007093ddc5cd6bac442f2770222552c2578b3df92b27141ffc","tests/ui/disambiguate-diamond/shared2.wit":"9cb9d0ccffc9d0400da97af00f0c6ca65c0b71bf7eba152ce4c17a94befa04f0","tests/ui/disambiguate-diamond/world.wit":"dc44c49f1f8a1831e183efab5705a9b24d1e03d57b24c59d70eb404ed5783ab7","tests/ui/empty.wit":"180aebeccf365462475063f210fc0e2fffd16d415b40c710112daa478fc05d2c","tests/ui/empty.wit.json":"f6e88371fc423cf186127ced701cef2e6a2d1408554be53bea33fc96b50c660a","tests/ui/error-context.wit":"bc6f8bf716ccd78f58d35ce867b3c516b7b9a00129a8e42a3b4284070081ec12","tests/ui/error-context.wit.json":"62d25fc35388148abf493577414247b90d3285c2f1f6a0d5b97f314afdbc4de7","tests/ui/feature-gates.wit":"6421b98446ab4de927677a37455163faafb8ccbe039c9dec9ea3edf601f62c3e","tests/ui/feature-gates.wit.json":"815eae0d8923390b821fdddbe1ba1492b9fc058a8f36f43c4645a84fc775b542","tests/ui/feature-types.wit":"42907c1e0228a5f5046cc977c0cf9fed6bdd2c7aa3df78ff8ed77fb4db9e96e1","tests/ui/feature-types.wit.json":"c44485247c77e2025c24b01acdb5b3b560fa2d6fc18deeac0242ad0ca1ab5797","tests/ui/foreign-deps-union.wit.json":"5d1400e9c28a3180dc934857151408b4d1bc0819b3d76b40690531834c40b608","tests/ui/foreign-deps-union/deps/another-pkg/other-doc.wit":"c9423fbe1a1122a74d7bade1ba92f768e402a815ebb6b904b8a10ad45fd1c98f","tests/ui/foreign-deps-union/deps/corp/saas.wit":"386928373ef82518259896404073bbc78efd0682c87e84db7946ee2cae9a6a25","tests/ui/foreign-deps-union/deps/different-pkg/the-doc.wit":"f13b9d7a0bb19e2d01b6376d4d24f62a5f1fd0383b28425c1aad8b2d3edba20a","tests/ui/foreign-deps-union/deps/foreign-pkg/the-doc.wit":"beb4afb21df52eeaa553260af4eec19caa91f17125943e220c53f38f53e815a7","tests/ui/foreign-deps-union/deps/some-pkg/some-doc.wit":"999d52ebb0be65f4bc181e98a396579fe58e084c11eeafb354bea9469c1a9119","tests/ui/foreign-deps-union/deps/wasi/clocks.wit":"105e3f217725547b1d4097003d4d4793f7b8b5233f10126078d3b78e6f73373f","tests/ui/foreign-deps-union/deps/wasi/filesystem.wit":"f3591626529a6ca7ede789909090cb6d59377f0374d7a474e94f47fab80bdd2b","tests/ui/foreign-deps-union/deps/wasi/wasi.wit":"992be12ee11207ddefc2ac531016a9e9519af214341af718972fb653924ce231","tests/ui/foreign-deps-union/root.wit":"4856bf403caea6403cd98b73c44a6277c9af52b7e3c16c756f6cc0e4711e3c3f","tests/ui/foreign-deps.wit.json":"e894a9c94e877c2f92592aaf5e51d71541d7c1d36dcf8d6db27d435ffc0126c2","tests/ui/foreign-deps/deps/another-pkg/other-doc.wit":"c9423fbe1a1122a74d7bade1ba92f768e402a815ebb6b904b8a10ad45fd1c98f","tests/ui/foreign-deps/deps/corp/saas.wit":"386928373ef82518259896404073bbc78efd0682c87e84db7946ee2cae9a6a25","tests/ui/foreign-deps/deps/different-pkg/the-doc.wit":"f13b9d7a0bb19e2d01b6376d4d24f62a5f1fd0383b28425c1aad8b2d3edba20a","tests/ui/foreign-deps/deps/foreign-pkg/the-doc.wit":"beb4afb21df52eeaa553260af4eec19caa91f17125943e220c53f38f53e815a7","tests/ui/foreign-deps/deps/some-pkg/some-doc.wit":"999d52ebb0be65f4bc181e98a396579fe58e084c11eeafb354bea9469c1a9119","tests/ui/foreign-deps/deps/wasi/clocks.wit":"105e3f217725547b1d4097003d4d4793f7b8b5233f10126078d3b78e6f73373f","tests/ui/foreign-deps/deps/wasi/filesystem.wit":"f3591626529a6ca7ede789909090cb6d59377f0374d7a474e94f47fab80bdd2b","tests/ui/foreign-deps/root.wit":"532f52d31c706b5ce3dea9869b0aa8fa0c0353309ab2fa9752d29a2aecd7aef0","tests/ui/foreign-interface-dep-gated.wit":"a4e2e64a17b2d145897ddf3280a47df60c80101124c13323bc25485a9cd9057b","tests/ui/foreign-interface-dep-gated.wit.json":"bc2ef7bf9cdbc2ca1ba1c446a2d57714d65faa155b8f126816ed8c8370bb39e6","tests/ui/foreign-world-dep-gated.wit":"b1f4c36d604270c079a645242690e60083bc39ad9d9a507cef89243fd848f579","tests/ui/foreign-world-dep-gated.wit.json":"bc2ef7bf9cdbc2ca1ba1c446a2d57714d65faa155b8f126816ed8c8370bb39e6","tests/ui/functions.wit":"909502792a27bcd571e1e4344fb6f0d03412d44a4afa1468f67896cc9ff479a6","tests/ui/functions.wit.json":"4e374a1fb01d7537a76c781e42bf59435babdbd3c3d3f323f886652707688fe6","tests/ui/gated-include.wit":"292d684e8413242ab91efded4e21ad779f3d11c4c48cf42ec2f37a17ce881f2d","tests/ui/gated-include.wit.json":"12139e81b9b0aee7f1f2a8263ec2ce05d8b3b9cf273e53337b67dcc36ee26e63","tests/ui/gated-use.wit":"792fbc77feeed4544311df936c0068335658d3b28b62880ee0f2c4b9027123bc","tests/ui/gated-use.wit.json":"da18c6d1e6902846e17f42c4b3c21c0bbdb4127f0d7ab965e5051ff847fbe9a5","tests/ui/ignore-files-deps.wit.json":"0a65f0ec2fc58a7429f6ef6d45276726e0900c989628bb3c390219db906d6f01","tests/ui/ignore-files-deps/deps/bar/types.wit":"3f6c58f614a5eb6e92dad08c37faf9a7a0ee3ca6bf0fccfa286b94d768375a60","tests/ui/ignore-files-deps/deps/ignore-me.txt":"4636723dbfd9d2967060094fb248e8121fe1620ec8e0e5ea505e66cf1e2781c2","tests/ui/ignore-files-deps/world.wit":"1e3baa2b60d49e5607534fa3d3069e1e2fe6d5084c8c83ca7e5135927ea9f53f","tests/ui/import-export-overlap1.wit":"1228074dc8caf72beecb3c6281e183769b8367d7162832cb9d0647d314a9b2ac","tests/ui/import-export-overlap1.wit.json":"67d8028378a4dc9365242b2b7f1f8bfea1bfec71a2c5df22ce87a62c3d75122a","tests/ui/import-export-overlap2.wit":"23f35f40aaf4b13e2745d201394add251746d523eb553b246f801715d9d79705","tests/ui/import-export-overlap2.wit.json":"087e6e1dd2d2901ed0c4ba31b61d6032859754ecd0abefb947fb2be314ffc9f3","tests/ui/include-reps.wit":"18b45384f26dd1660e721f00fa25bb45fcae247f91925b37b68b96c95d5a1983","tests/ui/include-reps.wit.json":"7fc06783fa6eefc29be483732ff0a07c2cdaee4028640d1c8d194e9d3d2fdf2c","tests/ui/kebab-name-include-with.wit":"e3018a921e3767a5f546713d8dd56801667d69b18353eff2f057b2e10c820273","tests/ui/kebab-name-include-with.wit.json":"eb626e1a2584eb5402ef71241fdc9be07f15a2502fd46dc45c2a03e1252358ab","tests/ui/kinds-of-deps.wit.json":"1b1ca68b2442b696d5afe8bc64094dd101ffe60729b67e9fd0d01fc873357c7c","tests/ui/kinds-of-deps/a.wit":"55532d4e836d80efd73ebda0d942adead4d6caec33076fe54a30edfc337a7703","tests/ui/kinds-of-deps/deps/b/root.wit":"10e833b051706c4882d451f7f66c7152880b5a4e60d75233a4709177cd45ddfb","tests/ui/kinds-of-deps/deps/c.wit":"4d6a716fabf7fe56efdd3de95afc2f520efa6592b10921d8b177b3640ff90d94","tests/ui/kinds-of-deps/deps/d.wat":"91deb49abbe77e312305d6e14ca746ebeeeed99207f099df49e26956add260ed","tests/ui/kinds-of-deps/deps/e.wasm":"33fc738466bf4d6e8dde7ff530a23831e3a42519d30e6f5d63269c292cd7255f","tests/ui/many-names.wit.json":"a15ab09ba624a77d24173f4e3cd2c7044e406e72eb128afa41933964e455bac7","tests/ui/many-names/a.wit":"9381b4e20f448e02d7cb27fe5db24c3f5f37e9ec1425561172edffc6c79f0a93","tests/ui/many-names/b.wit":"e5a20aa53d8673e38465e74f739a5c8cc4789da211fa43490222433c6131e43d","tests/ui/maps.wit":"245328c5953648a8068d0cd1b84cdd342590fd7ea066d650f40dfd7e5fd381a7","tests/ui/maps.wit.json":"6cd99c802177790f07f6708469b0db44f1e7478afdfa963dade9ccc96a1d489d","tests/ui/multi-file-multi-package.wit.json":"5fdfa45865f31de3c648614277721d86539c3e4c34d0c1ab0ff6ef79ddb3d1f2","tests/ui/multi-file-multi-package/a.wit":"4a996c8b1920aeb34f441d44131b3a7870f9769da5579bcbfd4b608e4a675fb5","tests/ui/multi-file-multi-package/b.wit":"b3f940591bd7adbcd1f61cc1606149c4019666efaf8dc76344bf8df89d138e90","tests/ui/multi-file.wit.json":"c64b219ea422ef8d73648ac2485079a7e1a9002ce5e35e2d67b8fe20590a0dc4","tests/ui/multi-file/bar.wit":"5e8d03741204f1e40e7a0f5bd2c043f31a3356c8de296762e2ddb38cfa89cfb4","tests/ui/multi-file/cycle-a.wit":"90612ed5fa9d552068c9c32a0b179355dc92d475c2d1b6521fec494bd9434738","tests/ui/multi-file/cycle-b.wit":"eecc7ed7ce638740ff1cf9fe20914f03b8c3920ddd247c2d80902914c7a4f8c7","tests/ui/multi-file/foo.wit":"ce81ee2316a34b064e2a37e01fa94ac982a663b1c3fc5be55b4723b6643b2970","tests/ui/multi-package-deps.wit.json":"f5d632858f6d4fc02a7c0713daa3555ffb88eed4d8a424dbcac9516291eb07a8","tests/ui/multi-package-deps/deps/dep.wit":"9d66626b787cd5d12b74354bf47e8d5b7e811f208cc512a4b985304ab7856dde","tests/ui/multi-package-deps/root.wit":"62338e53a74a0ca51e6fe81b8fe001a2fda456e64d1779e398525fbec8f236aa","tests/ui/multi-package-gated-include.wit":"109631bf21f46c17c146927e70579661934c28b0e42484378ccb07f65ffc084a","tests/ui/multi-package-gated-include.wit.json":"b5b5c7c2ce63ac25223a5d01ae42f69e6cbb326fb54073d3f58a1b4c904deffa","tests/ui/multi-package-shared-deps.wit.json":"a5a0cdd60e4b8ae10f5b9feff728faef8a81224880af5cc06f73b30757c733c1","tests/ui/multi-package-shared-deps/deps/dep1/types.wit":"b9cbbfcc38f90cd09b1ba9c9b474db0f858f596c054dda59d0de35fbabb26fa9","tests/ui/multi-package-shared-deps/deps/dep2/types.wit":"4f3bd8ecb0e14c6ff670192145dc4b24e20648176634338f7d9aa93ff5863db3","tests/ui/multi-package-shared-deps/packages.wit":"fb9a1bee65922b9d6372e07717899521a129919a23d6700f49b9f953f32df581","tests/ui/multi-package-transitive-deps.wit.json":"466bebe32e6a390148f4b6c9697148f87bacf65454a4825b8c48e565b217d4fa","tests/ui/multi-package-transitive-deps/deps/dep1/types.wit":"58a8ed5ed904dc9d04b7d0f84c400beeb262b79dd63258e66473ce4f36420b4e","tests/ui/multi-package-transitive-deps/deps/dep2/types.wit":"c2b7e5747fba9fbd25ce19b2a8b4fe7fc96831138f68c96e4af4ccc424cb1efe","tests/ui/multi-package-transitive-deps/packages.wit":"d5adbb7f4c6a9f182ee42155475aba911ddc21aea0ef619dfd68f7d4c7ff006c","tests/ui/name-both-resource-and-type.wit.json":"2345a2b52803a70dc14c3a97c5574b49ff23451c10a4036ed2bf6d682fadfb1f","tests/ui/name-both-resource-and-type/deps/dep/foo.wit":"1ff8e2a03e86e0676ed0459b6400b1f92957ce9e88424c91ef20dc2ce98414e3","tests/ui/name-both-resource-and-type/foo.wit":"b8338da8c7e942580d0654de494d68977f459f9e0fef2ffffc164380ea3293b9","tests/ui/package-syntax1.wit":"090709e7f0f85fb60f6a104c7b0ec325d11fc58fcc69a6c20b02f454a0636eee","tests/ui/package-syntax1.wit.json":"dcf5bf4334dc9ca156dc0a9a62d3dccf27ea1ebbe9525ab0b1b992599513fdb2","tests/ui/package-syntax3.wit":"ccadb54a828f5e200f6f2ca40d3e5bfca9431ab59b375e7dfde91a149b34fa7b","tests/ui/package-syntax3.wit.json":"e517e1ddee9cc8e123729f3e36cb85fba4328828421415150c99f6dc851c9e00","tests/ui/package-syntax4.wit":"516e3e21f7768a4ee479c0b52b68d3947b6983d0a0c04bba6044c05d784a2f41","tests/ui/package-syntax4.wit.json":"b7b65aeb4a33616707bbffc952e8b94b4d3f32e98a2cd3bcc2bf219db4a41850","tests/ui/packages-multiple-nested.wit":"feedd1dc072442d0183ff04562e5107c3081612e60939c1475a25dcb09c0d448","tests/ui/packages-multiple-nested.wit.json":"7ea283985310c900b7009e6c0c6f68be3d370cf71c831e68d5238dc1bb7ff637","tests/ui/packages-nested-colliding-decl-names.wit":"0875563840447d685523542c20262fb6b181bd0c77f56d4460a56211ce79fcac","tests/ui/packages-nested-colliding-decl-names.wit.json":"eab533e2b31ad4c86dc49ba98ae03e7f74730b01ff97296039b315517c4999e8","tests/ui/packages-nested-internal-references.wit":"8d60a92f19097442d2c17de549d41ca48b1d58025714ec9886153d636747ec30","tests/ui/packages-nested-internal-references.wit.json":"e2537174d20e50c7ce041dca4f1e4ac7a9c08ae16779141f6e9bc16db3b17c62","tests/ui/packages-nested-with-semver.wit":"bded1bf70c7d27493eb53571cecace850bf7e05b559f72b010d431c4a812900e","tests/ui/packages-nested-with-semver.wit.json":"d88a57595b4b70e3365dc3dfe8a387900d68663942b2a27c79b3c56403e314e9","tests/ui/packages-single-nested.wit":"b3c438ef0c0f467ec0dd15202d8b48636860921ce1c313968bbd0fdf4451c746","tests/ui/packages-single-nested.wit.json":"5341b377d4eae34b6acd116ca4d60ccc40aeac5da79d0b47d9c7fdb4cf94ad36","tests/ui/parse-fail/alias-no-type.wit":"6d717f638138d6536c634773058484f26bf1696630ccee86cbd98f20ef000185","tests/ui/parse-fail/alias-no-type.wit.result":"149e701639f259bc16082e7fd84542ac20a11480b8ebe6909788c78f42c9e6a6","tests/ui/parse-fail/async-bad-world.wit":"a5f91bfd0e6eb3d67392ba0be97fa037d73b6193f8014df64313d08e8d8dd233","tests/ui/parse-fail/async-bad-world.wit.result":"c326e18dd5737be4718a428cedbcc2dd177a3603fd91ba3b1bee8578bc65f3b0","tests/ui/parse-fail/async-bad-world2.wit":"110a4409ee12bbf9f1ba2e8264a694220ddc52cf6d236940cd6989d8a907b925","tests/ui/parse-fail/async-bad-world2.wit.result":"8fe7d414eb32a321b3e9b48b3f3ac269a9fa9f186e8cad87fe0fc6f1fd058e02","tests/ui/parse-fail/async-bad-world3.wit":"6f30f04652ab9a126f264540db6b63172e959fc1a189fcd0381605a7f4f103a4","tests/ui/parse-fail/async-bad-world3.wit.result":"ac9b153a9eb50546f14c22b737e45176a1dfdd70514fd53b3c0d277b529b1b00","tests/ui/parse-fail/async-bad-world4.wit":"d607651508ad944f22338e86b9226dfa58b83e7796e4c6af1c5fb65683640997","tests/ui/parse-fail/async-bad-world4.wit.result":"e320b3b7d91e7defab11693f6d316bf6b0d6ed5d7ba58d81cae79e5fa900305c","tests/ui/parse-fail/async-bad1.wit":"8c11bac371904041a93d4f04489e1f0fc2e731a1950a1f4a69d1d6a56fadcdea","tests/ui/parse-fail/async-bad1.wit.result":"55b81beea66b26a65c87e2c779f6b80f9fbc6a53a5f53c325e4bd9e5fb9e8a44","tests/ui/parse-fail/async-bad2.wit":"b779614996ac1c6ce2d5d3867e4c8772c66b093e5274807a83d0bb385b09a0d5","tests/ui/parse-fail/async-bad2.wit.result":"d20e721a50d13841ecc069795026e8ded6cd22735a4007a1748e2e3bf231042c","tests/ui/parse-fail/async.wit.result":"67ccac26d7fe73e8410404092b30398a778aa5bc2b460409c9de50d83f721c33","tests/ui/parse-fail/async1.wit.result":"3a04ed56850e4e60e05f72bd1a7d7646fa14bfa81b049e2d8d6a9dfd4837b3ad","tests/ui/parse-fail/bad-deprecated1.wit":"d792904a2c146aa5f247c23fd420e85565431b6f7975616de32bf78cabb78582","tests/ui/parse-fail/bad-deprecated1.wit.result":"0fa750df748b21c74a9ba10a318c21dd6fdd2f25497abbbda4fb36c2a25b82c3","tests/ui/parse-fail/bad-deprecated2.wit":"d333c32a598d23e0decad6f1f5d9278296bfca1320aca4e12291bc113d6e567c","tests/ui/parse-fail/bad-deprecated2.wit.result":"b808b7fe316cccbb96718b7f1f73ea0746af074d0305b6bd47f762e70732ba6c","tests/ui/parse-fail/bad-deprecated3.wit":"f72813a037e8718a7315fee317a080dbe73f3e44df0bc42408c0b9ccab1041f1","tests/ui/parse-fail/bad-deprecated3.wit.result":"e96dcb21216a1a2ae5e0ff3d063ba88dfbb610f5ae09b51853fe69ebdc44f96e","tests/ui/parse-fail/bad-deprecated4.wit":"96ad0d172b69432598acd101e2de83a6b36ef6c6980075d994d3961becc7ffe8","tests/ui/parse-fail/bad-deprecated4.wit.result":"443b255aed5611c14cf1751cd4da2dcde6d875c93599a5ae1bf999e913eb5a4c","tests/ui/parse-fail/bad-function.wit":"ebdaa7b0c3fb7713bd869b510c222e10e0fbe6b5e3c93b3ba8f077b59a9cdee2","tests/ui/parse-fail/bad-function.wit.result":"3480be5e024671f00c1a1d49b0b394dbe145b58d8100f89dff0912d7c39545d1","tests/ui/parse-fail/bad-function2.wit":"e501d5d676b0647999c3e508c4a494ba652cbd16c275be17583ae5fa02bf5e7f","tests/ui/parse-fail/bad-function2.wit.result":"a1c0b324816fd854dd85e9b2f29f9d3e09ad6a7f670244851032a734c96ed67e","tests/ui/parse-fail/bad-gate1.wit":"d427d68abe2e93f488569af3fecd08d5c6bb984ec461fac4f184a2b977d903a5","tests/ui/parse-fail/bad-gate1.wit.result":"21393b47dc8d07dd405941a137f55d94e6598efd449404aa3c42b57a3665b147","tests/ui/parse-fail/bad-gate2.wit":"dd536d413c6b7a0a59a15d39fdd1a52d7a4810d3900c59f8132fbf14d32da3e4","tests/ui/parse-fail/bad-gate2.wit.result":"ba82c990dbd4fa001d4ecfa46bd8730ccfc49a6c873265b0b81cc8454c9a58ab","tests/ui/parse-fail/bad-gate3.wit":"5e0d76a3029a0520b121f2ec6823ca39c3d3adfc57556c849898f69240f83a44","tests/ui/parse-fail/bad-gate3.wit.result":"b70ac740092d59b2d1e56c00e20c5bcaa9843f7a3072cd9f3c0a769818c15b78","tests/ui/parse-fail/bad-gate4.wit":"f5fbb50ad5087d0bb5401d290f05e733ee425bbffc514db3a2ed4d0a0dd366db","tests/ui/parse-fail/bad-gate4.wit.result":"8cc9f8a27b97f5861bacea7462002f3d351ea2038f54632d245385b0e9b95b68","tests/ui/parse-fail/bad-gate5.wit":"52b068c1f00f38174f53927cd7729b78648be636e2a7e2544397a8ea9ea8569e","tests/ui/parse-fail/bad-gate5.wit.result":"5fd577243fad4e78350484c79126566649b25a3744ede72e522baa138dca5034","tests/ui/parse-fail/bad-include1.wit":"05ec00177052bacfe2eef6ee2631abfd373a822d100f8d38d7178845cf3d2908","tests/ui/parse-fail/bad-include1.wit.result":"454bef60e7a0eb813b80b9e31187cef96bdbb389389b4238cc1ed45788eaa351","tests/ui/parse-fail/bad-include2.wit":"32d2bfa14dd78c78aecd93b31b28ba7013701411abd8d67e8c5277f1b8efd1a9","tests/ui/parse-fail/bad-include2.wit.result":"70e86e41d76100601131e14ce54df803ea699f4f7941a84e4a56ccd6c2f28d2b","tests/ui/parse-fail/bad-include3.wit":"44995ec365758dc52f7dc6824587df97777dd874f5d010c62222881a5b3ed929","tests/ui/parse-fail/bad-include3.wit.result":"fbe950700e42783b2126d0dddeb08a2fef837b76de2aa62e8f70c62fda7359f0","tests/ui/parse-fail/bad-list.wit":"20255af34f429589b311fd29367e4f7679eb8f1667538522b048ec5d9e5886e0","tests/ui/parse-fail/bad-list.wit.result":"b8323d11bf88203feee59ae6cb0f67a017ee75183e635269cec9a37b4518e38c","tests/ui/parse-fail/bad-list2.wit":"8325a40a06f2c29c0f106e39652b2519ff40a11f0829da3d32e2c91fd05dee81","tests/ui/parse-fail/bad-list2.wit.result":"7dd98a2e45abaa0fc1c97133df251aa57f855c112f46cd99f2c948e9a425b8c8","tests/ui/parse-fail/bad-list3.wit":"070c1d4580008679e693d5748069c67738620f36958bd71533aaa0813516edd1","tests/ui/parse-fail/bad-list3.wit.result":"460b21d80f73f1d518ae7723c436092bcae56d036c84cc6aee9c6cb616e4e3d3","tests/ui/parse-fail/bad-list4.wit":"474d295829f1303800b0e52ad5e9ff1f997c8f6db5a33028cc0a8502310e310d","tests/ui/parse-fail/bad-list4.wit.result":"74df59ff1e7058f1be49457c7eb8b77dcdf5fa06c007b6e5e7167990fad30b0b","tests/ui/parse-fail/bad-pkg1.wit.result":"8a63ad8c4e708640df5a2a7a064bc26d4ed64a3338215c5cae52518dc0a0f3a7","tests/ui/parse-fail/bad-pkg1/root.wit":"45df62dc512d8f9ead7982c32ea95318253fc243db73cf3b25aaefbe05778c4d","tests/ui/parse-fail/bad-pkg2.wit.result":"9423d8216ca764758513f53bef83fa053e49835f0bdb5b8bb77136b1d391a50f","tests/ui/parse-fail/bad-pkg2/deps/bar/empty.wit":"ccadb54a828f5e200f6f2ca40d3e5bfca9431ab59b375e7dfde91a149b34fa7b","tests/ui/parse-fail/bad-pkg2/root.wit":"3f04dc4f6d4c4adcf178cfeccba312f75439c3bf6a14f9f4d0bbc7d83e259582","tests/ui/parse-fail/bad-pkg3.wit.result":"444c65ff4abf7fa1c37a5403461539013c139ce49dc3ba0cf098683e4870d373","tests/ui/parse-fail/bad-pkg3/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg3/deps/bar/baz.wit":"f521c75f8fea0201278adcba4457115de7eb856a3338ec03dd4df223febe7409","tests/ui/parse-fail/bad-pkg3/root.wit":"3c1725bb749c1ace117e290e0085358bc6cceb4aaf9a6fc1e29c82c5a581ad24","tests/ui/parse-fail/bad-pkg4.wit.result":"cfa526440ae834e59214dfa67f92b0a1f013b4e54d705ec56a4f5341fe9853d3","tests/ui/parse-fail/bad-pkg4/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg4/deps/bar/baz.wit":"f0d7f373a2981f747ff15f994d10abdb7c5d9dc7181daf8e4b4610f98807658d","tests/ui/parse-fail/bad-pkg4/root.wit":"2b060a7ce9da4b0cd8960a28f069f046902633fdcd5dbac2f827658ab674f5d7","tests/ui/parse-fail/bad-pkg5.wit.result":"63d5877b3bf734e1900472a219ef4f20411bdf4d6608eb582ee342a0de5ce8fd","tests/ui/parse-fail/bad-pkg5/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg5/deps/bar/baz.wit":"43ba055c268fbdd4686b141395ce8582e1cddb6699b9564b10793a603abbcd37","tests/ui/parse-fail/bad-pkg5/root.wit":"8fe9c00d8a56e994c9914997d926013e43e01f6b610b27bb3311a9c89566bfbe","tests/ui/parse-fail/bad-pkg6.wit.result":"4c3238fe2df05329d6475277d73dc1731affa5b62717904b536f0609ac9c7341","tests/ui/parse-fail/bad-pkg6/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg6/deps/bar/baz.wit":"e0417499e5a97b2a5dedf83f881eb85830bdad3a2f2724cb07bf3bcd13e4a01e","tests/ui/parse-fail/bad-pkg6/root.wit":"62abc0d5005b2bc46c039978a056e3525c165c29449bf617ca2f4afdb6ebaa98","tests/ui/parse-fail/bad-resource1.wit":"d3783f455c501334f2ae8d132490afffee5142ad1e94ceb3fb0e576299419147","tests/ui/parse-fail/bad-resource1.wit.result":"63fe0c9f4045c9d1643a328d007807f34e495ed8b25c429b65f5721147e842cf","tests/ui/parse-fail/bad-resource10.wit":"4158f1b360360ea4e4429720b34e91b9d259eada8e574733af3c83393552fd38","tests/ui/parse-fail/bad-resource10.wit.result":"f4ed54d9da0802ab22cd25f00f300f8d9bfd1a34820b610ddb37336e210cc40b","tests/ui/parse-fail/bad-resource11.wit":"24459fbe029d94febe36a6823d5992a59732bc8b5436c4bedf2c5192e2c20be2","tests/ui/parse-fail/bad-resource11.wit.result":"54cd069d5119f632d36c4167a7ea9032ac9daa3564691aefd25473d474ab32fb","tests/ui/parse-fail/bad-resource12.wit":"da12b00ae70ece5df5faf295a75b484e89ef3bd5edb07bd7b76bf7dadb04dc45","tests/ui/parse-fail/bad-resource12.wit.result":"0fbb864a5ebb00a53afb87524a534a77de5fa5122d95bf33b7f92e217326fc44","tests/ui/parse-fail/bad-resource13.wit":"e01ae82c5dc83a1f201fb9942b01f469eddd63741a12e14c4b97510cd0b74daa","tests/ui/parse-fail/bad-resource13.wit.result":"f937ab865f5cf26b0302bb94126c2482323fb31d3c4ce606cd10d5750600f8c4","tests/ui/parse-fail/bad-resource14.wit":"ed4450c13763dbe83921828ae23f8900ed88de70ca0bf989874c31e88e929cba","tests/ui/parse-fail/bad-resource14.wit.result":"ac54d2dae60e13d89f6f1532ee4629a9dff3d410be0e9bcb37025d77da8d9176","tests/ui/parse-fail/bad-resource15.wit.result":"8234ca2888cd2ca50708c41de82461bbf64997269032e9a221b6b66ebcbeaa30","tests/ui/parse-fail/bad-resource15/deps/foo/foo.wit":"19b517ce45a205776724b53a0296780751b757e80b4836a0c1230f1238ec2f69","tests/ui/parse-fail/bad-resource15/foo.wit":"92a38c0eef30ffdb5a314889e127532289afc03d5c6a66d38fc6763869285a80","tests/ui/parse-fail/bad-resource16.wit":"c1b3724b5a2d0689db57521fb35f0e8f47302fff277e5fac4e077712b8d06ed5","tests/ui/parse-fail/bad-resource16.wit.result":"6684499b5f7745fbdefd81ae2b9507125364adc3799650f1ed9acb551daad264","tests/ui/parse-fail/bad-resource17.wit":"e3da1cf497d48033f3a91d25ae2f7129de54c004c9b448e5e810ceb2304364c9","tests/ui/parse-fail/bad-resource17.wit.result":"03cf4d36938c5ab1b0656e3ee0e0c0de66707cb0791cb7fb969723d042c40dc9","tests/ui/parse-fail/bad-resource2.wit":"78f8e65877b7254aaf8f448f7f5f4e50774d797fc3eb64ca2793532ff16a62ff","tests/ui/parse-fail/bad-resource2.wit.result":"d0d968ebf8a06cda2946fd4b30595826a6db0ffa40f71ba5472884e75601313e","tests/ui/parse-fail/bad-resource3.wit":"e8620477d3cc02bc3b130d2fc14f2431fffac0cf516cbc05aff2dda37740f2fb","tests/ui/parse-fail/bad-resource3.wit.result":"b19b0a6f8ba99e738504c433afb19e7f17081db14d10dc01506ade5c31b11cb9","tests/ui/parse-fail/bad-resource4.wit":"31537bd0d09e58dee09ea9b93054c8cbb3cfd39bc4a1fa9330bd7b945bd81681","tests/ui/parse-fail/bad-resource4.wit.result":"bca647b5172c6c0bceea3de7ac2dfc7426b68e55468d081beade9b4ff2b0b0fc","tests/ui/parse-fail/bad-resource5.wit":"854fac37c2b7c8edae5276aa1c7c6cc726a348ae757c0f9cc5cd4103d75dc640","tests/ui/parse-fail/bad-resource5.wit.result":"db20186fc1b39c832acedadcaebf2d1f7f803253a2df5eb57b7fd6f66f8d7b38","tests/ui/parse-fail/bad-resource6.wit":"a5f798328cbf777cce00069a637f1dc7d79423c685ebe11a21f7f8ead1bccef4","tests/ui/parse-fail/bad-resource6.wit.result":"1955db627b4a2db9dd86d37974567454572b222bcb33e70664393b31e244a0a9","tests/ui/parse-fail/bad-resource7.wit":"7d09275525b419858d26533211b6a9d3a7b67639e8aa1fc28eabd713dfff4eb1","tests/ui/parse-fail/bad-resource7.wit.result":"c62958d5564b25268b662677cd35b24c4131d985d906c2d61a80bc61ba11267d","tests/ui/parse-fail/bad-resource8.wit":"da8489525fe75a197731293d384c151da204fbb2a278b9ab7a6c30fee45efcdb","tests/ui/parse-fail/bad-resource8.wit.result":"eb657e7afedd3fd1b849780564c5b0350888531fb19092961181d11e31659499","tests/ui/parse-fail/bad-resource9.wit":"5bdde3d51bf8f3e86752a21a31d93776a6b390e41ae9aeedaf7b829e7afd8f19","tests/ui/parse-fail/bad-resource9.wit.result":"d2e74db311d6ddb2796837e9426a58b7a02e8140d72a6a681eea6f54a8731f9d","tests/ui/parse-fail/bad-since1.wit":"8180c2632f6d75ee675528f4e9fad184ea5c9675ba09f34f61d7bca5ced38344","tests/ui/parse-fail/bad-since1.wit.result":"b6023204b3da7c1f58491609dfe5016b05bb8b8cd61b5b38114591c01b24e1f4","tests/ui/parse-fail/bad-since3.wit":"477408c0e355c1383103aecbd4bd4769df5ce251bae1ae5405183dac9a920c6d","tests/ui/parse-fail/bad-since3.wit.result":"07a4d9d40e6fb85da01062a72e6dc0e3cab81fc6a9b5223796957fff492ded90","tests/ui/parse-fail/bad-world-type1.wit":"c04002fdb48270e72f804642932b84f8a0a6acdf03d335e7b809c61b9e5efe64","tests/ui/parse-fail/bad-world-type1.wit.result":"2073c4406bba9ab314d172840c8b43f2e505bee7f823a21abb0f7c649d81a504","tests/ui/parse-fail/case-insensitive-duplicates.wit":"0517099b9586ef9a1a22e4a340e00b3f9088891e5203906ee2303e5e47cf9a49","tests/ui/parse-fail/case-insensitive-duplicates.wit.result":"6404ed765277711fe927b011daf90c20a69942ed2578458a0df285424e6d0cf8","tests/ui/parse-fail/conflicting-package.wit.result":"7577d7f04ab4ecd2401b2b546d46cf42f3951d30f8a118ab843c043194599b33","tests/ui/parse-fail/conflicting-package/a.wit":"20fd778f4594d89d4b3282ed2b4e005cd3e7a377eedbd9a05ba9b96468f53d55","tests/ui/parse-fail/conflicting-package/b.wit":"05ce70a45e9d19c833579bdd20a4fbbc98cc2f2ce737e1030e41f35cab4f0066","tests/ui/parse-fail/cycle.wit":"6940cebea92951af95a7a352f76ec8c79326005a0698e977ec362923ddbddb8e","tests/ui/parse-fail/cycle.wit.result":"09ab288a56c511e8cea5cae9b72f474a4f2cc6ad4bf2840ee10d10e45a144d0b","tests/ui/parse-fail/cycle2.wit":"5c7d28994b1fd872236a03238d9d1b757eefed741a1e540a4bc55e0c2ad0fde2","tests/ui/parse-fail/cycle2.wit.result":"eba74322800b7476a356ad73d8eb40aa5165389624c555d58616144e11b7672c","tests/ui/parse-fail/cycle3.wit":"0f4c613e93478afad6065642b60b5979a8df4ec1e13359f0c9824a218c966de6","tests/ui/parse-fail/cycle3.wit.result":"d98f5432924f5feee6f1a60ace1c0dd82b555a260502b166ab51bad0312e82ec","tests/ui/parse-fail/cycle4.wit":"74fab6b8fff3e176bc1499f3e0acc46f1746e8664a7b0307389645e7ef03b696","tests/ui/parse-fail/cycle4.wit.result":"4b4c4b912e4363eae23b6ae92cb4e499f0582d24299912aedcc0ab78b6ba0e67","tests/ui/parse-fail/cycle5.wit":"c21c064e42ec81544a0ae5cfa0081313b8023fc4cc6725b27a8307ea0acc43cb","tests/ui/parse-fail/cycle5.wit.result":"155993cd465deceded417e0eeac9c04a50adadd6a521786e3a0d3b33b352c062","tests/ui/parse-fail/dangling-type.wit":"61ab6f89a622be1f4003dd4c6841d780646b78f314c0759b77dcf6b2bb91e355","tests/ui/parse-fail/dangling-type.wit.result":"d5d60bd20198bf6fee5066f0bb1bd1a6129a7b23ee28fd623a540f6830267e13","tests/ui/parse-fail/duplicate-function-params.wit":"7c86f5515793538b821a4797f4a8456930329a0fcd054d29e1b7b1117a29d295","tests/ui/parse-fail/duplicate-function-params.wit.result":"614f85899af13a69cf98d762c61d3e607dcfb3d3ed7e4ada211ed1eb7af8a9c9","tests/ui/parse-fail/duplicate-functions.wit":"9ff1bc0093dbe55b961e8a5f4b528c145c1d975bea619b2936cd6cf839edf0e6","tests/ui/parse-fail/duplicate-functions.wit.result":"aff563662f466c0bdaaec5bb197f0aeba8b31c7e962f84a6a1a26c3944601ffc","tests/ui/parse-fail/duplicate-interface.wit":"3acb5212bebafe8eb10e0176f74ffe999b20d9cdb7ce82f09672584a043f90eb","tests/ui/parse-fail/duplicate-interface.wit.result":"8ae55ae32e250a01caca352d9ab03e4a062060095f6e728011b8677fdff86de2","tests/ui/parse-fail/duplicate-interface2.wit.result":"f4f24a6a163cbe68f74613708cdd1b409fd55c775967c0983e466c5b1542a25a","tests/ui/parse-fail/duplicate-interface2/foo.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/ui/parse-fail/duplicate-interface2/foo2.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/ui/parse-fail/duplicate-type.wit":"0d1623865f9cb358f8344fa954becf249e948ee37bb22004c1405602c2f083b4","tests/ui/parse-fail/duplicate-type.wit.result":"de1f41c3125a8ef52719b845bb685b1e735c504b3c7b63e39374f826d7315055","tests/ui/parse-fail/empty-enum.wit":"4d345214cf0ee46c4b4108fc0e9f7b8aaeb7eff82171400aaf45c1fb283e558b","tests/ui/parse-fail/empty-enum.wit.result":"6338ac28789456fe02aa133185e8c3d9896812df9377d2211da2dc0f23076c67","tests/ui/parse-fail/empty-variant1.wit":"1f56da64ab09a7f282b1785241dae5bfd8ecb4bbd055a22dcdebed33971f1522","tests/ui/parse-fail/empty-variant1.wit.result":"d67d08b7b070a59b0f803d3e118dfad4ae0cfbdc404965a5cfc5c5198fde5fa9","tests/ui/parse-fail/export-twice.wit":"a3a7cf6e7cbbe513c5561a93e32f030364c622b5123118392e9e2aa6ae44dfef","tests/ui/parse-fail/export-twice.wit.result":"01bed0e73b437ccbc213a389a512a7dafb9a336eeb38d151cdfc8e14e98f450e","tests/ui/parse-fail/import-and-export1.wit":"626f705beb7506cd30d2adea9b339199f9e6d8ac6f62f5f7778e2e2d683b0230","tests/ui/parse-fail/import-and-export1.wit.result":"330a6ed19e4c4e0e89358e599110f5d62bed823e6e5982f576a23e0b25034ee8","tests/ui/parse-fail/import-and-export2.wit":"617a1b3d8e0b227eb4fbf74101133deb537ab5723811e9cc658d8bcb942425a1","tests/ui/parse-fail/import-and-export2.wit.result":"ec0b14b07e21bb21157155e9d056e1cc303affe16fc1536aaae5c948021ce6fd","tests/ui/parse-fail/import-and-export3.wit":"adc857f5752dbf55460be01bbdd19fb54dffedeb1781ea8f842a05041ae6bab5","tests/ui/parse-fail/import-and-export3.wit.result":"9a99411b891ffe302d8070cc8ad280cfb815a17c1d0cd4b72bba3e65df20dd6a","tests/ui/parse-fail/import-and-export4.wit":"9fd002997b30219720270a8c5399bfe45d55737d9052306c992f6eec30c4aad1","tests/ui/parse-fail/import-and-export4.wit.result":"6cd95a14a1eca775006c558013ef3179e715dc913f5d6a95e23cfd3f4bf4cfd9","tests/ui/parse-fail/import-and-export5.wit":"343bf3eeb13507dc168f1478ca452cf36964f002aad051f0283ff8a95ea40747","tests/ui/parse-fail/import-and-export5.wit.result":"ac812b21785e1f0244bd8ab5b59e94b57e29c5fac5db56c2fe339c92362e324a","tests/ui/parse-fail/import-twice.wit":"ba1975d057920962bf325b034b4ca2cfa7587e2fa79ff0b2bca4a0f950e0806e","tests/ui/parse-fail/import-twice.wit.result":"cfc3f8da5f3e65c73992dd7d39f5e3ef9b9154a883183bb7f3cae7339cef7c65","tests/ui/parse-fail/include-cycle.wit":"0c51410fa39f6afa1465696c4ff97b1496c6870dc8fc5a2a2f3c2a4826c24685","tests/ui/parse-fail/include-cycle.wit.result":"95e03934ed9695bbd1856fdbf4b588a429ee41ade3447e664edadda5c8c01256","tests/ui/parse-fail/include-foreign.wit.result":"5662f77092ae988280c0c1eb1f76a81297fcd2c23823f1cfe0904584bf1a36e8","tests/ui/parse-fail/include-foreign/deps/bar/empty.wit":"348f61ad0f69954f7438ebde4cd03acf45ee8a83fe7ac53f9f52576de2fbb30c","tests/ui/parse-fail/include-foreign/root.wit":"d436297400495dd1236cbf0b6268f3663722660e140f1ae68b3ba600399adcef","tests/ui/parse-fail/include-with-id.wit":"3f50cfcbeb23cf182941e6b273136d83b57531224230f47edf4ba6dc16ce40ce","tests/ui/parse-fail/include-with-id.wit.result":"03fa45329b179073500e002fbe014ea48e564ae7a274dbcbb0bc3b5d39959c89","tests/ui/parse-fail/include-with-on-id.wit":"64dcce8aef4c9fcc30376218696070d8f6a3d0d767fd00abb8c2f6672a99cc60","tests/ui/parse-fail/include-with-on-id.wit.result":"cd893a62379128b37045d0c81364e43c8c8fdf372811183c6aa95c6d17a7ad3d","tests/ui/parse-fail/invalid-toplevel.wit":"c292a6cf02880d580b76ebcb0aafbab2bf6c6f8545299016f9a0bc55dab16624","tests/ui/parse-fail/invalid-toplevel.wit.result":"23c34234dd7ba5af3c135487c7607442c6b45b9a328973ddd1bb3bf841ec2148","tests/ui/parse-fail/invalid-type-reference.wit":"61f8a73ee71a39489ff37a41967cdfe011889c25c1623af939cce809562b1915","tests/ui/parse-fail/invalid-type-reference.wit.result":"d0169e51f599096c65186211656e9b007f01698d2004d4ddc9ae26cbc78bcb57","tests/ui/parse-fail/invalid-type-reference2.wit":"9e1b00da3e1d7d39720c41cda330c3ffa338eeb6ab2faa25ab64332108a0e06f","tests/ui/parse-fail/invalid-type-reference2.wit.result":"a9b2a4a2b69b966e3a3d2ffa4a7f94abd775a02fba877f7c7ddb9ebc76a136ab","tests/ui/parse-fail/kebab-name-include-not-found.wit":"ac48583cf9bf4716cbbf22d6356dd897bbdc657530b9e02168b920da2928bd72","tests/ui/parse-fail/kebab-name-include-not-found.wit.result":"f56ed9f900ad4371561fc149bd0429261e10bb26ee76cff57c527febc502cd25","tests/ui/parse-fail/kebab-name-include.wit":"f81884221b5f20a69015ba9f94915785f9a7fbb5eaf8a02883ddabca510b7961","tests/ui/parse-fail/kebab-name-include.wit.result":"4c48c8a2b849e53ead974720172a4de0881a426a8717a024202a2329cdf74a3f","tests/ui/parse-fail/keyword.wit":"cd46fd9b045e79e0f5f8ace13a6327ae83e26951f699b25d6e0a872fcac71010","tests/ui/parse-fail/keyword.wit.result":"ef1b6510fb56e899c6bb38592a1953d165e01c5a46bc02249c33b73f99f28740","tests/ui/parse-fail/map-invalid-key.wit":"612eba223b7882277f74826312dd61958dea73443dc95ef1f6ddd8b5f4680c91","tests/ui/parse-fail/map-invalid-key.wit.result":"51555d75fa2b8b8897be3a7136829c35513a896344992d7543986a5ec4fa021b","tests/ui/parse-fail/missing-main-declaration-initial-main.wit":"208a8e0aea83d0aaf50edb322181a1b35728ee972bc7929b63f881ab3a923cfa","tests/ui/parse-fail/missing-main-declaration-initial-main.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/missing-main-declaration-initial-nested.wit":"eafc130098a084cebb71ed07c84432bbe8269d92e5c999728136cd90b99e3bb1","tests/ui/parse-fail/missing-main-declaration-initial-nested.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/missing-package.wit":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/missing-package.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/multi-file-missing-delimiter.wit.result":"0d5af4fc565143f116b46ab61e6a4b5fe4d74325af8c6b6180c3ee6a44516ea8","tests/ui/parse-fail/multi-file-missing-delimiter/observe.wit":"bea33af0bfc096aa7058a5d670322f67688b2927d0fcb1eed856593cb5c93b97","tests/ui/parse-fail/multi-file-missing-delimiter/world.wit":"d78271de8c919905008fb0192328770738f31cf2edf9310e7824bad487492c3d","tests/ui/parse-fail/multi-package-deps-share-nest.wit.result":"f4c43b6c9abefe4e13b6224c057276f30a8355363936e0c1c2b1292808f61147","tests/ui/parse-fail/multi-package-deps-share-nest/deps/dep1/types.wit":"dccf32826372acf61a4132d118d1759874c83b5e3032dcedb91fb283489bbf28","tests/ui/parse-fail/multi-package-deps-share-nest/deps/dep2/types.wit":"ccb04fe89839748a7cd9c09d333acd549c4900d84ea1d57cb8890d12ec4303c8","tests/ui/parse-fail/multi-package-deps-share-nest/root.wit":"7b874fb105af381d5361283b115d7d38885e6a055fa5af6867a85f03207ae7f6","tests/ui/parse-fail/multiple-package-docs.wit.result":"db1231691632699274fbdf8a94cbb52a3ddfd429870ddeb8eb15b11ebea0def5","tests/ui/parse-fail/multiple-package-docs/a.wit":"456ace15e375131385fa74f93d676b80ff9179a77b2a8c4cdf01e4cfeca80527","tests/ui/parse-fail/multiple-package-docs/b.wit":"9ad7758e29c6b08f0f072c8ab7ecedde3718abd161b2e05c284d46f95e68b208","tests/ui/parse-fail/multiple-package-inline-cycle.wit":"4c993b0b8a83f68090b85db4d95872145069d5bcd946dcab8a878770726e0b24","tests/ui/parse-fail/multiple-package-inline-cycle.wit.result":"a624984751c8f0674b50c4e297720b104658b5d9ebb15098717fe443ca3d0197","tests/ui/parse-fail/multiple-packages-no-scope-blocks.wit":"a45426e4136e28663f40278e268a390a7562027d6cb6f27168576e3853d66b25","tests/ui/parse-fail/multiple-packages-no-scope-blocks.wit.result":"1a416a1576e387ecc0d34b9a922ba7e5f536b6c48c46a881950e0100c1f569f6","tests/ui/parse-fail/nested-packages-colliding-names.wit":"a528b3e1dacab79c7aa2c7ad6ed42da2f0061c242f178d42152c25f45ead1baa","tests/ui/parse-fail/nested-packages-colliding-names.wit.result":"f2d637675a851babb091b4f6dfe8410bc48b5505499b65ef3519f714cc5d9ba6","tests/ui/parse-fail/nested-packages-with-error.wit":"f8d310644b61d2b0eb4641a003d8c1dbbbf8ec3f98752b3b5ec791d2a0fa7f58","tests/ui/parse-fail/nested-packages-with-error.wit.result":"973d5a905fa8c6149d03978458a2c63a4646a37b9541c5f045abfb1742ece093","tests/ui/parse-fail/no-access-to-sibling-use.wit.result":"3b640ef3569ac8602f155fdbbaa503203dd9f9d01c53c7b6c693787dea408d2f","tests/ui/parse-fail/no-access-to-sibling-use/bar.wit":"e52d3b5ce50a6c3260a367256406d67401d9a48c3aa9bdbb5c9dde30712951cd","tests/ui/parse-fail/no-access-to-sibling-use/foo.wit":"5c4d88f6af280b678722f265775abec5c577eae47e5be275d9bb2ae2b3092a99","tests/ui/parse-fail/non-existance-world-include.wit.result":"8179176b5d30fa1d472cf7269277753ae8f28d2337fd3d4d9409256df24391f7","tests/ui/parse-fail/non-existance-world-include/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/non-existance-world-include/deps/bar/baz.wit":"e0417499e5a97b2a5dedf83f881eb85830bdad3a2f2724cb07bf3bcd13e4a01e","tests/ui/parse-fail/non-existance-world-include/root.wit":"758be0657b943a7718ea8b8f6b68e39a71264f6ea55ae1602ea993352b7ca939","tests/ui/parse-fail/old-float-types.wit":"a331d50c87423e3ff6683e2a43b514d404e7c7920a4951e99bf7dd60b9a8e53a","tests/ui/parse-fail/old-float-types.wit.result":"1131f9caaf4efbe23923c836b71621c3a8c3b3b3293a1e4c6e1a8c589fd34ce2","tests/ui/parse-fail/pkg-cycle.wit.result":"9331660c2b320ad8e2b8477b1797769ed119137df99db9482c2ead7ad18dc573","tests/ui/parse-fail/pkg-cycle/deps/a1/root.wit":"a401664c52777f3542a756eb79a2344ef4d569908df54e15a0243c31aa77b58b","tests/ui/parse-fail/pkg-cycle/root.wit":"4d42e9e04ba377787b944aec6cb44e3ead0088d7130647db5ca67b4cca7be490","tests/ui/parse-fail/pkg-cycle2.wit.result":"048547c47dd0e85ae7df58f3492090c699b271b326f632900ae1e20ef81db276","tests/ui/parse-fail/pkg-cycle2/deps/a1/root.wit":"122dd6e3f2f3f4569b44533ed967b5facd458c38116bdcce3f936f3642005180","tests/ui/parse-fail/pkg-cycle2/deps/a2/root.wit":"b16a1b33f2525e49d3f3691fd1d43598a0e4cf0015bdc7a9979b73737085a830","tests/ui/parse-fail/pkg-cycle2/root.wit":"60bf50dbc32c8b2e702e042358884c293372689fb0a8a34866897fe995ccccd9","tests/ui/parse-fail/resources-multiple-returns-borrow.wit":"79b3bcb55c4df39cd2037e547aaa2200f920591722517db34652e7ad4e766b50","tests/ui/parse-fail/resources-multiple-returns-borrow.wit.result":"d4c6f5075e50d48dc277c5940d34f58640e8d78b2dad6f9a2f5827d975a11328","tests/ui/parse-fail/resources-return-borrow.wit":"7be90d00f626f87b85990a97d26862f5a00352d67acf4a89045c197cb555e6b8","tests/ui/parse-fail/resources-return-borrow.wit.result":"e43f5d3e7c577d8162b255cb0ec3ea0731634dc63801996fc9f7c328cbb36942","tests/ui/parse-fail/return-borrow1.wit":"1e76d092f4919748bac9db9907a638c26a6ca92ab599f026261511f8c2a662cf","tests/ui/parse-fail/return-borrow1.wit.result":"ff77a7717f0baa3b440edf0f9ab5d2a515c99d19a7f159db6f0d11dce06f18bb","tests/ui/parse-fail/return-borrow2.wit":"f707a3ae6de39ed0db7746410506040dcaa2621324b996708d54aba02c9c49bf","tests/ui/parse-fail/return-borrow2.wit.result":"f64b3af5d0c3e7ff1e8f8f773950aac6d4d5ba2169de1a6e998d3dd05f72dfe0","tests/ui/parse-fail/return-borrow3.wit":"5a5760e399143ba937e5d3d773fbf8920ef826397d63175c794488960c602256","tests/ui/parse-fail/return-borrow3.wit.result":"87e650418893bc64d7712873ff8ef86e32bb0337d73c5c87dcdf78ebbad2ae03","tests/ui/parse-fail/return-borrow4.wit":"3e26cf4beedfb48ef6cb449cfefb4977a9ce0e56afbbef96b01c9279eed9c7ba","tests/ui/parse-fail/return-borrow4.wit.result":"45dc8b37c04ff614222096a1060b84c837947d3e7598daa241706c00b55c8d88","tests/ui/parse-fail/return-borrow5.wit":"fc0883c45f58f9febce715c622cdacc4c7a30d8e7acf16e7862969910a621cd3","tests/ui/parse-fail/return-borrow5.wit.result":"73afcb04f4f80c7d8a30928f47843f6524e15e0c0f1a9d3ebe74b4a9a32a5003","tests/ui/parse-fail/return-borrow6.wit":"f7b0b935f130bf810cb4fd21b96ecdf95993d20da8b8d82522d18e5051633726","tests/ui/parse-fail/return-borrow6.wit.result":"a32b28110a8fff2f999491ffcc7aa6d918094abd361be6d2ba4aa0da73c82921","tests/ui/parse-fail/return-borrow7.wit":"63626a382d1213cae263363950c9a64d6d54099b9ac535c594ab6926cb1233bf","tests/ui/parse-fail/return-borrow7.wit.result":"f13777e7b0536fd025f84e6bd8d8a01d47d85d8fa94fa428537213541ae691b2","tests/ui/parse-fail/return-borrow8.wit.result":"9fb553cd5e9541f8624c06204f79ab75c8840c7dcb38a356615f105bc73a9b93","tests/ui/parse-fail/return-borrow8/deps/baz.wit":"62b2638655b890dcc9d7be49bac7ff4689a3ca553293ba1b577f197c6fc91afc","tests/ui/parse-fail/return-borrow8/foo.wit":"f7915c3b37ce20432539b9e7a0662cc773f00a24dd8c5f8e9924392e522c940b","tests/ui/parse-fail/type-and-resource-same-name.wit.result":"28f2c298385dd152ad21a5be43ee86518368fb003ca79985c301b22774e3a778","tests/ui/parse-fail/type-and-resource-same-name/deps/dep/foo.wit":"e209e375ac3c8a02332abadf1112b6ee88a36c0b78bec82141927b8209aeb793","tests/ui/parse-fail/type-and-resource-same-name/foo.wit":"1edf7997100c89b9e299693ef9d0021ffe43d041a39540e193b11d616bbfab35","tests/ui/parse-fail/undefined-typed.wit":"a5c783ac0da51d15526b0104a0d468bd72e6726706ecef1fbbd5cf6aa413e53d","tests/ui/parse-fail/undefined-typed.wit.result":"794055fa5bd2101d289b55236dd813ea1428bbac89133020bbf2270d2c707c30","tests/ui/parse-fail/unknown-interface.wit":"4813d741cead7412e6f453e728627407069ab17922445dd67acfb80cdf463deb","tests/ui/parse-fail/unknown-interface.wit.result":"545c3a6eee6e89b51a46145bd6609cae3f03ac65df0ebc735e439cef0541bacc","tests/ui/parse-fail/unresolved-interface1.wit":"aa48ae74e1dc3165f05a0d216fcc02b5a22e2cd8cab1c1d3fd9b4ec09da5a47f","tests/ui/parse-fail/unresolved-interface1.wit.result":"b4adf53a899553e08ed1e76457970a15753cad66147c39d40a2f2397734238d5","tests/ui/parse-fail/unresolved-interface2.wit":"0fea9d7ff4592d723e4a9c3dbf341357a4902509996d8eb30a6f520735d0a41e","tests/ui/parse-fail/unresolved-interface2.wit.result":"66b21536fd06f55c737bea8d783e11f707003f988d23764cab478eda8afa6555","tests/ui/parse-fail/unresolved-interface3.wit":"ca7dbd14ec8ee5d01ab2bb7c28b7a3713f31db8c092511b3233b46bc5c353c10","tests/ui/parse-fail/unresolved-interface3.wit.result":"6cd94000e5678a2fde3234638b510ce3bed9f0a2f1cfe589527ba0cfa4e9ba14","tests/ui/parse-fail/unresolved-interface4.wit":"cbb042a9274076b17b7e0c42fc971da6fecfe2e6707a1d7026dd4f647ce5426f","tests/ui/parse-fail/unresolved-interface4.wit.result":"4093b50bcb7aeb9d776139290c723a5979cd5c9b5240c3d4fff127755740675c","tests/ui/parse-fail/unresolved-use1.wit":"f6b32002e7060026cd91e879d11d5f55d1fd0abcd8cb89a37325f8816bde9a9a","tests/ui/parse-fail/unresolved-use1.wit.result":"c5347149bf31d2dae55360c12b266292e4e96a49bb1a3494877cc7c031841f8d","tests/ui/parse-fail/unresolved-use10.wit.result":"551a761df6989b52b2e042924bb1b3b0055f3ec7f451d1b0c70dd4b49e2e5f2c","tests/ui/parse-fail/unresolved-use10/bar.wit":"7dad62091e741838831396f8fd31846a26ef6de0fbcadc350ade8fff0bf575ee","tests/ui/parse-fail/unresolved-use10/foo.wit":"feecb9606feec3ea7f499a1e9d97a86185c861eeef81c6e31c4d3805752d099b","tests/ui/parse-fail/unresolved-use2.wit":"b57684da212586ce720cf3161f9a659d3abaec989a4081172a5cd05425777a9a","tests/ui/parse-fail/unresolved-use2.wit.result":"a62b50fe39176b748df8fcfbcc28c099e801762f1e099d65f751e95c92afabbf","tests/ui/parse-fail/unresolved-use3.wit":"47fd4331dd9f76416230f2b4236a1837d1fba2e17603b25376306d2afb72bf24","tests/ui/parse-fail/unresolved-use3.wit.result":"ebf46f8ec011c0a98a0593ad217c1fb90ad142898b76385ca6c02d01a34d883f","tests/ui/parse-fail/unresolved-use7.wit":"b57684da212586ce720cf3161f9a659d3abaec989a4081172a5cd05425777a9a","tests/ui/parse-fail/unresolved-use7.wit.result":"7be5ab3f67d7b0df5ef2d0df1f66c2f2995bf247042bc89ea90089c05d254f84","tests/ui/parse-fail/unresolved-use8.wit":"9208e402aa194d8d0fd3c04f5c3a63e070a6fba35aeb3ee6deb620bdbe825be6","tests/ui/parse-fail/unresolved-use8.wit.result":"0f326c857f8ef05ed3687fc35816318931e9a189a5d3730b8437a0d967f354ba","tests/ui/parse-fail/unresolved-use9.wit":"a55be65d32510b790f687a8cd1a17cc78d66fc348a73c202786ccfc73ef80cda","tests/ui/parse-fail/unresolved-use9.wit.result":"a2479c0725a0e882c20999e0f194d4054777292b5fd3e08115b28d87b6d1217d","tests/ui/parse-fail/unterminated-string.wit.result":"ad1667fb37e169ae458c86c87154fcc2c25c1194578812dfb83c8a941c2ed002","tests/ui/parse-fail/use-and-include-world.wit.result":"5817300629cfa4fc8275c63f2012f2328f27375b771d2da2a14a76d520dcc4e8","tests/ui/parse-fail/use-and-include-world/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/use-and-include-world/deps/bar/baz.wit":"a3bdbdbec31db5c6ae2d898c5d82e1513e39bec7d887b199e648595ed7845102","tests/ui/parse-fail/use-and-include-world/root.wit":"78da4438e0a957af1421dc8c503593f3e675c5179eda0e1671c856b3cdcb6af2","tests/ui/parse-fail/use-conflict.wit":"034cccb48e6d9a80967c432bb1590c753c12d483aec6fa6d0da96eb6dd95636d","tests/ui/parse-fail/use-conflict.wit.result":"27bbdcde0151687d6a785e785824b458eb8f3393266e16146641a0c6062fb6ac","tests/ui/parse-fail/use-conflict2.wit":"fae3ffc85bea2e71f6427442516a93346a1c078db321ff1d9c79f3aa803a8a80","tests/ui/parse-fail/use-conflict2.wit.result":"a10548056049674ab161e6c63bd34aa17388ccd01ed7afdf765d98a40cf42cac","tests/ui/parse-fail/use-conflict3.wit":"c7d3fec48232c0fac946535509b6da609454b8d167040c2545ac3a21f88d9daa","tests/ui/parse-fail/use-conflict3.wit.result":"fed3b72eeee230b2d7866e9eb8feca2481006ee1847ca52df1c535ca34314f97","tests/ui/parse-fail/use-cycle1.wit":"221c299f701cb74b83aca20e869d2c0aefb813fe24cabdc2e911a2c957eb7852","tests/ui/parse-fail/use-cycle1.wit.result":"33d47e1ea89d5fb0bae32e036c98b3d5399196207207c208f195bf509c186ffb","tests/ui/parse-fail/use-cycle4.wit":"e2be0e1404e32463030ca188fbc73e33b0742890b15dcfb49d958aefebd2c3f4","tests/ui/parse-fail/use-cycle4.wit.result":"382267390c78b50f7f88145e5d14535d2cf63bc666770e6bd059fa7354340671","tests/ui/parse-fail/use-shadow1.wit":"0aaecccbbb79cf9472ba313e2d46c05bf3880c45f653fae7b0c78f4b22a295df","tests/ui/parse-fail/use-shadow1.wit.result":"a773e07251372341385395796eadb1fed6c9874ad24da54695556189162a18cf","tests/ui/parse-fail/use-world.wit.result":"15bed7cfaa1a4f59221761ddf8aa7eac1663e17c24951cff8f6d4e18d90954a5","tests/ui/parse-fail/use-world/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/use-world/deps/bar/baz.wit":"a3bdbdbec31db5c6ae2d898c5d82e1513e39bec7d887b199e648595ed7845102","tests/ui/parse-fail/use-world/root.wit":"8acc2f7d198aac787e288e81bdfb1a088014f4a4d1afac464e2cf3f42845d6bd","tests/ui/parse-fail/very-nested-packages.wit":"634d9ea887eb80da7207f942d5ddc53fe6d2b06e7098e6766e4430dc8ead7742","tests/ui/parse-fail/very-nested-packages.wit.result":"ca58759135852a95265d4d55ddde1d43098c307de3423288462932451a5b3e89","tests/ui/parse-fail/world-interface-clash.wit":"6584c79206067af3dc3647f38deb9e5bbd7ea030b7a26f267e10db0b3243bb5b","tests/ui/parse-fail/world-interface-clash.wit.result":"a75d15d2d1eee8078553abbbadacc665c08de9a2a7ab098cf6916ff6bb2b9092","tests/ui/parse-fail/world-same-fields2.wit":"99e6297c3566e8d0df7d4a953b2d816303999fe040776956a8215de6f86a4c0a","tests/ui/parse-fail/world-same-fields2.wit.result":"421bff8bef32cec8f401c7c769c41775db49f10d31497eb66dd573503d342239","tests/ui/parse-fail/world-same-fields3.wit":"179e96948f1bd9b85b3fd53ccd932e1a5828c2ff6ce20f3f69a40295c9d3142c","tests/ui/parse-fail/world-same-fields3.wit.result":"6ae7d531dd1e711f54c3f367424a834da4834f7b1d0d1f0b851b8fdb36def6aa","tests/ui/parse-fail/world-top-level-func.wit":"25198b3e596b399f6724288ec81e7cb5a2b138db575ff2854e3263e4c1d345ea","tests/ui/parse-fail/world-top-level-func.wit.result":"3842657363ed9453b394f6cce0278a6b8cd0b7fb9c4c7044060b2a5a5a6ef093","tests/ui/parse-fail/world-top-level-func2.wit":"05ac462fe2731f3b4b3e0b16cfee74457302d376d14df35f22337016ba49df43","tests/ui/parse-fail/world-top-level-func2.wit.result":"da74d6cadafbea0711f432d1a0813615d8779784337d440f56391d77ebc66ef3","tests/ui/random.wit":"a308df65c57e4848930795bc110f1b2dde102c6e9963570a404c648b2b0be33a","tests/ui/random.wit.json":"7469b9e378f13f111e78657feeb3ef9873c6bcc3099260ae4e6090bdab28d85b","tests/ui/resources-empty.wit":"a7ad4630c28f52b6ed054520613feb8b11d632fcaa80c21ef5b84343cf649659","tests/ui/resources-empty.wit.json":"088c997de81f3366ef77ae83190d6d530810eabdd7f8c7aac4e4014cad90b5e0","tests/ui/resources-multiple-returns-own.wit":"7c665e511dbd2992fb6efcb6412241d1bda0074da78d394ead1070cf6be7f187","tests/ui/resources-multiple-returns-own.wit.json":"95a404930f7eb64112f9a661dcd0f047b6eb33d12f2e1de500e196c9d5b51edf","tests/ui/resources-multiple.wit":"98724d3b6a1d0d192970d9ae149e31694bd9c3f86bfe2e89c520e1a063724921","tests/ui/resources-multiple.wit.json":"265d1bd3914243d782d5c9b0fda62d285655ab5f43196ceeb32fba791909f116","tests/ui/resources-return-own.wit":"29d9f53bd39d0c2263c7260508a1f954e59b28923994f94bda0184cf037c4210","tests/ui/resources-return-own.wit.json":"8b60ee12530bab3e0643ddc7ed4e757b57f395e397b834a53eac2958c95824c7","tests/ui/resources.wit":"3535fc8c8381779d33082f54384362c0e3ab23cfe675562333e6840682d71ebe","tests/ui/resources.wit.json":"ba8fff6d19dcb72e277c925e52646f68b0e6e0b15eff6334de9d770a6f04465f","tests/ui/resources1.wit":"9eb5d63717f20c6801c6c71f6306ae3e2c37790bfe8a89659c11cce85797d128","tests/ui/resources1.wit.json":"090fa9e402168d2a157e7abdda3d450c48b90e2cc325bcc0be30447682ace656","tests/ui/same-name-import-export.wit":"95ba4578908c29d2af14fcdd8970362c8bafb2174916c0f0772b09437e8d57a4","tests/ui/same-name-import-export.wit.json":"c3d2c9fd7a219ffe2fe094233c369916ce0fee0a2efcebfac008a45bc7c5f8dd","tests/ui/shared-types.wit":"d145c035d916f453a7eeb034bf2a59c2e24f14061d8385ab39cc1f076c9265ae","tests/ui/shared-types.wit.json":"70be131e2e80cdf62ba7a2a20418f71f7480428e2e05e1c387dc1a24667dd652","tests/ui/simple-wasm-text.wat":"10e7380158502c5ca3a1ac9d4195b0455cc02438fed0fb3f7188674354c25c2c","tests/ui/simple-wasm-text.wit.json":"0f91dec1e13fb9e0c30b4e1ad6b4335ea22fdc435ff526e3549dc19a8af97443","tests/ui/since-and-unstable.wit":"312fe8ecc9f22c083f3e59ea306731c198b4d1dd8e2bc1b3d868e90b184163a6","tests/ui/since-and-unstable.wit.json":"6147a7d1ef4dd8dcd8572ade33e7423ace0eea398586cbd75bab5be2cd361e60","tests/ui/streams-and-futures.wit":"2d4d378de4dab66aebc90d4dcfec58b3afccc646f83491801d51999fb612cbe4","tests/ui/streams-and-futures.wit.json":"3e180d6002e03e72797e45bfd4003c4dbebcfbecfded930c646cd8837054a6b1","tests/ui/stress-export-elaborate.wit":"7d62775daf1c0e35c7576abd726077e45cde2f693cc21d8cadd542e88271590c","tests/ui/stress-export-elaborate.wit.json":"6930a623e84d06da7fbd49ec1e6d10b43f3821ee191cb7ff56902597210b4c06","tests/ui/type-then-eof.wit":"79610cbf6fe3e2d13ce1fd8c06e53fee6c81d42469ef56e1dd61c46bf5f57ca3","tests/ui/type-then-eof.wit.json":"bcffeaf61ef6ae2ad4752ef83fd5057ff5eeb649d00e797138aefeaedcf39d06","tests/ui/types.wit":"1da7140aa66c3de1867313e5071f18d6814e44d90ae650be25b86dbf58214afa","tests/ui/types.wit.json":"c981cdc0a58a7e500915497eb856a32f37015ca1bfb09b453e3e0bc3fd5b3edf","tests/ui/union-fuzz-1.wit":"c4f60248204707f8dfe134bf4d6ec3385ae343abc4dfa39239798dc9f3991753","tests/ui/union-fuzz-1.wit.json":"5599236aaea5ab475ce9c224bbba3a40de45d5d5a20f75eec23b09e723d14a01","tests/ui/union-fuzz-2.wit":"5e00d73b1b562fb3cb24067fb0b8ba4edf28b6cd71d914dd6b8716f58272f266","tests/ui/union-fuzz-2.wit.json":"5593decd80a12ef08a0937b429ce3414964cadd2eb9138ebd6961a87f0eaa6c8","tests/ui/unstable-resource.wit":"304a4e8cf205f6f7afdc9af0f2756931c1e2875ab7bb70323cd6f1414fb462e8","tests/ui/unstable-resource.wit.json":"98da87f01953568427e36b6676a527cd5b9d54d3a1d5838b65772a58c6ff34cb","tests/ui/use-chain.wit":"3daee8a895e3bfb7c0bd0252f095554a85d07baed2c569c1b7fba5592a1fb675","tests/ui/use-chain.wit.json":"8098e7e6cafb3b22d117a31b1b721d5bda895fd984fa415fdd5cb4490364166f","tests/ui/use.wit":"4c920ba13211fdeeabdb53341c983f002263c464f4bae2829b0dadae3308cbe8","tests/ui/use.wit.json":"0ca15c4eb705f51f0b499f78ce40a45e243f6af040878f9be9697589fb62b99c","tests/ui/version-syntax.wit":"18e83b2246c0271bc3da0bfe004e69ee7699fcfcb6a986ec970dfaab7ec315bb","tests/ui/version-syntax.wit.json":"1722a38926d815646f64ab37ab3181d3cb70d937665a416112bcb7ac50ce31b1","tests/ui/versions.wit.json":"6a2b4f5d9b1cea003a2c3d25cb91116249c02ff307a04109e554457cca2f139e","tests/ui/versions/deps/a1/foo.wit":"407bd32b2274c8b5c0cac5582097d797e1455926c069496a6d5964ebc571b291","tests/ui/versions/deps/a2/foo.wit":"b32843bb65739073b450cef6fd528b2a72bc7fe92fa0953883663a1bf7ced1c4","tests/ui/versions/foo.wit":"4da61a67927a401e08adecd5c1f0d7eb7894982d3beb356184149da458a9f553","tests/ui/wasi.wit":"7227877525a5b0e2fc9ebd6e312d29d110e398126e4706a7fdb07e2d3fa05ff6","tests/ui/wasi.wit.json":"96631c1e2b029e2e15cbc51d2649a8be20e53c0666e8a9a3debed7fffa95bbe4","tests/ui/with-resource-as.wit":"bfc965bbeee53ff610639bef7f6e70057771812395f4328b7025dc6005a5d334","tests/ui/with-resource-as.wit.json":"f230c8a309a799c31759e1e8bc69aa3692e1a8b9fc8eb167f8b5df177b5594f4","tests/ui/world-diamond.wit":"82ca9865f586a5839adee9d8d90a519aead5ead715c2607125e878286f0ce847","tests/ui/world-diamond.wit.json":"5d92d94856aeaca6f73a185c242cfeaadd7afd59a285b6c47ac8997ab5b8db72","tests/ui/world-iface-no-collide.wit":"f1bb804dc568a94c6aa467c8d720a26c4a47a00f3374f4fe045502686eea3d7b","tests/ui/world-iface-no-collide.wit.json":"9c26c5fc05be082e85d37cf928f0bf45750f020a6c1176c92ce8dcdd56cb1d2e","tests/ui/world-implicit-import1.wit":"59515a6a268a6329bcf4e0a6e74b8ed1f77a61638ba8fad5fae935eb0ab59a50","tests/ui/world-implicit-import1.wit.json":"ae22442a9da3bee72efca9bc3adb49df3af510aadf3eda999d6d7b0a21f65a8b","tests/ui/world-implicit-import2.wit":"14bb046b3bf18a2b02ab47ed8be2947f3f911ded88dd2410225ac08e02df8ede","tests/ui/world-implicit-import2.wit.json":"c8a5023cd0159301ac3b415a00a0c349149606f349a7447778f2478f3292182f","tests/ui/world-implicit-import3.wit":"0faf9a3afa61ffab3d3d5e2f869d35d92a39406d65b228865f4871035b93f2d7","tests/ui/world-implicit-import3.wit.json":"488978218df83a17c18274591777d89b8ad18f6958692e50d87483d0d2cd3f5f","tests/ui/world-same-fields4.wit":"8686e463450b6880f1572b0fcb9ac78dfa78c1bf7c1124e255aa79959a49ef7e","tests/ui/world-same-fields4.wit.json":"831f2370d2c565a9f5b9bce32cd05769cb8b1034967051e57d883055157a95c3","tests/ui/world-top-level-funcs.wit":"1ef7498d5c9cae3e8da77bf4af98b2fec439f56387d130b54109b0f16d156d0d","tests/ui/world-top-level-funcs.wit.json":"f3b894996007ca6c370a3f383947ad16c920446a8ea84a32b2082750616d6117","tests/ui/world-top-level-resources.wit":"61267d096998b68bfd72845854f6a2d5391d68f6a0094887fc05cf97cb54410e","tests/ui/world-top-level-resources.wit.json":"35e2342c86841c2b861b5547c6d0cde83bf6ac7af35f7e09af99b209887d19e1","tests/ui/worlds-union-dedup.wit":"1f9ac2813774c0fe1676734bd6e1779f4870091d0d6a8aa061643e865528be10","tests/ui/worlds-union-dedup.wit.json":"254ef09ce95718b658d109cacda832c7dfdc5b7e0420ce1da8fe56589e400dfd","tests/ui/worlds-with-types.wit":"a2e6d00eafed8d6c6278dc9cddbc2ab2542f836869f564cf449625fddc9476e8","tests/ui/worlds-with-types.wit.json":"6d3afdfc4192bc6b6cf8b3507a942d5e63dc5adae26fafed62d5ced0889f6f69"},"package":"ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"} \ No newline at end of file diff --git a/anneal/vendor/wit-parser/tests/.gitignore b/anneal/vendor/wit-parser/tests/.gitignore new file mode 100644 index 0000000000..9365962f41 --- /dev/null +++ b/anneal/vendor/wit-parser/tests/.gitignore @@ -0,0 +1,2 @@ +!*.wasm +!*.wat