[INFO] cloning repository https://github.com/Lordseriouspig/encode-image-to-minecraft
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/Lordseriouspig/encode-image-to-minecraft" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FLordseriouspig%2Fencode-image-to-minecraft", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FLordseriouspig%2Fencode-image-to-minecraft'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 6567d2cd56a8a2cdc60b05a62fc0f1a555114926
[INFO] checking Lordseriouspig/encode-image-to-minecraft against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FLordseriouspig%2Fencode-image-to-minecraft" "/workspace/builds/worker-4-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-4-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/Lordseriouspig/encode-image-to-minecraft
[INFO] finished tweaking git repo https://github.com/Lordseriouspig/encode-image-to-minecraft
[INFO] tweaked toml for git repo https://github.com/Lordseriouspig/encode-image-to-minecraft written to /workspace/builds/worker-4-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/Lordseriouspig/encode-image-to-minecraft on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/Lordseriouspig/encode-image-to-minecraft already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/target:/opt/rustwide/target:rw,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" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] b0694ec76780ebac8586a80a070a77f536b9824ff6eed9ec1dd6ffb253e0621e
[INFO] running `Command { std: "docker" "start" "b0694ec76780ebac8586a80a070a77f536b9824ff6eed9ec1dd6ffb253e0621e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b0694ec76780ebac8586a80a070a77f536b9824ff6eed9ec1dd6ffb253e0621e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "b0694ec76780ebac8586a80a070a77f536b9824ff6eed9ec1dd6ffb253e0621e" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b0694ec76780ebac8586a80a070a77f536b9824ff6eed9ec1dd6ffb253e0621e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-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" "-w" "/opt/rustwide/workdir" "--user" "0:0" "b0694ec76780ebac8586a80a070a77f536b9824ff6eed9ec1dd6ffb253e0621e" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.105
[INFO] [stderr]    Compiling quote v1.0.43
[INFO] [stderr]     Checking anstyle v1.0.13
[INFO] [stderr]     Checking clap_lex v0.7.7
[INFO] [stderr]    Compiling serde_core v1.0.228
[INFO] [stderr]     Checking twox-hash v1.6.3
[INFO] [stderr]     Checking lz4_flex v0.11.5
[INFO] [stderr]     Checking miniz_oxide v0.8.9
[INFO] [stderr]     Checking lz4-java-wrc v0.2.0
[INFO] [stderr]     Checking anstream v0.6.21
[INFO] [stderr]     Checking clap_builder v4.5.56
[INFO] [stderr]    Compiling syn v2.0.114
[INFO] [stderr]     Checking serde_bytes v0.11.19
[INFO] [stderr]    Compiling serde_derive v1.0.228
[INFO] [stderr]    Compiling thiserror-impl v1.0.69
[INFO] [stderr]    Compiling clap_derive v4.5.55
[INFO] [stderr]     Checking thiserror v1.0.69
[INFO] [stderr]     Checking mca v1.1.0
[INFO] [stderr]     Checking clap v4.5.56
[INFO] [stderr]     Checking serde v1.0.228
[INFO] [stderr]     Checking fastnbt v2.6.0
[INFO] [stderr]     Checking encode-image-to-minecraft v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:24:22
[INFO] [stdout]    |
[INFO] [stdout] 24 |     map.insert(0x00, "minecraft:barrier".into()); // null
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 24 -     map.insert(0x00, "minecraft:barrier".into()); // null
[INFO] [stdout] 24 +     map.insert(0x00, "minecraft:barrier"); // null
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 24 -     map.insert(0x00, "minecraft:barrier".into()); // null
[INFO] [stdout] 24 +     map.insert(0x00, <&str as Into<_>>::into("minecraft:barrier")); // null
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:25:22
[INFO] [stdout]    |
[INFO] [stdout] 25 |     map.insert(0x01, "minecraft:polished_basalt".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 25 -     map.insert(0x01, "minecraft:polished_basalt".into());
[INFO] [stdout] 25 +     map.insert(0x01, "minecraft:polished_basalt");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 25 -     map.insert(0x01, "minecraft:polished_basalt".into());
[INFO] [stdout] 25 +     map.insert(0x01, <&str as Into<_>>::into("minecraft:polished_basalt"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:26:22
[INFO] [stdout]    |
[INFO] [stdout] 26 |     map.insert(0x02, "minecraft:acacia_fence".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 26 -     map.insert(0x02, "minecraft:acacia_fence".into());
[INFO] [stdout] 26 +     map.insert(0x02, "minecraft:acacia_fence");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 26 -     map.insert(0x02, "minecraft:acacia_fence".into());
[INFO] [stdout] 26 +     map.insert(0x02, <&str as Into<_>>::into("minecraft:acacia_fence"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:27:22
[INFO] [stdout]    |
[INFO] [stdout] 27 |     map.insert(0x03, "minecraft:acacia_fence_gate".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 27 -     map.insert(0x03, "minecraft:acacia_fence_gate".into());
[INFO] [stdout] 27 +     map.insert(0x03, "minecraft:acacia_fence_gate");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 27 -     map.insert(0x03, "minecraft:acacia_fence_gate".into());
[INFO] [stdout] 27 +     map.insert(0x03, <&str as Into<_>>::into("minecraft:acacia_fence_gate"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:28:22
[INFO] [stdout]    |
[INFO] [stdout] 28 |     map.insert(0x04, "minecraft:polished_blackstone".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 28 -     map.insert(0x04, "minecraft:polished_blackstone".into());
[INFO] [stdout] 28 +     map.insert(0x04, "minecraft:polished_blackstone");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 28 -     map.insert(0x04, "minecraft:polished_blackstone".into());
[INFO] [stdout] 28 +     map.insert(0x04, <&str as Into<_>>::into("minecraft:polished_blackstone"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:29:22
[INFO] [stdout]    |
[INFO] [stdout] 29 |     map.insert(0x05, "minecraft:stripped_spruce_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 29 -     map.insert(0x05, "minecraft:stripped_spruce_log".into());
[INFO] [stdout] 29 +     map.insert(0x05, "minecraft:stripped_spruce_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 29 -     map.insert(0x05, "minecraft:stripped_spruce_log".into());
[INFO] [stdout] 29 +     map.insert(0x05, <&str as Into<_>>::into("minecraft:stripped_spruce_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:30:22
[INFO] [stdout]    |
[INFO] [stdout] 30 |     map.insert(0x06, "minecraft:acacia_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 30 -     map.insert(0x06, "minecraft:acacia_log".into());
[INFO] [stdout] 30 +     map.insert(0x06, "minecraft:acacia_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 30 -     map.insert(0x06, "minecraft:acacia_log".into());
[INFO] [stdout] 30 +     map.insert(0x06, <&str as Into<_>>::into("minecraft:acacia_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:31:22
[INFO] [stdout]    |
[INFO] [stdout] 31 |     map.insert(0x07, "minecraft:acacia_planks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 31 -     map.insert(0x07, "minecraft:acacia_planks".into());
[INFO] [stdout] 31 +     map.insert(0x07, "minecraft:acacia_planks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 31 -     map.insert(0x07, "minecraft:acacia_planks".into());
[INFO] [stdout] 31 +     map.insert(0x07, <&str as Into<_>>::into("minecraft:acacia_planks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:32:22
[INFO] [stdout]    |
[INFO] [stdout] 32 |     map.insert(0x08, "minecraft:stripped_acacia_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 32 -     map.insert(0x08, "minecraft:stripped_acacia_log".into());
[INFO] [stdout] 32 +     map.insert(0x08, "minecraft:stripped_acacia_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 32 -     map.insert(0x08, "minecraft:stripped_acacia_log".into());
[INFO] [stdout] 32 +     map.insert(0x08, <&str as Into<_>>::into("minecraft:stripped_acacia_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:33:22
[INFO] [stdout]    |
[INFO] [stdout] 33 |     map.insert(0x09, "minecraft:polished_andesite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 33 -     map.insert(0x09, "minecraft:polished_andesite".into());
[INFO] [stdout] 33 +     map.insert(0x09, "minecraft:polished_andesite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 33 -     map.insert(0x09, "minecraft:polished_andesite".into());
[INFO] [stdout] 33 +     map.insert(0x09, <&str as Into<_>>::into("minecraft:polished_andesite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:34:22
[INFO] [stdout]    |
[INFO] [stdout] 34 |     map.insert(0x0A, "minecraft:acacia_shelf".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 34 -     map.insert(0x0A, "minecraft:acacia_shelf".into());
[INFO] [stdout] 34 +     map.insert(0x0A, "minecraft:acacia_shelf");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 34 -     map.insert(0x0A, "minecraft:acacia_shelf".into());
[INFO] [stdout] 34 +     map.insert(0x0A, <&str as Into<_>>::into("minecraft:acacia_shelf"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:35:22
[INFO] [stdout]    |
[INFO] [stdout] 35 |     map.insert(0x0B, "minecraft:polished_deepslate".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 35 -     map.insert(0x0B, "minecraft:polished_deepslate".into());
[INFO] [stdout] 35 +     map.insert(0x0B, "minecraft:polished_deepslate");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 35 -     map.insert(0x0B, "minecraft:polished_deepslate".into());
[INFO] [stdout] 35 +     map.insert(0x0B, <&str as Into<_>>::into("minecraft:polished_deepslate"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:36:22
[INFO] [stdout]    |
[INFO] [stdout] 36 |     map.insert(0x0C, "minecraft:acacia_slab".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 36 -     map.insert(0x0C, "minecraft:acacia_slab".into());
[INFO] [stdout] 36 +     map.insert(0x0C, "minecraft:acacia_slab");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 36 -     map.insert(0x0C, "minecraft:acacia_slab".into());
[INFO] [stdout] 36 +     map.insert(0x0C, <&str as Into<_>>::into("minecraft:acacia_slab"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:37:22
[INFO] [stdout]    |
[INFO] [stdout] 37 |     map.insert(0x0D, "minecraft:acacia_stairs".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 37 -     map.insert(0x0D, "minecraft:acacia_stairs".into());
[INFO] [stdout] 37 +     map.insert(0x0D, "minecraft:acacia_stairs");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 37 -     map.insert(0x0D, "minecraft:acacia_stairs".into());
[INFO] [stdout] 37 +     map.insert(0x0D, <&str as Into<_>>::into("minecraft:acacia_stairs"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:38:22
[INFO] [stdout]    |
[INFO] [stdout] 38 |     map.insert(0x0E, "minecraft:acacia_trapdoor".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 38 -     map.insert(0x0E, "minecraft:acacia_trapdoor".into());
[INFO] [stdout] 38 +     map.insert(0x0E, "minecraft:acacia_trapdoor");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 38 -     map.insert(0x0E, "minecraft:acacia_trapdoor".into());
[INFO] [stdout] 38 +     map.insert(0x0E, <&str as Into<_>>::into("minecraft:acacia_trapdoor"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:39:22
[INFO] [stdout]    |
[INFO] [stdout] 39 |     map.insert(0x0F, "minecraft:polished_tuff".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 39 -     map.insert(0x0F, "minecraft:polished_tuff".into());
[INFO] [stdout] 39 +     map.insert(0x0F, "minecraft:polished_tuff");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 39 -     map.insert(0x0F, "minecraft:polished_tuff".into());
[INFO] [stdout] 39 +     map.insert(0x0F, <&str as Into<_>>::into("minecraft:polished_tuff"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:40:22
[INFO] [stdout]    |
[INFO] [stdout] 40 |     map.insert(0x10, "minecraft:end_stone_bricks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 40 -     map.insert(0x10, "minecraft:end_stone_bricks".into());
[INFO] [stdout] 40 +     map.insert(0x10, "minecraft:end_stone_bricks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 40 -     map.insert(0x10, "minecraft:end_stone_bricks".into());
[INFO] [stdout] 40 +     map.insert(0x10, <&str as Into<_>>::into("minecraft:end_stone_bricks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:41:22
[INFO] [stdout]    |
[INFO] [stdout] 41 |     map.insert(0x11, "minecraft:acacia_wood".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 41 -     map.insert(0x11, "minecraft:acacia_wood".into());
[INFO] [stdout] 41 +     map.insert(0x11, "minecraft:acacia_wood");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 41 -     map.insert(0x11, "minecraft:acacia_wood".into());
[INFO] [stdout] 41 +     map.insert(0x11, <&str as Into<_>>::into("minecraft:acacia_wood"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:42:22
[INFO] [stdout]    |
[INFO] [stdout] 42 |     map.insert(0x12, "minecraft:activator_rail".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 42 -     map.insert(0x12, "minecraft:activator_rail".into());
[INFO] [stdout] 42 +     map.insert(0x12, "minecraft:activator_rail");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -     map.insert(0x12, "minecraft:activator_rail".into());
[INFO] [stdout] 42 +     map.insert(0x12, <&str as Into<_>>::into("minecraft:activator_rail"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:43:22
[INFO] [stdout]    |
[INFO] [stdout] 43 |     map.insert(0x13, "minecraft:deepslate_bricks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 43 -     map.insert(0x13, "minecraft:deepslate_bricks".into());
[INFO] [stdout] 43 +     map.insert(0x13, "minecraft:deepslate_bricks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 43 -     map.insert(0x13, "minecraft:deepslate_bricks".into());
[INFO] [stdout] 43 +     map.insert(0x13, <&str as Into<_>>::into("minecraft:deepslate_bricks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:44:22
[INFO] [stdout]    |
[INFO] [stdout] 44 |     map.insert(0x14, "minecraft:polished_diorite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 44 -     map.insert(0x14, "minecraft:polished_diorite".into());
[INFO] [stdout] 44 +     map.insert(0x14, "minecraft:polished_diorite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 44 -     map.insert(0x14, "minecraft:polished_diorite".into());
[INFO] [stdout] 44 +     map.insert(0x14, <&str as Into<_>>::into("minecraft:polished_diorite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:45:22
[INFO] [stdout]    |
[INFO] [stdout] 45 |     map.insert(0x15, "minecraft:amethyst_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 45 -     map.insert(0x15, "minecraft:amethyst_block".into());
[INFO] [stdout] 45 +     map.insert(0x15, "minecraft:amethyst_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 45 -     map.insert(0x15, "minecraft:amethyst_block".into());
[INFO] [stdout] 45 +     map.insert(0x15, <&str as Into<_>>::into("minecraft:amethyst_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:46:22
[INFO] [stdout]    |
[INFO] [stdout] 46 |     map.insert(0x16, "minecraft:amethyst_cluster".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 46 -     map.insert(0x16, "minecraft:amethyst_cluster".into());
[INFO] [stdout] 46 +     map.insert(0x16, "minecraft:amethyst_cluster");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 46 -     map.insert(0x16, "minecraft:amethyst_cluster".into());
[INFO] [stdout] 46 +     map.insert(0x16, <&str as Into<_>>::into("minecraft:amethyst_cluster"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:47:22
[INFO] [stdout]    |
[INFO] [stdout] 47 |     map.insert(0x17, "minecraft:ancient_debris".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 47 -     map.insert(0x17, "minecraft:ancient_debris".into());
[INFO] [stdout] 47 +     map.insert(0x17, "minecraft:ancient_debris");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 47 -     map.insert(0x17, "minecraft:ancient_debris".into());
[INFO] [stdout] 47 +     map.insert(0x17, <&str as Into<_>>::into("minecraft:ancient_debris"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:48:22
[INFO] [stdout]    |
[INFO] [stdout] 48 |     map.insert(0x18, "minecraft:andesite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 48 -     map.insert(0x18, "minecraft:andesite".into());
[INFO] [stdout] 48 +     map.insert(0x18, "minecraft:andesite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 48 -     map.insert(0x18, "minecraft:andesite".into());
[INFO] [stdout] 48 +     map.insert(0x18, <&str as Into<_>>::into("minecraft:andesite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:49:22
[INFO] [stdout]    |
[INFO] [stdout] 49 |     map.insert(0x19, "minecraft:andesite_slab".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 49 -     map.insert(0x19, "minecraft:andesite_slab".into());
[INFO] [stdout] 49 +     map.insert(0x19, "minecraft:andesite_slab");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 49 -     map.insert(0x19, "minecraft:andesite_slab".into());
[INFO] [stdout] 49 +     map.insert(0x19, <&str as Into<_>>::into("minecraft:andesite_slab"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:50:22
[INFO] [stdout]    |
[INFO] [stdout] 50 |     map.insert(0x1A, "minecraft:andesite_stairs".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 50 -     map.insert(0x1A, "minecraft:andesite_stairs".into());
[INFO] [stdout] 50 +     map.insert(0x1A, "minecraft:andesite_stairs");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 -     map.insert(0x1A, "minecraft:andesite_stairs".into());
[INFO] [stdout] 50 +     map.insert(0x1A, <&str as Into<_>>::into("minecraft:andesite_stairs"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:51:22
[INFO] [stdout]    |
[INFO] [stdout] 51 |     map.insert(0x1B, "minecraft:andesite_wall".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 51 -     map.insert(0x1B, "minecraft:andesite_wall".into());
[INFO] [stdout] 51 +     map.insert(0x1B, "minecraft:andesite_wall");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 51 -     map.insert(0x1B, "minecraft:andesite_wall".into());
[INFO] [stdout] 51 +     map.insert(0x1B, <&str as Into<_>>::into("minecraft:andesite_wall"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:52:22
[INFO] [stdout]    |
[INFO] [stdout] 52 |     map.insert(0x1C, "minecraft:anvil".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 52 -     map.insert(0x1C, "minecraft:anvil".into());
[INFO] [stdout] 52 +     map.insert(0x1C, "minecraft:anvil");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 52 -     map.insert(0x1C, "minecraft:anvil".into());
[INFO] [stdout] 52 +     map.insert(0x1C, <&str as Into<_>>::into("minecraft:anvil"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:53:22
[INFO] [stdout]    |
[INFO] [stdout] 53 |     map.insert(0x1D, "minecraft:tuff".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 53 -     map.insert(0x1D, "minecraft:tuff".into());
[INFO] [stdout] 53 +     map.insert(0x1D, "minecraft:tuff");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 -     map.insert(0x1D, "minecraft:tuff".into());
[INFO] [stdout] 53 +     map.insert(0x1D, <&str as Into<_>>::into("minecraft:tuff"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:54:22
[INFO] [stdout]    |
[INFO] [stdout] 54 |     map.insert(0x1E, "minecraft:diorite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 54 -     map.insert(0x1E, "minecraft:diorite".into());
[INFO] [stdout] 54 +     map.insert(0x1E, "minecraft:diorite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -     map.insert(0x1E, "minecraft:diorite".into());
[INFO] [stdout] 54 +     map.insert(0x1E, <&str as Into<_>>::into("minecraft:diorite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:55:22
[INFO] [stdout]    |
[INFO] [stdout] 55 |     map.insert(0x1F, "minecraft:mycelium".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 55 -     map.insert(0x1F, "minecraft:mycelium".into());
[INFO] [stdout] 55 +     map.insert(0x1F, "minecraft:mycelium");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -     map.insert(0x1F, "minecraft:mycelium".into());
[INFO] [stdout] 55 +     map.insert(0x1F, <&str as Into<_>>::into("minecraft:mycelium"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:56:22
[INFO] [stdout]    |
[INFO] [stdout] 56 |     map.insert(0x20, "minecraft:stripped_jungle_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 56 -     map.insert(0x20, "minecraft:stripped_jungle_log".into());
[INFO] [stdout] 56 +     map.insert(0x20, "minecraft:stripped_jungle_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -     map.insert(0x20, "minecraft:stripped_jungle_log".into());
[INFO] [stdout] 56 +     map.insert(0x20, <&str as Into<_>>::into("minecraft:stripped_jungle_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:57:22
[INFO] [stdout]    |
[INFO] [stdout] 57 |     map.insert(0x21, "minecraft:polished_granite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 57 -     map.insert(0x21, "minecraft:polished_granite".into());
[INFO] [stdout] 57 +     map.insert(0x21, "minecraft:polished_granite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -     map.insert(0x21, "minecraft:polished_granite".into());
[INFO] [stdout] 57 +     map.insert(0x21, <&str as Into<_>>::into("minecraft:polished_granite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:58:22
[INFO] [stdout]    |
[INFO] [stdout] 58 |     map.insert(0x22, "minecraft:deepslate_tiles".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 58 -     map.insert(0x22, "minecraft:deepslate_tiles".into());
[INFO] [stdout] 58 +     map.insert(0x22, "minecraft:deepslate_tiles");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -     map.insert(0x22, "minecraft:deepslate_tiles".into());
[INFO] [stdout] 58 +     map.insert(0x22, <&str as Into<_>>::into("minecraft:deepslate_tiles"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:59:22
[INFO] [stdout]    |
[INFO] [stdout] 59 |     map.insert(0x23, "minecraft:bamboo_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 59 -     map.insert(0x23, "minecraft:bamboo_block".into());
[INFO] [stdout] 59 +     map.insert(0x23, "minecraft:bamboo_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -     map.insert(0x23, "minecraft:bamboo_block".into());
[INFO] [stdout] 59 +     map.insert(0x23, <&str as Into<_>>::into("minecraft:bamboo_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:60:22
[INFO] [stdout]    |
[INFO] [stdout] 60 |     map.insert(0x24, "minecraft:mud_bricks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 60 -     map.insert(0x24, "minecraft:mud_bricks".into());
[INFO] [stdout] 60 +     map.insert(0x24, "minecraft:mud_bricks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -     map.insert(0x24, "minecraft:mud_bricks".into());
[INFO] [stdout] 60 +     map.insert(0x24, <&str as Into<_>>::into("minecraft:mud_bricks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:61:22
[INFO] [stdout]    |
[INFO] [stdout] 61 |     map.insert(0x25, "minecraft:moss_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 61 -     map.insert(0x25, "minecraft:moss_block".into());
[INFO] [stdout] 61 +     map.insert(0x25, "minecraft:moss_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -     map.insert(0x25, "minecraft:moss_block".into());
[INFO] [stdout] 61 +     map.insert(0x25, <&str as Into<_>>::into("minecraft:moss_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:62:22
[INFO] [stdout]    |
[INFO] [stdout] 62 |     map.insert(0x26, "minecraft:bamboo_fence".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 62 -     map.insert(0x26, "minecraft:bamboo_fence".into());
[INFO] [stdout] 62 +     map.insert(0x26, "minecraft:bamboo_fence");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 -     map.insert(0x26, "minecraft:bamboo_fence".into());
[INFO] [stdout] 62 +     map.insert(0x26, <&str as Into<_>>::into("minecraft:bamboo_fence"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:63:22
[INFO] [stdout]    |
[INFO] [stdout] 63 |     map.insert(0x27, "minecraft:bamboo_fence_gate".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 63 -     map.insert(0x27, "minecraft:bamboo_fence_gate".into());
[INFO] [stdout] 63 +     map.insert(0x27, "minecraft:bamboo_fence_gate");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 -     map.insert(0x27, "minecraft:bamboo_fence_gate".into());
[INFO] [stdout] 63 +     map.insert(0x27, <&str as Into<_>>::into("minecraft:bamboo_fence_gate"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:64:22
[INFO] [stdout]    |
[INFO] [stdout] 64 |     map.insert(0x28, "minecraft:diamond_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 64 -     map.insert(0x28, "minecraft:diamond_block".into());
[INFO] [stdout] 64 +     map.insert(0x28, "minecraft:diamond_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 64 -     map.insert(0x28, "minecraft:diamond_block".into());
[INFO] [stdout] 64 +     map.insert(0x28, <&str as Into<_>>::into("minecraft:diamond_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:65:22
[INFO] [stdout]    |
[INFO] [stdout] 65 |     map.insert(0x29, "minecraft:bamboo_mosaic".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 65 -     map.insert(0x29, "minecraft:bamboo_mosaic".into());
[INFO] [stdout] 65 +     map.insert(0x29, "minecraft:bamboo_mosaic");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 65 -     map.insert(0x29, "minecraft:bamboo_mosaic".into());
[INFO] [stdout] 65 +     map.insert(0x29, <&str as Into<_>>::into("minecraft:bamboo_mosaic"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:66:22
[INFO] [stdout]    |
[INFO] [stdout] 66 |     map.insert(0x2A, "minecraft:bamboo_mosaic_slab".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 66 -     map.insert(0x2A, "minecraft:bamboo_mosaic_slab".into());
[INFO] [stdout] 66 +     map.insert(0x2A, "minecraft:bamboo_mosaic_slab");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 -     map.insert(0x2A, "minecraft:bamboo_mosaic_slab".into());
[INFO] [stdout] 66 +     map.insert(0x2A, <&str as Into<_>>::into("minecraft:bamboo_mosaic_slab"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:67:22
[INFO] [stdout]    |
[INFO] [stdout] 67 |     map.insert(0x2B, "minecraft:bamboo_mosaic_stairs".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 67 -     map.insert(0x2B, "minecraft:bamboo_mosaic_stairs".into());
[INFO] [stdout] 67 +     map.insert(0x2B, "minecraft:bamboo_mosaic_stairs");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 -     map.insert(0x2B, "minecraft:bamboo_mosaic_stairs".into());
[INFO] [stdout] 67 +     map.insert(0x2B, <&str as Into<_>>::into("minecraft:bamboo_mosaic_stairs"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:68:22
[INFO] [stdout]    |
[INFO] [stdout] 68 |     map.insert(0x2C, "minecraft:bamboo_planks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 68 -     map.insert(0x2C, "minecraft:bamboo_planks".into());
[INFO] [stdout] 68 +     map.insert(0x2C, "minecraft:bamboo_planks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 -     map.insert(0x2C, "minecraft:bamboo_planks".into());
[INFO] [stdout] 68 +     map.insert(0x2C, <&str as Into<_>>::into("minecraft:bamboo_planks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:69:22
[INFO] [stdout]    |
[INFO] [stdout] 69 |     map.insert(0x2D, "minecraft:stripped_bamboo_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 69 -     map.insert(0x2D, "minecraft:stripped_bamboo_block".into());
[INFO] [stdout] 69 +     map.insert(0x2D, "minecraft:stripped_bamboo_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 -     map.insert(0x2D, "minecraft:stripped_bamboo_block".into());
[INFO] [stdout] 69 +     map.insert(0x2D, <&str as Into<_>>::into("minecraft:stripped_bamboo_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:70:22
[INFO] [stdout]    |
[INFO] [stdout] 70 |     map.insert(0x2E, "minecraft:sandstone".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 70 -     map.insert(0x2E, "minecraft:sandstone".into());
[INFO] [stdout] 70 +     map.insert(0x2E, "minecraft:sandstone");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 70 -     map.insert(0x2E, "minecraft:sandstone".into());
[INFO] [stdout] 70 +     map.insert(0x2E, <&str as Into<_>>::into("minecraft:sandstone"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:71:22
[INFO] [stdout]    |
[INFO] [stdout] 71 |     map.insert(0x2F, "minecraft:bamboo_shelf".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 71 -     map.insert(0x2F, "minecraft:bamboo_shelf".into());
[INFO] [stdout] 71 +     map.insert(0x2F, "minecraft:bamboo_shelf");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 -     map.insert(0x2F, "minecraft:bamboo_shelf".into());
[INFO] [stdout] 71 +     map.insert(0x2F, <&str as Into<_>>::into("minecraft:bamboo_shelf"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:72:22
[INFO] [stdout]    |
[INFO] [stdout] 72 |     map.insert(0x30, "minecraft:emerald_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 72 -     map.insert(0x30, "minecraft:emerald_block".into());
[INFO] [stdout] 72 +     map.insert(0x30, "minecraft:emerald_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 -     map.insert(0x30, "minecraft:emerald_block".into());
[INFO] [stdout] 72 +     map.insert(0x30, <&str as Into<_>>::into("minecraft:emerald_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:73:22
[INFO] [stdout]    |
[INFO] [stdout] 73 |     map.insert(0x31, "minecraft:bamboo_slab".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 73 -     map.insert(0x31, "minecraft:bamboo_slab".into());
[INFO] [stdout] 73 +     map.insert(0x31, "minecraft:bamboo_slab");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 73 -     map.insert(0x31, "minecraft:bamboo_slab".into());
[INFO] [stdout] 73 +     map.insert(0x31, <&str as Into<_>>::into("minecraft:bamboo_slab"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:74:22
[INFO] [stdout]    |
[INFO] [stdout] 74 |     map.insert(0x32, "minecraft:bamboo_stairs".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 74 -     map.insert(0x32, "minecraft:bamboo_stairs".into());
[INFO] [stdout] 74 +     map.insert(0x32, "minecraft:bamboo_stairs");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 -     map.insert(0x32, "minecraft:bamboo_stairs".into());
[INFO] [stdout] 74 +     map.insert(0x32, <&str as Into<_>>::into("minecraft:bamboo_stairs"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:75:22
[INFO] [stdout]    |
[INFO] [stdout] 75 |     map.insert(0x33, "minecraft:bamboo_trapdoor".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 75 -     map.insert(0x33, "minecraft:bamboo_trapdoor".into());
[INFO] [stdout] 75 +     map.insert(0x33, "minecraft:bamboo_trapdoor");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 75 -     map.insert(0x33, "minecraft:bamboo_trapdoor".into());
[INFO] [stdout] 75 +     map.insert(0x33, <&str as Into<_>>::into("minecraft:bamboo_trapdoor"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:76:22
[INFO] [stdout]    |
[INFO] [stdout] 76 |     map.insert(0x34, "minecraft:iron_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 76 -     map.insert(0x34, "minecraft:iron_block".into());
[INFO] [stdout] 76 +     map.insert(0x34, "minecraft:iron_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 76 -     map.insert(0x34, "minecraft:iron_block".into());
[INFO] [stdout] 76 +     map.insert(0x34, <&str as Into<_>>::into("minecraft:iron_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:77:22
[INFO] [stdout]    |
[INFO] [stdout] 77 |     map.insert(0x35, "minecraft:gold_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 77 -     map.insert(0x35, "minecraft:gold_block".into());
[INFO] [stdout] 77 +     map.insert(0x35, "minecraft:gold_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 77 -     map.insert(0x35, "minecraft:gold_block".into());
[INFO] [stdout] 77 +     map.insert(0x35, <&str as Into<_>>::into("minecraft:gold_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:78:22
[INFO] [stdout]    |
[INFO] [stdout] 78 |     map.insert(0x36, "minecraft:barrel".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 78 -     map.insert(0x36, "minecraft:barrel".into());
[INFO] [stdout] 78 +     map.insert(0x36, "minecraft:barrel");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 78 -     map.insert(0x36, "minecraft:barrel".into());
[INFO] [stdout] 78 +     map.insert(0x36, <&str as Into<_>>::into("minecraft:barrel"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:79:22
[INFO] [stdout]    |
[INFO] [stdout] 79 |     map.insert(0x37, "minecraft:crimson_shelf".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 79 -     map.insert(0x37, "minecraft:crimson_shelf".into());
[INFO] [stdout] 79 +     map.insert(0x37, "minecraft:crimson_shelf");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 79 -     map.insert(0x37, "minecraft:crimson_shelf".into());
[INFO] [stdout] 79 +     map.insert(0x37, <&str as Into<_>>::into("minecraft:crimson_shelf"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:80:22
[INFO] [stdout]    |
[INFO] [stdout] 80 |     map.insert(0x38, "minecraft:basalt".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 80 -     map.insert(0x38, "minecraft:basalt".into());
[INFO] [stdout] 80 +     map.insert(0x38, "minecraft:basalt");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 -     map.insert(0x38, "minecraft:basalt".into());
[INFO] [stdout] 80 +     map.insert(0x38, <&str as Into<_>>::into("minecraft:basalt"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:81:22
[INFO] [stdout]    |
[INFO] [stdout] 81 |     map.insert(0x39, "minecraft:beacon".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 81 -     map.insert(0x39, "minecraft:beacon".into());
[INFO] [stdout] 81 +     map.insert(0x39, "minecraft:beacon");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 81 -     map.insert(0x39, "minecraft:beacon".into());
[INFO] [stdout] 81 +     map.insert(0x39, <&str as Into<_>>::into("minecraft:beacon"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:82:22
[INFO] [stdout]    |
[INFO] [stdout] 82 |     map.insert(0x3A, "minecraft:bedrock".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 82 -     map.insert(0x3A, "minecraft:bedrock".into());
[INFO] [stdout] 82 +     map.insert(0x3A, "minecraft:bedrock");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 -     map.insert(0x3A, "minecraft:bedrock".into());
[INFO] [stdout] 82 +     map.insert(0x3A, <&str as Into<_>>::into("minecraft:bedrock"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:83:22
[INFO] [stdout]    |
[INFO] [stdout] 83 |     map.insert(0x3B, "minecraft:bee_nest".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 83 -     map.insert(0x3B, "minecraft:bee_nest".into());
[INFO] [stdout] 83 +     map.insert(0x3B, "minecraft:bee_nest");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 -     map.insert(0x3B, "minecraft:bee_nest".into());
[INFO] [stdout] 83 +     map.insert(0x3B, <&str as Into<_>>::into("minecraft:bee_nest"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:84:22
[INFO] [stdout]    |
[INFO] [stdout] 84 |     map.insert(0x3C, "minecraft:beehive".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 84 -     map.insert(0x3C, "minecraft:beehive".into());
[INFO] [stdout] 84 +     map.insert(0x3C, "minecraft:beehive");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 -     map.insert(0x3C, "minecraft:beehive".into());
[INFO] [stdout] 84 +     map.insert(0x3C, <&str as Into<_>>::into("minecraft:beehive"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:85:22
[INFO] [stdout]    |
[INFO] [stdout] 85 |     map.insert(0x3D, "minecraft:grass_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 85 -     map.insert(0x3D, "minecraft:grass_block".into());
[INFO] [stdout] 85 +     map.insert(0x3D, "minecraft:grass_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 85 -     map.insert(0x3D, "minecraft:grass_block".into());
[INFO] [stdout] 85 +     map.insert(0x3D, <&str as Into<_>>::into("minecraft:grass_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:86:22
[INFO] [stdout]    |
[INFO] [stdout] 86 |     map.insert(0x3E, "minecraft:bell".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 86 -     map.insert(0x3E, "minecraft:bell".into());
[INFO] [stdout] 86 +     map.insert(0x3E, "minecraft:bell");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 86 -     map.insert(0x3E, "minecraft:bell".into());
[INFO] [stdout] 86 +     map.insert(0x3E, <&str as Into<_>>::into("minecraft:bell"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:87:22
[INFO] [stdout]    |
[INFO] [stdout] 87 |     map.insert(0x3F, "minecraft:fern".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 87 -     map.insert(0x3F, "minecraft:fern".into());
[INFO] [stdout] 87 +     map.insert(0x3F, "minecraft:fern");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 87 -     map.insert(0x3F, "minecraft:fern".into());
[INFO] [stdout] 87 +     map.insert(0x3F, <&str as Into<_>>::into("minecraft:fern"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:88:22
[INFO] [stdout]    |
[INFO] [stdout] 88 |     map.insert(0x40, "minecraft:granite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 88 -     map.insert(0x40, "minecraft:granite".into());
[INFO] [stdout] 88 +     map.insert(0x40, "minecraft:granite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 -     map.insert(0x40, "minecraft:granite".into());
[INFO] [stdout] 88 +     map.insert(0x40, <&str as Into<_>>::into("minecraft:granite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:89:22
[INFO] [stdout]    |
[INFO] [stdout] 89 |     map.insert(0x41, "minecraft:lapis_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 89 -     map.insert(0x41, "minecraft:lapis_block".into());
[INFO] [stdout] 89 +     map.insert(0x41, "minecraft:lapis_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 -     map.insert(0x41, "minecraft:lapis_block".into());
[INFO] [stdout] 89 +     map.insert(0x41, <&str as Into<_>>::into("minecraft:lapis_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:90:22
[INFO] [stdout]    |
[INFO] [stdout] 90 |     map.insert(0x42, "minecraft:dried_kelp_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 90 -     map.insert(0x42, "minecraft:dried_kelp_block".into());
[INFO] [stdout] 90 +     map.insert(0x42, "minecraft:dried_kelp_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 90 -     map.insert(0x42, "minecraft:dried_kelp_block".into());
[INFO] [stdout] 90 +     map.insert(0x42, <&str as Into<_>>::into("minecraft:dried_kelp_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:91:22
[INFO] [stdout]    |
[INFO] [stdout] 91 |     map.insert(0x43, "minecraft:birch_fence".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 91 -     map.insert(0x43, "minecraft:birch_fence".into());
[INFO] [stdout] 91 +     map.insert(0x43, "minecraft:birch_fence");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 -     map.insert(0x43, "minecraft:birch_fence".into());
[INFO] [stdout] 91 +     map.insert(0x43, <&str as Into<_>>::into("minecraft:birch_fence"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:92:22
[INFO] [stdout]    |
[INFO] [stdout] 92 |     map.insert(0x44, "minecraft:birch_fence_gate".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 92 -     map.insert(0x44, "minecraft:birch_fence_gate".into());
[INFO] [stdout] 92 +     map.insert(0x44, "minecraft:birch_fence_gate");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 92 -     map.insert(0x44, "minecraft:birch_fence_gate".into());
[INFO] [stdout] 92 +     map.insert(0x44, <&str as Into<_>>::into("minecraft:birch_fence_gate"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:93:22
[INFO] [stdout]    |
[INFO] [stdout] 93 |     map.insert(0x45, "minecraft:honeycomb_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 93 -     map.insert(0x45, "minecraft:honeycomb_block".into());
[INFO] [stdout] 93 +     map.insert(0x45, "minecraft:honeycomb_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 -     map.insert(0x45, "minecraft:honeycomb_block".into());
[INFO] [stdout] 93 +     map.insert(0x45, <&str as Into<_>>::into("minecraft:honeycomb_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:94:22
[INFO] [stdout]    |
[INFO] [stdout] 94 |     map.insert(0x46, "minecraft:stripped_mangrove_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 94 -     map.insert(0x46, "minecraft:stripped_mangrove_log".into());
[INFO] [stdout] 94 +     map.insert(0x46, "minecraft:stripped_mangrove_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 -     map.insert(0x46, "minecraft:stripped_mangrove_log".into());
[INFO] [stdout] 94 +     map.insert(0x46, <&str as Into<_>>::into("minecraft:stripped_mangrove_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:95:22
[INFO] [stdout]    |
[INFO] [stdout] 95 |     map.insert(0x47, "minecraft:birch_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 95 -     map.insert(0x47, "minecraft:birch_log".into());
[INFO] [stdout] 95 +     map.insert(0x47, "minecraft:birch_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 95 -     map.insert(0x47, "minecraft:birch_log".into());
[INFO] [stdout] 95 +     map.insert(0x47, <&str as Into<_>>::into("minecraft:birch_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:96:22
[INFO] [stdout]    |
[INFO] [stdout] 96 |     map.insert(0x48, "minecraft:birch_planks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 96 -     map.insert(0x48, "minecraft:birch_planks".into());
[INFO] [stdout] 96 +     map.insert(0x48, "minecraft:birch_planks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 -     map.insert(0x48, "minecraft:birch_planks".into());
[INFO] [stdout] 96 +     map.insert(0x48, <&str as Into<_>>::into("minecraft:birch_planks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:97:22
[INFO] [stdout]    |
[INFO] [stdout] 97 |     map.insert(0x49, "minecraft:stripped_birch_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 97 -     map.insert(0x49, "minecraft:stripped_birch_log".into());
[INFO] [stdout] 97 +     map.insert(0x49, "minecraft:stripped_birch_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 97 -     map.insert(0x49, "minecraft:stripped_birch_log".into());
[INFO] [stdout] 97 +     map.insert(0x49, <&str as Into<_>>::into("minecraft:stripped_birch_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:98:22
[INFO] [stdout]    |
[INFO] [stdout] 98 |     map.insert(0x4A, "minecraft:red_sandstone".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 98 -     map.insert(0x4A, "minecraft:red_sandstone".into());
[INFO] [stdout] 98 +     map.insert(0x4A, "minecraft:red_sandstone");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 98 -     map.insert(0x4A, "minecraft:red_sandstone".into());
[INFO] [stdout] 98 +     map.insert(0x4A, <&str as Into<_>>::into("minecraft:red_sandstone"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:99:22
[INFO] [stdout]    |
[INFO] [stdout] 99 |     map.insert(0x4B, "minecraft:birch_shelf".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 99 -     map.insert(0x4B, "minecraft:birch_shelf".into());
[INFO] [stdout] 99 +     map.insert(0x4B, "minecraft:birch_shelf");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 -     map.insert(0x4B, "minecraft:birch_shelf".into());
[INFO] [stdout] 99 +     map.insert(0x4B, <&str as Into<_>>::into("minecraft:birch_shelf"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:100:22
[INFO] [stdout]     |
[INFO] [stdout] 100 |     map.insert(0x4C, "minecraft:hay_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 100 -     map.insert(0x4C, "minecraft:hay_block".into());
[INFO] [stdout] 100 +     map.insert(0x4C, "minecraft:hay_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 -     map.insert(0x4C, "minecraft:hay_block".into());
[INFO] [stdout] 100 +     map.insert(0x4C, <&str as Into<_>>::into("minecraft:hay_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:101:22
[INFO] [stdout]     |
[INFO] [stdout] 101 |     map.insert(0x4D, "minecraft:birch_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 101 -     map.insert(0x4D, "minecraft:birch_slab".into());
[INFO] [stdout] 101 +     map.insert(0x4D, "minecraft:birch_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 101 -     map.insert(0x4D, "minecraft:birch_slab".into());
[INFO] [stdout] 101 +     map.insert(0x4D, <&str as Into<_>>::into("minecraft:birch_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:102:22
[INFO] [stdout]     |
[INFO] [stdout] 102 |     map.insert(0x4E, "minecraft:birch_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 102 -     map.insert(0x4E, "minecraft:birch_stairs".into());
[INFO] [stdout] 102 +     map.insert(0x4E, "minecraft:birch_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 102 -     map.insert(0x4E, "minecraft:birch_stairs".into());
[INFO] [stdout] 102 +     map.insert(0x4E, <&str as Into<_>>::into("minecraft:birch_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:103:22
[INFO] [stdout]     |
[INFO] [stdout] 103 |     map.insert(0x4F, "minecraft:birch_trapdoor".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 103 -     map.insert(0x4F, "minecraft:birch_trapdoor".into());
[INFO] [stdout] 103 +     map.insert(0x4F, "minecraft:birch_trapdoor");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 103 -     map.insert(0x4F, "minecraft:birch_trapdoor".into());
[INFO] [stdout] 103 +     map.insert(0x4F, <&str as Into<_>>::into("minecraft:birch_trapdoor"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:104:22
[INFO] [stdout]     |
[INFO] [stdout] 104 |     map.insert(0x50, "minecraft:glowstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 104 -     map.insert(0x50, "minecraft:glowstone".into());
[INFO] [stdout] 104 +     map.insert(0x50, "minecraft:glowstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 104 -     map.insert(0x50, "minecraft:glowstone".into());
[INFO] [stdout] 104 +     map.insert(0x50, <&str as Into<_>>::into("minecraft:glowstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:105:22
[INFO] [stdout]     |
[INFO] [stdout] 105 |     map.insert(0x51, "minecraft:nether_wart_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 105 -     map.insert(0x51, "minecraft:nether_wart_block".into());
[INFO] [stdout] 105 +     map.insert(0x51, "minecraft:nether_wart_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 105 -     map.insert(0x51, "minecraft:nether_wart_block".into());
[INFO] [stdout] 105 +     map.insert(0x51, <&str as Into<_>>::into("minecraft:nether_wart_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:106:22
[INFO] [stdout]     |
[INFO] [stdout] 106 |     map.insert(0x52, "minecraft:birch_wood".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 106 -     map.insert(0x52, "minecraft:birch_wood".into());
[INFO] [stdout] 106 +     map.insert(0x52, "minecraft:birch_wood");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 -     map.insert(0x52, "minecraft:birch_wood".into());
[INFO] [stdout] 106 +     map.insert(0x52, <&str as Into<_>>::into("minecraft:birch_wood"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:107:22
[INFO] [stdout]     |
[INFO] [stdout] 107 |     map.insert(0x53, "minecraft:mossy_cobblestone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 107 -     map.insert(0x53, "minecraft:mossy_cobblestone".into());
[INFO] [stdout] 107 +     map.insert(0x53, "minecraft:mossy_cobblestone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 107 -     map.insert(0x53, "minecraft:mossy_cobblestone".into());
[INFO] [stdout] 107 +     map.insert(0x53, <&str as Into<_>>::into("minecraft:mossy_cobblestone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:108:22
[INFO] [stdout]     |
[INFO] [stdout] 108 |     map.insert(0x54, "minecraft:white_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 108 -     map.insert(0x54, "minecraft:white_wool".into());
[INFO] [stdout] 108 +     map.insert(0x54, "minecraft:white_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 108 -     map.insert(0x54, "minecraft:white_wool".into());
[INFO] [stdout] 108 +     map.insert(0x54, <&str as Into<_>>::into("minecraft:white_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:109:22
[INFO] [stdout]     |
[INFO] [stdout] 109 |     map.insert(0x55, "minecraft:magma_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 109 -     map.insert(0x55, "minecraft:magma_block".into());
[INFO] [stdout] 109 +     map.insert(0x55, "minecraft:magma_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 109 -     map.insert(0x55, "minecraft:magma_block".into());
[INFO] [stdout] 109 +     map.insert(0x55, <&str as Into<_>>::into("minecraft:magma_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:110:22
[INFO] [stdout]     |
[INFO] [stdout] 110 |     map.insert(0x56, "minecraft:dark_oak_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 110 -     map.insert(0x56, "minecraft:dark_oak_log".into());
[INFO] [stdout] 110 +     map.insert(0x56, "minecraft:dark_oak_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 -     map.insert(0x56, "minecraft:dark_oak_log".into());
[INFO] [stdout] 110 +     map.insert(0x56, <&str as Into<_>>::into("minecraft:dark_oak_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:111:22
[INFO] [stdout]     |
[INFO] [stdout] 111 |     map.insert(0x57, "minecraft:prismarine".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 111 -     map.insert(0x57, "minecraft:prismarine".into());
[INFO] [stdout] 111 +     map.insert(0x57, "minecraft:prismarine");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 111 -     map.insert(0x57, "minecraft:prismarine".into());
[INFO] [stdout] 111 +     map.insert(0x57, <&str as Into<_>>::into("minecraft:prismarine"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:112:22
[INFO] [stdout]     |
[INFO] [stdout] 112 |     map.insert(0x58, "minecraft:black_concrete".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 112 -     map.insert(0x58, "minecraft:black_concrete".into());
[INFO] [stdout] 112 +     map.insert(0x58, "minecraft:black_concrete");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 112 -     map.insert(0x58, "minecraft:black_concrete".into());
[INFO] [stdout] 112 +     map.insert(0x58, <&str as Into<_>>::into("minecraft:black_concrete"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:113:22
[INFO] [stdout]     |
[INFO] [stdout] 113 |     map.insert(0x59, "minecraft:black_concrete_powder".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 113 -     map.insert(0x59, "minecraft:black_concrete_powder".into());
[INFO] [stdout] 113 +     map.insert(0x59, "minecraft:black_concrete_powder");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 113 -     map.insert(0x59, "minecraft:black_concrete_powder".into());
[INFO] [stdout] 113 +     map.insert(0x59, <&str as Into<_>>::into("minecraft:black_concrete_powder"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:114:22
[INFO] [stdout]     |
[INFO] [stdout] 114 |     map.insert(0x5A, "minecraft:black_glazed_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 114 -     map.insert(0x5A, "minecraft:black_glazed_terracotta".into());
[INFO] [stdout] 114 +     map.insert(0x5A, "minecraft:black_glazed_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 114 -     map.insert(0x5A, "minecraft:black_glazed_terracotta".into());
[INFO] [stdout] 114 +     map.insert(0x5A, <&str as Into<_>>::into("minecraft:black_glazed_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:115:22
[INFO] [stdout]     |
[INFO] [stdout] 115 |     map.insert(0x5B, "minecraft:dark_oak_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 115 -     map.insert(0x5B, "minecraft:dark_oak_planks".into());
[INFO] [stdout] 115 +     map.insert(0x5B, "minecraft:dark_oak_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 115 -     map.insert(0x5B, "minecraft:dark_oak_planks".into());
[INFO] [stdout] 115 +     map.insert(0x5B, <&str as Into<_>>::into("minecraft:dark_oak_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:116:22
[INFO] [stdout]     |
[INFO] [stdout] 116 |     map.insert(0x5C, "minecraft:black_stained_glass".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 116 -     map.insert(0x5C, "minecraft:black_stained_glass".into());
[INFO] [stdout] 116 +     map.insert(0x5C, "minecraft:black_stained_glass");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 116 -     map.insert(0x5C, "minecraft:black_stained_glass".into());
[INFO] [stdout] 116 +     map.insert(0x5C, <&str as Into<_>>::into("minecraft:black_stained_glass"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:117:22
[INFO] [stdout]     |
[INFO] [stdout] 117 |     map.insert(0x5D, "minecraft:black_stained_glass_pane".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 117 -     map.insert(0x5D, "minecraft:black_stained_glass_pane".into());
[INFO] [stdout] 117 +     map.insert(0x5D, "minecraft:black_stained_glass_pane");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 117 -     map.insert(0x5D, "minecraft:black_stained_glass_pane".into());
[INFO] [stdout] 117 +     map.insert(0x5D, <&str as Into<_>>::into("minecraft:black_stained_glass_pane"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:118:22
[INFO] [stdout]     |
[INFO] [stdout] 118 |     map.insert(0x5E, "minecraft:black_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 118 -     map.insert(0x5E, "minecraft:black_terracotta".into());
[INFO] [stdout] 118 +     map.insert(0x5E, "minecraft:black_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 118 -     map.insert(0x5E, "minecraft:black_terracotta".into());
[INFO] [stdout] 118 +     map.insert(0x5E, <&str as Into<_>>::into("minecraft:black_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:119:22
[INFO] [stdout]     |
[INFO] [stdout] 119 |     map.insert(0x5F, "minecraft:prismarine_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 119 -     map.insert(0x5F, "minecraft:prismarine_bricks".into());
[INFO] [stdout] 119 +     map.insert(0x5F, "minecraft:prismarine_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 119 -     map.insert(0x5F, "minecraft:prismarine_bricks".into());
[INFO] [stdout] 119 +     map.insert(0x5F, <&str as Into<_>>::into("minecraft:prismarine_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:120:22
[INFO] [stdout]     |
[INFO] [stdout] 120 |     map.insert(0x60, "minecraft:black_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 120 -     map.insert(0x60, "minecraft:black_wool".into());
[INFO] [stdout] 120 +     map.insert(0x60, "minecraft:black_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 120 -     map.insert(0x60, "minecraft:black_wool".into());
[INFO] [stdout] 120 +     map.insert(0x60, <&str as Into<_>>::into("minecraft:black_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:121:22
[INFO] [stdout]     |
[INFO] [stdout] 121 |     map.insert(0x61, "minecraft:blackstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 121 -     map.insert(0x61, "minecraft:blackstone".into());
[INFO] [stdout] 121 +     map.insert(0x61, "minecraft:blackstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 121 -     map.insert(0x61, "minecraft:blackstone".into());
[INFO] [stdout] 121 +     map.insert(0x61, <&str as Into<_>>::into("minecraft:blackstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:122:22
[INFO] [stdout]     |
[INFO] [stdout] 122 |     map.insert(0x62, "minecraft:blackstone_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 122 -     map.insert(0x62, "minecraft:blackstone_slab".into());
[INFO] [stdout] 122 +     map.insert(0x62, "minecraft:blackstone_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 122 -     map.insert(0x62, "minecraft:blackstone_slab".into());
[INFO] [stdout] 122 +     map.insert(0x62, <&str as Into<_>>::into("minecraft:blackstone_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:123:22
[INFO] [stdout]     |
[INFO] [stdout] 123 |     map.insert(0x63, "minecraft:blackstone_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 123 -     map.insert(0x63, "minecraft:blackstone_stairs".into());
[INFO] [stdout] 123 +     map.insert(0x63, "minecraft:blackstone_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 123 -     map.insert(0x63, "minecraft:blackstone_stairs".into());
[INFO] [stdout] 123 +     map.insert(0x63, <&str as Into<_>>::into("minecraft:blackstone_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:124:22
[INFO] [stdout]     |
[INFO] [stdout] 124 |     map.insert(0x64, "minecraft:blackstone_wall".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 124 -     map.insert(0x64, "minecraft:blackstone_wall".into());
[INFO] [stdout] 124 +     map.insert(0x64, "minecraft:blackstone_wall");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 124 -     map.insert(0x64, "minecraft:blackstone_wall".into());
[INFO] [stdout] 124 +     map.insert(0x64, <&str as Into<_>>::into("minecraft:blackstone_wall"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:125:22
[INFO] [stdout]     |
[INFO] [stdout] 125 |     map.insert(0x65, "minecraft:blast_furnace".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 125 -     map.insert(0x65, "minecraft:blast_furnace".into());
[INFO] [stdout] 125 +     map.insert(0x65, "minecraft:blast_furnace");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 125 -     map.insert(0x65, "minecraft:blast_furnace".into());
[INFO] [stdout] 125 +     map.insert(0x65, <&str as Into<_>>::into("minecraft:blast_furnace"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:126:22
[INFO] [stdout]     |
[INFO] [stdout] 126 |     map.insert(0x66, "minecraft:red_nether_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 126 -     map.insert(0x66, "minecraft:red_nether_bricks".into());
[INFO] [stdout] 126 +     map.insert(0x66, "minecraft:red_nether_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 126 -     map.insert(0x66, "minecraft:red_nether_bricks".into());
[INFO] [stdout] 126 +     map.insert(0x66, <&str as Into<_>>::into("minecraft:red_nether_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:127:22
[INFO] [stdout]     |
[INFO] [stdout] 127 |     map.insert(0x67, "minecraft:white_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 127 -     map.insert(0x67, "minecraft:white_terracotta".into());
[INFO] [stdout] 127 +     map.insert(0x67, "minecraft:white_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 -     map.insert(0x67, "minecraft:white_terracotta".into());
[INFO] [stdout] 127 +     map.insert(0x67, <&str as Into<_>>::into("minecraft:white_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:128:22
[INFO] [stdout]     |
[INFO] [stdout] 128 |     map.insert(0x68, "minecraft:lodestone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 128 -     map.insert(0x68, "minecraft:lodestone".into());
[INFO] [stdout] 128 +     map.insert(0x68, "minecraft:lodestone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 -     map.insert(0x68, "minecraft:lodestone".into());
[INFO] [stdout] 128 +     map.insert(0x68, <&str as Into<_>>::into("minecraft:lodestone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:129:22
[INFO] [stdout]     |
[INFO] [stdout] 129 |     map.insert(0x69, "minecraft:gilded_blackstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 129 -     map.insert(0x69, "minecraft:gilded_blackstone".into());
[INFO] [stdout] 129 +     map.insert(0x69, "minecraft:gilded_blackstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 129 -     map.insert(0x69, "minecraft:gilded_blackstone".into());
[INFO] [stdout] 129 +     map.insert(0x69, <&str as Into<_>>::into("minecraft:gilded_blackstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:130:22
[INFO] [stdout]     |
[INFO] [stdout] 130 |     map.insert(0x6A, "minecraft:dark_prismarine".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 130 -     map.insert(0x6A, "minecraft:dark_prismarine".into());
[INFO] [stdout] 130 +     map.insert(0x6A, "minecraft:dark_prismarine");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 130 -     map.insert(0x6A, "minecraft:dark_prismarine".into());
[INFO] [stdout] 130 +     map.insert(0x6A, <&str as Into<_>>::into("minecraft:dark_prismarine"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:131:22
[INFO] [stdout]     |
[INFO] [stdout] 131 |     map.insert(0x6B, "minecraft:blue_concrete".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 131 -     map.insert(0x6B, "minecraft:blue_concrete".into());
[INFO] [stdout] 131 +     map.insert(0x6B, "minecraft:blue_concrete");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 131 -     map.insert(0x6B, "minecraft:blue_concrete".into());
[INFO] [stdout] 131 +     map.insert(0x6B, <&str as Into<_>>::into("minecraft:blue_concrete"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:132:22
[INFO] [stdout]     |
[INFO] [stdout] 132 |     map.insert(0x6C, "minecraft:blue_concrete_powder".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 132 -     map.insert(0x6C, "minecraft:blue_concrete_powder".into());
[INFO] [stdout] 132 +     map.insert(0x6C, "minecraft:blue_concrete_powder");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 132 -     map.insert(0x6C, "minecraft:blue_concrete_powder".into());
[INFO] [stdout] 132 +     map.insert(0x6C, <&str as Into<_>>::into("minecraft:blue_concrete_powder"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:133:22
[INFO] [stdout]     |
[INFO] [stdout] 133 |     map.insert(0x6D, "minecraft:blue_glazed_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 133 -     map.insert(0x6D, "minecraft:blue_glazed_terracotta".into());
[INFO] [stdout] 133 +     map.insert(0x6D, "minecraft:blue_glazed_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 133 -     map.insert(0x6D, "minecraft:blue_glazed_terracotta".into());
[INFO] [stdout] 133 +     map.insert(0x6D, <&str as Into<_>>::into("minecraft:blue_glazed_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:134:22
[INFO] [stdout]     |
[INFO] [stdout] 134 |     map.insert(0x6E, "minecraft:blue_ice".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 134 -     map.insert(0x6E, "minecraft:blue_ice".into());
[INFO] [stdout] 134 +     map.insert(0x6E, "minecraft:blue_ice");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 134 -     map.insert(0x6E, "minecraft:blue_ice".into());
[INFO] [stdout] 134 +     map.insert(0x6E, <&str as Into<_>>::into("minecraft:blue_ice"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:135:22
[INFO] [stdout]     |
[INFO] [stdout] 135 |     map.insert(0x6F, "minecraft:purpur_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 135 -     map.insert(0x6F, "minecraft:purpur_block".into());
[INFO] [stdout] 135 +     map.insert(0x6F, "minecraft:purpur_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 135 -     map.insert(0x6F, "minecraft:purpur_block".into());
[INFO] [stdout] 135 +     map.insert(0x6F, <&str as Into<_>>::into("minecraft:purpur_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:136:22
[INFO] [stdout]     |
[INFO] [stdout] 136 |     map.insert(0x70, "minecraft:spruce_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 136 -     map.insert(0x70, "minecraft:spruce_planks".into());
[INFO] [stdout] 136 +     map.insert(0x70, "minecraft:spruce_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 136 -     map.insert(0x70, "minecraft:spruce_planks".into());
[INFO] [stdout] 136 +     map.insert(0x70, <&str as Into<_>>::into("minecraft:spruce_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:137:22
[INFO] [stdout]     |
[INFO] [stdout] 137 |     map.insert(0x71, "minecraft:blue_stained_glass".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 137 -     map.insert(0x71, "minecraft:blue_stained_glass".into());
[INFO] [stdout] 137 +     map.insert(0x71, "minecraft:blue_stained_glass");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 137 -     map.insert(0x71, "minecraft:blue_stained_glass".into());
[INFO] [stdout] 137 +     map.insert(0x71, <&str as Into<_>>::into("minecraft:blue_stained_glass"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:138:22
[INFO] [stdout]     |
[INFO] [stdout] 138 |     map.insert(0x72, "minecraft:blue_stained_glass_pane".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 138 -     map.insert(0x72, "minecraft:blue_stained_glass_pane".into());
[INFO] [stdout] 138 +     map.insert(0x72, "minecraft:blue_stained_glass_pane");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 138 -     map.insert(0x72, "minecraft:blue_stained_glass_pane".into());
[INFO] [stdout] 138 +     map.insert(0x72, <&str as Into<_>>::into("minecraft:blue_stained_glass_pane"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:139:22
[INFO] [stdout]     |
[INFO] [stdout] 139 |     map.insert(0x73, "minecraft:blue_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 139 -     map.insert(0x73, "minecraft:blue_terracotta".into());
[INFO] [stdout] 139 +     map.insert(0x73, "minecraft:blue_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 139 -     map.insert(0x73, "minecraft:blue_terracotta".into());
[INFO] [stdout] 139 +     map.insert(0x73, <&str as Into<_>>::into("minecraft:blue_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:140:22
[INFO] [stdout]     |
[INFO] [stdout] 140 |     map.insert(0x74, "minecraft:warped_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 140 -     map.insert(0x74, "minecraft:warped_planks".into());
[INFO] [stdout] 140 +     map.insert(0x74, "minecraft:warped_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 140 -     map.insert(0x74, "minecraft:warped_planks".into());
[INFO] [stdout] 140 +     map.insert(0x74, <&str as Into<_>>::into("minecraft:warped_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:141:22
[INFO] [stdout]     |
[INFO] [stdout] 141 |     map.insert(0x75, "minecraft:blue_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 141 -     map.insert(0x75, "minecraft:blue_wool".into());
[INFO] [stdout] 141 +     map.insert(0x75, "minecraft:blue_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 141 -     map.insert(0x75, "minecraft:blue_wool".into());
[INFO] [stdout] 141 +     map.insert(0x75, <&str as Into<_>>::into("minecraft:blue_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:142:22
[INFO] [stdout]     |
[INFO] [stdout] 142 |     map.insert(0x76, "minecraft:bone_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 142 -     map.insert(0x76, "minecraft:bone_block".into());
[INFO] [stdout] 142 +     map.insert(0x76, "minecraft:bone_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 -     map.insert(0x76, "minecraft:bone_block".into());
[INFO] [stdout] 142 +     map.insert(0x76, <&str as Into<_>>::into("minecraft:bone_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:143:22
[INFO] [stdout]     |
[INFO] [stdout] 143 |     map.insert(0x77, "minecraft:bookshelf".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 143 -     map.insert(0x77, "minecraft:bookshelf".into());
[INFO] [stdout] 143 +     map.insert(0x77, "minecraft:bookshelf");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 -     map.insert(0x77, "minecraft:bookshelf".into());
[INFO] [stdout] 143 +     map.insert(0x77, <&str as Into<_>>::into("minecraft:bookshelf"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:144:22
[INFO] [stdout]     |
[INFO] [stdout] 144 |     map.insert(0x78, "minecraft:cyan_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 144 -     map.insert(0x78, "minecraft:cyan_wool".into());
[INFO] [stdout] 144 +     map.insert(0x78, "minecraft:cyan_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 144 -     map.insert(0x78, "minecraft:cyan_wool".into());
[INFO] [stdout] 144 +     map.insert(0x78, <&str as Into<_>>::into("minecraft:cyan_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:145:22
[INFO] [stdout]     |
[INFO] [stdout] 145 |     map.insert(0x79, "minecraft:gray_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 145 -     map.insert(0x79, "minecraft:gray_wool".into());
[INFO] [stdout] 145 +     map.insert(0x79, "minecraft:gray_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 -     map.insert(0x79, "minecraft:gray_wool".into());
[INFO] [stdout] 145 +     map.insert(0x79, <&str as Into<_>>::into("minecraft:gray_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:146:22
[INFO] [stdout]     |
[INFO] [stdout] 146 |     map.insert(0x7A, "minecraft:green_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 146 -     map.insert(0x7A, "minecraft:green_wool".into());
[INFO] [stdout] 146 +     map.insert(0x7A, "minecraft:green_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 146 -     map.insert(0x7A, "minecraft:green_wool".into());
[INFO] [stdout] 146 +     map.insert(0x7A, <&str as Into<_>>::into("minecraft:green_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:147:22
[INFO] [stdout]     |
[INFO] [stdout] 147 |     map.insert(0x7B, "minecraft:light_blue_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 147 -     map.insert(0x7B, "minecraft:light_blue_wool".into());
[INFO] [stdout] 147 +     map.insert(0x7B, "minecraft:light_blue_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 147 -     map.insert(0x7B, "minecraft:light_blue_wool".into());
[INFO] [stdout] 147 +     map.insert(0x7B, <&str as Into<_>>::into("minecraft:light_blue_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:148:22
[INFO] [stdout]     |
[INFO] [stdout] 148 |     map.insert(0x7C, "minecraft:brewing_stand".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 148 -     map.insert(0x7C, "minecraft:brewing_stand".into());
[INFO] [stdout] 148 +     map.insert(0x7C, "minecraft:brewing_stand");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 148 -     map.insert(0x7C, "minecraft:brewing_stand".into());
[INFO] [stdout] 148 +     map.insert(0x7C, <&str as Into<_>>::into("minecraft:brewing_stand"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:149:22
[INFO] [stdout]     |
[INFO] [stdout] 149 |     map.insert(0x7D, "minecraft:brick_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 149 -     map.insert(0x7D, "minecraft:brick_slab".into());
[INFO] [stdout] 149 +     map.insert(0x7D, "minecraft:brick_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 -     map.insert(0x7D, "minecraft:brick_slab".into());
[INFO] [stdout] 149 +     map.insert(0x7D, <&str as Into<_>>::into("minecraft:brick_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:150:22
[INFO] [stdout]     |
[INFO] [stdout] 150 |     map.insert(0x7E, "minecraft:brick_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 150 -     map.insert(0x7E, "minecraft:brick_stairs".into());
[INFO] [stdout] 150 +     map.insert(0x7E, "minecraft:brick_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 150 -     map.insert(0x7E, "minecraft:brick_stairs".into());
[INFO] [stdout] 150 +     map.insert(0x7E, <&str as Into<_>>::into("minecraft:brick_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:151:22
[INFO] [stdout]     |
[INFO] [stdout] 151 |     map.insert(0x7F, "minecraft:brick_wall".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 151 -     map.insert(0x7F, "minecraft:brick_wall".into());
[INFO] [stdout] 151 +     map.insert(0x7F, "minecraft:brick_wall");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 151 -     map.insert(0x7F, "minecraft:brick_wall".into());
[INFO] [stdout] 151 +     map.insert(0x7F, <&str as Into<_>>::into("minecraft:brick_wall"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:152:22
[INFO] [stdout]     |
[INFO] [stdout] 152 |     map.insert(0x80, "minecraft:bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 152 -     map.insert(0x80, "minecraft:bricks".into());
[INFO] [stdout] 152 +     map.insert(0x80, "minecraft:bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 152 -     map.insert(0x80, "minecraft:bricks".into());
[INFO] [stdout] 152 +     map.insert(0x80, <&str as Into<_>>::into("minecraft:bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:153:22
[INFO] [stdout]     |
[INFO] [stdout] 153 |     map.insert(0x81, "minecraft:warped_wart_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 153 -     map.insert(0x81, "minecraft:warped_wart_block".into());
[INFO] [stdout] 153 +     map.insert(0x81, "minecraft:warped_wart_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 153 -     map.insert(0x81, "minecraft:warped_wart_block".into());
[INFO] [stdout] 153 +     map.insert(0x81, <&str as Into<_>>::into("minecraft:warped_wart_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:154:22
[INFO] [stdout]     |
[INFO] [stdout] 154 |     map.insert(0x82, "minecraft:red_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 154 -     map.insert(0x82, "minecraft:red_wool".into());
[INFO] [stdout] 154 +     map.insert(0x82, "minecraft:red_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 154 -     map.insert(0x82, "minecraft:red_wool".into());
[INFO] [stdout] 154 +     map.insert(0x82, <&str as Into<_>>::into("minecraft:red_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:155:22
[INFO] [stdout]     |
[INFO] [stdout] 155 |     map.insert(0x83, "minecraft:cut_sandstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 155 -     map.insert(0x83, "minecraft:cut_sandstone".into());
[INFO] [stdout] 155 +     map.insert(0x83, "minecraft:cut_sandstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 155 -     map.insert(0x83, "minecraft:cut_sandstone".into());
[INFO] [stdout] 155 +     map.insert(0x83, <&str as Into<_>>::into("minecraft:cut_sandstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:156:22
[INFO] [stdout]     |
[INFO] [stdout] 156 |     map.insert(0x84, "minecraft:cut_red_sandstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 156 -     map.insert(0x84, "minecraft:cut_red_sandstone".into());
[INFO] [stdout] 156 +     map.insert(0x84, "minecraft:cut_red_sandstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 156 -     map.insert(0x84, "minecraft:cut_red_sandstone".into());
[INFO] [stdout] 156 +     map.insert(0x84, <&str as Into<_>>::into("minecraft:cut_red_sandstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:157:22
[INFO] [stdout]     |
[INFO] [stdout] 157 |     map.insert(0x85, "minecraft:quartz_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 157 -     map.insert(0x85, "minecraft:quartz_block".into());
[INFO] [stdout] 157 +     map.insert(0x85, "minecraft:quartz_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 157 -     map.insert(0x85, "minecraft:quartz_block".into());
[INFO] [stdout] 157 +     map.insert(0x85, <&str as Into<_>>::into("minecraft:quartz_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:158:22
[INFO] [stdout]     |
[INFO] [stdout] 158 |     map.insert(0x86, "minecraft:brown_concrete".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 158 -     map.insert(0x86, "minecraft:brown_concrete".into());
[INFO] [stdout] 158 +     map.insert(0x86, "minecraft:brown_concrete");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 158 -     map.insert(0x86, "minecraft:brown_concrete".into());
[INFO] [stdout] 158 +     map.insert(0x86, <&str as Into<_>>::into("minecraft:brown_concrete"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:159:22
[INFO] [stdout]     |
[INFO] [stdout] 159 |     map.insert(0x87, "minecraft:brown_concrete_powder".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 159 -     map.insert(0x87, "minecraft:brown_concrete_powder".into());
[INFO] [stdout] 159 +     map.insert(0x87, "minecraft:brown_concrete_powder");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 159 -     map.insert(0x87, "minecraft:brown_concrete_powder".into());
[INFO] [stdout] 159 +     map.insert(0x87, <&str as Into<_>>::into("minecraft:brown_concrete_powder"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:160:22
[INFO] [stdout]     |
[INFO] [stdout] 160 |     map.insert(0x88, "minecraft:brown_glazed_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 160 -     map.insert(0x88, "minecraft:brown_glazed_terracotta".into());
[INFO] [stdout] 160 +     map.insert(0x88, "minecraft:brown_glazed_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 160 -     map.insert(0x88, "minecraft:brown_glazed_terracotta".into());
[INFO] [stdout] 160 +     map.insert(0x88, <&str as Into<_>>::into("minecraft:brown_glazed_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:161:22
[INFO] [stdout]     |
[INFO] [stdout] 161 |     map.insert(0x89, "minecraft:nether_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 161 -     map.insert(0x89, "minecraft:nether_bricks".into());
[INFO] [stdout] 161 +     map.insert(0x89, "minecraft:nether_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 161 -     map.insert(0x89, "minecraft:nether_bricks".into());
[INFO] [stdout] 161 +     map.insert(0x89, <&str as Into<_>>::into("minecraft:nether_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:162:22
[INFO] [stdout]     |
[INFO] [stdout] 162 |     map.insert(0x8A, "minecraft:brown_mushroom_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 162 -     map.insert(0x8A, "minecraft:brown_mushroom_block".into());
[INFO] [stdout] 162 +     map.insert(0x8A, "minecraft:brown_mushroom_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 -     map.insert(0x8A, "minecraft:brown_mushroom_block".into());
[INFO] [stdout] 162 +     map.insert(0x8A, <&str as Into<_>>::into("minecraft:brown_mushroom_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:163:22
[INFO] [stdout]     |
[INFO] [stdout] 163 |     map.insert(0x8B, "minecraft:jungle_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 163 -     map.insert(0x8B, "minecraft:jungle_log".into());
[INFO] [stdout] 163 +     map.insert(0x8B, "minecraft:jungle_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 -     map.insert(0x8B, "minecraft:jungle_log".into());
[INFO] [stdout] 163 +     map.insert(0x8B, <&str as Into<_>>::into("minecraft:jungle_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:164:22
[INFO] [stdout]     |
[INFO] [stdout] 164 |     map.insert(0x8C, "minecraft:brown_stained_glass".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 164 -     map.insert(0x8C, "minecraft:brown_stained_glass".into());
[INFO] [stdout] 164 +     map.insert(0x8C, "minecraft:brown_stained_glass");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 -     map.insert(0x8C, "minecraft:brown_stained_glass".into());
[INFO] [stdout] 164 +     map.insert(0x8C, <&str as Into<_>>::into("minecraft:brown_stained_glass"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:165:22
[INFO] [stdout]     |
[INFO] [stdout] 165 |     map.insert(0x8D, "minecraft:brown_stained_glass_pane".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 165 -     map.insert(0x8D, "minecraft:brown_stained_glass_pane".into());
[INFO] [stdout] 165 +     map.insert(0x8D, "minecraft:brown_stained_glass_pane");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 -     map.insert(0x8D, "minecraft:brown_stained_glass_pane".into());
[INFO] [stdout] 165 +     map.insert(0x8D, <&str as Into<_>>::into("minecraft:brown_stained_glass_pane"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:166:22
[INFO] [stdout]     |
[INFO] [stdout] 166 |     map.insert(0x8E, "minecraft:brown_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 166 -     map.insert(0x8E, "minecraft:brown_terracotta".into());
[INFO] [stdout] 166 +     map.insert(0x8E, "minecraft:brown_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 166 -     map.insert(0x8E, "minecraft:brown_terracotta".into());
[INFO] [stdout] 166 +     map.insert(0x8E, <&str as Into<_>>::into("minecraft:brown_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:167:22
[INFO] [stdout]     |
[INFO] [stdout] 167 |     map.insert(0x8F, "minecraft:warped_hyphae".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 167 -     map.insert(0x8F, "minecraft:warped_hyphae".into());
[INFO] [stdout] 167 +     map.insert(0x8F, "minecraft:warped_hyphae");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 167 -     map.insert(0x8F, "minecraft:warped_hyphae".into());
[INFO] [stdout] 167 +     map.insert(0x8F, <&str as Into<_>>::into("minecraft:warped_hyphae"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:168:22
[INFO] [stdout]     |
[INFO] [stdout] 168 |     map.insert(0x90, "minecraft:brown_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 168 -     map.insert(0x90, "minecraft:brown_wool".into());
[INFO] [stdout] 168 +     map.insert(0x90, "minecraft:brown_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 168 -     map.insert(0x90, "minecraft:brown_wool".into());
[INFO] [stdout] 168 +     map.insert(0x90, <&str as Into<_>>::into("minecraft:brown_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:169:22
[INFO] [stdout]     |
[INFO] [stdout] 169 |     map.insert(0x91, "minecraft:deepslate".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 169 -     map.insert(0x91, "minecraft:deepslate".into());
[INFO] [stdout] 169 +     map.insert(0x91, "minecraft:deepslate");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 169 -     map.insert(0x91, "minecraft:deepslate".into());
[INFO] [stdout] 169 +     map.insert(0x91, <&str as Into<_>>::into("minecraft:deepslate"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:170:22
[INFO] [stdout]     |
[INFO] [stdout] 170 |     map.insert(0x92, "minecraft:light_gray_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 170 -     map.insert(0x92, "minecraft:light_gray_wool".into());
[INFO] [stdout] 170 +     map.insert(0x92, "minecraft:light_gray_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 170 -     map.insert(0x92, "minecraft:light_gray_wool".into());
[INFO] [stdout] 170 +     map.insert(0x92, <&str as Into<_>>::into("minecraft:light_gray_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:171:22
[INFO] [stdout]     |
[INFO] [stdout] 171 |     map.insert(0x93, "minecraft:lime_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 171 -     map.insert(0x93, "minecraft:lime_wool".into());
[INFO] [stdout] 171 +     map.insert(0x93, "minecraft:lime_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 -     map.insert(0x93, "minecraft:lime_wool".into());
[INFO] [stdout] 171 +     map.insert(0x93, <&str as Into<_>>::into("minecraft:lime_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:172:22
[INFO] [stdout]     |
[INFO] [stdout] 172 |     map.insert(0x94, "minecraft:magenta_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 172 -     map.insert(0x94, "minecraft:magenta_wool".into());
[INFO] [stdout] 172 +     map.insert(0x94, "minecraft:magenta_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 172 -     map.insert(0x94, "minecraft:magenta_wool".into());
[INFO] [stdout] 172 +     map.insert(0x94, <&str as Into<_>>::into("minecraft:magenta_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:173:22
[INFO] [stdout]     |
[INFO] [stdout] 173 |     map.insert(0x95, "minecraft:orange_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 173 -     map.insert(0x95, "minecraft:orange_wool".into());
[INFO] [stdout] 173 +     map.insert(0x95, "minecraft:orange_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 173 -     map.insert(0x95, "minecraft:orange_wool".into());
[INFO] [stdout] 173 +     map.insert(0x95, <&str as Into<_>>::into("minecraft:orange_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:174:22
[INFO] [stdout]     |
[INFO] [stdout] 174 |     map.insert(0x96, "minecraft:budding_amethyst".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 174 -     map.insert(0x96, "minecraft:budding_amethyst".into());
[INFO] [stdout] 174 +     map.insert(0x96, "minecraft:budding_amethyst");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 174 -     map.insert(0x96, "minecraft:budding_amethyst".into());
[INFO] [stdout] 174 +     map.insert(0x96, <&str as Into<_>>::into("minecraft:budding_amethyst"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:175:22
[INFO] [stdout]     |
[INFO] [stdout] 175 |     map.insert(0x97, "minecraft:end_stone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 175 -     map.insert(0x97, "minecraft:end_stone".into());
[INFO] [stdout] 175 +     map.insert(0x97, "minecraft:end_stone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 175 -     map.insert(0x97, "minecraft:end_stone".into());
[INFO] [stdout] 175 +     map.insert(0x97, <&str as Into<_>>::into("minecraft:end_stone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:176:22
[INFO] [stdout]     |
[INFO] [stdout] 176 |     map.insert(0x98, "minecraft:sand".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 176 -     map.insert(0x98, "minecraft:sand".into());
[INFO] [stdout] 176 +     map.insert(0x98, "minecraft:sand");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 176 -     map.insert(0x98, "minecraft:sand".into());
[INFO] [stdout] 176 +     map.insert(0x98, <&str as Into<_>>::into("minecraft:sand"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:177:22
[INFO] [stdout]     |
[INFO] [stdout] 177 |     map.insert(0x99, "minecraft:netherrack".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 177 -     map.insert(0x99, "minecraft:netherrack".into());
[INFO] [stdout] 177 +     map.insert(0x99, "minecraft:netherrack");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 -     map.insert(0x99, "minecraft:netherrack".into());
[INFO] [stdout] 177 +     map.insert(0x99, <&str as Into<_>>::into("minecraft:netherrack"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:178:22
[INFO] [stdout]     |
[INFO] [stdout] 178 |     map.insert(0x9A, "minecraft:cake".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 178 -     map.insert(0x9A, "minecraft:cake".into());
[INFO] [stdout] 178 +     map.insert(0x9A, "minecraft:cake");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 178 -     map.insert(0x9A, "minecraft:cake".into());
[INFO] [stdout] 178 +     map.insert(0x9A, <&str as Into<_>>::into("minecraft:cake"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:179:22
[INFO] [stdout]     |
[INFO] [stdout] 179 |     map.insert(0x9B, "minecraft:calcite".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 179 -     map.insert(0x9B, "minecraft:calcite".into());
[INFO] [stdout] 179 +     map.insert(0x9B, "minecraft:calcite");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 179 -     map.insert(0x9B, "minecraft:calcite".into());
[INFO] [stdout] 179 +     map.insert(0x9B, <&str as Into<_>>::into("minecraft:calcite"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:180:22
[INFO] [stdout]     |
[INFO] [stdout] 180 |     map.insert(0x9C, "minecraft:calibrated_sculk_sensor".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 180 -     map.insert(0x9C, "minecraft:calibrated_sculk_sensor".into());
[INFO] [stdout] 180 +     map.insert(0x9C, "minecraft:calibrated_sculk_sensor");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 180 -     map.insert(0x9C, "minecraft:calibrated_sculk_sensor".into());
[INFO] [stdout] 180 +     map.insert(0x9C, <&str as Into<_>>::into("minecraft:calibrated_sculk_sensor"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:181:22
[INFO] [stdout]     |
[INFO] [stdout] 181 |     map.insert(0x9D, "minecraft:campfire".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 181 -     map.insert(0x9D, "minecraft:campfire".into());
[INFO] [stdout] 181 +     map.insert(0x9D, "minecraft:campfire");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 181 -     map.insert(0x9D, "minecraft:campfire".into());
[INFO] [stdout] 181 +     map.insert(0x9D, <&str as Into<_>>::into("minecraft:campfire"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:182:22
[INFO] [stdout]     |
[INFO] [stdout] 182 |     map.insert(0x9E, "minecraft:smooth_stone_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 182 -     map.insert(0x9E, "minecraft:smooth_stone_slab".into());
[INFO] [stdout] 182 +     map.insert(0x9E, "minecraft:smooth_stone_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 182 -     map.insert(0x9E, "minecraft:smooth_stone_slab".into());
[INFO] [stdout] 182 +     map.insert(0x9E, <&str as Into<_>>::into("minecraft:smooth_stone_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:183:22
[INFO] [stdout]     |
[INFO] [stdout] 183 |     map.insert(0x9F, "minecraft:smooth_basalt".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 183 -     map.insert(0x9F, "minecraft:smooth_basalt".into());
[INFO] [stdout] 183 +     map.insert(0x9F, "minecraft:smooth_basalt");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 183 -     map.insert(0x9F, "minecraft:smooth_basalt".into());
[INFO] [stdout] 183 +     map.insert(0x9F, <&str as Into<_>>::into("minecraft:smooth_basalt"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:184:22
[INFO] [stdout]     |
[INFO] [stdout] 184 |     map.insert(0xA0, "minecraft:podzol".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 184 -     map.insert(0xA0, "minecraft:podzol".into());
[INFO] [stdout] 184 +     map.insert(0xA0, "minecraft:podzol");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 -     map.insert(0xA0, "minecraft:podzol".into());
[INFO] [stdout] 184 +     map.insert(0xA0, <&str as Into<_>>::into("minecraft:podzol"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:185:22
[INFO] [stdout]     |
[INFO] [stdout] 185 |     map.insert(0xA1, "minecraft:cartography_table".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 185 -     map.insert(0xA1, "minecraft:cartography_table".into());
[INFO] [stdout] 185 +     map.insert(0xA1, "minecraft:cartography_table");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 185 -     map.insert(0xA1, "minecraft:cartography_table".into());
[INFO] [stdout] 185 +     map.insert(0xA1, <&str as Into<_>>::into("minecraft:cartography_table"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:186:22
[INFO] [stdout]     |
[INFO] [stdout] 186 |     map.insert(0xA2, "minecraft:carved_pumpkin".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 186 -     map.insert(0xA2, "minecraft:carved_pumpkin".into());
[INFO] [stdout] 186 +     map.insert(0xA2, "minecraft:carved_pumpkin");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 186 -     map.insert(0xA2, "minecraft:carved_pumpkin".into());
[INFO] [stdout] 186 +     map.insert(0xA2, <&str as Into<_>>::into("minecraft:carved_pumpkin"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:187:22
[INFO] [stdout]     |
[INFO] [stdout] 187 |     map.insert(0xA3, "minecraft:cauldron".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 187 -     map.insert(0xA3, "minecraft:cauldron".into());
[INFO] [stdout] 187 +     map.insert(0xA3, "minecraft:cauldron");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 -     map.insert(0xA3, "minecraft:cauldron".into());
[INFO] [stdout] 187 +     map.insert(0xA3, <&str as Into<_>>::into("minecraft:cauldron"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:188:22
[INFO] [stdout]     |
[INFO] [stdout] 188 |     map.insert(0xA4, "minecraft:pink_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 188 -     map.insert(0xA4, "minecraft:pink_wool".into());
[INFO] [stdout] 188 +     map.insert(0xA4, "minecraft:pink_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 188 -     map.insert(0xA4, "minecraft:pink_wool".into());
[INFO] [stdout] 188 +     map.insert(0xA4, <&str as Into<_>>::into("minecraft:pink_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:189:22
[INFO] [stdout]     |
[INFO] [stdout] 189 |     map.insert(0xA5, "minecraft:dirt".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 189 -     map.insert(0xA5, "minecraft:dirt".into());
[INFO] [stdout] 189 +     map.insert(0xA5, "minecraft:dirt");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 189 -     map.insert(0xA5, "minecraft:dirt".into());
[INFO] [stdout] 189 +     map.insert(0xA5, <&str as Into<_>>::into("minecraft:dirt"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:190:22
[INFO] [stdout]     |
[INFO] [stdout] 190 |     map.insert(0xA6, "minecraft:obsidian".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 190 -     map.insert(0xA6, "minecraft:obsidian".into());
[INFO] [stdout] 190 +     map.insert(0xA6, "minecraft:obsidian");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 190 -     map.insert(0xA6, "minecraft:obsidian".into());
[INFO] [stdout] 190 +     map.insert(0xA6, <&str as Into<_>>::into("minecraft:obsidian"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:191:22
[INFO] [stdout]     |
[INFO] [stdout] 191 |     map.insert(0xA7, "minecraft:chain_command_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 191 -     map.insert(0xA7, "minecraft:chain_command_block".into());
[INFO] [stdout] 191 +     map.insert(0xA7, "minecraft:chain_command_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 191 -     map.insert(0xA7, "minecraft:chain_command_block".into());
[INFO] [stdout] 191 +     map.insert(0xA7, <&str as Into<_>>::into("minecraft:chain_command_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:192:22
[INFO] [stdout]     |
[INFO] [stdout] 192 |     map.insert(0xA8, "minecraft:dripstone_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 192 -     map.insert(0xA8, "minecraft:dripstone_block".into());
[INFO] [stdout] 192 +     map.insert(0xA8, "minecraft:dripstone_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 192 -     map.insert(0xA8, "minecraft:dripstone_block".into());
[INFO] [stdout] 192 +     map.insert(0xA8, <&str as Into<_>>::into("minecraft:dripstone_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:193:22
[INFO] [stdout]     |
[INFO] [stdout] 193 |     map.insert(0xA9, "minecraft:rooted_dirt".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 193 -     map.insert(0xA9, "minecraft:rooted_dirt".into());
[INFO] [stdout] 193 +     map.insert(0xA9, "minecraft:rooted_dirt");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 -     map.insert(0xA9, "minecraft:rooted_dirt".into());
[INFO] [stdout] 193 +     map.insert(0xA9, <&str as Into<_>>::into("minecraft:rooted_dirt"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:194:22
[INFO] [stdout]     |
[INFO] [stdout] 194 |     map.insert(0xAA, "minecraft:cherry_fence".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 194 -     map.insert(0xAA, "minecraft:cherry_fence".into());
[INFO] [stdout] 194 +     map.insert(0xAA, "minecraft:cherry_fence");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 194 -     map.insert(0xAA, "minecraft:cherry_fence".into());
[INFO] [stdout] 194 +     map.insert(0xAA, <&str as Into<_>>::into("minecraft:cherry_fence"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:195:22
[INFO] [stdout]     |
[INFO] [stdout] 195 |     map.insert(0xAB, "minecraft:cherry_fence_gate".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 195 -     map.insert(0xAB, "minecraft:cherry_fence_gate".into());
[INFO] [stdout] 195 +     map.insert(0xAB, "minecraft:cherry_fence_gate");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 195 -     map.insert(0xAB, "minecraft:cherry_fence_gate".into());
[INFO] [stdout] 195 +     map.insert(0xAB, <&str as Into<_>>::into("minecraft:cherry_fence_gate"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:196:22
[INFO] [stdout]     |
[INFO] [stdout] 196 |     map.insert(0xAC, "minecraft:mud".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 196 -     map.insert(0xAC, "minecraft:mud".into());
[INFO] [stdout] 196 +     map.insert(0xAC, "minecraft:mud");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 196 -     map.insert(0xAC, "minecraft:mud".into());
[INFO] [stdout] 196 +     map.insert(0xAC, <&str as Into<_>>::into("minecraft:mud"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:197:22
[INFO] [stdout]     |
[INFO] [stdout] 197 |     map.insert(0xAD, "minecraft:spruce_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 197 -     map.insert(0xAD, "minecraft:spruce_log".into());
[INFO] [stdout] 197 +     map.insert(0xAD, "minecraft:spruce_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 -     map.insert(0xAD, "minecraft:spruce_log".into());
[INFO] [stdout] 197 +     map.insert(0xAD, <&str as Into<_>>::into("minecraft:spruce_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:198:22
[INFO] [stdout]     |
[INFO] [stdout] 198 |     map.insert(0xAE, "minecraft:cherry_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 198 -     map.insert(0xAE, "minecraft:cherry_log".into());
[INFO] [stdout] 198 +     map.insert(0xAE, "minecraft:cherry_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 -     map.insert(0xAE, "minecraft:cherry_log".into());
[INFO] [stdout] 198 +     map.insert(0xAE, <&str as Into<_>>::into("minecraft:cherry_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:199:22
[INFO] [stdout]     |
[INFO] [stdout] 199 |     map.insert(0xAF, "minecraft:cherry_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 199 -     map.insert(0xAF, "minecraft:cherry_planks".into());
[INFO] [stdout] 199 +     map.insert(0xAF, "minecraft:cherry_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 -     map.insert(0xAF, "minecraft:cherry_planks".into());
[INFO] [stdout] 199 +     map.insert(0xAF, <&str as Into<_>>::into("minecraft:cherry_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:200:22
[INFO] [stdout]     |
[INFO] [stdout] 200 |     map.insert(0xB0, "minecraft:stripped_cherry_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 200 -     map.insert(0xB0, "minecraft:stripped_cherry_log".into());
[INFO] [stdout] 200 +     map.insert(0xB0, "minecraft:stripped_cherry_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 200 -     map.insert(0xB0, "minecraft:stripped_cherry_log".into());
[INFO] [stdout] 200 +     map.insert(0xB0, <&str as Into<_>>::into("minecraft:stripped_cherry_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:201:22
[INFO] [stdout]     |
[INFO] [stdout] 201 |     map.insert(0xB1, "minecraft:stone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 201 -     map.insert(0xB1, "minecraft:stone".into());
[INFO] [stdout] 201 +     map.insert(0xB1, "minecraft:stone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 -     map.insert(0xB1, "minecraft:stone".into());
[INFO] [stdout] 201 +     map.insert(0xB1, <&str as Into<_>>::into("minecraft:stone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:202:22
[INFO] [stdout]     |
[INFO] [stdout] 202 |     map.insert(0xB2, "minecraft:cherry_shelf".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 202 -     map.insert(0xB2, "minecraft:cherry_shelf".into());
[INFO] [stdout] 202 +     map.insert(0xB2, "minecraft:cherry_shelf");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 202 -     map.insert(0xB2, "minecraft:cherry_shelf".into());
[INFO] [stdout] 202 +     map.insert(0xB2, <&str as Into<_>>::into("minecraft:cherry_shelf"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:203:22
[INFO] [stdout]     |
[INFO] [stdout] 203 |     map.insert(0xB3, "minecraft:packed_mud".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 203 -     map.insert(0xB3, "minecraft:packed_mud".into());
[INFO] [stdout] 203 +     map.insert(0xB3, "minecraft:packed_mud");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 -     map.insert(0xB3, "minecraft:packed_mud".into());
[INFO] [stdout] 203 +     map.insert(0xB3, <&str as Into<_>>::into("minecraft:packed_mud"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:204:22
[INFO] [stdout]     |
[INFO] [stdout] 204 |     map.insert(0xB4, "minecraft:cherry_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 204 -     map.insert(0xB4, "minecraft:cherry_slab".into());
[INFO] [stdout] 204 +     map.insert(0xB4, "minecraft:cherry_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 204 -     map.insert(0xB4, "minecraft:cherry_slab".into());
[INFO] [stdout] 204 +     map.insert(0xB4, <&str as Into<_>>::into("minecraft:cherry_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:205:22
[INFO] [stdout]     |
[INFO] [stdout] 205 |     map.insert(0xB5, "minecraft:cherry_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 205 -     map.insert(0xB5, "minecraft:cherry_stairs".into());
[INFO] [stdout] 205 +     map.insert(0xB5, "minecraft:cherry_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 -     map.insert(0xB5, "minecraft:cherry_stairs".into());
[INFO] [stdout] 205 +     map.insert(0xB5, <&str as Into<_>>::into("minecraft:cherry_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:206:22
[INFO] [stdout]     |
[INFO] [stdout] 206 |     map.insert(0xB6, "minecraft:cherry_trapdoor".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 206 -     map.insert(0xB6, "minecraft:cherry_trapdoor".into());
[INFO] [stdout] 206 +     map.insert(0xB6, "minecraft:cherry_trapdoor");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 206 -     map.insert(0xB6, "minecraft:cherry_trapdoor".into());
[INFO] [stdout] 206 +     map.insert(0xB6, <&str as Into<_>>::into("minecraft:cherry_trapdoor"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:207:22
[INFO] [stdout]     |
[INFO] [stdout] 207 |     map.insert(0xB7, "minecraft:sculk_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 207 -     map.insert(0xB7, "minecraft:sculk_block".into());
[INFO] [stdout] 207 +     map.insert(0xB7, "minecraft:sculk_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 207 -     map.insert(0xB7, "minecraft:sculk_block".into());
[INFO] [stdout] 207 +     map.insert(0xB7, <&str as Into<_>>::into("minecraft:sculk_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:208:22
[INFO] [stdout]     |
[INFO] [stdout] 208 |     map.insert(0xB8, "minecraft:sculk_catalyst".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 208 -     map.insert(0xB8, "minecraft:sculk_catalyst".into());
[INFO] [stdout] 208 +     map.insert(0xB8, "minecraft:sculk_catalyst");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 208 -     map.insert(0xB8, "minecraft:sculk_catalyst".into());
[INFO] [stdout] 208 +     map.insert(0xB8, <&str as Into<_>>::into("minecraft:sculk_catalyst"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:209:22
[INFO] [stdout]     |
[INFO] [stdout] 209 |     map.insert(0xB9, "minecraft:cherry_wood".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 209 -     map.insert(0xB9, "minecraft:cherry_wood".into());
[INFO] [stdout] 209 +     map.insert(0xB9, "minecraft:cherry_wood");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 -     map.insert(0xB9, "minecraft:cherry_wood".into());
[INFO] [stdout] 209 +     map.insert(0xB9, <&str as Into<_>>::into("minecraft:cherry_wood"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:210:22
[INFO] [stdout]     |
[INFO] [stdout] 210 |     map.insert(0xBA, "minecraft:oak_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 210 -     map.insert(0xBA, "minecraft:oak_planks".into());
[INFO] [stdout] 210 +     map.insert(0xBA, "minecraft:oak_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 210 -     map.insert(0xBA, "minecraft:oak_planks".into());
[INFO] [stdout] 210 +     map.insert(0xBA, <&str as Into<_>>::into("minecraft:oak_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:211:22
[INFO] [stdout]     |
[INFO] [stdout] 211 |     map.insert(0xBB, "minecraft:chipped_anvil".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 211 -     map.insert(0xBB, "minecraft:chipped_anvil".into());
[INFO] [stdout] 211 +     map.insert(0xBB, "minecraft:chipped_anvil");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 -     map.insert(0xBB, "minecraft:chipped_anvil".into());
[INFO] [stdout] 211 +     map.insert(0xBB, <&str as Into<_>>::into("minecraft:chipped_anvil"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:212:22
[INFO] [stdout]     |
[INFO] [stdout] 212 |     map.insert(0xBC, "minecraft:chiseled_bookshelf".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 212 -     map.insert(0xBC, "minecraft:chiseled_bookshelf".into());
[INFO] [stdout] 212 +     map.insert(0xBC, "minecraft:chiseled_bookshelf");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 -     map.insert(0xBC, "minecraft:chiseled_bookshelf".into());
[INFO] [stdout] 212 +     map.insert(0xBC, <&str as Into<_>>::into("minecraft:chiseled_bookshelf"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:213:22
[INFO] [stdout]     |
[INFO] [stdout] 213 |     map.insert(0xBD, "minecraft:sculk_sensor".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 213 -     map.insert(0xBD, "minecraft:sculk_sensor".into());
[INFO] [stdout] 213 +     map.insert(0xBD, "minecraft:sculk_sensor");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 -     map.insert(0xBD, "minecraft:sculk_sensor".into());
[INFO] [stdout] 213 +     map.insert(0xBD, <&str as Into<_>>::into("minecraft:sculk_sensor"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:214:22
[INFO] [stdout]     |
[INFO] [stdout] 214 |     map.insert(0xBE, "minecraft:chiseled_deepslate".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 214 -     map.insert(0xBE, "minecraft:chiseled_deepslate".into());
[INFO] [stdout] 214 +     map.insert(0xBE, "minecraft:chiseled_deepslate");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 -     map.insert(0xBE, "minecraft:chiseled_deepslate".into());
[INFO] [stdout] 214 +     map.insert(0xBE, <&str as Into<_>>::into("minecraft:chiseled_deepslate"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:215:22
[INFO] [stdout]     |
[INFO] [stdout] 215 |     map.insert(0xBF, "minecraft:chiseled_nether_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 215 -     map.insert(0xBF, "minecraft:chiseled_nether_bricks".into());
[INFO] [stdout] 215 +     map.insert(0xBF, "minecraft:chiseled_nether_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 215 -     map.insert(0xBF, "minecraft:chiseled_nether_bricks".into());
[INFO] [stdout] 215 +     map.insert(0xBF, <&str as Into<_>>::into("minecraft:chiseled_nether_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:216:22
[INFO] [stdout]     |
[INFO] [stdout] 216 |     map.insert(0xC0, "minecraft:chiseled_polished_blackstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 216 -     map.insert(0xC0, "minecraft:chiseled_polished_blackstone".into());
[INFO] [stdout] 216 +     map.insert(0xC0, "minecraft:chiseled_polished_blackstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 216 -     map.insert(0xC0, "minecraft:chiseled_polished_blackstone".into());
[INFO] [stdout] 216 +     map.insert(0xC0, <&str as Into<_>>::into("minecraft:chiseled_polished_blackstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:217:22
[INFO] [stdout]     |
[INFO] [stdout] 217 |     map.insert(0xC1, "minecraft:chiseled_quartz_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 217 -     map.insert(0xC1, "minecraft:chiseled_quartz_block".into());
[INFO] [stdout] 217 +     map.insert(0xC1, "minecraft:chiseled_quartz_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 -     map.insert(0xC1, "minecraft:chiseled_quartz_block".into());
[INFO] [stdout] 217 +     map.insert(0xC1, <&str as Into<_>>::into("minecraft:chiseled_quartz_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:218:22
[INFO] [stdout]     |
[INFO] [stdout] 218 |     map.insert(0xC2, "minecraft:chiseled_red_sandstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 218 -     map.insert(0xC2, "minecraft:chiseled_red_sandstone".into());
[INFO] [stdout] 218 +     map.insert(0xC2, "minecraft:chiseled_red_sandstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 218 -     map.insert(0xC2, "minecraft:chiseled_red_sandstone".into());
[INFO] [stdout] 218 +     map.insert(0xC2, <&str as Into<_>>::into("minecraft:chiseled_red_sandstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:219:22
[INFO] [stdout]     |
[INFO] [stdout] 219 |     map.insert(0xC3, "minecraft:chiseled_resin_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 219 -     map.insert(0xC3, "minecraft:chiseled_resin_bricks".into());
[INFO] [stdout] 219 +     map.insert(0xC3, "minecraft:chiseled_resin_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 219 -     map.insert(0xC3, "minecraft:chiseled_resin_bricks".into());
[INFO] [stdout] 219 +     map.insert(0xC3, <&str as Into<_>>::into("minecraft:chiseled_resin_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:220:22
[INFO] [stdout]     |
[INFO] [stdout] 220 |     map.insert(0xC4, "minecraft:chiseled_sandstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 220 -     map.insert(0xC4, "minecraft:chiseled_sandstone".into());
[INFO] [stdout] 220 +     map.insert(0xC4, "minecraft:chiseled_sandstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 220 -     map.insert(0xC4, "minecraft:chiseled_sandstone".into());
[INFO] [stdout] 220 +     map.insert(0xC4, <&str as Into<_>>::into("minecraft:chiseled_sandstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:221:22
[INFO] [stdout]     |
[INFO] [stdout] 221 |     map.insert(0xC5, "minecraft:chiseled_stone_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 221 -     map.insert(0xC5, "minecraft:chiseled_stone_bricks".into());
[INFO] [stdout] 221 +     map.insert(0xC5, "minecraft:chiseled_stone_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 221 -     map.insert(0xC5, "minecraft:chiseled_stone_bricks".into());
[INFO] [stdout] 221 +     map.insert(0xC5, <&str as Into<_>>::into("minecraft:chiseled_stone_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:222:22
[INFO] [stdout]     |
[INFO] [stdout] 222 |     map.insert(0xC6, "minecraft:chiseled_tuff".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 222 -     map.insert(0xC6, "minecraft:chiseled_tuff".into());
[INFO] [stdout] 222 +     map.insert(0xC6, "minecraft:chiseled_tuff");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 -     map.insert(0xC6, "minecraft:chiseled_tuff".into());
[INFO] [stdout] 222 +     map.insert(0xC6, <&str as Into<_>>::into("minecraft:chiseled_tuff"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:223:22
[INFO] [stdout]     |
[INFO] [stdout] 223 |     map.insert(0xC7, "minecraft:chiseled_tuff_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 223 -     map.insert(0xC7, "minecraft:chiseled_tuff_bricks".into());
[INFO] [stdout] 223 +     map.insert(0xC7, "minecraft:chiseled_tuff_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 223 -     map.insert(0xC7, "minecraft:chiseled_tuff_bricks".into());
[INFO] [stdout] 223 +     map.insert(0xC7, <&str as Into<_>>::into("minecraft:chiseled_tuff_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:224:22
[INFO] [stdout]     |
[INFO] [stdout] 224 |     map.insert(0xC8, "minecraft:smooth_stone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 224 -     map.insert(0xC8, "minecraft:smooth_stone".into());
[INFO] [stdout] 224 +     map.insert(0xC8, "minecraft:smooth_stone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 224 -     map.insert(0xC8, "minecraft:smooth_stone".into());
[INFO] [stdout] 224 +     map.insert(0xC8, <&str as Into<_>>::into("minecraft:smooth_stone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:225:22
[INFO] [stdout]     |
[INFO] [stdout] 225 |     map.insert(0xC9, "minecraft:chorus_plant".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 225 -     map.insert(0xC9, "minecraft:chorus_plant".into());
[INFO] [stdout] 225 +     map.insert(0xC9, "minecraft:chorus_plant");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 225 -     map.insert(0xC9, "minecraft:chorus_plant".into());
[INFO] [stdout] 225 +     map.insert(0xC9, <&str as Into<_>>::into("minecraft:chorus_plant"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:226:22
[INFO] [stdout]     |
[INFO] [stdout] 226 |     map.insert(0xCA, "minecraft:clay".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 226 -     map.insert(0xCA, "minecraft:clay".into());
[INFO] [stdout] 226 +     map.insert(0xCA, "minecraft:clay");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 226 -     map.insert(0xCA, "minecraft:clay".into());
[INFO] [stdout] 226 +     map.insert(0xCA, <&str as Into<_>>::into("minecraft:clay"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:227:22
[INFO] [stdout]     |
[INFO] [stdout] 227 |     map.insert(0xCB, "minecraft:terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 227 -     map.insert(0xCB, "minecraft:terracotta".into());
[INFO] [stdout] 227 +     map.insert(0xCB, "minecraft:terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 227 -     map.insert(0xCB, "minecraft:terracotta".into());
[INFO] [stdout] 227 +     map.insert(0xCB, <&str as Into<_>>::into("minecraft:terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:228:22
[INFO] [stdout]     |
[INFO] [stdout] 228 |     map.insert(0xCC, "minecraft:coal_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 228 -     map.insert(0xCC, "minecraft:coal_block".into());
[INFO] [stdout] 228 +     map.insert(0xCC, "minecraft:coal_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 228 -     map.insert(0xCC, "minecraft:coal_block".into());
[INFO] [stdout] 228 +     map.insert(0xCC, <&str as Into<_>>::into("minecraft:coal_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:229:22
[INFO] [stdout]     |
[INFO] [stdout] 229 |     map.insert(0xCD, "minecraft:coal_ore".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 229 -     map.insert(0xCD, "minecraft:coal_ore".into());
[INFO] [stdout] 229 +     map.insert(0xCD, "minecraft:coal_ore");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 229 -     map.insert(0xCD, "minecraft:coal_ore".into());
[INFO] [stdout] 229 +     map.insert(0xCD, <&str as Into<_>>::into("minecraft:coal_ore"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:230:22
[INFO] [stdout]     |
[INFO] [stdout] 230 |     map.insert(0xCE, "minecraft:coarse_dirt".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 230 -     map.insert(0xCE, "minecraft:coarse_dirt".into());
[INFO] [stdout] 230 +     map.insert(0xCE, "minecraft:coarse_dirt");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 230 -     map.insert(0xCE, "minecraft:coarse_dirt".into());
[INFO] [stdout] 230 +     map.insert(0xCE, <&str as Into<_>>::into("minecraft:coarse_dirt"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:231:22
[INFO] [stdout]     |
[INFO] [stdout] 231 |     map.insert(0xCF, "minecraft:cobbled_deepslate".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 231 -     map.insert(0xCF, "minecraft:cobbled_deepslate".into());
[INFO] [stdout] 231 +     map.insert(0xCF, "minecraft:cobbled_deepslate");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 231 -     map.insert(0xCF, "minecraft:cobbled_deepslate".into());
[INFO] [stdout] 231 +     map.insert(0xCF, <&str as Into<_>>::into("minecraft:cobbled_deepslate"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:232:22
[INFO] [stdout]     |
[INFO] [stdout] 232 |     map.insert(0xD0, "minecraft:cobbled_deepslate_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 232 -     map.insert(0xD0, "minecraft:cobbled_deepslate_slab".into());
[INFO] [stdout] 232 +     map.insert(0xD0, "minecraft:cobbled_deepslate_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 232 -     map.insert(0xD0, "minecraft:cobbled_deepslate_slab".into());
[INFO] [stdout] 232 +     map.insert(0xD0, <&str as Into<_>>::into("minecraft:cobbled_deepslate_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:233:22
[INFO] [stdout]     |
[INFO] [stdout] 233 |     map.insert(0xD1, "minecraft:cobbled_deepslate_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 233 -     map.insert(0xD1, "minecraft:cobbled_deepslate_stairs".into());
[INFO] [stdout] 233 +     map.insert(0xD1, "minecraft:cobbled_deepslate_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 -     map.insert(0xD1, "minecraft:cobbled_deepslate_stairs".into());
[INFO] [stdout] 233 +     map.insert(0xD1, <&str as Into<_>>::into("minecraft:cobbled_deepslate_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:234:22
[INFO] [stdout]     |
[INFO] [stdout] 234 |     map.insert(0xD2, "minecraft:cobbled_deepslate_wall".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 234 -     map.insert(0xD2, "minecraft:cobbled_deepslate_wall".into());
[INFO] [stdout] 234 +     map.insert(0xD2, "minecraft:cobbled_deepslate_wall");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 234 -     map.insert(0xD2, "minecraft:cobbled_deepslate_wall".into());
[INFO] [stdout] 234 +     map.insert(0xD2, <&str as Into<_>>::into("minecraft:cobbled_deepslate_wall"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:235:22
[INFO] [stdout]     |
[INFO] [stdout] 235 |     map.insert(0xD3, "minecraft:cobblestone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 235 -     map.insert(0xD3, "minecraft:cobblestone".into());
[INFO] [stdout] 235 +     map.insert(0xD3, "minecraft:cobblestone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 235 -     map.insert(0xD3, "minecraft:cobblestone".into());
[INFO] [stdout] 235 +     map.insert(0xD3, <&str as Into<_>>::into("minecraft:cobblestone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:236:22
[INFO] [stdout]     |
[INFO] [stdout] 236 |     map.insert(0xD4, "minecraft:cobblestone_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 236 -     map.insert(0xD4, "minecraft:cobblestone_slab".into());
[INFO] [stdout] 236 +     map.insert(0xD4, "minecraft:cobblestone_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 236 -     map.insert(0xD4, "minecraft:cobblestone_slab".into());
[INFO] [stdout] 236 +     map.insert(0xD4, <&str as Into<_>>::into("minecraft:cobblestone_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:237:22
[INFO] [stdout]     |
[INFO] [stdout] 237 |     map.insert(0xD5, "minecraft:cobblestone_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 237 -     map.insert(0xD5, "minecraft:cobblestone_stairs".into());
[INFO] [stdout] 237 +     map.insert(0xD5, "minecraft:cobblestone_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 237 -     map.insert(0xD5, "minecraft:cobblestone_stairs".into());
[INFO] [stdout] 237 +     map.insert(0xD5, <&str as Into<_>>::into("minecraft:cobblestone_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:238:22
[INFO] [stdout]     |
[INFO] [stdout] 238 |     map.insert(0xD6, "minecraft:cobblestone_wall".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 238 -     map.insert(0xD6, "minecraft:cobblestone_wall".into());
[INFO] [stdout] 238 +     map.insert(0xD6, "minecraft:cobblestone_wall");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 -     map.insert(0xD6, "minecraft:cobblestone_wall".into());
[INFO] [stdout] 238 +     map.insert(0xD6, <&str as Into<_>>::into("minecraft:cobblestone_wall"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:239:22
[INFO] [stdout]     |
[INFO] [stdout] 239 |     map.insert(0xD7, "minecraft:cobweb".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 239 -     map.insert(0xD7, "minecraft:cobweb".into());
[INFO] [stdout] 239 +     map.insert(0xD7, "minecraft:cobweb");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 -     map.insert(0xD7, "minecraft:cobweb".into());
[INFO] [stdout] 239 +     map.insert(0xD7, <&str as Into<_>>::into("minecraft:cobweb"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:240:22
[INFO] [stdout]     |
[INFO] [stdout] 240 |     map.insert(0xD8, "minecraft:jungle_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 240 -     map.insert(0xD8, "minecraft:jungle_planks".into());
[INFO] [stdout] 240 +     map.insert(0xD8, "minecraft:jungle_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 -     map.insert(0xD8, "minecraft:jungle_planks".into());
[INFO] [stdout] 240 +     map.insert(0xD8, <&str as Into<_>>::into("minecraft:jungle_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:241:22
[INFO] [stdout]     |
[INFO] [stdout] 241 |     map.insert(0xD9, "minecraft:command_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 241 -     map.insert(0xD9, "minecraft:command_block".into());
[INFO] [stdout] 241 +     map.insert(0xD9, "minecraft:command_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 241 -     map.insert(0xD9, "minecraft:command_block".into());
[INFO] [stdout] 241 +     map.insert(0xD9, <&str as Into<_>>::into("minecraft:command_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:242:22
[INFO] [stdout]     |
[INFO] [stdout] 242 |     map.insert(0xDA, "minecraft:comparator".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 242 -     map.insert(0xDA, "minecraft:comparator".into());
[INFO] [stdout] 242 +     map.insert(0xDA, "minecraft:comparator");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 242 -     map.insert(0xDA, "minecraft:comparator".into());
[INFO] [stdout] 242 +     map.insert(0xDA, <&str as Into<_>>::into("minecraft:comparator"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:243:22
[INFO] [stdout]     |
[INFO] [stdout] 243 |     map.insert(0xDB, "minecraft:composter".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 243 -     map.insert(0xDB, "minecraft:composter".into());
[INFO] [stdout] 243 +     map.insert(0xDB, "minecraft:composter");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 243 -     map.insert(0xDB, "minecraft:composter".into());
[INFO] [stdout] 243 +     map.insert(0xDB, <&str as Into<_>>::into("minecraft:composter"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:244:22
[INFO] [stdout]     |
[INFO] [stdout] 244 |     map.insert(0xDC, "minecraft:packed_ice".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 244 -     map.insert(0xDC, "minecraft:packed_ice".into());
[INFO] [stdout] 244 +     map.insert(0xDC, "minecraft:packed_ice");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 -     map.insert(0xDC, "minecraft:packed_ice".into());
[INFO] [stdout] 244 +     map.insert(0xDC, <&str as Into<_>>::into("minecraft:packed_ice"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:245:22
[INFO] [stdout]     |
[INFO] [stdout] 245 |     map.insert(0xDD, "minecraft:iron_bars".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 245 -     map.insert(0xDD, "minecraft:iron_bars".into());
[INFO] [stdout] 245 +     map.insert(0xDD, "minecraft:iron_bars");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 245 -     map.insert(0xDD, "minecraft:iron_bars".into());
[INFO] [stdout] 245 +     map.insert(0xDD, <&str as Into<_>>::into("minecraft:iron_bars"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:246:22
[INFO] [stdout]     |
[INFO] [stdout] 246 |     map.insert(0xDE, "minecraft:crying_obsidian".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 246 -     map.insert(0xDE, "minecraft:crying_obsidian".into());
[INFO] [stdout] 246 +     map.insert(0xDE, "minecraft:crying_obsidian");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 246 -     map.insert(0xDE, "minecraft:crying_obsidian".into());
[INFO] [stdout] 246 +     map.insert(0xDE, <&str as Into<_>>::into("minecraft:crying_obsidian"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:247:22
[INFO] [stdout]     |
[INFO] [stdout] 247 |     map.insert(0xDF, "minecraft:respawn_anchor".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 247 -     map.insert(0xDF, "minecraft:respawn_anchor".into());
[INFO] [stdout] 247 +     map.insert(0xDF, "minecraft:respawn_anchor");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 247 -     map.insert(0xDF, "minecraft:respawn_anchor".into());
[INFO] [stdout] 247 +     map.insert(0xDF, <&str as Into<_>>::into("minecraft:respawn_anchor"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:248:22
[INFO] [stdout]     |
[INFO] [stdout] 248 |     map.insert(0xE0, "minecraft:chain".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 248 -     map.insert(0xE0, "minecraft:chain".into());
[INFO] [stdout] 248 +     map.insert(0xE0, "minecraft:chain");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 248 -     map.insert(0xE0, "minecraft:chain".into());
[INFO] [stdout] 248 +     map.insert(0xE0, <&str as Into<_>>::into("minecraft:chain"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:249:22
[INFO] [stdout]     |
[INFO] [stdout] 249 |     map.insert(0xE1, "minecraft:stripped_oak_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 249 -     map.insert(0xE1, "minecraft:stripped_oak_log".into());
[INFO] [stdout] 249 +     map.insert(0xE1, "minecraft:stripped_oak_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 -     map.insert(0xE1, "minecraft:stripped_oak_log".into());
[INFO] [stdout] 249 +     map.insert(0xE1, <&str as Into<_>>::into("minecraft:stripped_oak_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:250:22
[INFO] [stdout]     |
[INFO] [stdout] 250 |     map.insert(0xE2, "minecraft:waxed_copper_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 250 -     map.insert(0xE2, "minecraft:waxed_copper_block".into());
[INFO] [stdout] 250 +     map.insert(0xE2, "minecraft:waxed_copper_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 250 -     map.insert(0xE2, "minecraft:waxed_copper_block".into());
[INFO] [stdout] 250 +     map.insert(0xE2, <&str as Into<_>>::into("minecraft:waxed_copper_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:251:22
[INFO] [stdout]     |
[INFO] [stdout] 251 |     map.insert(0xE3, "minecraft:dispenser".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 251 -     map.insert(0xE3, "minecraft:dispenser".into());
[INFO] [stdout] 251 +     map.insert(0xE3, "minecraft:dispenser");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 251 -     map.insert(0xE3, "minecraft:dispenser".into());
[INFO] [stdout] 251 +     map.insert(0xE3, <&str as Into<_>>::into("minecraft:dispenser"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:252:22
[INFO] [stdout]     |
[INFO] [stdout] 252 |     map.insert(0xE4, "minecraft:dropper".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 252 -     map.insert(0xE4, "minecraft:dropper".into());
[INFO] [stdout] 252 +     map.insert(0xE4, "minecraft:dropper");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 252 -     map.insert(0xE4, "minecraft:dropper".into());
[INFO] [stdout] 252 +     map.insert(0xE4, <&str as Into<_>>::into("minecraft:dropper"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:253:22
[INFO] [stdout]     |
[INFO] [stdout] 253 |     map.insert(0xE5, "minecraft:stripped_dark_oak_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 253 -     map.insert(0xE5, "minecraft:stripped_dark_oak_log".into());
[INFO] [stdout] 253 +     map.insert(0xE5, "minecraft:stripped_dark_oak_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 253 -     map.insert(0xE5, "minecraft:stripped_dark_oak_log".into());
[INFO] [stdout] 253 +     map.insert(0xE5, <&str as Into<_>>::into("minecraft:stripped_dark_oak_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:254:22
[INFO] [stdout]     |
[INFO] [stdout] 254 |     map.insert(0xE6, "minecraft:diamond_ore".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 254 -     map.insert(0xE6, "minecraft:diamond_ore".into());
[INFO] [stdout] 254 +     map.insert(0xE6, "minecraft:diamond_ore");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 254 -     map.insert(0xE6, "minecraft:diamond_ore".into());
[INFO] [stdout] 254 +     map.insert(0xE6, <&str as Into<_>>::into("minecraft:diamond_ore"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:255:22
[INFO] [stdout]     |
[INFO] [stdout] 255 |     map.insert(0xE7, "minecraft:soul_torch".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 255 -     map.insert(0xE7, "minecraft:soul_torch".into());
[INFO] [stdout] 255 +     map.insert(0xE7, "minecraft:soul_torch");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 255 -     map.insert(0xE7, "minecraft:soul_torch".into());
[INFO] [stdout] 255 +     map.insert(0xE7, <&str as Into<_>>::into("minecraft:soul_torch"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:256:22
[INFO] [stdout]     |
[INFO] [stdout] 256 |     map.insert(0xE8, "minecraft:soul_wall_torch".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 256 -     map.insert(0xE8, "minecraft:soul_wall_torch".into());
[INFO] [stdout] 256 +     map.insert(0xE8, "minecraft:soul_wall_torch");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 256 -     map.insert(0xE8, "minecraft:soul_wall_torch".into());
[INFO] [stdout] 256 +     map.insert(0xE8, <&str as Into<_>>::into("minecraft:soul_wall_torch"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:257:22
[INFO] [stdout]     |
[INFO] [stdout] 257 |     map.insert(0xE9, "minecraft:mangrove_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 257 -     map.insert(0xE9, "minecraft:mangrove_planks".into());
[INFO] [stdout] 257 +     map.insert(0xE9, "minecraft:mangrove_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 -     map.insert(0xE9, "minecraft:mangrove_planks".into());
[INFO] [stdout] 257 +     map.insert(0xE9, <&str as Into<_>>::into("minecraft:mangrove_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:258:22
[INFO] [stdout]     |
[INFO] [stdout] 258 |     map.insert(0xEA, "minecraft:gravel".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 258 -     map.insert(0xEA, "minecraft:gravel".into());
[INFO] [stdout] 258 +     map.insert(0xEA, "minecraft:gravel");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 258 -     map.insert(0xEA, "minecraft:gravel".into());
[INFO] [stdout] 258 +     map.insert(0xEA, <&str as Into<_>>::into("minecraft:gravel"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:259:22
[INFO] [stdout]     |
[INFO] [stdout] 259 |     map.insert(0xEB, "minecraft:cracked_deepslate_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 259 -     map.insert(0xEB, "minecraft:cracked_deepslate_bricks".into());
[INFO] [stdout] 259 +     map.insert(0xEB, "minecraft:cracked_deepslate_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 -     map.insert(0xEB, "minecraft:cracked_deepslate_bricks".into());
[INFO] [stdout] 259 +     map.insert(0xEB, <&str as Into<_>>::into("minecraft:cracked_deepslate_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:260:22
[INFO] [stdout]     |
[INFO] [stdout] 260 |     map.insert(0xEC, "minecraft:cracked_deepslate_tiles".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 260 -     map.insert(0xEC, "minecraft:cracked_deepslate_tiles".into());
[INFO] [stdout] 260 +     map.insert(0xEC, "minecraft:cracked_deepslate_tiles");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 260 -     map.insert(0xEC, "minecraft:cracked_deepslate_tiles".into());
[INFO] [stdout] 260 +     map.insert(0xEC, <&str as Into<_>>::into("minecraft:cracked_deepslate_tiles"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:261:22
[INFO] [stdout]     |
[INFO] [stdout] 261 |     map.insert(0xED, "minecraft:cracked_nether_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 261 -     map.insert(0xED, "minecraft:cracked_nether_bricks".into());
[INFO] [stdout] 261 +     map.insert(0xED, "minecraft:cracked_nether_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 -     map.insert(0xED, "minecraft:cracked_nether_bricks".into());
[INFO] [stdout] 261 +     map.insert(0xED, <&str as Into<_>>::into("minecraft:cracked_nether_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:262:22
[INFO] [stdout]     |
[INFO] [stdout] 262 |     map.insert(0xEE, "minecraft:cracked_polished_blackstone_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 262 -     map.insert(0xEE, "minecraft:cracked_polished_blackstone_bricks".into());
[INFO] [stdout] 262 +     map.insert(0xEE, "minecraft:cracked_polished_blackstone_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 -     map.insert(0xEE, "minecraft:cracked_polished_blackstone_bricks".into());
[INFO] [stdout] 262 +     map.insert(0xEE, <&str as Into<_>>::into("minecraft:cracked_polished_blackstone_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:263:22
[INFO] [stdout]     |
[INFO] [stdout] 263 |     map.insert(0xEF, "minecraft:cracked_stone_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 263 -     map.insert(0xEF, "minecraft:cracked_stone_bricks".into());
[INFO] [stdout] 263 +     map.insert(0xEF, "minecraft:cracked_stone_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 263 -     map.insert(0xEF, "minecraft:cracked_stone_bricks".into());
[INFO] [stdout] 263 +     map.insert(0xEF, <&str as Into<_>>::into("minecraft:cracked_stone_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:264:22
[INFO] [stdout]     |
[INFO] [stdout] 264 |     map.insert(0xF0, "minecraft:crafter".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 264 -     map.insert(0xF0, "minecraft:crafter".into());
[INFO] [stdout] 264 +     map.insert(0xF0, "minecraft:crafter");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 264 -     map.insert(0xF0, "minecraft:crafter".into());
[INFO] [stdout] 264 +     map.insert(0xF0, <&str as Into<_>>::into("minecraft:crafter"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:265:22
[INFO] [stdout]     |
[INFO] [stdout] 265 |     map.insert(0xF1, "minecraft:crafting_table".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 265 -     map.insert(0xF1, "minecraft:crafting_table".into());
[INFO] [stdout] 265 +     map.insert(0xF1, "minecraft:crafting_table");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 265 -     map.insert(0xF1, "minecraft:crafting_table".into());
[INFO] [stdout] 265 +     map.insert(0xF1, <&str as Into<_>>::into("minecraft:crafting_table"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:266:22
[INFO] [stdout]     |
[INFO] [stdout] 266 |     map.insert(0xF2, "minecraft:creaking_heart".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 266 -     map.insert(0xF2, "minecraft:creaking_heart".into());
[INFO] [stdout] 266 +     map.insert(0xF2, "minecraft:creaking_heart");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 266 -     map.insert(0xF2, "minecraft:creaking_heart".into());
[INFO] [stdout] 266 +     map.insert(0xF2, <&str as Into<_>>::into("minecraft:creaking_heart"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:267:22
[INFO] [stdout]     |
[INFO] [stdout] 267 |     map.insert(0xF3, "minecraft:creeper_head".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 267 -     map.insert(0xF3, "minecraft:creeper_head".into());
[INFO] [stdout] 267 +     map.insert(0xF3, "minecraft:creeper_head");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 -     map.insert(0xF3, "minecraft:creeper_head".into());
[INFO] [stdout] 267 +     map.insert(0xF3, <&str as Into<_>>::into("minecraft:creeper_head"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:268:22
[INFO] [stdout]     |
[INFO] [stdout] 268 |     map.insert(0xF4, "minecraft:oak_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 268 -     map.insert(0xF4, "minecraft:oak_log".into());
[INFO] [stdout] 268 +     map.insert(0xF4, "minecraft:oak_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 -     map.insert(0xF4, "minecraft:oak_log".into());
[INFO] [stdout] 268 +     map.insert(0xF4, <&str as Into<_>>::into("minecraft:oak_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:269:22
[INFO] [stdout]     |
[INFO] [stdout] 269 |     map.insert(0xF5, "minecraft:waxed_exposed_copper".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 269 -     map.insert(0xF5, "minecraft:waxed_exposed_copper".into());
[INFO] [stdout] 269 +     map.insert(0xF5, "minecraft:waxed_exposed_copper");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 269 -     map.insert(0xF5, "minecraft:waxed_exposed_copper".into());
[INFO] [stdout] 269 +     map.insert(0xF5, <&str as Into<_>>::into("minecraft:waxed_exposed_copper"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:270:22
[INFO] [stdout]     |
[INFO] [stdout] 270 |     map.insert(0xF6, "minecraft:waxed_weathered_copper".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 270 -     map.insert(0xF6, "minecraft:waxed_weathered_copper".into());
[INFO] [stdout] 270 +     map.insert(0xF6, "minecraft:waxed_weathered_copper");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 270 -     map.insert(0xF6, "minecraft:waxed_weathered_copper".into());
[INFO] [stdout] 270 +     map.insert(0xF6, <&str as Into<_>>::into("minecraft:waxed_weathered_copper"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:271:22
[INFO] [stdout]     |
[INFO] [stdout] 271 |     map.insert(0xF7, "minecraft:crimson_fence".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 271 -     map.insert(0xF7, "minecraft:crimson_fence".into());
[INFO] [stdout] 271 +     map.insert(0xF7, "minecraft:crimson_fence");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 271 -     map.insert(0xF7, "minecraft:crimson_fence".into());
[INFO] [stdout] 271 +     map.insert(0xF7, <&str as Into<_>>::into("minecraft:crimson_fence"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:272:22
[INFO] [stdout]     |
[INFO] [stdout] 272 |     map.insert(0xF8, "minecraft:crimson_fence_gate".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 272 -     map.insert(0xF8, "minecraft:crimson_fence_gate".into());
[INFO] [stdout] 272 +     map.insert(0xF8, "minecraft:crimson_fence_gate");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 -     map.insert(0xF8, "minecraft:crimson_fence_gate".into());
[INFO] [stdout] 272 +     map.insert(0xF8, <&str as Into<_>>::into("minecraft:crimson_fence_gate"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:273:22
[INFO] [stdout]     |
[INFO] [stdout] 273 |     map.insert(0xF9, "minecraft:warped_stem".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 273 -     map.insert(0xF9, "minecraft:warped_stem".into());
[INFO] [stdout] 273 +     map.insert(0xF9, "minecraft:warped_stem");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 273 -     map.insert(0xF9, "minecraft:warped_stem".into());
[INFO] [stdout] 273 +     map.insert(0xF9, <&str as Into<_>>::into("minecraft:warped_stem"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:274:22
[INFO] [stdout]     |
[INFO] [stdout] 274 |     map.insert(0xFA, "minecraft:waxed_oxidized_copper".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 274 -     map.insert(0xFA, "minecraft:waxed_oxidized_copper".into());
[INFO] [stdout] 274 +     map.insert(0xFA, "minecraft:waxed_oxidized_copper");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 274 -     map.insert(0xFA, "minecraft:waxed_oxidized_copper".into());
[INFO] [stdout] 274 +     map.insert(0xFA, <&str as Into<_>>::into("minecraft:waxed_oxidized_copper"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:275:22
[INFO] [stdout]     |
[INFO] [stdout] 275 |     map.insert(0xFB, "minecraft:crimson_hyphae".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 275 -     map.insert(0xFB, "minecraft:crimson_hyphae".into());
[INFO] [stdout] 275 +     map.insert(0xFB, "minecraft:crimson_hyphae");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 -     map.insert(0xFB, "minecraft:crimson_hyphae".into());
[INFO] [stdout] 275 +     map.insert(0xFB, <&str as Into<_>>::into("minecraft:crimson_hyphae"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:276:22
[INFO] [stdout]     |
[INFO] [stdout] 276 |     map.insert(0xFC, "minecraft:crimson_nylium".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 276 -     map.insert(0xFC, "minecraft:crimson_nylium".into());
[INFO] [stdout] 276 +     map.insert(0xFC, "minecraft:crimson_nylium");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 -     map.insert(0xFC, "minecraft:crimson_nylium".into());
[INFO] [stdout] 276 +     map.insert(0xFC, <&str as Into<_>>::into("minecraft:crimson_nylium"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:277:22
[INFO] [stdout]     |
[INFO] [stdout] 277 |     map.insert(0xFD, "minecraft:crimson_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -     map.insert(0xFD, "minecraft:crimson_planks".into());
[INFO] [stdout] 277 +     map.insert(0xFD, "minecraft:crimson_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -     map.insert(0xFD, "minecraft:crimson_planks".into());
[INFO] [stdout] 277 +     map.insert(0xFD, <&str as Into<_>>::into("minecraft:crimson_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:278:22
[INFO] [stdout]     |
[INFO] [stdout] 278 |     map.insert(0xFE, "minecraft:stripped_crimson_stem".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 278 -     map.insert(0xFE, "minecraft:stripped_crimson_stem".into());
[INFO] [stdout] 278 +     map.insert(0xFE, "minecraft:stripped_crimson_stem");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 278 -     map.insert(0xFE, "minecraft:stripped_crimson_stem".into());
[INFO] [stdout] 278 +     map.insert(0xFE, <&str as Into<_>>::into("minecraft:stripped_crimson_stem"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:279:22
[INFO] [stdout]     |
[INFO] [stdout] 279 |     map.insert(0xFF, "minecraft:purple_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 279 -     map.insert(0xFF, "minecraft:purple_wool".into());
[INFO] [stdout] 279 +     map.insert(0xFF, "minecraft:purple_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 279 -     map.insert(0xFF, "minecraft:purple_wool".into());
[INFO] [stdout] 279 +     map.insert(0xFF, <&str as Into<_>>::into("minecraft:purple_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `encode-image-to-minecraft` (bin "encode-image-to-minecraft" test) due to 256 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:24:22
[INFO] [stdout]    |
[INFO] [stdout] 24 |     map.insert(0x00, "minecraft:barrier".into()); // null
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 24 -     map.insert(0x00, "minecraft:barrier".into()); // null
[INFO] [stdout] 24 +     map.insert(0x00, "minecraft:barrier"); // null
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 24 -     map.insert(0x00, "minecraft:barrier".into()); // null
[INFO] [stdout] 24 +     map.insert(0x00, <&str as Into<_>>::into("minecraft:barrier")); // null
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:25:22
[INFO] [stdout]    |
[INFO] [stdout] 25 |     map.insert(0x01, "minecraft:polished_basalt".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 25 -     map.insert(0x01, "minecraft:polished_basalt".into());
[INFO] [stdout] 25 +     map.insert(0x01, "minecraft:polished_basalt");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 25 -     map.insert(0x01, "minecraft:polished_basalt".into());
[INFO] [stdout] 25 +     map.insert(0x01, <&str as Into<_>>::into("minecraft:polished_basalt"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:26:22
[INFO] [stdout]    |
[INFO] [stdout] 26 |     map.insert(0x02, "minecraft:acacia_fence".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 26 -     map.insert(0x02, "minecraft:acacia_fence".into());
[INFO] [stdout] 26 +     map.insert(0x02, "minecraft:acacia_fence");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 26 -     map.insert(0x02, "minecraft:acacia_fence".into());
[INFO] [stdout] 26 +     map.insert(0x02, <&str as Into<_>>::into("minecraft:acacia_fence"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:27:22
[INFO] [stdout]    |
[INFO] [stdout] 27 |     map.insert(0x03, "minecraft:acacia_fence_gate".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 27 -     map.insert(0x03, "minecraft:acacia_fence_gate".into());
[INFO] [stdout] 27 +     map.insert(0x03, "minecraft:acacia_fence_gate");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 27 -     map.insert(0x03, "minecraft:acacia_fence_gate".into());
[INFO] [stdout] 27 +     map.insert(0x03, <&str as Into<_>>::into("minecraft:acacia_fence_gate"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:28:22
[INFO] [stdout]    |
[INFO] [stdout] 28 |     map.insert(0x04, "minecraft:polished_blackstone".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 28 -     map.insert(0x04, "minecraft:polished_blackstone".into());
[INFO] [stdout] 28 +     map.insert(0x04, "minecraft:polished_blackstone");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 28 -     map.insert(0x04, "minecraft:polished_blackstone".into());
[INFO] [stdout] 28 +     map.insert(0x04, <&str as Into<_>>::into("minecraft:polished_blackstone"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:29:22
[INFO] [stdout]    |
[INFO] [stdout] 29 |     map.insert(0x05, "minecraft:stripped_spruce_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 29 -     map.insert(0x05, "minecraft:stripped_spruce_log".into());
[INFO] [stdout] 29 +     map.insert(0x05, "minecraft:stripped_spruce_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 29 -     map.insert(0x05, "minecraft:stripped_spruce_log".into());
[INFO] [stdout] 29 +     map.insert(0x05, <&str as Into<_>>::into("minecraft:stripped_spruce_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:30:22
[INFO] [stdout]    |
[INFO] [stdout] 30 |     map.insert(0x06, "minecraft:acacia_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 30 -     map.insert(0x06, "minecraft:acacia_log".into());
[INFO] [stdout] 30 +     map.insert(0x06, "minecraft:acacia_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 30 -     map.insert(0x06, "minecraft:acacia_log".into());
[INFO] [stdout] 30 +     map.insert(0x06, <&str as Into<_>>::into("minecraft:acacia_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:31:22
[INFO] [stdout]    |
[INFO] [stdout] 31 |     map.insert(0x07, "minecraft:acacia_planks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 31 -     map.insert(0x07, "minecraft:acacia_planks".into());
[INFO] [stdout] 31 +     map.insert(0x07, "minecraft:acacia_planks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 31 -     map.insert(0x07, "minecraft:acacia_planks".into());
[INFO] [stdout] 31 +     map.insert(0x07, <&str as Into<_>>::into("minecraft:acacia_planks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:32:22
[INFO] [stdout]    |
[INFO] [stdout] 32 |     map.insert(0x08, "minecraft:stripped_acacia_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 32 -     map.insert(0x08, "minecraft:stripped_acacia_log".into());
[INFO] [stdout] 32 +     map.insert(0x08, "minecraft:stripped_acacia_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 32 -     map.insert(0x08, "minecraft:stripped_acacia_log".into());
[INFO] [stdout] 32 +     map.insert(0x08, <&str as Into<_>>::into("minecraft:stripped_acacia_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:33:22
[INFO] [stdout]    |
[INFO] [stdout] 33 |     map.insert(0x09, "minecraft:polished_andesite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 33 -     map.insert(0x09, "minecraft:polished_andesite".into());
[INFO] [stdout] 33 +     map.insert(0x09, "minecraft:polished_andesite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 33 -     map.insert(0x09, "minecraft:polished_andesite".into());
[INFO] [stdout] 33 +     map.insert(0x09, <&str as Into<_>>::into("minecraft:polished_andesite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:34:22
[INFO] [stdout]    |
[INFO] [stdout] 34 |     map.insert(0x0A, "minecraft:acacia_shelf".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 34 -     map.insert(0x0A, "minecraft:acacia_shelf".into());
[INFO] [stdout] 34 +     map.insert(0x0A, "minecraft:acacia_shelf");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 34 -     map.insert(0x0A, "minecraft:acacia_shelf".into());
[INFO] [stdout] 34 +     map.insert(0x0A, <&str as Into<_>>::into("minecraft:acacia_shelf"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:35:22
[INFO] [stdout]    |
[INFO] [stdout] 35 |     map.insert(0x0B, "minecraft:polished_deepslate".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 35 -     map.insert(0x0B, "minecraft:polished_deepslate".into());
[INFO] [stdout] 35 +     map.insert(0x0B, "minecraft:polished_deepslate");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 35 -     map.insert(0x0B, "minecraft:polished_deepslate".into());
[INFO] [stdout] 35 +     map.insert(0x0B, <&str as Into<_>>::into("minecraft:polished_deepslate"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:36:22
[INFO] [stdout]    |
[INFO] [stdout] 36 |     map.insert(0x0C, "minecraft:acacia_slab".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 36 -     map.insert(0x0C, "minecraft:acacia_slab".into());
[INFO] [stdout] 36 +     map.insert(0x0C, "minecraft:acacia_slab");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 36 -     map.insert(0x0C, "minecraft:acacia_slab".into());
[INFO] [stdout] 36 +     map.insert(0x0C, <&str as Into<_>>::into("minecraft:acacia_slab"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:37:22
[INFO] [stdout]    |
[INFO] [stdout] 37 |     map.insert(0x0D, "minecraft:acacia_stairs".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 37 -     map.insert(0x0D, "minecraft:acacia_stairs".into());
[INFO] [stdout] 37 +     map.insert(0x0D, "minecraft:acacia_stairs");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 37 -     map.insert(0x0D, "minecraft:acacia_stairs".into());
[INFO] [stdout] 37 +     map.insert(0x0D, <&str as Into<_>>::into("minecraft:acacia_stairs"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:38:22
[INFO] [stdout]    |
[INFO] [stdout] 38 |     map.insert(0x0E, "minecraft:acacia_trapdoor".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 38 -     map.insert(0x0E, "minecraft:acacia_trapdoor".into());
[INFO] [stdout] 38 +     map.insert(0x0E, "minecraft:acacia_trapdoor");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 38 -     map.insert(0x0E, "minecraft:acacia_trapdoor".into());
[INFO] [stdout] 38 +     map.insert(0x0E, <&str as Into<_>>::into("minecraft:acacia_trapdoor"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:39:22
[INFO] [stdout]    |
[INFO] [stdout] 39 |     map.insert(0x0F, "minecraft:polished_tuff".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 39 -     map.insert(0x0F, "minecraft:polished_tuff".into());
[INFO] [stdout] 39 +     map.insert(0x0F, "minecraft:polished_tuff");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 39 -     map.insert(0x0F, "minecraft:polished_tuff".into());
[INFO] [stdout] 39 +     map.insert(0x0F, <&str as Into<_>>::into("minecraft:polished_tuff"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:40:22
[INFO] [stdout]    |
[INFO] [stdout] 40 |     map.insert(0x10, "minecraft:end_stone_bricks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 40 -     map.insert(0x10, "minecraft:end_stone_bricks".into());
[INFO] [stdout] 40 +     map.insert(0x10, "minecraft:end_stone_bricks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 40 -     map.insert(0x10, "minecraft:end_stone_bricks".into());
[INFO] [stdout] 40 +     map.insert(0x10, <&str as Into<_>>::into("minecraft:end_stone_bricks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:41:22
[INFO] [stdout]    |
[INFO] [stdout] 41 |     map.insert(0x11, "minecraft:acacia_wood".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 41 -     map.insert(0x11, "minecraft:acacia_wood".into());
[INFO] [stdout] 41 +     map.insert(0x11, "minecraft:acacia_wood");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 41 -     map.insert(0x11, "minecraft:acacia_wood".into());
[INFO] [stdout] 41 +     map.insert(0x11, <&str as Into<_>>::into("minecraft:acacia_wood"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:42:22
[INFO] [stdout]    |
[INFO] [stdout] 42 |     map.insert(0x12, "minecraft:activator_rail".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 42 -     map.insert(0x12, "minecraft:activator_rail".into());
[INFO] [stdout] 42 +     map.insert(0x12, "minecraft:activator_rail");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -     map.insert(0x12, "minecraft:activator_rail".into());
[INFO] [stdout] 42 +     map.insert(0x12, <&str as Into<_>>::into("minecraft:activator_rail"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:43:22
[INFO] [stdout]    |
[INFO] [stdout] 43 |     map.insert(0x13, "minecraft:deepslate_bricks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 43 -     map.insert(0x13, "minecraft:deepslate_bricks".into());
[INFO] [stdout] 43 +     map.insert(0x13, "minecraft:deepslate_bricks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 43 -     map.insert(0x13, "minecraft:deepslate_bricks".into());
[INFO] [stdout] 43 +     map.insert(0x13, <&str as Into<_>>::into("minecraft:deepslate_bricks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:44:22
[INFO] [stdout]    |
[INFO] [stdout] 44 |     map.insert(0x14, "minecraft:polished_diorite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 44 -     map.insert(0x14, "minecraft:polished_diorite".into());
[INFO] [stdout] 44 +     map.insert(0x14, "minecraft:polished_diorite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 44 -     map.insert(0x14, "minecraft:polished_diorite".into());
[INFO] [stdout] 44 +     map.insert(0x14, <&str as Into<_>>::into("minecraft:polished_diorite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:45:22
[INFO] [stdout]    |
[INFO] [stdout] 45 |     map.insert(0x15, "minecraft:amethyst_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 45 -     map.insert(0x15, "minecraft:amethyst_block".into());
[INFO] [stdout] 45 +     map.insert(0x15, "minecraft:amethyst_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 45 -     map.insert(0x15, "minecraft:amethyst_block".into());
[INFO] [stdout] 45 +     map.insert(0x15, <&str as Into<_>>::into("minecraft:amethyst_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:46:22
[INFO] [stdout]    |
[INFO] [stdout] 46 |     map.insert(0x16, "minecraft:amethyst_cluster".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 46 -     map.insert(0x16, "minecraft:amethyst_cluster".into());
[INFO] [stdout] 46 +     map.insert(0x16, "minecraft:amethyst_cluster");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 46 -     map.insert(0x16, "minecraft:amethyst_cluster".into());
[INFO] [stdout] 46 +     map.insert(0x16, <&str as Into<_>>::into("minecraft:amethyst_cluster"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:47:22
[INFO] [stdout]    |
[INFO] [stdout] 47 |     map.insert(0x17, "minecraft:ancient_debris".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 47 -     map.insert(0x17, "minecraft:ancient_debris".into());
[INFO] [stdout] 47 +     map.insert(0x17, "minecraft:ancient_debris");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 47 -     map.insert(0x17, "minecraft:ancient_debris".into());
[INFO] [stdout] 47 +     map.insert(0x17, <&str as Into<_>>::into("minecraft:ancient_debris"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:48:22
[INFO] [stdout]    |
[INFO] [stdout] 48 |     map.insert(0x18, "minecraft:andesite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 48 -     map.insert(0x18, "minecraft:andesite".into());
[INFO] [stdout] 48 +     map.insert(0x18, "minecraft:andesite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 48 -     map.insert(0x18, "minecraft:andesite".into());
[INFO] [stdout] 48 +     map.insert(0x18, <&str as Into<_>>::into("minecraft:andesite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:49:22
[INFO] [stdout]    |
[INFO] [stdout] 49 |     map.insert(0x19, "minecraft:andesite_slab".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 49 -     map.insert(0x19, "minecraft:andesite_slab".into());
[INFO] [stdout] 49 +     map.insert(0x19, "minecraft:andesite_slab");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 49 -     map.insert(0x19, "minecraft:andesite_slab".into());
[INFO] [stdout] 49 +     map.insert(0x19, <&str as Into<_>>::into("minecraft:andesite_slab"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:50:22
[INFO] [stdout]    |
[INFO] [stdout] 50 |     map.insert(0x1A, "minecraft:andesite_stairs".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 50 -     map.insert(0x1A, "minecraft:andesite_stairs".into());
[INFO] [stdout] 50 +     map.insert(0x1A, "minecraft:andesite_stairs");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 -     map.insert(0x1A, "minecraft:andesite_stairs".into());
[INFO] [stdout] 50 +     map.insert(0x1A, <&str as Into<_>>::into("minecraft:andesite_stairs"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:51:22
[INFO] [stdout]    |
[INFO] [stdout] 51 |     map.insert(0x1B, "minecraft:andesite_wall".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 51 -     map.insert(0x1B, "minecraft:andesite_wall".into());
[INFO] [stdout] 51 +     map.insert(0x1B, "minecraft:andesite_wall");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 51 -     map.insert(0x1B, "minecraft:andesite_wall".into());
[INFO] [stdout] 51 +     map.insert(0x1B, <&str as Into<_>>::into("minecraft:andesite_wall"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:52:22
[INFO] [stdout]    |
[INFO] [stdout] 52 |     map.insert(0x1C, "minecraft:anvil".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 52 -     map.insert(0x1C, "minecraft:anvil".into());
[INFO] [stdout] 52 +     map.insert(0x1C, "minecraft:anvil");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 52 -     map.insert(0x1C, "minecraft:anvil".into());
[INFO] [stdout] 52 +     map.insert(0x1C, <&str as Into<_>>::into("minecraft:anvil"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:53:22
[INFO] [stdout]    |
[INFO] [stdout] 53 |     map.insert(0x1D, "minecraft:tuff".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 53 -     map.insert(0x1D, "minecraft:tuff".into());
[INFO] [stdout] 53 +     map.insert(0x1D, "minecraft:tuff");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 -     map.insert(0x1D, "minecraft:tuff".into());
[INFO] [stdout] 53 +     map.insert(0x1D, <&str as Into<_>>::into("minecraft:tuff"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:54:22
[INFO] [stdout]    |
[INFO] [stdout] 54 |     map.insert(0x1E, "minecraft:diorite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 54 -     map.insert(0x1E, "minecraft:diorite".into());
[INFO] [stdout] 54 +     map.insert(0x1E, "minecraft:diorite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -     map.insert(0x1E, "minecraft:diorite".into());
[INFO] [stdout] 54 +     map.insert(0x1E, <&str as Into<_>>::into("minecraft:diorite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:55:22
[INFO] [stdout]    |
[INFO] [stdout] 55 |     map.insert(0x1F, "minecraft:mycelium".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 55 -     map.insert(0x1F, "minecraft:mycelium".into());
[INFO] [stdout] 55 +     map.insert(0x1F, "minecraft:mycelium");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -     map.insert(0x1F, "minecraft:mycelium".into());
[INFO] [stdout] 55 +     map.insert(0x1F, <&str as Into<_>>::into("minecraft:mycelium"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:56:22
[INFO] [stdout]    |
[INFO] [stdout] 56 |     map.insert(0x20, "minecraft:stripped_jungle_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 56 -     map.insert(0x20, "minecraft:stripped_jungle_log".into());
[INFO] [stdout] 56 +     map.insert(0x20, "minecraft:stripped_jungle_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -     map.insert(0x20, "minecraft:stripped_jungle_log".into());
[INFO] [stdout] 56 +     map.insert(0x20, <&str as Into<_>>::into("minecraft:stripped_jungle_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:57:22
[INFO] [stdout]    |
[INFO] [stdout] 57 |     map.insert(0x21, "minecraft:polished_granite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 57 -     map.insert(0x21, "minecraft:polished_granite".into());
[INFO] [stdout] 57 +     map.insert(0x21, "minecraft:polished_granite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -     map.insert(0x21, "minecraft:polished_granite".into());
[INFO] [stdout] 57 +     map.insert(0x21, <&str as Into<_>>::into("minecraft:polished_granite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:58:22
[INFO] [stdout]    |
[INFO] [stdout] 58 |     map.insert(0x22, "minecraft:deepslate_tiles".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 58 -     map.insert(0x22, "minecraft:deepslate_tiles".into());
[INFO] [stdout] 58 +     map.insert(0x22, "minecraft:deepslate_tiles");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -     map.insert(0x22, "minecraft:deepslate_tiles".into());
[INFO] [stdout] 58 +     map.insert(0x22, <&str as Into<_>>::into("minecraft:deepslate_tiles"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:59:22
[INFO] [stdout]    |
[INFO] [stdout] 59 |     map.insert(0x23, "minecraft:bamboo_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 59 -     map.insert(0x23, "minecraft:bamboo_block".into());
[INFO] [stdout] 59 +     map.insert(0x23, "minecraft:bamboo_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -     map.insert(0x23, "minecraft:bamboo_block".into());
[INFO] [stdout] 59 +     map.insert(0x23, <&str as Into<_>>::into("minecraft:bamboo_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:60:22
[INFO] [stdout]    |
[INFO] [stdout] 60 |     map.insert(0x24, "minecraft:mud_bricks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 60 -     map.insert(0x24, "minecraft:mud_bricks".into());
[INFO] [stdout] 60 +     map.insert(0x24, "minecraft:mud_bricks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -     map.insert(0x24, "minecraft:mud_bricks".into());
[INFO] [stdout] 60 +     map.insert(0x24, <&str as Into<_>>::into("minecraft:mud_bricks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:61:22
[INFO] [stdout]    |
[INFO] [stdout] 61 |     map.insert(0x25, "minecraft:moss_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 61 -     map.insert(0x25, "minecraft:moss_block".into());
[INFO] [stdout] 61 +     map.insert(0x25, "minecraft:moss_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -     map.insert(0x25, "minecraft:moss_block".into());
[INFO] [stdout] 61 +     map.insert(0x25, <&str as Into<_>>::into("minecraft:moss_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:62:22
[INFO] [stdout]    |
[INFO] [stdout] 62 |     map.insert(0x26, "minecraft:bamboo_fence".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 62 -     map.insert(0x26, "minecraft:bamboo_fence".into());
[INFO] [stdout] 62 +     map.insert(0x26, "minecraft:bamboo_fence");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 -     map.insert(0x26, "minecraft:bamboo_fence".into());
[INFO] [stdout] 62 +     map.insert(0x26, <&str as Into<_>>::into("minecraft:bamboo_fence"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:63:22
[INFO] [stdout]    |
[INFO] [stdout] 63 |     map.insert(0x27, "minecraft:bamboo_fence_gate".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 63 -     map.insert(0x27, "minecraft:bamboo_fence_gate".into());
[INFO] [stdout] 63 +     map.insert(0x27, "minecraft:bamboo_fence_gate");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 -     map.insert(0x27, "minecraft:bamboo_fence_gate".into());
[INFO] [stdout] 63 +     map.insert(0x27, <&str as Into<_>>::into("minecraft:bamboo_fence_gate"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:64:22
[INFO] [stdout]    |
[INFO] [stdout] 64 |     map.insert(0x28, "minecraft:diamond_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 64 -     map.insert(0x28, "minecraft:diamond_block".into());
[INFO] [stdout] 64 +     map.insert(0x28, "minecraft:diamond_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 64 -     map.insert(0x28, "minecraft:diamond_block".into());
[INFO] [stdout] 64 +     map.insert(0x28, <&str as Into<_>>::into("minecraft:diamond_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:65:22
[INFO] [stdout]    |
[INFO] [stdout] 65 |     map.insert(0x29, "minecraft:bamboo_mosaic".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 65 -     map.insert(0x29, "minecraft:bamboo_mosaic".into());
[INFO] [stdout] 65 +     map.insert(0x29, "minecraft:bamboo_mosaic");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 65 -     map.insert(0x29, "minecraft:bamboo_mosaic".into());
[INFO] [stdout] 65 +     map.insert(0x29, <&str as Into<_>>::into("minecraft:bamboo_mosaic"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:66:22
[INFO] [stdout]    |
[INFO] [stdout] 66 |     map.insert(0x2A, "minecraft:bamboo_mosaic_slab".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 66 -     map.insert(0x2A, "minecraft:bamboo_mosaic_slab".into());
[INFO] [stdout] 66 +     map.insert(0x2A, "minecraft:bamboo_mosaic_slab");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 -     map.insert(0x2A, "minecraft:bamboo_mosaic_slab".into());
[INFO] [stdout] 66 +     map.insert(0x2A, <&str as Into<_>>::into("minecraft:bamboo_mosaic_slab"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:67:22
[INFO] [stdout]    |
[INFO] [stdout] 67 |     map.insert(0x2B, "minecraft:bamboo_mosaic_stairs".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 67 -     map.insert(0x2B, "minecraft:bamboo_mosaic_stairs".into());
[INFO] [stdout] 67 +     map.insert(0x2B, "minecraft:bamboo_mosaic_stairs");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 -     map.insert(0x2B, "minecraft:bamboo_mosaic_stairs".into());
[INFO] [stdout] 67 +     map.insert(0x2B, <&str as Into<_>>::into("minecraft:bamboo_mosaic_stairs"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:68:22
[INFO] [stdout]    |
[INFO] [stdout] 68 |     map.insert(0x2C, "minecraft:bamboo_planks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 68 -     map.insert(0x2C, "minecraft:bamboo_planks".into());
[INFO] [stdout] 68 +     map.insert(0x2C, "minecraft:bamboo_planks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 -     map.insert(0x2C, "minecraft:bamboo_planks".into());
[INFO] [stdout] 68 +     map.insert(0x2C, <&str as Into<_>>::into("minecraft:bamboo_planks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:69:22
[INFO] [stdout]    |
[INFO] [stdout] 69 |     map.insert(0x2D, "minecraft:stripped_bamboo_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 69 -     map.insert(0x2D, "minecraft:stripped_bamboo_block".into());
[INFO] [stdout] 69 +     map.insert(0x2D, "minecraft:stripped_bamboo_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 -     map.insert(0x2D, "minecraft:stripped_bamboo_block".into());
[INFO] [stdout] 69 +     map.insert(0x2D, <&str as Into<_>>::into("minecraft:stripped_bamboo_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:70:22
[INFO] [stdout]    |
[INFO] [stdout] 70 |     map.insert(0x2E, "minecraft:sandstone".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 70 -     map.insert(0x2E, "minecraft:sandstone".into());
[INFO] [stdout] 70 +     map.insert(0x2E, "minecraft:sandstone");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 70 -     map.insert(0x2E, "minecraft:sandstone".into());
[INFO] [stdout] 70 +     map.insert(0x2E, <&str as Into<_>>::into("minecraft:sandstone"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:71:22
[INFO] [stdout]    |
[INFO] [stdout] 71 |     map.insert(0x2F, "minecraft:bamboo_shelf".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 71 -     map.insert(0x2F, "minecraft:bamboo_shelf".into());
[INFO] [stdout] 71 +     map.insert(0x2F, "minecraft:bamboo_shelf");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 -     map.insert(0x2F, "minecraft:bamboo_shelf".into());
[INFO] [stdout] 71 +     map.insert(0x2F, <&str as Into<_>>::into("minecraft:bamboo_shelf"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:72:22
[INFO] [stdout]    |
[INFO] [stdout] 72 |     map.insert(0x30, "minecraft:emerald_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 72 -     map.insert(0x30, "minecraft:emerald_block".into());
[INFO] [stdout] 72 +     map.insert(0x30, "minecraft:emerald_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 -     map.insert(0x30, "minecraft:emerald_block".into());
[INFO] [stdout] 72 +     map.insert(0x30, <&str as Into<_>>::into("minecraft:emerald_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:73:22
[INFO] [stdout]    |
[INFO] [stdout] 73 |     map.insert(0x31, "minecraft:bamboo_slab".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 73 -     map.insert(0x31, "minecraft:bamboo_slab".into());
[INFO] [stdout] 73 +     map.insert(0x31, "minecraft:bamboo_slab");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 73 -     map.insert(0x31, "minecraft:bamboo_slab".into());
[INFO] [stdout] 73 +     map.insert(0x31, <&str as Into<_>>::into("minecraft:bamboo_slab"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:74:22
[INFO] [stdout]    |
[INFO] [stdout] 74 |     map.insert(0x32, "minecraft:bamboo_stairs".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 74 -     map.insert(0x32, "minecraft:bamboo_stairs".into());
[INFO] [stdout] 74 +     map.insert(0x32, "minecraft:bamboo_stairs");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 -     map.insert(0x32, "minecraft:bamboo_stairs".into());
[INFO] [stdout] 74 +     map.insert(0x32, <&str as Into<_>>::into("minecraft:bamboo_stairs"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:75:22
[INFO] [stdout]    |
[INFO] [stdout] 75 |     map.insert(0x33, "minecraft:bamboo_trapdoor".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 75 -     map.insert(0x33, "minecraft:bamboo_trapdoor".into());
[INFO] [stdout] 75 +     map.insert(0x33, "minecraft:bamboo_trapdoor");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 75 -     map.insert(0x33, "minecraft:bamboo_trapdoor".into());
[INFO] [stdout] 75 +     map.insert(0x33, <&str as Into<_>>::into("minecraft:bamboo_trapdoor"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:76:22
[INFO] [stdout]    |
[INFO] [stdout] 76 |     map.insert(0x34, "minecraft:iron_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 76 -     map.insert(0x34, "minecraft:iron_block".into());
[INFO] [stdout] 76 +     map.insert(0x34, "minecraft:iron_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 76 -     map.insert(0x34, "minecraft:iron_block".into());
[INFO] [stdout] 76 +     map.insert(0x34, <&str as Into<_>>::into("minecraft:iron_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:77:22
[INFO] [stdout]    |
[INFO] [stdout] 77 |     map.insert(0x35, "minecraft:gold_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 77 -     map.insert(0x35, "minecraft:gold_block".into());
[INFO] [stdout] 77 +     map.insert(0x35, "minecraft:gold_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 77 -     map.insert(0x35, "minecraft:gold_block".into());
[INFO] [stdout] 77 +     map.insert(0x35, <&str as Into<_>>::into("minecraft:gold_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:78:22
[INFO] [stdout]    |
[INFO] [stdout] 78 |     map.insert(0x36, "minecraft:barrel".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 78 -     map.insert(0x36, "minecraft:barrel".into());
[INFO] [stdout] 78 +     map.insert(0x36, "minecraft:barrel");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 78 -     map.insert(0x36, "minecraft:barrel".into());
[INFO] [stdout] 78 +     map.insert(0x36, <&str as Into<_>>::into("minecraft:barrel"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:79:22
[INFO] [stdout]    |
[INFO] [stdout] 79 |     map.insert(0x37, "minecraft:crimson_shelf".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 79 -     map.insert(0x37, "minecraft:crimson_shelf".into());
[INFO] [stdout] 79 +     map.insert(0x37, "minecraft:crimson_shelf");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 79 -     map.insert(0x37, "minecraft:crimson_shelf".into());
[INFO] [stdout] 79 +     map.insert(0x37, <&str as Into<_>>::into("minecraft:crimson_shelf"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:80:22
[INFO] [stdout]    |
[INFO] [stdout] 80 |     map.insert(0x38, "minecraft:basalt".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 80 -     map.insert(0x38, "minecraft:basalt".into());
[INFO] [stdout] 80 +     map.insert(0x38, "minecraft:basalt");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 -     map.insert(0x38, "minecraft:basalt".into());
[INFO] [stdout] 80 +     map.insert(0x38, <&str as Into<_>>::into("minecraft:basalt"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:81:22
[INFO] [stdout]    |
[INFO] [stdout] 81 |     map.insert(0x39, "minecraft:beacon".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 81 -     map.insert(0x39, "minecraft:beacon".into());
[INFO] [stdout] 81 +     map.insert(0x39, "minecraft:beacon");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 81 -     map.insert(0x39, "minecraft:beacon".into());
[INFO] [stdout] 81 +     map.insert(0x39, <&str as Into<_>>::into("minecraft:beacon"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:82:22
[INFO] [stdout]    |
[INFO] [stdout] 82 |     map.insert(0x3A, "minecraft:bedrock".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 82 -     map.insert(0x3A, "minecraft:bedrock".into());
[INFO] [stdout] 82 +     map.insert(0x3A, "minecraft:bedrock");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 -     map.insert(0x3A, "minecraft:bedrock".into());
[INFO] [stdout] 82 +     map.insert(0x3A, <&str as Into<_>>::into("minecraft:bedrock"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:83:22
[INFO] [stdout]    |
[INFO] [stdout] 83 |     map.insert(0x3B, "minecraft:bee_nest".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 83 -     map.insert(0x3B, "minecraft:bee_nest".into());
[INFO] [stdout] 83 +     map.insert(0x3B, "minecraft:bee_nest");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 -     map.insert(0x3B, "minecraft:bee_nest".into());
[INFO] [stdout] 83 +     map.insert(0x3B, <&str as Into<_>>::into("minecraft:bee_nest"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:84:22
[INFO] [stdout]    |
[INFO] [stdout] 84 |     map.insert(0x3C, "minecraft:beehive".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 84 -     map.insert(0x3C, "minecraft:beehive".into());
[INFO] [stdout] 84 +     map.insert(0x3C, "minecraft:beehive");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 -     map.insert(0x3C, "minecraft:beehive".into());
[INFO] [stdout] 84 +     map.insert(0x3C, <&str as Into<_>>::into("minecraft:beehive"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:85:22
[INFO] [stdout]    |
[INFO] [stdout] 85 |     map.insert(0x3D, "minecraft:grass_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 85 -     map.insert(0x3D, "minecraft:grass_block".into());
[INFO] [stdout] 85 +     map.insert(0x3D, "minecraft:grass_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 85 -     map.insert(0x3D, "minecraft:grass_block".into());
[INFO] [stdout] 85 +     map.insert(0x3D, <&str as Into<_>>::into("minecraft:grass_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:86:22
[INFO] [stdout]    |
[INFO] [stdout] 86 |     map.insert(0x3E, "minecraft:bell".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 86 -     map.insert(0x3E, "minecraft:bell".into());
[INFO] [stdout] 86 +     map.insert(0x3E, "minecraft:bell");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 86 -     map.insert(0x3E, "minecraft:bell".into());
[INFO] [stdout] 86 +     map.insert(0x3E, <&str as Into<_>>::into("minecraft:bell"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:87:22
[INFO] [stdout]    |
[INFO] [stdout] 87 |     map.insert(0x3F, "minecraft:fern".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 87 -     map.insert(0x3F, "minecraft:fern".into());
[INFO] [stdout] 87 +     map.insert(0x3F, "minecraft:fern");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 87 -     map.insert(0x3F, "minecraft:fern".into());
[INFO] [stdout] 87 +     map.insert(0x3F, <&str as Into<_>>::into("minecraft:fern"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:88:22
[INFO] [stdout]    |
[INFO] [stdout] 88 |     map.insert(0x40, "minecraft:granite".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 88 -     map.insert(0x40, "minecraft:granite".into());
[INFO] [stdout] 88 +     map.insert(0x40, "minecraft:granite");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 -     map.insert(0x40, "minecraft:granite".into());
[INFO] [stdout] 88 +     map.insert(0x40, <&str as Into<_>>::into("minecraft:granite"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:89:22
[INFO] [stdout]    |
[INFO] [stdout] 89 |     map.insert(0x41, "minecraft:lapis_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 89 -     map.insert(0x41, "minecraft:lapis_block".into());
[INFO] [stdout] 89 +     map.insert(0x41, "minecraft:lapis_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 -     map.insert(0x41, "minecraft:lapis_block".into());
[INFO] [stdout] 89 +     map.insert(0x41, <&str as Into<_>>::into("minecraft:lapis_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:90:22
[INFO] [stdout]    |
[INFO] [stdout] 90 |     map.insert(0x42, "minecraft:dried_kelp_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 90 -     map.insert(0x42, "minecraft:dried_kelp_block".into());
[INFO] [stdout] 90 +     map.insert(0x42, "minecraft:dried_kelp_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 90 -     map.insert(0x42, "minecraft:dried_kelp_block".into());
[INFO] [stdout] 90 +     map.insert(0x42, <&str as Into<_>>::into("minecraft:dried_kelp_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:91:22
[INFO] [stdout]    |
[INFO] [stdout] 91 |     map.insert(0x43, "minecraft:birch_fence".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 91 -     map.insert(0x43, "minecraft:birch_fence".into());
[INFO] [stdout] 91 +     map.insert(0x43, "minecraft:birch_fence");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 -     map.insert(0x43, "minecraft:birch_fence".into());
[INFO] [stdout] 91 +     map.insert(0x43, <&str as Into<_>>::into("minecraft:birch_fence"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:92:22
[INFO] [stdout]    |
[INFO] [stdout] 92 |     map.insert(0x44, "minecraft:birch_fence_gate".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 92 -     map.insert(0x44, "minecraft:birch_fence_gate".into());
[INFO] [stdout] 92 +     map.insert(0x44, "minecraft:birch_fence_gate");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 92 -     map.insert(0x44, "minecraft:birch_fence_gate".into());
[INFO] [stdout] 92 +     map.insert(0x44, <&str as Into<_>>::into("minecraft:birch_fence_gate"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:93:22
[INFO] [stdout]    |
[INFO] [stdout] 93 |     map.insert(0x45, "minecraft:honeycomb_block".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 93 -     map.insert(0x45, "minecraft:honeycomb_block".into());
[INFO] [stdout] 93 +     map.insert(0x45, "minecraft:honeycomb_block");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 -     map.insert(0x45, "minecraft:honeycomb_block".into());
[INFO] [stdout] 93 +     map.insert(0x45, <&str as Into<_>>::into("minecraft:honeycomb_block"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:94:22
[INFO] [stdout]    |
[INFO] [stdout] 94 |     map.insert(0x46, "minecraft:stripped_mangrove_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 94 -     map.insert(0x46, "minecraft:stripped_mangrove_log".into());
[INFO] [stdout] 94 +     map.insert(0x46, "minecraft:stripped_mangrove_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 -     map.insert(0x46, "minecraft:stripped_mangrove_log".into());
[INFO] [stdout] 94 +     map.insert(0x46, <&str as Into<_>>::into("minecraft:stripped_mangrove_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:95:22
[INFO] [stdout]    |
[INFO] [stdout] 95 |     map.insert(0x47, "minecraft:birch_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 95 -     map.insert(0x47, "minecraft:birch_log".into());
[INFO] [stdout] 95 +     map.insert(0x47, "minecraft:birch_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 95 -     map.insert(0x47, "minecraft:birch_log".into());
[INFO] [stdout] 95 +     map.insert(0x47, <&str as Into<_>>::into("minecraft:birch_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:96:22
[INFO] [stdout]    |
[INFO] [stdout] 96 |     map.insert(0x48, "minecraft:birch_planks".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 96 -     map.insert(0x48, "minecraft:birch_planks".into());
[INFO] [stdout] 96 +     map.insert(0x48, "minecraft:birch_planks");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 -     map.insert(0x48, "minecraft:birch_planks".into());
[INFO] [stdout] 96 +     map.insert(0x48, <&str as Into<_>>::into("minecraft:birch_planks"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:97:22
[INFO] [stdout]    |
[INFO] [stdout] 97 |     map.insert(0x49, "minecraft:stripped_birch_log".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 97 -     map.insert(0x49, "minecraft:stripped_birch_log".into());
[INFO] [stdout] 97 +     map.insert(0x49, "minecraft:stripped_birch_log");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 97 -     map.insert(0x49, "minecraft:stripped_birch_log".into());
[INFO] [stdout] 97 +     map.insert(0x49, <&str as Into<_>>::into("minecraft:stripped_birch_log"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:98:22
[INFO] [stdout]    |
[INFO] [stdout] 98 |     map.insert(0x4A, "minecraft:red_sandstone".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 98 -     map.insert(0x4A, "minecraft:red_sandstone".into());
[INFO] [stdout] 98 +     map.insert(0x4A, "minecraft:red_sandstone");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 98 -     map.insert(0x4A, "minecraft:red_sandstone".into());
[INFO] [stdout] 98 +     map.insert(0x4A, <&str as Into<_>>::into("minecraft:red_sandstone"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/models/blocks.rs:99:22
[INFO] [stdout]    |
[INFO] [stdout] 99 |     map.insert(0x4B, "minecraft:birch_shelf".into());
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 99 -     map.insert(0x4B, "minecraft:birch_shelf".into());
[INFO] [stdout] 99 +     map.insert(0x4B, "minecraft:birch_shelf");
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 -     map.insert(0x4B, "minecraft:birch_shelf".into());
[INFO] [stdout] 99 +     map.insert(0x4B, <&str as Into<_>>::into("minecraft:birch_shelf"));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:100:22
[INFO] [stdout]     |
[INFO] [stdout] 100 |     map.insert(0x4C, "minecraft:hay_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 100 -     map.insert(0x4C, "minecraft:hay_block".into());
[INFO] [stdout] 100 +     map.insert(0x4C, "minecraft:hay_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 -     map.insert(0x4C, "minecraft:hay_block".into());
[INFO] [stdout] 100 +     map.insert(0x4C, <&str as Into<_>>::into("minecraft:hay_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:101:22
[INFO] [stdout]     |
[INFO] [stdout] 101 |     map.insert(0x4D, "minecraft:birch_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 101 -     map.insert(0x4D, "minecraft:birch_slab".into());
[INFO] [stdout] 101 +     map.insert(0x4D, "minecraft:birch_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 101 -     map.insert(0x4D, "minecraft:birch_slab".into());
[INFO] [stdout] 101 +     map.insert(0x4D, <&str as Into<_>>::into("minecraft:birch_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:102:22
[INFO] [stdout]     |
[INFO] [stdout] 102 |     map.insert(0x4E, "minecraft:birch_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 102 -     map.insert(0x4E, "minecraft:birch_stairs".into());
[INFO] [stdout] 102 +     map.insert(0x4E, "minecraft:birch_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 102 -     map.insert(0x4E, "minecraft:birch_stairs".into());
[INFO] [stdout] 102 +     map.insert(0x4E, <&str as Into<_>>::into("minecraft:birch_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:103:22
[INFO] [stdout]     |
[INFO] [stdout] 103 |     map.insert(0x4F, "minecraft:birch_trapdoor".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 103 -     map.insert(0x4F, "minecraft:birch_trapdoor".into());
[INFO] [stdout] 103 +     map.insert(0x4F, "minecraft:birch_trapdoor");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 103 -     map.insert(0x4F, "minecraft:birch_trapdoor".into());
[INFO] [stdout] 103 +     map.insert(0x4F, <&str as Into<_>>::into("minecraft:birch_trapdoor"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:104:22
[INFO] [stdout]     |
[INFO] [stdout] 104 |     map.insert(0x50, "minecraft:glowstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 104 -     map.insert(0x50, "minecraft:glowstone".into());
[INFO] [stdout] 104 +     map.insert(0x50, "minecraft:glowstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 104 -     map.insert(0x50, "minecraft:glowstone".into());
[INFO] [stdout] 104 +     map.insert(0x50, <&str as Into<_>>::into("minecraft:glowstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:105:22
[INFO] [stdout]     |
[INFO] [stdout] 105 |     map.insert(0x51, "minecraft:nether_wart_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 105 -     map.insert(0x51, "minecraft:nether_wart_block".into());
[INFO] [stdout] 105 +     map.insert(0x51, "minecraft:nether_wart_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 105 -     map.insert(0x51, "minecraft:nether_wart_block".into());
[INFO] [stdout] 105 +     map.insert(0x51, <&str as Into<_>>::into("minecraft:nether_wart_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:106:22
[INFO] [stdout]     |
[INFO] [stdout] 106 |     map.insert(0x52, "minecraft:birch_wood".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 106 -     map.insert(0x52, "minecraft:birch_wood".into());
[INFO] [stdout] 106 +     map.insert(0x52, "minecraft:birch_wood");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 -     map.insert(0x52, "minecraft:birch_wood".into());
[INFO] [stdout] 106 +     map.insert(0x52, <&str as Into<_>>::into("minecraft:birch_wood"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:107:22
[INFO] [stdout]     |
[INFO] [stdout] 107 |     map.insert(0x53, "minecraft:mossy_cobblestone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 107 -     map.insert(0x53, "minecraft:mossy_cobblestone".into());
[INFO] [stdout] 107 +     map.insert(0x53, "minecraft:mossy_cobblestone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 107 -     map.insert(0x53, "minecraft:mossy_cobblestone".into());
[INFO] [stdout] 107 +     map.insert(0x53, <&str as Into<_>>::into("minecraft:mossy_cobblestone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:108:22
[INFO] [stdout]     |
[INFO] [stdout] 108 |     map.insert(0x54, "minecraft:white_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 108 -     map.insert(0x54, "minecraft:white_wool".into());
[INFO] [stdout] 108 +     map.insert(0x54, "minecraft:white_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 108 -     map.insert(0x54, "minecraft:white_wool".into());
[INFO] [stdout] 108 +     map.insert(0x54, <&str as Into<_>>::into("minecraft:white_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:109:22
[INFO] [stdout]     |
[INFO] [stdout] 109 |     map.insert(0x55, "minecraft:magma_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 109 -     map.insert(0x55, "minecraft:magma_block".into());
[INFO] [stdout] 109 +     map.insert(0x55, "minecraft:magma_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 109 -     map.insert(0x55, "minecraft:magma_block".into());
[INFO] [stdout] 109 +     map.insert(0x55, <&str as Into<_>>::into("minecraft:magma_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:110:22
[INFO] [stdout]     |
[INFO] [stdout] 110 |     map.insert(0x56, "minecraft:dark_oak_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 110 -     map.insert(0x56, "minecraft:dark_oak_log".into());
[INFO] [stdout] 110 +     map.insert(0x56, "minecraft:dark_oak_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 -     map.insert(0x56, "minecraft:dark_oak_log".into());
[INFO] [stdout] 110 +     map.insert(0x56, <&str as Into<_>>::into("minecraft:dark_oak_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:111:22
[INFO] [stdout]     |
[INFO] [stdout] 111 |     map.insert(0x57, "minecraft:prismarine".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 111 -     map.insert(0x57, "minecraft:prismarine".into());
[INFO] [stdout] 111 +     map.insert(0x57, "minecraft:prismarine");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 111 -     map.insert(0x57, "minecraft:prismarine".into());
[INFO] [stdout] 111 +     map.insert(0x57, <&str as Into<_>>::into("minecraft:prismarine"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:112:22
[INFO] [stdout]     |
[INFO] [stdout] 112 |     map.insert(0x58, "minecraft:black_concrete".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 112 -     map.insert(0x58, "minecraft:black_concrete".into());
[INFO] [stdout] 112 +     map.insert(0x58, "minecraft:black_concrete");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 112 -     map.insert(0x58, "minecraft:black_concrete".into());
[INFO] [stdout] 112 +     map.insert(0x58, <&str as Into<_>>::into("minecraft:black_concrete"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:113:22
[INFO] [stdout]     |
[INFO] [stdout] 113 |     map.insert(0x59, "minecraft:black_concrete_powder".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 113 -     map.insert(0x59, "minecraft:black_concrete_powder".into());
[INFO] [stdout] 113 +     map.insert(0x59, "minecraft:black_concrete_powder");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 113 -     map.insert(0x59, "minecraft:black_concrete_powder".into());
[INFO] [stdout] 113 +     map.insert(0x59, <&str as Into<_>>::into("minecraft:black_concrete_powder"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:114:22
[INFO] [stdout]     |
[INFO] [stdout] 114 |     map.insert(0x5A, "minecraft:black_glazed_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 114 -     map.insert(0x5A, "minecraft:black_glazed_terracotta".into());
[INFO] [stdout] 114 +     map.insert(0x5A, "minecraft:black_glazed_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 114 -     map.insert(0x5A, "minecraft:black_glazed_terracotta".into());
[INFO] [stdout] 114 +     map.insert(0x5A, <&str as Into<_>>::into("minecraft:black_glazed_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:115:22
[INFO] [stdout]     |
[INFO] [stdout] 115 |     map.insert(0x5B, "minecraft:dark_oak_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 115 -     map.insert(0x5B, "minecraft:dark_oak_planks".into());
[INFO] [stdout] 115 +     map.insert(0x5B, "minecraft:dark_oak_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 115 -     map.insert(0x5B, "minecraft:dark_oak_planks".into());
[INFO] [stdout] 115 +     map.insert(0x5B, <&str as Into<_>>::into("minecraft:dark_oak_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:116:22
[INFO] [stdout]     |
[INFO] [stdout] 116 |     map.insert(0x5C, "minecraft:black_stained_glass".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 116 -     map.insert(0x5C, "minecraft:black_stained_glass".into());
[INFO] [stdout] 116 +     map.insert(0x5C, "minecraft:black_stained_glass");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 116 -     map.insert(0x5C, "minecraft:black_stained_glass".into());
[INFO] [stdout] 116 +     map.insert(0x5C, <&str as Into<_>>::into("minecraft:black_stained_glass"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:117:22
[INFO] [stdout]     |
[INFO] [stdout] 117 |     map.insert(0x5D, "minecraft:black_stained_glass_pane".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 117 -     map.insert(0x5D, "minecraft:black_stained_glass_pane".into());
[INFO] [stdout] 117 +     map.insert(0x5D, "minecraft:black_stained_glass_pane");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 117 -     map.insert(0x5D, "minecraft:black_stained_glass_pane".into());
[INFO] [stdout] 117 +     map.insert(0x5D, <&str as Into<_>>::into("minecraft:black_stained_glass_pane"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:118:22
[INFO] [stdout]     |
[INFO] [stdout] 118 |     map.insert(0x5E, "minecraft:black_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 118 -     map.insert(0x5E, "minecraft:black_terracotta".into());
[INFO] [stdout] 118 +     map.insert(0x5E, "minecraft:black_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 118 -     map.insert(0x5E, "minecraft:black_terracotta".into());
[INFO] [stdout] 118 +     map.insert(0x5E, <&str as Into<_>>::into("minecraft:black_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:119:22
[INFO] [stdout]     |
[INFO] [stdout] 119 |     map.insert(0x5F, "minecraft:prismarine_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 119 -     map.insert(0x5F, "minecraft:prismarine_bricks".into());
[INFO] [stdout] 119 +     map.insert(0x5F, "minecraft:prismarine_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 119 -     map.insert(0x5F, "minecraft:prismarine_bricks".into());
[INFO] [stdout] 119 +     map.insert(0x5F, <&str as Into<_>>::into("minecraft:prismarine_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:120:22
[INFO] [stdout]     |
[INFO] [stdout] 120 |     map.insert(0x60, "minecraft:black_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 120 -     map.insert(0x60, "minecraft:black_wool".into());
[INFO] [stdout] 120 +     map.insert(0x60, "minecraft:black_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 120 -     map.insert(0x60, "minecraft:black_wool".into());
[INFO] [stdout] 120 +     map.insert(0x60, <&str as Into<_>>::into("minecraft:black_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:121:22
[INFO] [stdout]     |
[INFO] [stdout] 121 |     map.insert(0x61, "minecraft:blackstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 121 -     map.insert(0x61, "minecraft:blackstone".into());
[INFO] [stdout] 121 +     map.insert(0x61, "minecraft:blackstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 121 -     map.insert(0x61, "minecraft:blackstone".into());
[INFO] [stdout] 121 +     map.insert(0x61, <&str as Into<_>>::into("minecraft:blackstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:122:22
[INFO] [stdout]     |
[INFO] [stdout] 122 |     map.insert(0x62, "minecraft:blackstone_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 122 -     map.insert(0x62, "minecraft:blackstone_slab".into());
[INFO] [stdout] 122 +     map.insert(0x62, "minecraft:blackstone_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 122 -     map.insert(0x62, "minecraft:blackstone_slab".into());
[INFO] [stdout] 122 +     map.insert(0x62, <&str as Into<_>>::into("minecraft:blackstone_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:123:22
[INFO] [stdout]     |
[INFO] [stdout] 123 |     map.insert(0x63, "minecraft:blackstone_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 123 -     map.insert(0x63, "minecraft:blackstone_stairs".into());
[INFO] [stdout] 123 +     map.insert(0x63, "minecraft:blackstone_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 123 -     map.insert(0x63, "minecraft:blackstone_stairs".into());
[INFO] [stdout] 123 +     map.insert(0x63, <&str as Into<_>>::into("minecraft:blackstone_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:124:22
[INFO] [stdout]     |
[INFO] [stdout] 124 |     map.insert(0x64, "minecraft:blackstone_wall".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 124 -     map.insert(0x64, "minecraft:blackstone_wall".into());
[INFO] [stdout] 124 +     map.insert(0x64, "minecraft:blackstone_wall");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 124 -     map.insert(0x64, "minecraft:blackstone_wall".into());
[INFO] [stdout] 124 +     map.insert(0x64, <&str as Into<_>>::into("minecraft:blackstone_wall"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:125:22
[INFO] [stdout]     |
[INFO] [stdout] 125 |     map.insert(0x65, "minecraft:blast_furnace".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 125 -     map.insert(0x65, "minecraft:blast_furnace".into());
[INFO] [stdout] 125 +     map.insert(0x65, "minecraft:blast_furnace");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 125 -     map.insert(0x65, "minecraft:blast_furnace".into());
[INFO] [stdout] 125 +     map.insert(0x65, <&str as Into<_>>::into("minecraft:blast_furnace"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:126:22
[INFO] [stdout]     |
[INFO] [stdout] 126 |     map.insert(0x66, "minecraft:red_nether_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 126 -     map.insert(0x66, "minecraft:red_nether_bricks".into());
[INFO] [stdout] 126 +     map.insert(0x66, "minecraft:red_nether_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 126 -     map.insert(0x66, "minecraft:red_nether_bricks".into());
[INFO] [stdout] 126 +     map.insert(0x66, <&str as Into<_>>::into("minecraft:red_nether_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:127:22
[INFO] [stdout]     |
[INFO] [stdout] 127 |     map.insert(0x67, "minecraft:white_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 127 -     map.insert(0x67, "minecraft:white_terracotta".into());
[INFO] [stdout] 127 +     map.insert(0x67, "minecraft:white_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 -     map.insert(0x67, "minecraft:white_terracotta".into());
[INFO] [stdout] 127 +     map.insert(0x67, <&str as Into<_>>::into("minecraft:white_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:128:22
[INFO] [stdout]     |
[INFO] [stdout] 128 |     map.insert(0x68, "minecraft:lodestone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 128 -     map.insert(0x68, "minecraft:lodestone".into());
[INFO] [stdout] 128 +     map.insert(0x68, "minecraft:lodestone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 -     map.insert(0x68, "minecraft:lodestone".into());
[INFO] [stdout] 128 +     map.insert(0x68, <&str as Into<_>>::into("minecraft:lodestone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:129:22
[INFO] [stdout]     |
[INFO] [stdout] 129 |     map.insert(0x69, "minecraft:gilded_blackstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 129 -     map.insert(0x69, "minecraft:gilded_blackstone".into());
[INFO] [stdout] 129 +     map.insert(0x69, "minecraft:gilded_blackstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 129 -     map.insert(0x69, "minecraft:gilded_blackstone".into());
[INFO] [stdout] 129 +     map.insert(0x69, <&str as Into<_>>::into("minecraft:gilded_blackstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:130:22
[INFO] [stdout]     |
[INFO] [stdout] 130 |     map.insert(0x6A, "minecraft:dark_prismarine".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 130 -     map.insert(0x6A, "minecraft:dark_prismarine".into());
[INFO] [stdout] 130 +     map.insert(0x6A, "minecraft:dark_prismarine");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 130 -     map.insert(0x6A, "minecraft:dark_prismarine".into());
[INFO] [stdout] 130 +     map.insert(0x6A, <&str as Into<_>>::into("minecraft:dark_prismarine"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:131:22
[INFO] [stdout]     |
[INFO] [stdout] 131 |     map.insert(0x6B, "minecraft:blue_concrete".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 131 -     map.insert(0x6B, "minecraft:blue_concrete".into());
[INFO] [stdout] 131 +     map.insert(0x6B, "minecraft:blue_concrete");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 131 -     map.insert(0x6B, "minecraft:blue_concrete".into());
[INFO] [stdout] 131 +     map.insert(0x6B, <&str as Into<_>>::into("minecraft:blue_concrete"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:132:22
[INFO] [stdout]     |
[INFO] [stdout] 132 |     map.insert(0x6C, "minecraft:blue_concrete_powder".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 132 -     map.insert(0x6C, "minecraft:blue_concrete_powder".into());
[INFO] [stdout] 132 +     map.insert(0x6C, "minecraft:blue_concrete_powder");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 132 -     map.insert(0x6C, "minecraft:blue_concrete_powder".into());
[INFO] [stdout] 132 +     map.insert(0x6C, <&str as Into<_>>::into("minecraft:blue_concrete_powder"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:133:22
[INFO] [stdout]     |
[INFO] [stdout] 133 |     map.insert(0x6D, "minecraft:blue_glazed_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 133 -     map.insert(0x6D, "minecraft:blue_glazed_terracotta".into());
[INFO] [stdout] 133 +     map.insert(0x6D, "minecraft:blue_glazed_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 133 -     map.insert(0x6D, "minecraft:blue_glazed_terracotta".into());
[INFO] [stdout] 133 +     map.insert(0x6D, <&str as Into<_>>::into("minecraft:blue_glazed_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:134:22
[INFO] [stdout]     |
[INFO] [stdout] 134 |     map.insert(0x6E, "minecraft:blue_ice".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 134 -     map.insert(0x6E, "minecraft:blue_ice".into());
[INFO] [stdout] 134 +     map.insert(0x6E, "minecraft:blue_ice");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 134 -     map.insert(0x6E, "minecraft:blue_ice".into());
[INFO] [stdout] 134 +     map.insert(0x6E, <&str as Into<_>>::into("minecraft:blue_ice"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:135:22
[INFO] [stdout]     |
[INFO] [stdout] 135 |     map.insert(0x6F, "minecraft:purpur_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 135 -     map.insert(0x6F, "minecraft:purpur_block".into());
[INFO] [stdout] 135 +     map.insert(0x6F, "minecraft:purpur_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 135 -     map.insert(0x6F, "minecraft:purpur_block".into());
[INFO] [stdout] 135 +     map.insert(0x6F, <&str as Into<_>>::into("minecraft:purpur_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:136:22
[INFO] [stdout]     |
[INFO] [stdout] 136 |     map.insert(0x70, "minecraft:spruce_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 136 -     map.insert(0x70, "minecraft:spruce_planks".into());
[INFO] [stdout] 136 +     map.insert(0x70, "minecraft:spruce_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 136 -     map.insert(0x70, "minecraft:spruce_planks".into());
[INFO] [stdout] 136 +     map.insert(0x70, <&str as Into<_>>::into("minecraft:spruce_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:137:22
[INFO] [stdout]     |
[INFO] [stdout] 137 |     map.insert(0x71, "minecraft:blue_stained_glass".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 137 -     map.insert(0x71, "minecraft:blue_stained_glass".into());
[INFO] [stdout] 137 +     map.insert(0x71, "minecraft:blue_stained_glass");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 137 -     map.insert(0x71, "minecraft:blue_stained_glass".into());
[INFO] [stdout] 137 +     map.insert(0x71, <&str as Into<_>>::into("minecraft:blue_stained_glass"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:138:22
[INFO] [stdout]     |
[INFO] [stdout] 138 |     map.insert(0x72, "minecraft:blue_stained_glass_pane".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 138 -     map.insert(0x72, "minecraft:blue_stained_glass_pane".into());
[INFO] [stdout] 138 +     map.insert(0x72, "minecraft:blue_stained_glass_pane");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 138 -     map.insert(0x72, "minecraft:blue_stained_glass_pane".into());
[INFO] [stdout] 138 +     map.insert(0x72, <&str as Into<_>>::into("minecraft:blue_stained_glass_pane"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:139:22
[INFO] [stdout]     |
[INFO] [stdout] 139 |     map.insert(0x73, "minecraft:blue_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 139 -     map.insert(0x73, "minecraft:blue_terracotta".into());
[INFO] [stdout] 139 +     map.insert(0x73, "minecraft:blue_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 139 -     map.insert(0x73, "minecraft:blue_terracotta".into());
[INFO] [stdout] 139 +     map.insert(0x73, <&str as Into<_>>::into("minecraft:blue_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:140:22
[INFO] [stdout]     |
[INFO] [stdout] 140 |     map.insert(0x74, "minecraft:warped_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 140 -     map.insert(0x74, "minecraft:warped_planks".into());
[INFO] [stdout] 140 +     map.insert(0x74, "minecraft:warped_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 140 -     map.insert(0x74, "minecraft:warped_planks".into());
[INFO] [stdout] 140 +     map.insert(0x74, <&str as Into<_>>::into("minecraft:warped_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:141:22
[INFO] [stdout]     |
[INFO] [stdout] 141 |     map.insert(0x75, "minecraft:blue_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 141 -     map.insert(0x75, "minecraft:blue_wool".into());
[INFO] [stdout] 141 +     map.insert(0x75, "minecraft:blue_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 141 -     map.insert(0x75, "minecraft:blue_wool".into());
[INFO] [stdout] 141 +     map.insert(0x75, <&str as Into<_>>::into("minecraft:blue_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:142:22
[INFO] [stdout]     |
[INFO] [stdout] 142 |     map.insert(0x76, "minecraft:bone_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 142 -     map.insert(0x76, "minecraft:bone_block".into());
[INFO] [stdout] 142 +     map.insert(0x76, "minecraft:bone_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 -     map.insert(0x76, "minecraft:bone_block".into());
[INFO] [stdout] 142 +     map.insert(0x76, <&str as Into<_>>::into("minecraft:bone_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:143:22
[INFO] [stdout]     |
[INFO] [stdout] 143 |     map.insert(0x77, "minecraft:bookshelf".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 143 -     map.insert(0x77, "minecraft:bookshelf".into());
[INFO] [stdout] 143 +     map.insert(0x77, "minecraft:bookshelf");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 -     map.insert(0x77, "minecraft:bookshelf".into());
[INFO] [stdout] 143 +     map.insert(0x77, <&str as Into<_>>::into("minecraft:bookshelf"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:144:22
[INFO] [stdout]     |
[INFO] [stdout] 144 |     map.insert(0x78, "minecraft:cyan_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 144 -     map.insert(0x78, "minecraft:cyan_wool".into());
[INFO] [stdout] 144 +     map.insert(0x78, "minecraft:cyan_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 144 -     map.insert(0x78, "minecraft:cyan_wool".into());
[INFO] [stdout] 144 +     map.insert(0x78, <&str as Into<_>>::into("minecraft:cyan_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:145:22
[INFO] [stdout]     |
[INFO] [stdout] 145 |     map.insert(0x79, "minecraft:gray_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 145 -     map.insert(0x79, "minecraft:gray_wool".into());
[INFO] [stdout] 145 +     map.insert(0x79, "minecraft:gray_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 -     map.insert(0x79, "minecraft:gray_wool".into());
[INFO] [stdout] 145 +     map.insert(0x79, <&str as Into<_>>::into("minecraft:gray_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:146:22
[INFO] [stdout]     |
[INFO] [stdout] 146 |     map.insert(0x7A, "minecraft:green_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 146 -     map.insert(0x7A, "minecraft:green_wool".into());
[INFO] [stdout] 146 +     map.insert(0x7A, "minecraft:green_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 146 -     map.insert(0x7A, "minecraft:green_wool".into());
[INFO] [stdout] 146 +     map.insert(0x7A, <&str as Into<_>>::into("minecraft:green_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:147:22
[INFO] [stdout]     |
[INFO] [stdout] 147 |     map.insert(0x7B, "minecraft:light_blue_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 147 -     map.insert(0x7B, "minecraft:light_blue_wool".into());
[INFO] [stdout] 147 +     map.insert(0x7B, "minecraft:light_blue_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 147 -     map.insert(0x7B, "minecraft:light_blue_wool".into());
[INFO] [stdout] 147 +     map.insert(0x7B, <&str as Into<_>>::into("minecraft:light_blue_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:148:22
[INFO] [stdout]     |
[INFO] [stdout] 148 |     map.insert(0x7C, "minecraft:brewing_stand".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 148 -     map.insert(0x7C, "minecraft:brewing_stand".into());
[INFO] [stdout] 148 +     map.insert(0x7C, "minecraft:brewing_stand");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 148 -     map.insert(0x7C, "minecraft:brewing_stand".into());
[INFO] [stdout] 148 +     map.insert(0x7C, <&str as Into<_>>::into("minecraft:brewing_stand"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:149:22
[INFO] [stdout]     |
[INFO] [stdout] 149 |     map.insert(0x7D, "minecraft:brick_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 149 -     map.insert(0x7D, "minecraft:brick_slab".into());
[INFO] [stdout] 149 +     map.insert(0x7D, "minecraft:brick_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 -     map.insert(0x7D, "minecraft:brick_slab".into());
[INFO] [stdout] 149 +     map.insert(0x7D, <&str as Into<_>>::into("minecraft:brick_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:150:22
[INFO] [stdout]     |
[INFO] [stdout] 150 |     map.insert(0x7E, "minecraft:brick_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 150 -     map.insert(0x7E, "minecraft:brick_stairs".into());
[INFO] [stdout] 150 +     map.insert(0x7E, "minecraft:brick_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 150 -     map.insert(0x7E, "minecraft:brick_stairs".into());
[INFO] [stdout] 150 +     map.insert(0x7E, <&str as Into<_>>::into("minecraft:brick_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:151:22
[INFO] [stdout]     |
[INFO] [stdout] 151 |     map.insert(0x7F, "minecraft:brick_wall".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 151 -     map.insert(0x7F, "minecraft:brick_wall".into());
[INFO] [stdout] 151 +     map.insert(0x7F, "minecraft:brick_wall");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 151 -     map.insert(0x7F, "minecraft:brick_wall".into());
[INFO] [stdout] 151 +     map.insert(0x7F, <&str as Into<_>>::into("minecraft:brick_wall"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:152:22
[INFO] [stdout]     |
[INFO] [stdout] 152 |     map.insert(0x80, "minecraft:bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 152 -     map.insert(0x80, "minecraft:bricks".into());
[INFO] [stdout] 152 +     map.insert(0x80, "minecraft:bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 152 -     map.insert(0x80, "minecraft:bricks".into());
[INFO] [stdout] 152 +     map.insert(0x80, <&str as Into<_>>::into("minecraft:bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:153:22
[INFO] [stdout]     |
[INFO] [stdout] 153 |     map.insert(0x81, "minecraft:warped_wart_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 153 -     map.insert(0x81, "minecraft:warped_wart_block".into());
[INFO] [stdout] 153 +     map.insert(0x81, "minecraft:warped_wart_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 153 -     map.insert(0x81, "minecraft:warped_wart_block".into());
[INFO] [stdout] 153 +     map.insert(0x81, <&str as Into<_>>::into("minecraft:warped_wart_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:154:22
[INFO] [stdout]     |
[INFO] [stdout] 154 |     map.insert(0x82, "minecraft:red_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 154 -     map.insert(0x82, "minecraft:red_wool".into());
[INFO] [stdout] 154 +     map.insert(0x82, "minecraft:red_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 154 -     map.insert(0x82, "minecraft:red_wool".into());
[INFO] [stdout] 154 +     map.insert(0x82, <&str as Into<_>>::into("minecraft:red_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:155:22
[INFO] [stdout]     |
[INFO] [stdout] 155 |     map.insert(0x83, "minecraft:cut_sandstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 155 -     map.insert(0x83, "minecraft:cut_sandstone".into());
[INFO] [stdout] 155 +     map.insert(0x83, "minecraft:cut_sandstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 155 -     map.insert(0x83, "minecraft:cut_sandstone".into());
[INFO] [stdout] 155 +     map.insert(0x83, <&str as Into<_>>::into("minecraft:cut_sandstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:156:22
[INFO] [stdout]     |
[INFO] [stdout] 156 |     map.insert(0x84, "minecraft:cut_red_sandstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 156 -     map.insert(0x84, "minecraft:cut_red_sandstone".into());
[INFO] [stdout] 156 +     map.insert(0x84, "minecraft:cut_red_sandstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 156 -     map.insert(0x84, "minecraft:cut_red_sandstone".into());
[INFO] [stdout] 156 +     map.insert(0x84, <&str as Into<_>>::into("minecraft:cut_red_sandstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:157:22
[INFO] [stdout]     |
[INFO] [stdout] 157 |     map.insert(0x85, "minecraft:quartz_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 157 -     map.insert(0x85, "minecraft:quartz_block".into());
[INFO] [stdout] 157 +     map.insert(0x85, "minecraft:quartz_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 157 -     map.insert(0x85, "minecraft:quartz_block".into());
[INFO] [stdout] 157 +     map.insert(0x85, <&str as Into<_>>::into("minecraft:quartz_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:158:22
[INFO] [stdout]     |
[INFO] [stdout] 158 |     map.insert(0x86, "minecraft:brown_concrete".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 158 -     map.insert(0x86, "minecraft:brown_concrete".into());
[INFO] [stdout] 158 +     map.insert(0x86, "minecraft:brown_concrete");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 158 -     map.insert(0x86, "minecraft:brown_concrete".into());
[INFO] [stdout] 158 +     map.insert(0x86, <&str as Into<_>>::into("minecraft:brown_concrete"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:159:22
[INFO] [stdout]     |
[INFO] [stdout] 159 |     map.insert(0x87, "minecraft:brown_concrete_powder".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 159 -     map.insert(0x87, "minecraft:brown_concrete_powder".into());
[INFO] [stdout] 159 +     map.insert(0x87, "minecraft:brown_concrete_powder");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 159 -     map.insert(0x87, "minecraft:brown_concrete_powder".into());
[INFO] [stdout] 159 +     map.insert(0x87, <&str as Into<_>>::into("minecraft:brown_concrete_powder"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:160:22
[INFO] [stdout]     |
[INFO] [stdout] 160 |     map.insert(0x88, "minecraft:brown_glazed_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 160 -     map.insert(0x88, "minecraft:brown_glazed_terracotta".into());
[INFO] [stdout] 160 +     map.insert(0x88, "minecraft:brown_glazed_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 160 -     map.insert(0x88, "minecraft:brown_glazed_terracotta".into());
[INFO] [stdout] 160 +     map.insert(0x88, <&str as Into<_>>::into("minecraft:brown_glazed_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:161:22
[INFO] [stdout]     |
[INFO] [stdout] 161 |     map.insert(0x89, "minecraft:nether_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 161 -     map.insert(0x89, "minecraft:nether_bricks".into());
[INFO] [stdout] 161 +     map.insert(0x89, "minecraft:nether_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 161 -     map.insert(0x89, "minecraft:nether_bricks".into());
[INFO] [stdout] 161 +     map.insert(0x89, <&str as Into<_>>::into("minecraft:nether_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:162:22
[INFO] [stdout]     |
[INFO] [stdout] 162 |     map.insert(0x8A, "minecraft:brown_mushroom_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 162 -     map.insert(0x8A, "minecraft:brown_mushroom_block".into());
[INFO] [stdout] 162 +     map.insert(0x8A, "minecraft:brown_mushroom_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 -     map.insert(0x8A, "minecraft:brown_mushroom_block".into());
[INFO] [stdout] 162 +     map.insert(0x8A, <&str as Into<_>>::into("minecraft:brown_mushroom_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:163:22
[INFO] [stdout]     |
[INFO] [stdout] 163 |     map.insert(0x8B, "minecraft:jungle_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 163 -     map.insert(0x8B, "minecraft:jungle_log".into());
[INFO] [stdout] 163 +     map.insert(0x8B, "minecraft:jungle_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 -     map.insert(0x8B, "minecraft:jungle_log".into());
[INFO] [stdout] 163 +     map.insert(0x8B, <&str as Into<_>>::into("minecraft:jungle_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:164:22
[INFO] [stdout]     |
[INFO] [stdout] 164 |     map.insert(0x8C, "minecraft:brown_stained_glass".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 164 -     map.insert(0x8C, "minecraft:brown_stained_glass".into());
[INFO] [stdout] 164 +     map.insert(0x8C, "minecraft:brown_stained_glass");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 -     map.insert(0x8C, "minecraft:brown_stained_glass".into());
[INFO] [stdout] 164 +     map.insert(0x8C, <&str as Into<_>>::into("minecraft:brown_stained_glass"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:165:22
[INFO] [stdout]     |
[INFO] [stdout] 165 |     map.insert(0x8D, "minecraft:brown_stained_glass_pane".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 165 -     map.insert(0x8D, "minecraft:brown_stained_glass_pane".into());
[INFO] [stdout] 165 +     map.insert(0x8D, "minecraft:brown_stained_glass_pane");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 -     map.insert(0x8D, "minecraft:brown_stained_glass_pane".into());
[INFO] [stdout] 165 +     map.insert(0x8D, <&str as Into<_>>::into("minecraft:brown_stained_glass_pane"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:166:22
[INFO] [stdout]     |
[INFO] [stdout] 166 |     map.insert(0x8E, "minecraft:brown_terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 166 -     map.insert(0x8E, "minecraft:brown_terracotta".into());
[INFO] [stdout] 166 +     map.insert(0x8E, "minecraft:brown_terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 166 -     map.insert(0x8E, "minecraft:brown_terracotta".into());
[INFO] [stdout] 166 +     map.insert(0x8E, <&str as Into<_>>::into("minecraft:brown_terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:167:22
[INFO] [stdout]     |
[INFO] [stdout] 167 |     map.insert(0x8F, "minecraft:warped_hyphae".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 167 -     map.insert(0x8F, "minecraft:warped_hyphae".into());
[INFO] [stdout] 167 +     map.insert(0x8F, "minecraft:warped_hyphae");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 167 -     map.insert(0x8F, "minecraft:warped_hyphae".into());
[INFO] [stdout] 167 +     map.insert(0x8F, <&str as Into<_>>::into("minecraft:warped_hyphae"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:168:22
[INFO] [stdout]     |
[INFO] [stdout] 168 |     map.insert(0x90, "minecraft:brown_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 168 -     map.insert(0x90, "minecraft:brown_wool".into());
[INFO] [stdout] 168 +     map.insert(0x90, "minecraft:brown_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 168 -     map.insert(0x90, "minecraft:brown_wool".into());
[INFO] [stdout] 168 +     map.insert(0x90, <&str as Into<_>>::into("minecraft:brown_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:169:22
[INFO] [stdout]     |
[INFO] [stdout] 169 |     map.insert(0x91, "minecraft:deepslate".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 169 -     map.insert(0x91, "minecraft:deepslate".into());
[INFO] [stdout] 169 +     map.insert(0x91, "minecraft:deepslate");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 169 -     map.insert(0x91, "minecraft:deepslate".into());
[INFO] [stdout] 169 +     map.insert(0x91, <&str as Into<_>>::into("minecraft:deepslate"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:170:22
[INFO] [stdout]     |
[INFO] [stdout] 170 |     map.insert(0x92, "minecraft:light_gray_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 170 -     map.insert(0x92, "minecraft:light_gray_wool".into());
[INFO] [stdout] 170 +     map.insert(0x92, "minecraft:light_gray_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 170 -     map.insert(0x92, "minecraft:light_gray_wool".into());
[INFO] [stdout] 170 +     map.insert(0x92, <&str as Into<_>>::into("minecraft:light_gray_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:171:22
[INFO] [stdout]     |
[INFO] [stdout] 171 |     map.insert(0x93, "minecraft:lime_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 171 -     map.insert(0x93, "minecraft:lime_wool".into());
[INFO] [stdout] 171 +     map.insert(0x93, "minecraft:lime_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 -     map.insert(0x93, "minecraft:lime_wool".into());
[INFO] [stdout] 171 +     map.insert(0x93, <&str as Into<_>>::into("minecraft:lime_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:172:22
[INFO] [stdout]     |
[INFO] [stdout] 172 |     map.insert(0x94, "minecraft:magenta_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 172 -     map.insert(0x94, "minecraft:magenta_wool".into());
[INFO] [stdout] 172 +     map.insert(0x94, "minecraft:magenta_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 172 -     map.insert(0x94, "minecraft:magenta_wool".into());
[INFO] [stdout] 172 +     map.insert(0x94, <&str as Into<_>>::into("minecraft:magenta_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:173:22
[INFO] [stdout]     |
[INFO] [stdout] 173 |     map.insert(0x95, "minecraft:orange_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 173 -     map.insert(0x95, "minecraft:orange_wool".into());
[INFO] [stdout] 173 +     map.insert(0x95, "minecraft:orange_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 173 -     map.insert(0x95, "minecraft:orange_wool".into());
[INFO] [stdout] 173 +     map.insert(0x95, <&str as Into<_>>::into("minecraft:orange_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:174:22
[INFO] [stdout]     |
[INFO] [stdout] 174 |     map.insert(0x96, "minecraft:budding_amethyst".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 174 -     map.insert(0x96, "minecraft:budding_amethyst".into());
[INFO] [stdout] 174 +     map.insert(0x96, "minecraft:budding_amethyst");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 174 -     map.insert(0x96, "minecraft:budding_amethyst".into());
[INFO] [stdout] 174 +     map.insert(0x96, <&str as Into<_>>::into("minecraft:budding_amethyst"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:175:22
[INFO] [stdout]     |
[INFO] [stdout] 175 |     map.insert(0x97, "minecraft:end_stone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 175 -     map.insert(0x97, "minecraft:end_stone".into());
[INFO] [stdout] 175 +     map.insert(0x97, "minecraft:end_stone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 175 -     map.insert(0x97, "minecraft:end_stone".into());
[INFO] [stdout] 175 +     map.insert(0x97, <&str as Into<_>>::into("minecraft:end_stone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:176:22
[INFO] [stdout]     |
[INFO] [stdout] 176 |     map.insert(0x98, "minecraft:sand".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 176 -     map.insert(0x98, "minecraft:sand".into());
[INFO] [stdout] 176 +     map.insert(0x98, "minecraft:sand");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 176 -     map.insert(0x98, "minecraft:sand".into());
[INFO] [stdout] 176 +     map.insert(0x98, <&str as Into<_>>::into("minecraft:sand"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:177:22
[INFO] [stdout]     |
[INFO] [stdout] 177 |     map.insert(0x99, "minecraft:netherrack".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 177 -     map.insert(0x99, "minecraft:netherrack".into());
[INFO] [stdout] 177 +     map.insert(0x99, "minecraft:netherrack");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 -     map.insert(0x99, "minecraft:netherrack".into());
[INFO] [stdout] 177 +     map.insert(0x99, <&str as Into<_>>::into("minecraft:netherrack"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:178:22
[INFO] [stdout]     |
[INFO] [stdout] 178 |     map.insert(0x9A, "minecraft:cake".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 178 -     map.insert(0x9A, "minecraft:cake".into());
[INFO] [stdout] 178 +     map.insert(0x9A, "minecraft:cake");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 178 -     map.insert(0x9A, "minecraft:cake".into());
[INFO] [stdout] 178 +     map.insert(0x9A, <&str as Into<_>>::into("minecraft:cake"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:179:22
[INFO] [stdout]     |
[INFO] [stdout] 179 |     map.insert(0x9B, "minecraft:calcite".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 179 -     map.insert(0x9B, "minecraft:calcite".into());
[INFO] [stdout] 179 +     map.insert(0x9B, "minecraft:calcite");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 179 -     map.insert(0x9B, "minecraft:calcite".into());
[INFO] [stdout] 179 +     map.insert(0x9B, <&str as Into<_>>::into("minecraft:calcite"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:180:22
[INFO] [stdout]     |
[INFO] [stdout] 180 |     map.insert(0x9C, "minecraft:calibrated_sculk_sensor".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 180 -     map.insert(0x9C, "minecraft:calibrated_sculk_sensor".into());
[INFO] [stdout] 180 +     map.insert(0x9C, "minecraft:calibrated_sculk_sensor");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 180 -     map.insert(0x9C, "minecraft:calibrated_sculk_sensor".into());
[INFO] [stdout] 180 +     map.insert(0x9C, <&str as Into<_>>::into("minecraft:calibrated_sculk_sensor"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:181:22
[INFO] [stdout]     |
[INFO] [stdout] 181 |     map.insert(0x9D, "minecraft:campfire".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 181 -     map.insert(0x9D, "minecraft:campfire".into());
[INFO] [stdout] 181 +     map.insert(0x9D, "minecraft:campfire");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 181 -     map.insert(0x9D, "minecraft:campfire".into());
[INFO] [stdout] 181 +     map.insert(0x9D, <&str as Into<_>>::into("minecraft:campfire"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:182:22
[INFO] [stdout]     |
[INFO] [stdout] 182 |     map.insert(0x9E, "minecraft:smooth_stone_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 182 -     map.insert(0x9E, "minecraft:smooth_stone_slab".into());
[INFO] [stdout] 182 +     map.insert(0x9E, "minecraft:smooth_stone_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 182 -     map.insert(0x9E, "minecraft:smooth_stone_slab".into());
[INFO] [stdout] 182 +     map.insert(0x9E, <&str as Into<_>>::into("minecraft:smooth_stone_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:183:22
[INFO] [stdout]     |
[INFO] [stdout] 183 |     map.insert(0x9F, "minecraft:smooth_basalt".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 183 -     map.insert(0x9F, "minecraft:smooth_basalt".into());
[INFO] [stdout] 183 +     map.insert(0x9F, "minecraft:smooth_basalt");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 183 -     map.insert(0x9F, "minecraft:smooth_basalt".into());
[INFO] [stdout] 183 +     map.insert(0x9F, <&str as Into<_>>::into("minecraft:smooth_basalt"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:184:22
[INFO] [stdout]     |
[INFO] [stdout] 184 |     map.insert(0xA0, "minecraft:podzol".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 184 -     map.insert(0xA0, "minecraft:podzol".into());
[INFO] [stdout] 184 +     map.insert(0xA0, "minecraft:podzol");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 -     map.insert(0xA0, "minecraft:podzol".into());
[INFO] [stdout] 184 +     map.insert(0xA0, <&str as Into<_>>::into("minecraft:podzol"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:185:22
[INFO] [stdout]     |
[INFO] [stdout] 185 |     map.insert(0xA1, "minecraft:cartography_table".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 185 -     map.insert(0xA1, "minecraft:cartography_table".into());
[INFO] [stdout] 185 +     map.insert(0xA1, "minecraft:cartography_table");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 185 -     map.insert(0xA1, "minecraft:cartography_table".into());
[INFO] [stdout] 185 +     map.insert(0xA1, <&str as Into<_>>::into("minecraft:cartography_table"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:186:22
[INFO] [stdout]     |
[INFO] [stdout] 186 |     map.insert(0xA2, "minecraft:carved_pumpkin".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 186 -     map.insert(0xA2, "minecraft:carved_pumpkin".into());
[INFO] [stdout] 186 +     map.insert(0xA2, "minecraft:carved_pumpkin");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 186 -     map.insert(0xA2, "minecraft:carved_pumpkin".into());
[INFO] [stdout] 186 +     map.insert(0xA2, <&str as Into<_>>::into("minecraft:carved_pumpkin"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:187:22
[INFO] [stdout]     |
[INFO] [stdout] 187 |     map.insert(0xA3, "minecraft:cauldron".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 187 -     map.insert(0xA3, "minecraft:cauldron".into());
[INFO] [stdout] 187 +     map.insert(0xA3, "minecraft:cauldron");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 -     map.insert(0xA3, "minecraft:cauldron".into());
[INFO] [stdout] 187 +     map.insert(0xA3, <&str as Into<_>>::into("minecraft:cauldron"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:188:22
[INFO] [stdout]     |
[INFO] [stdout] 188 |     map.insert(0xA4, "minecraft:pink_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 188 -     map.insert(0xA4, "minecraft:pink_wool".into());
[INFO] [stdout] 188 +     map.insert(0xA4, "minecraft:pink_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 188 -     map.insert(0xA4, "minecraft:pink_wool".into());
[INFO] [stdout] 188 +     map.insert(0xA4, <&str as Into<_>>::into("minecraft:pink_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:189:22
[INFO] [stdout]     |
[INFO] [stdout] 189 |     map.insert(0xA5, "minecraft:dirt".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 189 -     map.insert(0xA5, "minecraft:dirt".into());
[INFO] [stdout] 189 +     map.insert(0xA5, "minecraft:dirt");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 189 -     map.insert(0xA5, "minecraft:dirt".into());
[INFO] [stdout] 189 +     map.insert(0xA5, <&str as Into<_>>::into("minecraft:dirt"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:190:22
[INFO] [stdout]     |
[INFO] [stdout] 190 |     map.insert(0xA6, "minecraft:obsidian".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 190 -     map.insert(0xA6, "minecraft:obsidian".into());
[INFO] [stdout] 190 +     map.insert(0xA6, "minecraft:obsidian");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 190 -     map.insert(0xA6, "minecraft:obsidian".into());
[INFO] [stdout] 190 +     map.insert(0xA6, <&str as Into<_>>::into("minecraft:obsidian"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:191:22
[INFO] [stdout]     |
[INFO] [stdout] 191 |     map.insert(0xA7, "minecraft:chain_command_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 191 -     map.insert(0xA7, "minecraft:chain_command_block".into());
[INFO] [stdout] 191 +     map.insert(0xA7, "minecraft:chain_command_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 191 -     map.insert(0xA7, "minecraft:chain_command_block".into());
[INFO] [stdout] 191 +     map.insert(0xA7, <&str as Into<_>>::into("minecraft:chain_command_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:192:22
[INFO] [stdout]     |
[INFO] [stdout] 192 |     map.insert(0xA8, "minecraft:dripstone_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 192 -     map.insert(0xA8, "minecraft:dripstone_block".into());
[INFO] [stdout] 192 +     map.insert(0xA8, "minecraft:dripstone_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 192 -     map.insert(0xA8, "minecraft:dripstone_block".into());
[INFO] [stdout] 192 +     map.insert(0xA8, <&str as Into<_>>::into("minecraft:dripstone_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:193:22
[INFO] [stdout]     |
[INFO] [stdout] 193 |     map.insert(0xA9, "minecraft:rooted_dirt".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 193 -     map.insert(0xA9, "minecraft:rooted_dirt".into());
[INFO] [stdout] 193 +     map.insert(0xA9, "minecraft:rooted_dirt");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 -     map.insert(0xA9, "minecraft:rooted_dirt".into());
[INFO] [stdout] 193 +     map.insert(0xA9, <&str as Into<_>>::into("minecraft:rooted_dirt"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:194:22
[INFO] [stdout]     |
[INFO] [stdout] 194 |     map.insert(0xAA, "minecraft:cherry_fence".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 194 -     map.insert(0xAA, "minecraft:cherry_fence".into());
[INFO] [stdout] 194 +     map.insert(0xAA, "minecraft:cherry_fence");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 194 -     map.insert(0xAA, "minecraft:cherry_fence".into());
[INFO] [stdout] 194 +     map.insert(0xAA, <&str as Into<_>>::into("minecraft:cherry_fence"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:195:22
[INFO] [stdout]     |
[INFO] [stdout] 195 |     map.insert(0xAB, "minecraft:cherry_fence_gate".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 195 -     map.insert(0xAB, "minecraft:cherry_fence_gate".into());
[INFO] [stdout] 195 +     map.insert(0xAB, "minecraft:cherry_fence_gate");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 195 -     map.insert(0xAB, "minecraft:cherry_fence_gate".into());
[INFO] [stdout] 195 +     map.insert(0xAB, <&str as Into<_>>::into("minecraft:cherry_fence_gate"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:196:22
[INFO] [stdout]     |
[INFO] [stdout] 196 |     map.insert(0xAC, "minecraft:mud".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 196 -     map.insert(0xAC, "minecraft:mud".into());
[INFO] [stdout] 196 +     map.insert(0xAC, "minecraft:mud");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 196 -     map.insert(0xAC, "minecraft:mud".into());
[INFO] [stdout] 196 +     map.insert(0xAC, <&str as Into<_>>::into("minecraft:mud"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:197:22
[INFO] [stdout]     |
[INFO] [stdout] 197 |     map.insert(0xAD, "minecraft:spruce_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 197 -     map.insert(0xAD, "minecraft:spruce_log".into());
[INFO] [stdout] 197 +     map.insert(0xAD, "minecraft:spruce_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 -     map.insert(0xAD, "minecraft:spruce_log".into());
[INFO] [stdout] 197 +     map.insert(0xAD, <&str as Into<_>>::into("minecraft:spruce_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:198:22
[INFO] [stdout]     |
[INFO] [stdout] 198 |     map.insert(0xAE, "minecraft:cherry_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 198 -     map.insert(0xAE, "minecraft:cherry_log".into());
[INFO] [stdout] 198 +     map.insert(0xAE, "minecraft:cherry_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 -     map.insert(0xAE, "minecraft:cherry_log".into());
[INFO] [stdout] 198 +     map.insert(0xAE, <&str as Into<_>>::into("minecraft:cherry_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:199:22
[INFO] [stdout]     |
[INFO] [stdout] 199 |     map.insert(0xAF, "minecraft:cherry_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 199 -     map.insert(0xAF, "minecraft:cherry_planks".into());
[INFO] [stdout] 199 +     map.insert(0xAF, "minecraft:cherry_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 -     map.insert(0xAF, "minecraft:cherry_planks".into());
[INFO] [stdout] 199 +     map.insert(0xAF, <&str as Into<_>>::into("minecraft:cherry_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:200:22
[INFO] [stdout]     |
[INFO] [stdout] 200 |     map.insert(0xB0, "minecraft:stripped_cherry_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 200 -     map.insert(0xB0, "minecraft:stripped_cherry_log".into());
[INFO] [stdout] 200 +     map.insert(0xB0, "minecraft:stripped_cherry_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 200 -     map.insert(0xB0, "minecraft:stripped_cherry_log".into());
[INFO] [stdout] 200 +     map.insert(0xB0, <&str as Into<_>>::into("minecraft:stripped_cherry_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:201:22
[INFO] [stdout]     |
[INFO] [stdout] 201 |     map.insert(0xB1, "minecraft:stone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 201 -     map.insert(0xB1, "minecraft:stone".into());
[INFO] [stdout] 201 +     map.insert(0xB1, "minecraft:stone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 -     map.insert(0xB1, "minecraft:stone".into());
[INFO] [stdout] 201 +     map.insert(0xB1, <&str as Into<_>>::into("minecraft:stone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:202:22
[INFO] [stdout]     |
[INFO] [stdout] 202 |     map.insert(0xB2, "minecraft:cherry_shelf".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 202 -     map.insert(0xB2, "minecraft:cherry_shelf".into());
[INFO] [stdout] 202 +     map.insert(0xB2, "minecraft:cherry_shelf");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 202 -     map.insert(0xB2, "minecraft:cherry_shelf".into());
[INFO] [stdout] 202 +     map.insert(0xB2, <&str as Into<_>>::into("minecraft:cherry_shelf"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:203:22
[INFO] [stdout]     |
[INFO] [stdout] 203 |     map.insert(0xB3, "minecraft:packed_mud".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 203 -     map.insert(0xB3, "minecraft:packed_mud".into());
[INFO] [stdout] 203 +     map.insert(0xB3, "minecraft:packed_mud");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 -     map.insert(0xB3, "minecraft:packed_mud".into());
[INFO] [stdout] 203 +     map.insert(0xB3, <&str as Into<_>>::into("minecraft:packed_mud"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:204:22
[INFO] [stdout]     |
[INFO] [stdout] 204 |     map.insert(0xB4, "minecraft:cherry_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 204 -     map.insert(0xB4, "minecraft:cherry_slab".into());
[INFO] [stdout] 204 +     map.insert(0xB4, "minecraft:cherry_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 204 -     map.insert(0xB4, "minecraft:cherry_slab".into());
[INFO] [stdout] 204 +     map.insert(0xB4, <&str as Into<_>>::into("minecraft:cherry_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:205:22
[INFO] [stdout]     |
[INFO] [stdout] 205 |     map.insert(0xB5, "minecraft:cherry_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 205 -     map.insert(0xB5, "minecraft:cherry_stairs".into());
[INFO] [stdout] 205 +     map.insert(0xB5, "minecraft:cherry_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 -     map.insert(0xB5, "minecraft:cherry_stairs".into());
[INFO] [stdout] 205 +     map.insert(0xB5, <&str as Into<_>>::into("minecraft:cherry_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:206:22
[INFO] [stdout]     |
[INFO] [stdout] 206 |     map.insert(0xB6, "minecraft:cherry_trapdoor".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 206 -     map.insert(0xB6, "minecraft:cherry_trapdoor".into());
[INFO] [stdout] 206 +     map.insert(0xB6, "minecraft:cherry_trapdoor");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 206 -     map.insert(0xB6, "minecraft:cherry_trapdoor".into());
[INFO] [stdout] 206 +     map.insert(0xB6, <&str as Into<_>>::into("minecraft:cherry_trapdoor"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:207:22
[INFO] [stdout]     |
[INFO] [stdout] 207 |     map.insert(0xB7, "minecraft:sculk_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 207 -     map.insert(0xB7, "minecraft:sculk_block".into());
[INFO] [stdout] 207 +     map.insert(0xB7, "minecraft:sculk_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 207 -     map.insert(0xB7, "minecraft:sculk_block".into());
[INFO] [stdout] 207 +     map.insert(0xB7, <&str as Into<_>>::into("minecraft:sculk_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:208:22
[INFO] [stdout]     |
[INFO] [stdout] 208 |     map.insert(0xB8, "minecraft:sculk_catalyst".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 208 -     map.insert(0xB8, "minecraft:sculk_catalyst".into());
[INFO] [stdout] 208 +     map.insert(0xB8, "minecraft:sculk_catalyst");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 208 -     map.insert(0xB8, "minecraft:sculk_catalyst".into());
[INFO] [stdout] 208 +     map.insert(0xB8, <&str as Into<_>>::into("minecraft:sculk_catalyst"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:209:22
[INFO] [stdout]     |
[INFO] [stdout] 209 |     map.insert(0xB9, "minecraft:cherry_wood".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 209 -     map.insert(0xB9, "minecraft:cherry_wood".into());
[INFO] [stdout] 209 +     map.insert(0xB9, "minecraft:cherry_wood");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 -     map.insert(0xB9, "minecraft:cherry_wood".into());
[INFO] [stdout] 209 +     map.insert(0xB9, <&str as Into<_>>::into("minecraft:cherry_wood"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:210:22
[INFO] [stdout]     |
[INFO] [stdout] 210 |     map.insert(0xBA, "minecraft:oak_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 210 -     map.insert(0xBA, "minecraft:oak_planks".into());
[INFO] [stdout] 210 +     map.insert(0xBA, "minecraft:oak_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 210 -     map.insert(0xBA, "minecraft:oak_planks".into());
[INFO] [stdout] 210 +     map.insert(0xBA, <&str as Into<_>>::into("minecraft:oak_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:211:22
[INFO] [stdout]     |
[INFO] [stdout] 211 |     map.insert(0xBB, "minecraft:chipped_anvil".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 211 -     map.insert(0xBB, "minecraft:chipped_anvil".into());
[INFO] [stdout] 211 +     map.insert(0xBB, "minecraft:chipped_anvil");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 -     map.insert(0xBB, "minecraft:chipped_anvil".into());
[INFO] [stdout] 211 +     map.insert(0xBB, <&str as Into<_>>::into("minecraft:chipped_anvil"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:212:22
[INFO] [stdout]     |
[INFO] [stdout] 212 |     map.insert(0xBC, "minecraft:chiseled_bookshelf".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 212 -     map.insert(0xBC, "minecraft:chiseled_bookshelf".into());
[INFO] [stdout] 212 +     map.insert(0xBC, "minecraft:chiseled_bookshelf");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 -     map.insert(0xBC, "minecraft:chiseled_bookshelf".into());
[INFO] [stdout] 212 +     map.insert(0xBC, <&str as Into<_>>::into("minecraft:chiseled_bookshelf"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:213:22
[INFO] [stdout]     |
[INFO] [stdout] 213 |     map.insert(0xBD, "minecraft:sculk_sensor".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 213 -     map.insert(0xBD, "minecraft:sculk_sensor".into());
[INFO] [stdout] 213 +     map.insert(0xBD, "minecraft:sculk_sensor");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 -     map.insert(0xBD, "minecraft:sculk_sensor".into());
[INFO] [stdout] 213 +     map.insert(0xBD, <&str as Into<_>>::into("minecraft:sculk_sensor"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:214:22
[INFO] [stdout]     |
[INFO] [stdout] 214 |     map.insert(0xBE, "minecraft:chiseled_deepslate".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 214 -     map.insert(0xBE, "minecraft:chiseled_deepslate".into());
[INFO] [stdout] 214 +     map.insert(0xBE, "minecraft:chiseled_deepslate");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 -     map.insert(0xBE, "minecraft:chiseled_deepslate".into());
[INFO] [stdout] 214 +     map.insert(0xBE, <&str as Into<_>>::into("minecraft:chiseled_deepslate"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:215:22
[INFO] [stdout]     |
[INFO] [stdout] 215 |     map.insert(0xBF, "minecraft:chiseled_nether_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 215 -     map.insert(0xBF, "minecraft:chiseled_nether_bricks".into());
[INFO] [stdout] 215 +     map.insert(0xBF, "minecraft:chiseled_nether_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 215 -     map.insert(0xBF, "minecraft:chiseled_nether_bricks".into());
[INFO] [stdout] 215 +     map.insert(0xBF, <&str as Into<_>>::into("minecraft:chiseled_nether_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:216:22
[INFO] [stdout]     |
[INFO] [stdout] 216 |     map.insert(0xC0, "minecraft:chiseled_polished_blackstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 216 -     map.insert(0xC0, "minecraft:chiseled_polished_blackstone".into());
[INFO] [stdout] 216 +     map.insert(0xC0, "minecraft:chiseled_polished_blackstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 216 -     map.insert(0xC0, "minecraft:chiseled_polished_blackstone".into());
[INFO] [stdout] 216 +     map.insert(0xC0, <&str as Into<_>>::into("minecraft:chiseled_polished_blackstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:217:22
[INFO] [stdout]     |
[INFO] [stdout] 217 |     map.insert(0xC1, "minecraft:chiseled_quartz_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 217 -     map.insert(0xC1, "minecraft:chiseled_quartz_block".into());
[INFO] [stdout] 217 +     map.insert(0xC1, "minecraft:chiseled_quartz_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 -     map.insert(0xC1, "minecraft:chiseled_quartz_block".into());
[INFO] [stdout] 217 +     map.insert(0xC1, <&str as Into<_>>::into("minecraft:chiseled_quartz_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:218:22
[INFO] [stdout]     |
[INFO] [stdout] 218 |     map.insert(0xC2, "minecraft:chiseled_red_sandstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 218 -     map.insert(0xC2, "minecraft:chiseled_red_sandstone".into());
[INFO] [stdout] 218 +     map.insert(0xC2, "minecraft:chiseled_red_sandstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 218 -     map.insert(0xC2, "minecraft:chiseled_red_sandstone".into());
[INFO] [stdout] 218 +     map.insert(0xC2, <&str as Into<_>>::into("minecraft:chiseled_red_sandstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:219:22
[INFO] [stdout]     |
[INFO] [stdout] 219 |     map.insert(0xC3, "minecraft:chiseled_resin_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 219 -     map.insert(0xC3, "minecraft:chiseled_resin_bricks".into());
[INFO] [stdout] 219 +     map.insert(0xC3, "minecraft:chiseled_resin_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 219 -     map.insert(0xC3, "minecraft:chiseled_resin_bricks".into());
[INFO] [stdout] 219 +     map.insert(0xC3, <&str as Into<_>>::into("minecraft:chiseled_resin_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:220:22
[INFO] [stdout]     |
[INFO] [stdout] 220 |     map.insert(0xC4, "minecraft:chiseled_sandstone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 220 -     map.insert(0xC4, "minecraft:chiseled_sandstone".into());
[INFO] [stdout] 220 +     map.insert(0xC4, "minecraft:chiseled_sandstone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 220 -     map.insert(0xC4, "minecraft:chiseled_sandstone".into());
[INFO] [stdout] 220 +     map.insert(0xC4, <&str as Into<_>>::into("minecraft:chiseled_sandstone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:221:22
[INFO] [stdout]     |
[INFO] [stdout] 221 |     map.insert(0xC5, "minecraft:chiseled_stone_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 221 -     map.insert(0xC5, "minecraft:chiseled_stone_bricks".into());
[INFO] [stdout] 221 +     map.insert(0xC5, "minecraft:chiseled_stone_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 221 -     map.insert(0xC5, "minecraft:chiseled_stone_bricks".into());
[INFO] [stdout] 221 +     map.insert(0xC5, <&str as Into<_>>::into("minecraft:chiseled_stone_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:222:22
[INFO] [stdout]     |
[INFO] [stdout] 222 |     map.insert(0xC6, "minecraft:chiseled_tuff".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 222 -     map.insert(0xC6, "minecraft:chiseled_tuff".into());
[INFO] [stdout] 222 +     map.insert(0xC6, "minecraft:chiseled_tuff");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 -     map.insert(0xC6, "minecraft:chiseled_tuff".into());
[INFO] [stdout] 222 +     map.insert(0xC6, <&str as Into<_>>::into("minecraft:chiseled_tuff"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:223:22
[INFO] [stdout]     |
[INFO] [stdout] 223 |     map.insert(0xC7, "minecraft:chiseled_tuff_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 223 -     map.insert(0xC7, "minecraft:chiseled_tuff_bricks".into());
[INFO] [stdout] 223 +     map.insert(0xC7, "minecraft:chiseled_tuff_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 223 -     map.insert(0xC7, "minecraft:chiseled_tuff_bricks".into());
[INFO] [stdout] 223 +     map.insert(0xC7, <&str as Into<_>>::into("minecraft:chiseled_tuff_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:224:22
[INFO] [stdout]     |
[INFO] [stdout] 224 |     map.insert(0xC8, "minecraft:smooth_stone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 224 -     map.insert(0xC8, "minecraft:smooth_stone".into());
[INFO] [stdout] 224 +     map.insert(0xC8, "minecraft:smooth_stone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 224 -     map.insert(0xC8, "minecraft:smooth_stone".into());
[INFO] [stdout] 224 +     map.insert(0xC8, <&str as Into<_>>::into("minecraft:smooth_stone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:225:22
[INFO] [stdout]     |
[INFO] [stdout] 225 |     map.insert(0xC9, "minecraft:chorus_plant".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 225 -     map.insert(0xC9, "minecraft:chorus_plant".into());
[INFO] [stdout] 225 +     map.insert(0xC9, "minecraft:chorus_plant");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 225 -     map.insert(0xC9, "minecraft:chorus_plant".into());
[INFO] [stdout] 225 +     map.insert(0xC9, <&str as Into<_>>::into("minecraft:chorus_plant"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:226:22
[INFO] [stdout]     |
[INFO] [stdout] 226 |     map.insert(0xCA, "minecraft:clay".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 226 -     map.insert(0xCA, "minecraft:clay".into());
[INFO] [stdout] 226 +     map.insert(0xCA, "minecraft:clay");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 226 -     map.insert(0xCA, "minecraft:clay".into());
[INFO] [stdout] 226 +     map.insert(0xCA, <&str as Into<_>>::into("minecraft:clay"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:227:22
[INFO] [stdout]     |
[INFO] [stdout] 227 |     map.insert(0xCB, "minecraft:terracotta".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 227 -     map.insert(0xCB, "minecraft:terracotta".into());
[INFO] [stdout] 227 +     map.insert(0xCB, "minecraft:terracotta");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 227 -     map.insert(0xCB, "minecraft:terracotta".into());
[INFO] [stdout] 227 +     map.insert(0xCB, <&str as Into<_>>::into("minecraft:terracotta"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:228:22
[INFO] [stdout]     |
[INFO] [stdout] 228 |     map.insert(0xCC, "minecraft:coal_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 228 -     map.insert(0xCC, "minecraft:coal_block".into());
[INFO] [stdout] 228 +     map.insert(0xCC, "minecraft:coal_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 228 -     map.insert(0xCC, "minecraft:coal_block".into());
[INFO] [stdout] 228 +     map.insert(0xCC, <&str as Into<_>>::into("minecraft:coal_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:229:22
[INFO] [stdout]     |
[INFO] [stdout] 229 |     map.insert(0xCD, "minecraft:coal_ore".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 229 -     map.insert(0xCD, "minecraft:coal_ore".into());
[INFO] [stdout] 229 +     map.insert(0xCD, "minecraft:coal_ore");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 229 -     map.insert(0xCD, "minecraft:coal_ore".into());
[INFO] [stdout] 229 +     map.insert(0xCD, <&str as Into<_>>::into("minecraft:coal_ore"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:230:22
[INFO] [stdout]     |
[INFO] [stdout] 230 |     map.insert(0xCE, "minecraft:coarse_dirt".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 230 -     map.insert(0xCE, "minecraft:coarse_dirt".into());
[INFO] [stdout] 230 +     map.insert(0xCE, "minecraft:coarse_dirt");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 230 -     map.insert(0xCE, "minecraft:coarse_dirt".into());
[INFO] [stdout] 230 +     map.insert(0xCE, <&str as Into<_>>::into("minecraft:coarse_dirt"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:231:22
[INFO] [stdout]     |
[INFO] [stdout] 231 |     map.insert(0xCF, "minecraft:cobbled_deepslate".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 231 -     map.insert(0xCF, "minecraft:cobbled_deepslate".into());
[INFO] [stdout] 231 +     map.insert(0xCF, "minecraft:cobbled_deepslate");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 231 -     map.insert(0xCF, "minecraft:cobbled_deepslate".into());
[INFO] [stdout] 231 +     map.insert(0xCF, <&str as Into<_>>::into("minecraft:cobbled_deepslate"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:232:22
[INFO] [stdout]     |
[INFO] [stdout] 232 |     map.insert(0xD0, "minecraft:cobbled_deepslate_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 232 -     map.insert(0xD0, "minecraft:cobbled_deepslate_slab".into());
[INFO] [stdout] 232 +     map.insert(0xD0, "minecraft:cobbled_deepslate_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 232 -     map.insert(0xD0, "minecraft:cobbled_deepslate_slab".into());
[INFO] [stdout] 232 +     map.insert(0xD0, <&str as Into<_>>::into("minecraft:cobbled_deepslate_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:233:22
[INFO] [stdout]     |
[INFO] [stdout] 233 |     map.insert(0xD1, "minecraft:cobbled_deepslate_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 233 -     map.insert(0xD1, "minecraft:cobbled_deepslate_stairs".into());
[INFO] [stdout] 233 +     map.insert(0xD1, "minecraft:cobbled_deepslate_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 -     map.insert(0xD1, "minecraft:cobbled_deepslate_stairs".into());
[INFO] [stdout] 233 +     map.insert(0xD1, <&str as Into<_>>::into("minecraft:cobbled_deepslate_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:234:22
[INFO] [stdout]     |
[INFO] [stdout] 234 |     map.insert(0xD2, "minecraft:cobbled_deepslate_wall".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 234 -     map.insert(0xD2, "minecraft:cobbled_deepslate_wall".into());
[INFO] [stdout] 234 +     map.insert(0xD2, "minecraft:cobbled_deepslate_wall");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 234 -     map.insert(0xD2, "minecraft:cobbled_deepslate_wall".into());
[INFO] [stdout] 234 +     map.insert(0xD2, <&str as Into<_>>::into("minecraft:cobbled_deepslate_wall"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:235:22
[INFO] [stdout]     |
[INFO] [stdout] 235 |     map.insert(0xD3, "minecraft:cobblestone".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 235 -     map.insert(0xD3, "minecraft:cobblestone".into());
[INFO] [stdout] 235 +     map.insert(0xD3, "minecraft:cobblestone");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 235 -     map.insert(0xD3, "minecraft:cobblestone".into());
[INFO] [stdout] 235 +     map.insert(0xD3, <&str as Into<_>>::into("minecraft:cobblestone"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:236:22
[INFO] [stdout]     |
[INFO] [stdout] 236 |     map.insert(0xD4, "minecraft:cobblestone_slab".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 236 -     map.insert(0xD4, "minecraft:cobblestone_slab".into());
[INFO] [stdout] 236 +     map.insert(0xD4, "minecraft:cobblestone_slab");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 236 -     map.insert(0xD4, "minecraft:cobblestone_slab".into());
[INFO] [stdout] 236 +     map.insert(0xD4, <&str as Into<_>>::into("minecraft:cobblestone_slab"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:237:22
[INFO] [stdout]     |
[INFO] [stdout] 237 |     map.insert(0xD5, "minecraft:cobblestone_stairs".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 237 -     map.insert(0xD5, "minecraft:cobblestone_stairs".into());
[INFO] [stdout] 237 +     map.insert(0xD5, "minecraft:cobblestone_stairs");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 237 -     map.insert(0xD5, "minecraft:cobblestone_stairs".into());
[INFO] [stdout] 237 +     map.insert(0xD5, <&str as Into<_>>::into("minecraft:cobblestone_stairs"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:238:22
[INFO] [stdout]     |
[INFO] [stdout] 238 |     map.insert(0xD6, "minecraft:cobblestone_wall".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 238 -     map.insert(0xD6, "minecraft:cobblestone_wall".into());
[INFO] [stdout] 238 +     map.insert(0xD6, "minecraft:cobblestone_wall");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 -     map.insert(0xD6, "minecraft:cobblestone_wall".into());
[INFO] [stdout] 238 +     map.insert(0xD6, <&str as Into<_>>::into("minecraft:cobblestone_wall"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:239:22
[INFO] [stdout]     |
[INFO] [stdout] 239 |     map.insert(0xD7, "minecraft:cobweb".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 239 -     map.insert(0xD7, "minecraft:cobweb".into());
[INFO] [stdout] 239 +     map.insert(0xD7, "minecraft:cobweb");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 -     map.insert(0xD7, "minecraft:cobweb".into());
[INFO] [stdout] 239 +     map.insert(0xD7, <&str as Into<_>>::into("minecraft:cobweb"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:240:22
[INFO] [stdout]     |
[INFO] [stdout] 240 |     map.insert(0xD8, "minecraft:jungle_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 240 -     map.insert(0xD8, "minecraft:jungle_planks".into());
[INFO] [stdout] 240 +     map.insert(0xD8, "minecraft:jungle_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 -     map.insert(0xD8, "minecraft:jungle_planks".into());
[INFO] [stdout] 240 +     map.insert(0xD8, <&str as Into<_>>::into("minecraft:jungle_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:241:22
[INFO] [stdout]     |
[INFO] [stdout] 241 |     map.insert(0xD9, "minecraft:command_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 241 -     map.insert(0xD9, "minecraft:command_block".into());
[INFO] [stdout] 241 +     map.insert(0xD9, "minecraft:command_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 241 -     map.insert(0xD9, "minecraft:command_block".into());
[INFO] [stdout] 241 +     map.insert(0xD9, <&str as Into<_>>::into("minecraft:command_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:242:22
[INFO] [stdout]     |
[INFO] [stdout] 242 |     map.insert(0xDA, "minecraft:comparator".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 242 -     map.insert(0xDA, "minecraft:comparator".into());
[INFO] [stdout] 242 +     map.insert(0xDA, "minecraft:comparator");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 242 -     map.insert(0xDA, "minecraft:comparator".into());
[INFO] [stdout] 242 +     map.insert(0xDA, <&str as Into<_>>::into("minecraft:comparator"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:243:22
[INFO] [stdout]     |
[INFO] [stdout] 243 |     map.insert(0xDB, "minecraft:composter".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 243 -     map.insert(0xDB, "minecraft:composter".into());
[INFO] [stdout] 243 +     map.insert(0xDB, "minecraft:composter");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 243 -     map.insert(0xDB, "minecraft:composter".into());
[INFO] [stdout] 243 +     map.insert(0xDB, <&str as Into<_>>::into("minecraft:composter"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:244:22
[INFO] [stdout]     |
[INFO] [stdout] 244 |     map.insert(0xDC, "minecraft:packed_ice".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 244 -     map.insert(0xDC, "minecraft:packed_ice".into());
[INFO] [stdout] 244 +     map.insert(0xDC, "minecraft:packed_ice");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 -     map.insert(0xDC, "minecraft:packed_ice".into());
[INFO] [stdout] 244 +     map.insert(0xDC, <&str as Into<_>>::into("minecraft:packed_ice"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:245:22
[INFO] [stdout]     |
[INFO] [stdout] 245 |     map.insert(0xDD, "minecraft:iron_bars".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 245 -     map.insert(0xDD, "minecraft:iron_bars".into());
[INFO] [stdout] 245 +     map.insert(0xDD, "minecraft:iron_bars");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 245 -     map.insert(0xDD, "minecraft:iron_bars".into());
[INFO] [stdout] 245 +     map.insert(0xDD, <&str as Into<_>>::into("minecraft:iron_bars"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:246:22
[INFO] [stdout]     |
[INFO] [stdout] 246 |     map.insert(0xDE, "minecraft:crying_obsidian".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 246 -     map.insert(0xDE, "minecraft:crying_obsidian".into());
[INFO] [stdout] 246 +     map.insert(0xDE, "minecraft:crying_obsidian");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 246 -     map.insert(0xDE, "minecraft:crying_obsidian".into());
[INFO] [stdout] 246 +     map.insert(0xDE, <&str as Into<_>>::into("minecraft:crying_obsidian"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:247:22
[INFO] [stdout]     |
[INFO] [stdout] 247 |     map.insert(0xDF, "minecraft:respawn_anchor".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 247 -     map.insert(0xDF, "minecraft:respawn_anchor".into());
[INFO] [stdout] 247 +     map.insert(0xDF, "minecraft:respawn_anchor");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 247 -     map.insert(0xDF, "minecraft:respawn_anchor".into());
[INFO] [stdout] 247 +     map.insert(0xDF, <&str as Into<_>>::into("minecraft:respawn_anchor"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:248:22
[INFO] [stdout]     |
[INFO] [stdout] 248 |     map.insert(0xE0, "minecraft:chain".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 248 -     map.insert(0xE0, "minecraft:chain".into());
[INFO] [stdout] 248 +     map.insert(0xE0, "minecraft:chain");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 248 -     map.insert(0xE0, "minecraft:chain".into());
[INFO] [stdout] 248 +     map.insert(0xE0, <&str as Into<_>>::into("minecraft:chain"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:249:22
[INFO] [stdout]     |
[INFO] [stdout] 249 |     map.insert(0xE1, "minecraft:stripped_oak_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 249 -     map.insert(0xE1, "minecraft:stripped_oak_log".into());
[INFO] [stdout] 249 +     map.insert(0xE1, "minecraft:stripped_oak_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 -     map.insert(0xE1, "minecraft:stripped_oak_log".into());
[INFO] [stdout] 249 +     map.insert(0xE1, <&str as Into<_>>::into("minecraft:stripped_oak_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:250:22
[INFO] [stdout]     |
[INFO] [stdout] 250 |     map.insert(0xE2, "minecraft:waxed_copper_block".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 250 -     map.insert(0xE2, "minecraft:waxed_copper_block".into());
[INFO] [stdout] 250 +     map.insert(0xE2, "minecraft:waxed_copper_block");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 250 -     map.insert(0xE2, "minecraft:waxed_copper_block".into());
[INFO] [stdout] 250 +     map.insert(0xE2, <&str as Into<_>>::into("minecraft:waxed_copper_block"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:251:22
[INFO] [stdout]     |
[INFO] [stdout] 251 |     map.insert(0xE3, "minecraft:dispenser".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 251 -     map.insert(0xE3, "minecraft:dispenser".into());
[INFO] [stdout] 251 +     map.insert(0xE3, "minecraft:dispenser");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 251 -     map.insert(0xE3, "minecraft:dispenser".into());
[INFO] [stdout] 251 +     map.insert(0xE3, <&str as Into<_>>::into("minecraft:dispenser"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:252:22
[INFO] [stdout]     |
[INFO] [stdout] 252 |     map.insert(0xE4, "minecraft:dropper".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 252 -     map.insert(0xE4, "minecraft:dropper".into());
[INFO] [stdout] 252 +     map.insert(0xE4, "minecraft:dropper");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 252 -     map.insert(0xE4, "minecraft:dropper".into());
[INFO] [stdout] 252 +     map.insert(0xE4, <&str as Into<_>>::into("minecraft:dropper"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:253:22
[INFO] [stdout]     |
[INFO] [stdout] 253 |     map.insert(0xE5, "minecraft:stripped_dark_oak_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 253 -     map.insert(0xE5, "minecraft:stripped_dark_oak_log".into());
[INFO] [stdout] 253 +     map.insert(0xE5, "minecraft:stripped_dark_oak_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 253 -     map.insert(0xE5, "minecraft:stripped_dark_oak_log".into());
[INFO] [stdout] 253 +     map.insert(0xE5, <&str as Into<_>>::into("minecraft:stripped_dark_oak_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:254:22
[INFO] [stdout]     |
[INFO] [stdout] 254 |     map.insert(0xE6, "minecraft:diamond_ore".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 254 -     map.insert(0xE6, "minecraft:diamond_ore".into());
[INFO] [stdout] 254 +     map.insert(0xE6, "minecraft:diamond_ore");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 254 -     map.insert(0xE6, "minecraft:diamond_ore".into());
[INFO] [stdout] 254 +     map.insert(0xE6, <&str as Into<_>>::into("minecraft:diamond_ore"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:255:22
[INFO] [stdout]     |
[INFO] [stdout] 255 |     map.insert(0xE7, "minecraft:soul_torch".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 255 -     map.insert(0xE7, "minecraft:soul_torch".into());
[INFO] [stdout] 255 +     map.insert(0xE7, "minecraft:soul_torch");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 255 -     map.insert(0xE7, "minecraft:soul_torch".into());
[INFO] [stdout] 255 +     map.insert(0xE7, <&str as Into<_>>::into("minecraft:soul_torch"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:256:22
[INFO] [stdout]     |
[INFO] [stdout] 256 |     map.insert(0xE8, "minecraft:soul_wall_torch".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 256 -     map.insert(0xE8, "minecraft:soul_wall_torch".into());
[INFO] [stdout] 256 +     map.insert(0xE8, "minecraft:soul_wall_torch");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 256 -     map.insert(0xE8, "minecraft:soul_wall_torch".into());
[INFO] [stdout] 256 +     map.insert(0xE8, <&str as Into<_>>::into("minecraft:soul_wall_torch"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:257:22
[INFO] [stdout]     |
[INFO] [stdout] 257 |     map.insert(0xE9, "minecraft:mangrove_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 257 -     map.insert(0xE9, "minecraft:mangrove_planks".into());
[INFO] [stdout] 257 +     map.insert(0xE9, "minecraft:mangrove_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 -     map.insert(0xE9, "minecraft:mangrove_planks".into());
[INFO] [stdout] 257 +     map.insert(0xE9, <&str as Into<_>>::into("minecraft:mangrove_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:258:22
[INFO] [stdout]     |
[INFO] [stdout] 258 |     map.insert(0xEA, "minecraft:gravel".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 258 -     map.insert(0xEA, "minecraft:gravel".into());
[INFO] [stdout] 258 +     map.insert(0xEA, "minecraft:gravel");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 258 -     map.insert(0xEA, "minecraft:gravel".into());
[INFO] [stdout] 258 +     map.insert(0xEA, <&str as Into<_>>::into("minecraft:gravel"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:259:22
[INFO] [stdout]     |
[INFO] [stdout] 259 |     map.insert(0xEB, "minecraft:cracked_deepslate_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 259 -     map.insert(0xEB, "minecraft:cracked_deepslate_bricks".into());
[INFO] [stdout] 259 +     map.insert(0xEB, "minecraft:cracked_deepslate_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 -     map.insert(0xEB, "minecraft:cracked_deepslate_bricks".into());
[INFO] [stdout] 259 +     map.insert(0xEB, <&str as Into<_>>::into("minecraft:cracked_deepslate_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:260:22
[INFO] [stdout]     |
[INFO] [stdout] 260 |     map.insert(0xEC, "minecraft:cracked_deepslate_tiles".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 260 -     map.insert(0xEC, "minecraft:cracked_deepslate_tiles".into());
[INFO] [stdout] 260 +     map.insert(0xEC, "minecraft:cracked_deepslate_tiles");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 260 -     map.insert(0xEC, "minecraft:cracked_deepslate_tiles".into());
[INFO] [stdout] 260 +     map.insert(0xEC, <&str as Into<_>>::into("minecraft:cracked_deepslate_tiles"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:261:22
[INFO] [stdout]     |
[INFO] [stdout] 261 |     map.insert(0xED, "minecraft:cracked_nether_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 261 -     map.insert(0xED, "minecraft:cracked_nether_bricks".into());
[INFO] [stdout] 261 +     map.insert(0xED, "minecraft:cracked_nether_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 -     map.insert(0xED, "minecraft:cracked_nether_bricks".into());
[INFO] [stdout] 261 +     map.insert(0xED, <&str as Into<_>>::into("minecraft:cracked_nether_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:262:22
[INFO] [stdout]     |
[INFO] [stdout] 262 |     map.insert(0xEE, "minecraft:cracked_polished_blackstone_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 262 -     map.insert(0xEE, "minecraft:cracked_polished_blackstone_bricks".into());
[INFO] [stdout] 262 +     map.insert(0xEE, "minecraft:cracked_polished_blackstone_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 -     map.insert(0xEE, "minecraft:cracked_polished_blackstone_bricks".into());
[INFO] [stdout] 262 +     map.insert(0xEE, <&str as Into<_>>::into("minecraft:cracked_polished_blackstone_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:263:22
[INFO] [stdout]     |
[INFO] [stdout] 263 |     map.insert(0xEF, "minecraft:cracked_stone_bricks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 263 -     map.insert(0xEF, "minecraft:cracked_stone_bricks".into());
[INFO] [stdout] 263 +     map.insert(0xEF, "minecraft:cracked_stone_bricks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 263 -     map.insert(0xEF, "minecraft:cracked_stone_bricks".into());
[INFO] [stdout] 263 +     map.insert(0xEF, <&str as Into<_>>::into("minecraft:cracked_stone_bricks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:264:22
[INFO] [stdout]     |
[INFO] [stdout] 264 |     map.insert(0xF0, "minecraft:crafter".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 264 -     map.insert(0xF0, "minecraft:crafter".into());
[INFO] [stdout] 264 +     map.insert(0xF0, "minecraft:crafter");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 264 -     map.insert(0xF0, "minecraft:crafter".into());
[INFO] [stdout] 264 +     map.insert(0xF0, <&str as Into<_>>::into("minecraft:crafter"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:265:22
[INFO] [stdout]     |
[INFO] [stdout] 265 |     map.insert(0xF1, "minecraft:crafting_table".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 265 -     map.insert(0xF1, "minecraft:crafting_table".into());
[INFO] [stdout] 265 +     map.insert(0xF1, "minecraft:crafting_table");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 265 -     map.insert(0xF1, "minecraft:crafting_table".into());
[INFO] [stdout] 265 +     map.insert(0xF1, <&str as Into<_>>::into("minecraft:crafting_table"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:266:22
[INFO] [stdout]     |
[INFO] [stdout] 266 |     map.insert(0xF2, "minecraft:creaking_heart".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 266 -     map.insert(0xF2, "minecraft:creaking_heart".into());
[INFO] [stdout] 266 +     map.insert(0xF2, "minecraft:creaking_heart");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 266 -     map.insert(0xF2, "minecraft:creaking_heart".into());
[INFO] [stdout] 266 +     map.insert(0xF2, <&str as Into<_>>::into("minecraft:creaking_heart"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:267:22
[INFO] [stdout]     |
[INFO] [stdout] 267 |     map.insert(0xF3, "minecraft:creeper_head".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 267 -     map.insert(0xF3, "minecraft:creeper_head".into());
[INFO] [stdout] 267 +     map.insert(0xF3, "minecraft:creeper_head");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 -     map.insert(0xF3, "minecraft:creeper_head".into());
[INFO] [stdout] 267 +     map.insert(0xF3, <&str as Into<_>>::into("minecraft:creeper_head"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:268:22
[INFO] [stdout]     |
[INFO] [stdout] 268 |     map.insert(0xF4, "minecraft:oak_log".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 268 -     map.insert(0xF4, "minecraft:oak_log".into());
[INFO] [stdout] 268 +     map.insert(0xF4, "minecraft:oak_log");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 -     map.insert(0xF4, "minecraft:oak_log".into());
[INFO] [stdout] 268 +     map.insert(0xF4, <&str as Into<_>>::into("minecraft:oak_log"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:269:22
[INFO] [stdout]     |
[INFO] [stdout] 269 |     map.insert(0xF5, "minecraft:waxed_exposed_copper".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 269 -     map.insert(0xF5, "minecraft:waxed_exposed_copper".into());
[INFO] [stdout] 269 +     map.insert(0xF5, "minecraft:waxed_exposed_copper");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 269 -     map.insert(0xF5, "minecraft:waxed_exposed_copper".into());
[INFO] [stdout] 269 +     map.insert(0xF5, <&str as Into<_>>::into("minecraft:waxed_exposed_copper"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:270:22
[INFO] [stdout]     |
[INFO] [stdout] 270 |     map.insert(0xF6, "minecraft:waxed_weathered_copper".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 270 -     map.insert(0xF6, "minecraft:waxed_weathered_copper".into());
[INFO] [stdout] 270 +     map.insert(0xF6, "minecraft:waxed_weathered_copper");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 270 -     map.insert(0xF6, "minecraft:waxed_weathered_copper".into());
[INFO] [stdout] 270 +     map.insert(0xF6, <&str as Into<_>>::into("minecraft:waxed_weathered_copper"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:271:22
[INFO] [stdout]     |
[INFO] [stdout] 271 |     map.insert(0xF7, "minecraft:crimson_fence".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 271 -     map.insert(0xF7, "minecraft:crimson_fence".into());
[INFO] [stdout] 271 +     map.insert(0xF7, "minecraft:crimson_fence");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 271 -     map.insert(0xF7, "minecraft:crimson_fence".into());
[INFO] [stdout] 271 +     map.insert(0xF7, <&str as Into<_>>::into("minecraft:crimson_fence"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:272:22
[INFO] [stdout]     |
[INFO] [stdout] 272 |     map.insert(0xF8, "minecraft:crimson_fence_gate".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 272 -     map.insert(0xF8, "minecraft:crimson_fence_gate".into());
[INFO] [stdout] 272 +     map.insert(0xF8, "minecraft:crimson_fence_gate");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 -     map.insert(0xF8, "minecraft:crimson_fence_gate".into());
[INFO] [stdout] 272 +     map.insert(0xF8, <&str as Into<_>>::into("minecraft:crimson_fence_gate"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:273:22
[INFO] [stdout]     |
[INFO] [stdout] 273 |     map.insert(0xF9, "minecraft:warped_stem".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 273 -     map.insert(0xF9, "minecraft:warped_stem".into());
[INFO] [stdout] 273 +     map.insert(0xF9, "minecraft:warped_stem");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 273 -     map.insert(0xF9, "minecraft:warped_stem".into());
[INFO] [stdout] 273 +     map.insert(0xF9, <&str as Into<_>>::into("minecraft:warped_stem"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:274:22
[INFO] [stdout]     |
[INFO] [stdout] 274 |     map.insert(0xFA, "minecraft:waxed_oxidized_copper".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 274 -     map.insert(0xFA, "minecraft:waxed_oxidized_copper".into());
[INFO] [stdout] 274 +     map.insert(0xFA, "minecraft:waxed_oxidized_copper");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 274 -     map.insert(0xFA, "minecraft:waxed_oxidized_copper".into());
[INFO] [stdout] 274 +     map.insert(0xFA, <&str as Into<_>>::into("minecraft:waxed_oxidized_copper"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:275:22
[INFO] [stdout]     |
[INFO] [stdout] 275 |     map.insert(0xFB, "minecraft:crimson_hyphae".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 275 -     map.insert(0xFB, "minecraft:crimson_hyphae".into());
[INFO] [stdout] 275 +     map.insert(0xFB, "minecraft:crimson_hyphae");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 -     map.insert(0xFB, "minecraft:crimson_hyphae".into());
[INFO] [stdout] 275 +     map.insert(0xFB, <&str as Into<_>>::into("minecraft:crimson_hyphae"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:276:22
[INFO] [stdout]     |
[INFO] [stdout] 276 |     map.insert(0xFC, "minecraft:crimson_nylium".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 276 -     map.insert(0xFC, "minecraft:crimson_nylium".into());
[INFO] [stdout] 276 +     map.insert(0xFC, "minecraft:crimson_nylium");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 -     map.insert(0xFC, "minecraft:crimson_nylium".into());
[INFO] [stdout] 276 +     map.insert(0xFC, <&str as Into<_>>::into("minecraft:crimson_nylium"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:277:22
[INFO] [stdout]     |
[INFO] [stdout] 277 |     map.insert(0xFD, "minecraft:crimson_planks".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -     map.insert(0xFD, "minecraft:crimson_planks".into());
[INFO] [stdout] 277 +     map.insert(0xFD, "minecraft:crimson_planks");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -     map.insert(0xFD, "minecraft:crimson_planks".into());
[INFO] [stdout] 277 +     map.insert(0xFD, <&str as Into<_>>::into("minecraft:crimson_planks"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:278:22
[INFO] [stdout]     |
[INFO] [stdout] 278 |     map.insert(0xFE, "minecraft:stripped_crimson_stem".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 278 -     map.insert(0xFE, "minecraft:stripped_crimson_stem".into());
[INFO] [stdout] 278 +     map.insert(0xFE, "minecraft:stripped_crimson_stem");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 278 -     map.insert(0xFE, "minecraft:stripped_crimson_stem".into());
[INFO] [stdout] 278 +     map.insert(0xFE, <&str as Into<_>>::into("minecraft:stripped_crimson_stem"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/models/blocks.rs:279:22
[INFO] [stdout]     |
[INFO] [stdout] 279 |     map.insert(0xFF, "minecraft:purple_wool".into());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 279 -     map.insert(0xFF, "minecraft:purple_wool".into());
[INFO] [stdout] 279 +     map.insert(0xFF, "minecraft:purple_wool");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 279 -     map.insert(0xFF, "minecraft:purple_wool".into());
[INFO] [stdout] 279 +     map.insert(0xFF, <&str as Into<_>>::into("minecraft:purple_wool"));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `encode-image-to-minecraft` (bin "encode-image-to-minecraft") due to 256 previous errors
[INFO] running `Command { std: "docker" "inspect" "b0694ec76780ebac8586a80a070a77f536b9824ff6eed9ec1dd6ffb253e0621e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "b0694ec76780ebac8586a80a070a77f536b9824ff6eed9ec1dd6ffb253e0621e", kill_on_drop: false }`
[INFO] [stdout] b0694ec76780ebac8586a80a070a77f536b9824ff6eed9ec1dd6ffb253e0621e
