[INFO] fetching crate word_sensitive 0.1.2...
[INFO] testing word_sensitive-0.1.2 against master#c90bcb9571b7aab0d8beaa2ce8a998ffaf079d38 for pr-146098-7
[INFO] extracting crate word_sensitive 0.1.2 into /workspace/builds/worker-5-tc1/source
[INFO] started tweaking crates.io crate word_sensitive 0.1.2
[INFO] finished tweaking crates.io crate word_sensitive 0.1.2
[INFO] tweaked toml for crates.io crate word_sensitive 0.1.2 written to /workspace/builds/worker-5-tc1/source/Cargo.toml
[INFO] validating manifest of crates.io crate word_sensitive 0.1.2 on toolchain c90bcb9571b7aab0d8beaa2ce8a998ffaf079d38
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c90bcb9571b7aab0d8beaa2ce8a998ffaf079d38" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c90bcb9571b7aab0d8beaa2ce8a998ffaf079d38" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c90bcb9571b7aab0d8beaa2ce8a998ffaf079d38" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:4848fb76d95f26979359cc7e45710b1dbc8f3acb7aeedee7c460d7702230f228" "/opt/rustwide/cargo-home/bin/cargo" "+c90bcb9571b7aab0d8beaa2ce8a998ffaf079d38" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 6f7c8c2eb7e11f6a108915531296747e389bd4ba10e77e7a3b82f69ac4ec2feb
[INFO] running `Command { std: "docker" "start" "-a" "6f7c8c2eb7e11f6a108915531296747e389bd4ba10e77e7a3b82f69ac4ec2feb", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "6f7c8c2eb7e11f6a108915531296747e389bd4ba10e77e7a3b82f69ac4ec2feb", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "6f7c8c2eb7e11f6a108915531296747e389bd4ba10e77e7a3b82f69ac4ec2feb", kill_on_drop: false }`
[INFO] [stdout] 6f7c8c2eb7e11f6a108915531296747e389bd4ba10e77e7a3b82f69ac4ec2feb
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:4848fb76d95f26979359cc7e45710b1dbc8f3acb7aeedee7c460d7702230f228" "/opt/rustwide/cargo-home/bin/cargo" "+c90bcb9571b7aab0d8beaa2ce8a998ffaf079d38" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] dbbc85ddcd51fd038977e4e9a4fc44efd8439658c4dfc76be90e021a27a63601
[INFO] running `Command { std: "docker" "start" "-a" "dbbc85ddcd51fd038977e4e9a4fc44efd8439658c4dfc76be90e021a27a63601", kill_on_drop: false }`
[INFO] [stderr]    Compiling word_sensitive v0.1.2 (/opt/rustwide/workdir)
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.53s
[INFO] running `Command { std: "docker" "inspect" "dbbc85ddcd51fd038977e4e9a4fc44efd8439658c4dfc76be90e021a27a63601", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "dbbc85ddcd51fd038977e4e9a4fc44efd8439658c4dfc76be90e021a27a63601", kill_on_drop: false }`
[INFO] [stdout] dbbc85ddcd51fd038977e4e9a4fc44efd8439658c4dfc76be90e021a27a63601
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:4848fb76d95f26979359cc7e45710b1dbc8f3acb7aeedee7c460d7702230f228" "/opt/rustwide/cargo-home/bin/cargo" "+c90bcb9571b7aab0d8beaa2ce8a998ffaf079d38" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] f56935227f24459f451728614a4da333d716d663ab989005376bbe4fa8759088
[INFO] running `Command { std: "docker" "start" "-a" "f56935227f24459f451728614a4da333d716d663ab989005376bbe4fa8759088", kill_on_drop: false }`
[INFO] [stderr]    Compiling word_sensitive v0.1.2 (/opt/rustwide/workdir)
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:39:15
[INFO] [stdout]    |
[INFO] [stdout] 39 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:39:15
[INFO] [stdout]    |
[INFO] [stdout] 39 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    = note: `#[deny(dangerous_implicit_autorefs)]` on by default
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 39 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).val,
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:43:15
[INFO] [stdout]    |
[INFO] [stdout] 43 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:43:15
[INFO] [stdout]    |
[INFO] [stdout] 43 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 43 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr())
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:51:15
[INFO] [stdout]    |
[INFO] [stdout] 51 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:51:15
[INFO] [stdout]    |
[INFO] [stdout] 51 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 51 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).val,
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:55:15
[INFO] [stdout]    |
[INFO] [stdout] 55 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:55:15
[INFO] [stdout]    |
[INFO] [stdout] 55 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 55 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr())
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:61:15
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stdout]    |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:61:15
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).val,
[INFO] [stdout]    |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:61:17
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stdout]    |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:61:17
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stdout]    |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:66:15
[INFO] [stdout]    |
[INFO] [stdout] 66 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:66:15
[INFO] [stdout]    |
[INFO] [stdout] 66 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 66 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).ext,
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:70:15
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:70:15
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stdout]    |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:70:17
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:70:17
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:84:15
[INFO] [stdout]    |
[INFO] [stdout] 84 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:84:15
[INFO] [stdout]    |
[INFO] [stdout] 84 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 84 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).ext,
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:88:15
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:88:15
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stdout]    |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:88:17
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:88:17
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:92:15
[INFO] [stdout]    |
[INFO] [stdout] 92 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |  _______________|
[INFO] [stdout]    | |
[INFO] [stdout] 93 | |                 .children[&2]
[INFO] [stdout]    | |_____________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:92:15
[INFO] [stdout]    |
[INFO] [stdout] 92 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |  _______________^
[INFO] [stdout] 93 | |                 .children[&2]
[INFO] [stdout]    | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 92 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout] 93 ~                 .children)[&2]
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:92:17
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:92:17
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stdout]    |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:92:19
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:92:19
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:100:15
[INFO] [stdout]     |
[INFO] [stdout] 100 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:100:15
[INFO] [stdout]     |
[INFO] [stdout] 100 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 100 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stdout]     |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:104:15
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:104:15
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr()).ext,
[INFO] [stdout]     |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:104:17
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:104:17
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:108:15
[INFO] [stdout]     |
[INFO] [stdout] 108 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _______________|
[INFO] [stdout]     | |
[INFO] [stdout] 109 | |                 .children[&3]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:108:15
[INFO] [stdout]     |
[INFO] [stdout] 108 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |  _______________^
[INFO] [stdout] 109 | |                 .children[&3]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 108 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout] 109 ~                 .children)[&3]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:108:17
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:108:17
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:108:19
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:108:19
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:116:15
[INFO] [stdout]     |
[INFO] [stdout] 116 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stdout]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:116:15
[INFO] [stdout]     |
[INFO] [stdout] 116 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 116 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).ext,
[INFO] [stdout]     |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:120:15
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:120:15
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr()).ext,
[INFO] [stdout]     |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:120:17
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:120:17
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:124:15
[INFO] [stdout]     |
[INFO] [stdout] 124 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _______________|
[INFO] [stdout]     | |
[INFO] [stdout] 125 | |                 .children[&5]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:124:15
[INFO] [stdout]     |
[INFO] [stdout] 124 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |  _______________^
[INFO] [stdout] 125 | |                 .children[&5]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 124 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout] 125 ~                 .children)[&5]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:124:17
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:124:17
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:124:19
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:124:19
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:134:15
[INFO] [stdout]     |
[INFO] [stdout] 134 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:134:15
[INFO] [stdout]     |
[INFO] [stdout] 134 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 134 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).ext,
[INFO] [stdout]     |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:138:15
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:138:15
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stdout]     |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:138:17
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:138:17
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:142:15
[INFO] [stdout]     |
[INFO] [stdout] 142 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _______________|
[INFO] [stdout]     | |
[INFO] [stdout] 143 | |                 .children[&2]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:142:15
[INFO] [stdout]     |
[INFO] [stdout] 142 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |  _______________^
[INFO] [stdout] 143 | |                 .children[&2]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 142 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout] 143 ~                 .children)[&2]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:142:17
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:142:17
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:142:19
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:142:19
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:150:15
[INFO] [stdout]     |
[INFO] [stdout] 150 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:150:15
[INFO] [stdout]     |
[INFO] [stdout] 150 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 150 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stdout]     |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:154:15
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:154:15
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr()).ext,
[INFO] [stdout]     |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:154:17
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:154:17
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:158:15
[INFO] [stdout]     |
[INFO] [stdout] 158 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _______________|
[INFO] [stdout]     | |
[INFO] [stdout] 159 | |                 .children[&3]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:158:15
[INFO] [stdout]     |
[INFO] [stdout] 158 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |  _______________^
[INFO] [stdout] 159 | |                 .children[&3]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 158 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout] 159 ~                 .children)[&3]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:158:17
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:158:17
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:158:19
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:158:19
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:166:15
[INFO] [stdout]     |
[INFO] [stdout] 166 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stdout]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:166:15
[INFO] [stdout]     |
[INFO] [stdout] 166 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 166 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).ext,
[INFO] [stdout]     |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:170:15
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:170:15
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr()).ext,
[INFO] [stdout]     |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:170:17
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:170:17
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:174:15
[INFO] [stdout]     |
[INFO] [stdout] 174 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _______________|
[INFO] [stdout]     | |
[INFO] [stdout] 175 | |                 .children[&5]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:174:15
[INFO] [stdout]     |
[INFO] [stdout] 174 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |  _______________^
[INFO] [stdout] 175 | |                 .children[&5]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 174 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout] 175 ~                 .children)[&5]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:174:17
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:174:17
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:174:19
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:174:19
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:183:17
[INFO] [stdout]     |
[INFO] [stdout] 183 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:183:17
[INFO] [stdout]     |
[INFO] [stdout] 183 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 183 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr())
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:191:17
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:191:17
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:191:19
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:191:19
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:199:17
[INFO] [stdout]     |
[INFO] [stdout] 199 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _________________|
[INFO] [stdout]     | |
[INFO] [stdout] 200 | |                 .children[&2]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:199:17
[INFO] [stdout]     |
[INFO] [stdout] 199 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |  _________________^
[INFO] [stdout] 200 | |                 .children[&2]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 199 ~             (*(*(&(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout] 200 ~                 .children)[&2]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:199:19
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:199:19
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stdout]     |                   ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:199:21
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                     ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                       |
[INFO] [stdout]     |                       this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:199:21
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                     ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:210:17
[INFO] [stdout]     |
[INFO] [stdout] 210 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:210:17
[INFO] [stdout]     |
[INFO] [stdout] 210 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 210 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr())
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:218:17
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:218:17
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:218:19
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:218:19
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:226:17
[INFO] [stdout]     |
[INFO] [stdout] 226 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _________________|
[INFO] [stdout]     | |
[INFO] [stdout] 227 | |                 .children[&3]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:226:17
[INFO] [stdout]     |
[INFO] [stdout] 226 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |  _________________^
[INFO] [stdout] 227 | |                 .children[&3]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 226 ~             (*(*(&(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout] 227 ~                 .children)[&3]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:226:19
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:226:19
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stdout]     |                   ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:226:21
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                     ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                       |
[INFO] [stdout]     |                       this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:226:21
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                     ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:237:17
[INFO] [stdout]     |
[INFO] [stdout] 237 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr())
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:237:17
[INFO] [stdout]     |
[INFO] [stdout] 237 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 237 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr())
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:245:17
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:245:17
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:245:19
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:245:19
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:253:17
[INFO] [stdout]     |
[INFO] [stdout] 253 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _________________|
[INFO] [stdout]     | |
[INFO] [stdout] 254 | |                 .children[&5]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:253:17
[INFO] [stdout]     |
[INFO] [stdout] 253 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |  _________________^
[INFO] [stdout] 254 | |                 .children[&5]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 253 ~             (*(*(&(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout] 254 ~                 .children)[&5]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:253:19
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:253:19
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stdout]     |                   ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:253:21
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                     ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                       |
[INFO] [stdout]     |                       this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:253:21
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                     ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `word_sensitive` (test "trie_test") due to 63 previous errors
[INFO] running `Command { std: "docker" "inspect" "f56935227f24459f451728614a4da333d716d663ab989005376bbe4fa8759088", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "f56935227f24459f451728614a4da333d716d663ab989005376bbe4fa8759088", kill_on_drop: false }`
[INFO] [stdout] f56935227f24459f451728614a4da333d716d663ab989005376bbe4fa8759088
