[INFO] cloning repository https://github.com/niomaster/smt-multiplex [INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/niomaster/smt-multiplex" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fniomaster%2Fsmt-multiplex", kill_on_drop: false }` [INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fniomaster%2Fsmt-multiplex'... [INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }` [INFO] [stdout] 376d349624633b999b6182274ce16b84a84f1317 [INFO] checking niomaster/smt-multiplex against master#1f12b9b0fdbe735968ac002792a720f0ba4faca6 for crater-rollup-uwu [INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fniomaster%2Fsmt-multiplex" "/workspace/builds/worker-7-tc1/source", kill_on_drop: false }` [INFO] [stderr] Cloning into '/workspace/builds/worker-7-tc1/source'... [INFO] [stderr] done. [INFO] validating manifest of git repo https://github.com/niomaster/smt-multiplex on toolchain 1f12b9b0fdbe735968ac002792a720f0ba4faca6 [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1f12b9b0fdbe735968ac002792a720f0ba4faca6" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] started tweaking git repo https://github.com/niomaster/smt-multiplex [INFO] finished tweaking git repo https://github.com/niomaster/smt-multiplex [INFO] tweaked toml for git repo https://github.com/niomaster/smt-multiplex written to /workspace/builds/worker-7-tc1/source/Cargo.toml [INFO] crate git repo https://github.com/niomaster/smt-multiplex 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" "+1f12b9b0fdbe735968ac002792a720f0ba4faca6" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Updating crates.io index [INFO] [stderr] Downloading crates ... [INFO] [stderr] Downloaded utf8-read v0.4.0 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:923055f121b5182466d55868a8b05e67af8ba4a3a3f6bad814e953ca3cd3ac2a" "/opt/rustwide/cargo-home/bin/cargo" "+1f12b9b0fdbe735968ac002792a720f0ba4faca6" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] ae03196c6f008d09ce166ace315b653f9a860ef2099e4ef9f464798b9d5a258e [INFO] running `Command { std: "docker" "start" "-a" "ae03196c6f008d09ce166ace315b653f9a860ef2099e4ef9f464798b9d5a258e", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "ae03196c6f008d09ce166ace315b653f9a860ef2099e4ef9f464798b9d5a258e", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "ae03196c6f008d09ce166ace315b653f9a860ef2099e4ef9f464798b9d5a258e", kill_on_drop: false }` [INFO] [stdout] ae03196c6f008d09ce166ace315b653f9a860ef2099e4ef9f464798b9d5a258e [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:923055f121b5182466d55868a8b05e67af8ba4a3a3f6bad814e953ca3cd3ac2a" "/opt/rustwide/cargo-home/bin/cargo" "+1f12b9b0fdbe735968ac002792a720f0ba4faca6" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] be34c6c9b8f0a32ad18e82e575ee50c8643e31b5fdca0acc5cd6518eb9a36574 [INFO] running `Command { std: "docker" "start" "-a" "be34c6c9b8f0a32ad18e82e575ee50c8643e31b5fdca0acc5cd6518eb9a36574", kill_on_drop: false }` [INFO] [stderr] Compiling autocfg v1.1.0 [INFO] [stderr] Compiling radium v0.7.0 [INFO] [stderr] Checking tap v1.0.1 [INFO] [stderr] Checking funty v2.0.0 [INFO] [stderr] Checking utf8-read v0.4.0 [INFO] [stderr] Checking wyz v0.5.0 [INFO] [stderr] Compiling num-traits v0.2.14 [INFO] [stderr] Compiling num-integer v0.1.44 [INFO] [stderr] Compiling num-bigint v0.4.3 [INFO] [stderr] Checking bitvec v1.0.0 [INFO] [stderr] Checking bigdecimal v0.3.0 [INFO] [stderr] Checking smt_multiplex v0.1.0 (/opt/rustwide/workdir) [INFO] [stdout] warning: unused variable: `f` [INFO] [stdout] --> src/display.rs:409:19 [INFO] [stdout] | [INFO] [stdout] 409 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { [INFO] [stdout] | ^ help: if this is intentional, prefix it with an underscore: `_f` [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_variables)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused variable: `result` [INFO] [stdout] --> src/smt_server.rs:74:17 [INFO] [stdout] | [INFO] [stdout] 74 | let result = match command { [INFO] [stdout] | ^^^^^^ help: if this is intentional, prefix it with an underscore: `_result` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused variable: `f` [INFO] [stdout] --> src/display.rs:409:19 [INFO] [stdout] | [INFO] [stdout] 409 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { [INFO] [stdout] | ^ help: if this is intentional, prefix it with an underscore: `_f` [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_variables)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused variable: `result` [INFO] [stdout] --> src/smt_server.rs:74:17 [INFO] [stdout] | [INFO] [stdout] 74 | let result = match command { [INFO] [stdout] | ^^^^^^ help: if this is intentional, prefix it with an underscore: `_result` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: 2 warnings emitted [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: 2 warnings emitted [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] Finished `dev` profile [unoptimized + debuginfo] target(s) in 2.28s [INFO] running `Command { std: "docker" "inspect" "be34c6c9b8f0a32ad18e82e575ee50c8643e31b5fdca0acc5cd6518eb9a36574", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "be34c6c9b8f0a32ad18e82e575ee50c8643e31b5fdca0acc5cd6518eb9a36574", kill_on_drop: false }` [INFO] [stdout] be34c6c9b8f0a32ad18e82e575ee50c8643e31b5fdca0acc5cd6518eb9a36574 [INFO] checking niomaster/smt-multiplex against try#f9935d29d867449445ee008640ccca1bf1ae0889+rustflags=-Dtail_expr_drop_order for crater-rollup-uwu [INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fniomaster%2Fsmt-multiplex" "/workspace/builds/worker-7-tc2/source", kill_on_drop: false }` [INFO] [stderr] Cloning into '/workspace/builds/worker-7-tc2/source'... [INFO] [stderr] done. [INFO] validating manifest of git repo https://github.com/niomaster/smt-multiplex on toolchain f9935d29d867449445ee008640ccca1bf1ae0889 [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+f9935d29d867449445ee008640ccca1bf1ae0889" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] started tweaking git repo https://github.com/niomaster/smt-multiplex [INFO] finished tweaking git repo https://github.com/niomaster/smt-multiplex [INFO] tweaked toml for git repo https://github.com/niomaster/smt-multiplex written to /workspace/builds/worker-7-tc2/source/Cargo.toml [INFO] crate git repo https://github.com/niomaster/smt-multiplex 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" "+f9935d29d867449445ee008640ccca1bf1ae0889" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:923055f121b5182466d55868a8b05e67af8ba4a3a3f6bad814e953ca3cd3ac2a" "/opt/rustwide/cargo-home/bin/cargo" "+f9935d29d867449445ee008640ccca1bf1ae0889" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] 74062464e5285f3c8c7d0cb8b1ab6bcc88967ce5cec7e476ac16e3441b3d9011 [INFO] running `Command { std: "docker" "start" "-a" "74062464e5285f3c8c7d0cb8b1ab6bcc88967ce5cec7e476ac16e3441b3d9011", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "74062464e5285f3c8c7d0cb8b1ab6bcc88967ce5cec7e476ac16e3441b3d9011", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "74062464e5285f3c8c7d0cb8b1ab6bcc88967ce5cec7e476ac16e3441b3d9011", kill_on_drop: false }` [INFO] [stdout] 74062464e5285f3c8c7d0cb8b1ab6bcc88967ce5cec7e476ac16e3441b3d9011 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid -Dtail_expr_drop_order" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:923055f121b5182466d55868a8b05e67af8ba4a3a3f6bad814e953ca3cd3ac2a" "/opt/rustwide/cargo-home/bin/cargo" "+f9935d29d867449445ee008640ccca1bf1ae0889" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 50ab9fe8a8bab54a26e6b017d4b1ddfc3e5839d2fc8edfde632818271453fcea [INFO] running `Command { std: "docker" "start" "-a" "50ab9fe8a8bab54a26e6b017d4b1ddfc3e5839d2fc8edfde632818271453fcea", kill_on_drop: false }` [INFO] [stderr] Compiling autocfg v1.1.0 [INFO] [stderr] Compiling radium v0.7.0 [INFO] [stderr] Checking tap v1.0.1 [INFO] [stderr] Checking funty v2.0.0 [INFO] [stderr] Checking utf8-read v0.4.0 [INFO] [stderr] Checking wyz v0.5.0 [INFO] [stderr] Compiling num-traits v0.2.14 [INFO] [stderr] Compiling num-integer v0.1.44 [INFO] [stderr] Compiling num-bigint v0.4.3 [INFO] [stderr] Checking bitvec v1.0.0 [INFO] [stderr] Checking bigdecimal v0.3.0 [INFO] [stderr] Checking smt_multiplex v0.1.0 (/opt/rustwide/workdir) [INFO] [stdout] warning: unused variable: `f` [INFO] [stdout] --> src/display.rs:409:19 [INFO] [stdout] | [INFO] [stdout] 409 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { [INFO] [stdout] | ^ help: if this is intentional, prefix it with an underscore: `_f` [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_variables)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused variable: `result` [INFO] [stdout] --> src/smt_server.rs:74:17 [INFO] [stdout] | [INFO] [stdout] 74 | let result = match command { [INFO] [stdout] | ^^^^^^ help: if this is intentional, prefix it with an underscore: `_result` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/lexer.rs:83:20 [INFO] [stdout] | [INFO] [stdout] 81 | pub fn new(read: R) -> Self { [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 82 | Self { [INFO] [stdout] 83 | input: Reader::new(read), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] = note: requested on the command line with `-D tail-expr-drop-order` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/lexer.rs:85:18 [INFO] [stdout] | [INFO] [stdout] 81 | pub fn new(read: R) -> Self { [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 85 | err: None, [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:62:20 [INFO] [stdout] | [INFO] [stdout] 58 | fn context(self, ctx: Context) -> Self { [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 62 | inner: Box::new(self), [INFO] [stdout] | ^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:81:33 [INFO] [stdout] | [INFO] [stdout] 80 | pub fn new(read: R) -> Self { [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 81 | Self::from_token_reader(lexer::TokenReader::new(read)) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:88:18 [INFO] [stdout] | [INFO] [stdout] 84 | pub fn from_token_reader(mut lexer: lexer::TokenReader) -> Self { [INFO] [stdout] | -------------------------------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 88 | buf: None, [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:131:12 [INFO] [stdout] | [INFO] [stdout] 122 | let mut alt_errs = Vec::::new(); [INFO] [stdout] | -------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 131 | Ok(Err(RecoverableParseError::NoAlt { rule: ctx.rule, alts: alt_errs })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:277:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 277 | Ok(Ok(SpecConst::Numeral(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:281:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 281 | Ok(Ok(SpecConst::Decimal(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:285:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 284 | let n = expect!(ctx, this.hexadecimal()); [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 285 | Ok(Ok(SpecConst::Hexadecimal(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:289:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 288 | let n = expect!(ctx, this.binary()); [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 289 | Ok(Ok(SpecConst::Binary(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:293:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 293 | Ok(Ok(SpecConst::String(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:303:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 301 | let args = then_expect!(ctx, self.star(&|this: &mut Self| this.s_expr())); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 302 | then_expect!(ctx, self.paren_close()); [INFO] [stdout] 303 | Ok(Ok(args)) [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:311:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 310 | let c = expect!(ctx, this.spec_constant()); [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 311 | Ok(Ok(SExpr::Const(c))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:315:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 315 | Ok(Ok(SExpr::Symbol(symb))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:319:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 319 | Ok(Ok(SExpr::Reserved(res))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:323:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 323 | Ok(Ok(SExpr::Keyword(kwd))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:327:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 326 | let args = expect!(ctx, this.s_expr_expr()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 327 | Ok(Ok(SExpr::Expr(args))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:337:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 337 | Ok(Ok(Index::Numeric(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:341:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 341 | Ok(Ok(Index::Symbol(s))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:350:12 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 350 | Ok(Ok(Identifier::Indexed(name, indices))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:358:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 358 | Ok(Ok(Identifier::Simple(name))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:365:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 365 | Ok(Ok(result)) [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:375:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 374 | let c = expect!(ctx, this.spec_constant()); [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 375 | Ok(Ok(AttributeValue::Const(c))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:379:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 379 | Ok(Ok(AttributeValue::Symbol(symb))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:383:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 382 | let args = expect!(ctx, this.s_expr_expr()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 383 | Ok(Ok(AttributeValue::Expr(args))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:393:12 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 391 | let value = then_expect!(ctx, self.maybe(&|this: &mut Self| this.attribute_value())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 392 | [INFO] [stdout] 393 | Ok(Ok(match value { [INFO] [stdout] | ____________^ [INFO] [stdout] 394 | | None => Attribute::Key(key), [INFO] [stdout] 395 | | Some(val) => Attribute::Pair(key, val) [INFO] [stdout] 396 | | })) [INFO] [stdout] | |__________^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:405:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 405 | Ok(Ok(Sort::Name(name))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:412:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 412 | Ok(Ok(Sort::Parametric(name, args))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:421:12 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 421 | Ok(Ok(QualifiedIdentifier::Qualified(name, sort))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:429:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 429 | Ok(Ok(QualifiedIdentifier::Simple(id))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:436:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 436 | Ok(Ok(result)) [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:447:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 445 | let value = then_expect!(ctx, self.term()); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 446 | then_expect!(ctx, self.paren_close()); [INFO] [stdout] 447 | Ok(Ok(VarBinding { name, value })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:456:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 456 | Ok(Ok(SortedVar { name, sort })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:464:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 464 | Ok(Ok(Pattern::Binding(name))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:471:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 471 | Ok(Ok(Pattern::Application { function, args })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:482:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 480 | let result = then_expect!(ctx, self.term()); [INFO] [stdout] | ------ these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 481 | then_expect!(ctx, self.paren_close()); [INFO] [stdout] 482 | Ok(Ok(MatchCase { pattern, result })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:490:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 489 | let c = expect!(ctx, this.spec_constant()); [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 490 | Ok(Ok(Term::Const(c))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:494:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 494 | Ok(Ok(Term::Name(QualifiedIdentifier::Simple(Identifier::Simple(name))))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:503:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 503 | Ok(Ok(Term::Name(QualifiedIdentifier::Simple(id)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:509:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 509 | Ok(Ok(Term::Name(id))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:515:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 514 | let args = then_expect!(ctx, this.plus(&|this: &mut Self| this.term())); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 515 | Ok(Ok(Term::Apply { function, args })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:524:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 521 | let bindings = then_expect!(ctx, this.plus(&|this: &mut Self| this.var_binding())); [INFO] [stdout] | -------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 522 | then_expect!(ctx, this.paren_close()); [INFO] [stdout] 523 | let body = then_expect!(ctx, this.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 524 | Ok(Ok(Term::Let { bindings, body: Box::new(body) })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:533:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 532 | let body = then_expect!(ctx, this.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 533 | Ok(Ok(Term::Forall { bindings, body: Box::new(body) })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:542:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 541 | let body = then_expect!(ctx, this.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 542 | Ok(Ok(Term::Exists { bindings, body: Box::new(body) })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:551:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 547 | let term = then_expect!(ctx, this.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 548 | then_expect!(ctx, this.paren_open()); [INFO] [stdout] 549 | let cases = then_expect!(ctx, this.plus(&|this: &mut Self| this.match_case())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 550 | then_expect!(ctx, this.paren_close()); [INFO] [stdout] 551 | Ok(Ok(Term::Match { term: Box::new(term), cases })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:559:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 556 | let term = then_expect!(ctx, this.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 557 | // SMT-LIB requires a non-zero attribute count [INFO] [stdout] 558 | let attributes = then_expect!(ctx, this.star(&|this: &mut Self| this.attribute())); [INFO] [stdout] | ---------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 559 | Ok(Ok(Term::Attributed { term: Box::new(term), attributes })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:576:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 576 | Ok(Ok(SortDec { name, idx })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:585:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 585 | Ok(Ok(SelectorDec { name, sort })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:594:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 594 | Ok(Ok(ConstructorDec { name, selectors })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:602:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 602 | Ok(Ok(DatatypeDec { params: vec![], constructors })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:612:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 612 | Ok(Ok(DatatypeDec { params, constructors })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:622:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 622 | Ok(Ok(result)) [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:631:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 631 | Ok(Ok((SortDec { name, idx: 0u32.into() }, dec))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:641:12 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 641 | Ok(Ok(FunctionDec { name, sort, args })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:649:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 649 | Ok(Ok(result)) [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:656:12 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 655 | let body = then_expect!(ctx, self.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 656 | Ok(Ok(FunctionDef { dec, body })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:664:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 664 | Ok(Ok(PropLiteral::Positive(name))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:671:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 671 | Ok(Ok(PropLiteral::Negative(name))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:844:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 679 | let result = then_expect!(ctx, self.alts(ctx, vec![ [INFO] [stdout] | ------ these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 844 | Ok(Ok(result)) [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:693:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 693 | Ok(Ok(ScriptCommand::CheckSatAssuming(literals))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:699:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 699 | Ok(Ok(ScriptCommand::DeclareConst(name, sort))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:705:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 705 | Ok(Ok(ScriptCommand::DeclareDatatype(name, dec))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:729:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 729 | Ok(Ok(ScriptCommand::DeclareDatatypes(sort_decs, datatype_decs))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:718:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 718 | Ok(Ok((sort_decs, datatype_decs))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:726:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 726 | Ok(Ok(sort_datatype_decs.into_iter().unzip())) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:738:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 738 | Ok(Ok(ScriptCommand::DeclareFun { name, sort, args })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:745:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 745 | Ok(Ok(ScriptCommand::DeclareSort(name, idx))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:753:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 752 | let value = then_expect!(ctx, this.term()); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 753 | Ok(Ok(ScriptCommand::DefineConst(name, sort, value))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:758:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 757 | let dec = then_expect!(ctx, this.function_def()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 758 | Ok(Ok(ScriptCommand::DefineFun(dec))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:763:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 762 | let dec = then_expect!(ctx, this.function_def()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 763 | Ok(Ok(ScriptCommand::DefineFunRec(dec))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:773:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 771 | let bodies = then_expect!(ctx, this.plus(&|this: &mut Self| this.term())); [INFO] [stdout] | ------ these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 772 | then_expect!(ctx, this.paren_close()); [INFO] [stdout] 773 | Ok(Ok(ScriptCommand::DefineFunsRec(decs, bodies))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:782:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 782 | Ok(Ok(ScriptCommand::DefineSort { name, args, def })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:787:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 787 | Ok(Ok(ScriptCommand::Echo(message))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:795:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 795 | Ok(Ok(ScriptCommand::GetInfo(what))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:801:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 801 | Ok(Ok(ScriptCommand::GetOption(what))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:811:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 809 | let terms = then_expect!(ctx, this.plus(&|this: &mut Self| this.term())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 810 | then_expect!(ctx, this.paren_close()); [INFO] [stdout] 811 | Ok(Ok(ScriptCommand::GetValue(terms))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:817:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 817 | Ok(Ok(ScriptCommand::Pop(count))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:823:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 823 | Ok(Ok(ScriptCommand::Push(count))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:830:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 829 | let what = then_expect!(ctx, this.attribute()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 830 | Ok(Ok(ScriptCommand::SetInfo(what))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:835:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 835 | Ok(Ok(ScriptCommand::SetLogic(logic))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:840:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 839 | let setting = then_expect!(ctx, this.attribute()); [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 840 | Ok(Ok(ScriptCommand::SetOption(setting))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:864:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 862 | let err = then_expect!(ctx, self.error_inner()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 863 | then_expect!(ctx, self.paren_close()); [INFO] [stdout] 864 | Ok(Ok(err)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:908:35 [INFO] [stdout] | [INFO] [stdout] 908 | &|this: &mut Self| Ok(Ok(Ok(EchoResponse(expect!(ctx, this.string()))))), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:924:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 919 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 924 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:921:43 [INFO] [stdout] | [INFO] [stdout] 921 | &|this: &mut Self| Ok(Ok(Ok(GetAssertionsResponse(expect!(ctx, this.star(&|this: &mut Self| this.term())))))), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:938:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 938 | Ok(Ok((name, v))) [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:955:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 955 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:951:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 951 | Ok(Ok(Ok(GetAssignmentResponse(pairs)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:974:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 966 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 974 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:970:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 969 | let pairs = expect!(ctx, this.star(&|this: &mut Self| this.attribute())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 970 | Ok(Ok(Ok(GetInfoResponse(pairs)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1005:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 982 | let res = then_expect!(ctx, self.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1005 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:986:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 985 | let def = then_expect!(ctx, this.function_def()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 986 | Ok(Ok(ModelResponse::Func(def))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:991:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 990 | let def = then_expect!(ctx, this.function_def()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 991 | Ok(Ok(ModelResponse::RecFunc(def))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1001:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 999 | let bodies = then_expect!(ctx, this.plus(&|this: &mut Self| this.term())); [INFO] [stdout] | ------ these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1000 | then_expect!(ctx, this.paren_close()); [INFO] [stdout] 1001 | Ok(Ok(ModelResponse::RecFuncs(decs, bodies))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1022:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1014 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1022 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1018:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1017 | let pairs = expect!(ctx, this.star(&|this: &mut Self| this.model_response())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1018 | Ok(Ok(Ok(GetModelResponse(pairs)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1042:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1034 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1042 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1038:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1037 | let args = expect!(ctx, this.star(&|this: &mut Self| this.s_expr())); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1038 | Ok(Ok(Ok(GetOptionResponse(AttributeValue::Expr(args))))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1044:83 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1044 | &|this: &mut Self| { let v = expect!(ctx, this.attribute_value()); Ok(Ok(Ok(GetOptionResponse(v)))) }, [INFO] [stdout] | - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1063:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1055 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1063 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1059:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1058 | let args = expect!(ctx, this.star(&|this: &mut Self| this.s_expr())); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1059 | Ok(Ok(Ok(GetProofResponse(SExpr::Expr(args))))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused variable: `f` [INFO] [stdout] --> src/display.rs:409:19 [INFO] [stdout] | [INFO] [stdout] 409 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { [INFO] [stdout] | ^ help: if this is intentional, prefix it with an underscore: `_f` [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_variables)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1065:74 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1065 | &|this: &mut Self| { let v = expect!(ctx, this.s_expr()); Ok(Ok(Ok(GetProofResponse(v)))) }, [INFO] [stdout] | - ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1083:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1083 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused variable: `result` [INFO] [stdout] --> src/smt_server.rs:74:17 [INFO] [stdout] | [INFO] [stdout] 74 | let result = match command { [INFO] [stdout] | ^^^^^^ help: if this is intentional, prefix it with an underscore: `_result` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1079:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1079 | Ok(Ok(Ok(GetUnsatAssumptionsResponse(args)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1102:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1102 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1098:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1098 | Ok(Ok(Ok(GetUnsatCoreResponse(args)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1113:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1110 | let key = then_expect!(ctx, self.term()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1111 | let value = then_expect!(ctx, self.term()); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1112 | then_expect!(ctx, self.paren_close()); [INFO] [stdout] 1113 | Ok(Ok((key, value))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1130:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1122 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1130 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1126:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1125 | let pairs = expect!(ctx, this.star(&|this: &mut Self| this.valuation_pair())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1126 | Ok(Ok(Ok(GetValueResponse(pairs)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1144:21 [INFO] [stdout] | [INFO] [stdout] 1142 | pub fn new(read: R) -> Self { [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1143 | Self { [INFO] [stdout] 1144 | parser: Parser::new(read), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1145:18 [INFO] [stdout] | [INFO] [stdout] 1142 | pub fn new(read: R) -> Self { [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1145 | err: None, [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/smt_client.rs:11:24 [INFO] [stdout] | [INFO] [stdout] 10 | pub fn new(reader: R, writer: W) -> Self { [INFO] [stdout] | --------- --------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 11 | Self { reader: Parser::new(reader), writer } [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/smt_server.rs:66:24 [INFO] [stdout] | [INFO] [stdout] 65 | pub fn new(read: R, write: W, solver: S) -> Self { [INFO] [stdout] | ------- -------- --------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | | | [INFO] [stdout] | | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 66 | Self { reader: ScriptParser::new(read), writer: write, solver, print_success: true } [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/lexer.rs:83:20 [INFO] [stdout] | [INFO] [stdout] 81 | pub fn new(read: R) -> Self { [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 82 | Self { [INFO] [stdout] 83 | input: Reader::new(read), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] = note: requested on the command line with `-D tail-expr-drop-order` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/lexer.rs:85:18 [INFO] [stdout] | [INFO] [stdout] 81 | pub fn new(read: R) -> Self { [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 85 | err: None, [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:62:20 [INFO] [stdout] | [INFO] [stdout] 58 | fn context(self, ctx: Context) -> Self { [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 62 | inner: Box::new(self), [INFO] [stdout] | ^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:81:33 [INFO] [stdout] | [INFO] [stdout] 80 | pub fn new(read: R) -> Self { [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 81 | Self::from_token_reader(lexer::TokenReader::new(read)) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:88:18 [INFO] [stdout] | [INFO] [stdout] 84 | pub fn from_token_reader(mut lexer: lexer::TokenReader) -> Self { [INFO] [stdout] | -------------------------------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 88 | buf: None, [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:131:12 [INFO] [stdout] | [INFO] [stdout] 122 | let mut alt_errs = Vec::::new(); [INFO] [stdout] | -------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 131 | Ok(Err(RecoverableParseError::NoAlt { rule: ctx.rule, alts: alt_errs })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:277:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 277 | Ok(Ok(SpecConst::Numeral(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:281:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 281 | Ok(Ok(SpecConst::Decimal(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:285:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 284 | let n = expect!(ctx, this.hexadecimal()); [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 285 | Ok(Ok(SpecConst::Hexadecimal(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:289:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 288 | let n = expect!(ctx, this.binary()); [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 289 | Ok(Ok(SpecConst::Binary(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:293:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 293 | Ok(Ok(SpecConst::String(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:303:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 301 | let args = then_expect!(ctx, self.star(&|this: &mut Self| this.s_expr())); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 302 | then_expect!(ctx, self.paren_close()); [INFO] [stdout] 303 | Ok(Ok(args)) [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:311:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 310 | let c = expect!(ctx, this.spec_constant()); [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 311 | Ok(Ok(SExpr::Const(c))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:315:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 315 | Ok(Ok(SExpr::Symbol(symb))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:319:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 319 | Ok(Ok(SExpr::Reserved(res))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:323:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 323 | Ok(Ok(SExpr::Keyword(kwd))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:327:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 326 | let args = expect!(ctx, this.s_expr_expr()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 327 | Ok(Ok(SExpr::Expr(args))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:337:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 337 | Ok(Ok(Index::Numeric(n))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:341:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 341 | Ok(Ok(Index::Symbol(s))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:350:12 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 350 | Ok(Ok(Identifier::Indexed(name, indices))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:358:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 358 | Ok(Ok(Identifier::Simple(name))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:365:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 365 | Ok(Ok(result)) [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:375:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 374 | let c = expect!(ctx, this.spec_constant()); [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 375 | Ok(Ok(AttributeValue::Const(c))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:379:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 379 | Ok(Ok(AttributeValue::Symbol(symb))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:383:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 382 | let args = expect!(ctx, this.s_expr_expr()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 383 | Ok(Ok(AttributeValue::Expr(args))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:393:12 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 391 | let value = then_expect!(ctx, self.maybe(&|this: &mut Self| this.attribute_value())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 392 | [INFO] [stdout] 393 | Ok(Ok(match value { [INFO] [stdout] | ____________^ [INFO] [stdout] 394 | | None => Attribute::Key(key), [INFO] [stdout] 395 | | Some(val) => Attribute::Pair(key, val) [INFO] [stdout] 396 | | })) [INFO] [stdout] | |__________^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:405:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 405 | Ok(Ok(Sort::Name(name))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:412:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 412 | Ok(Ok(Sort::Parametric(name, args))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:421:12 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 421 | Ok(Ok(QualifiedIdentifier::Qualified(name, sort))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:429:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 429 | Ok(Ok(QualifiedIdentifier::Simple(id))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:436:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 436 | Ok(Ok(result)) [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:447:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 445 | let value = then_expect!(ctx, self.term()); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 446 | then_expect!(ctx, self.paren_close()); [INFO] [stdout] 447 | Ok(Ok(VarBinding { name, value })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:456:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 456 | Ok(Ok(SortedVar { name, sort })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:464:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 464 | Ok(Ok(Pattern::Binding(name))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:471:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 471 | Ok(Ok(Pattern::Application { function, args })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:482:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 480 | let result = then_expect!(ctx, self.term()); [INFO] [stdout] | ------ these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 481 | then_expect!(ctx, self.paren_close()); [INFO] [stdout] 482 | Ok(Ok(MatchCase { pattern, result })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:490:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 489 | let c = expect!(ctx, this.spec_constant()); [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 490 | Ok(Ok(Term::Const(c))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:494:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 494 | Ok(Ok(Term::Name(QualifiedIdentifier::Simple(Identifier::Simple(name))))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:503:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 503 | Ok(Ok(Term::Name(QualifiedIdentifier::Simple(id)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:509:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 509 | Ok(Ok(Term::Name(id))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:515:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 514 | let args = then_expect!(ctx, this.plus(&|this: &mut Self| this.term())); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 515 | Ok(Ok(Term::Apply { function, args })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:524:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 521 | let bindings = then_expect!(ctx, this.plus(&|this: &mut Self| this.var_binding())); [INFO] [stdout] | -------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 522 | then_expect!(ctx, this.paren_close()); [INFO] [stdout] 523 | let body = then_expect!(ctx, this.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 524 | Ok(Ok(Term::Let { bindings, body: Box::new(body) })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: aborting due to 113 previous errors; 2 warnings emitted [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:533:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 532 | let body = then_expect!(ctx, this.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 533 | Ok(Ok(Term::Forall { bindings, body: Box::new(body) })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:542:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 541 | let body = then_expect!(ctx, this.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 542 | Ok(Ok(Term::Exists { bindings, body: Box::new(body) })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:551:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 547 | let term = then_expect!(ctx, this.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 548 | then_expect!(ctx, this.paren_open()); [INFO] [stdout] 549 | let cases = then_expect!(ctx, this.plus(&|this: &mut Self| this.match_case())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 550 | then_expect!(ctx, this.paren_close()); [INFO] [stdout] 551 | Ok(Ok(Term::Match { term: Box::new(term), cases })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:559:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 556 | let term = then_expect!(ctx, this.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 557 | // SMT-LIB requires a non-zero attribute count [INFO] [stdout] 558 | let attributes = then_expect!(ctx, this.star(&|this: &mut Self| this.attribute())); [INFO] [stdout] | ---------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 559 | Ok(Ok(Term::Attributed { term: Box::new(term), attributes })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:576:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 576 | Ok(Ok(SortDec { name, idx })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `smt_multiplex` (bin "smt_multiplex" test) due to 114 previous errors; 2 warnings emitted [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:585:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 585 | Ok(Ok(SelectorDec { name, sort })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:594:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 594 | Ok(Ok(ConstructorDec { name, selectors })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:602:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 602 | Ok(Ok(DatatypeDec { params: vec![], constructors })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:612:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 612 | Ok(Ok(DatatypeDec { params, constructors })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:622:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 622 | Ok(Ok(result)) [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:631:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 631 | Ok(Ok((SortDec { name, idx: 0u32.into() }, dec))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:641:12 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 641 | Ok(Ok(FunctionDec { name, sort, args })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:649:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 649 | Ok(Ok(result)) [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:656:12 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 655 | let body = then_expect!(ctx, self.term()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 656 | Ok(Ok(FunctionDef { dec, body })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:664:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 664 | Ok(Ok(PropLiteral::Positive(name))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:671:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 671 | Ok(Ok(PropLiteral::Negative(name))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:844:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 679 | let result = then_expect!(ctx, self.alts(ctx, vec![ [INFO] [stdout] | ------ these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 844 | Ok(Ok(result)) [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:693:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 693 | Ok(Ok(ScriptCommand::CheckSatAssuming(literals))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:699:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 699 | Ok(Ok(ScriptCommand::DeclareConst(name, sort))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:705:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 705 | Ok(Ok(ScriptCommand::DeclareDatatype(name, dec))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:729:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 729 | Ok(Ok(ScriptCommand::DeclareDatatypes(sort_decs, datatype_decs))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:718:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 718 | Ok(Ok((sort_decs, datatype_decs))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:726:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 726 | Ok(Ok(sort_datatype_decs.into_iter().unzip())) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:738:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 738 | Ok(Ok(ScriptCommand::DeclareFun { name, sort, args })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:745:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 745 | Ok(Ok(ScriptCommand::DeclareSort(name, idx))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:753:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 752 | let value = then_expect!(ctx, this.term()); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 753 | Ok(Ok(ScriptCommand::DefineConst(name, sort, value))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:758:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 757 | let dec = then_expect!(ctx, this.function_def()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 758 | Ok(Ok(ScriptCommand::DefineFun(dec))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:763:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 762 | let dec = then_expect!(ctx, this.function_def()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 763 | Ok(Ok(ScriptCommand::DefineFunRec(dec))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:773:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 771 | let bodies = then_expect!(ctx, this.plus(&|this: &mut Self| this.term())); [INFO] [stdout] | ------ these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 772 | then_expect!(ctx, this.paren_close()); [INFO] [stdout] 773 | Ok(Ok(ScriptCommand::DefineFunsRec(decs, bodies))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:782:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 782 | Ok(Ok(ScriptCommand::DefineSort { name, args, def })) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:787:20 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 787 | Ok(Ok(ScriptCommand::Echo(message))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:795:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 795 | Ok(Ok(ScriptCommand::GetInfo(what))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:801:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 801 | Ok(Ok(ScriptCommand::GetOption(what))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:811:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 809 | let terms = then_expect!(ctx, this.plus(&|this: &mut Self| this.term())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 810 | then_expect!(ctx, this.paren_close()); [INFO] [stdout] 811 | Ok(Ok(ScriptCommand::GetValue(terms))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:817:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 817 | Ok(Ok(ScriptCommand::Pop(count))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:823:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 823 | Ok(Ok(ScriptCommand::Push(count))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:830:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 829 | let what = then_expect!(ctx, this.attribute()); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 830 | Ok(Ok(ScriptCommand::SetInfo(what))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:835:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 835 | Ok(Ok(ScriptCommand::SetLogic(logic))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:840:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 839 | let setting = then_expect!(ctx, this.attribute()); [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 840 | Ok(Ok(ScriptCommand::SetOption(setting))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:864:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 862 | let err = then_expect!(ctx, self.error_inner()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 863 | then_expect!(ctx, self.paren_close()); [INFO] [stdout] 864 | Ok(Ok(err)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:908:35 [INFO] [stdout] | [INFO] [stdout] 908 | &|this: &mut Self| Ok(Ok(Ok(EchoResponse(expect!(ctx, this.string()))))), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:924:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 919 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 924 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:921:43 [INFO] [stdout] | [INFO] [stdout] 921 | &|this: &mut Self| Ok(Ok(Ok(GetAssertionsResponse(expect!(ctx, this.star(&|this: &mut Self| this.term())))))), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:938:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 938 | Ok(Ok((name, v))) [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:955:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 955 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:951:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 951 | Ok(Ok(Ok(GetAssignmentResponse(pairs)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:974:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 966 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 974 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:970:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 969 | let pairs = expect!(ctx, this.star(&|this: &mut Self| this.attribute())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 970 | Ok(Ok(Ok(GetInfoResponse(pairs)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1005:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 982 | let res = then_expect!(ctx, self.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1005 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:986:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 985 | let def = then_expect!(ctx, this.function_def()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 986 | Ok(Ok(ModelResponse::Func(def))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:991:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 990 | let def = then_expect!(ctx, this.function_def()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 991 | Ok(Ok(ModelResponse::RecFunc(def))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1001:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 999 | let bodies = then_expect!(ctx, this.plus(&|this: &mut Self| this.term())); [INFO] [stdout] | ------ these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1000 | then_expect!(ctx, this.paren_close()); [INFO] [stdout] 1001 | Ok(Ok(ModelResponse::RecFuncs(decs, bodies))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1022:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1014 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1022 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1018:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1017 | let pairs = expect!(ctx, this.star(&|this: &mut Self| this.model_response())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1018 | Ok(Ok(Ok(GetModelResponse(pairs)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1042:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1034 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1042 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1038:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1037 | let args = expect!(ctx, this.star(&|this: &mut Self| this.s_expr())); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1038 | Ok(Ok(Ok(GetOptionResponse(AttributeValue::Expr(args))))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1044:83 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1044 | &|this: &mut Self| { let v = expect!(ctx, this.attribute_value()); Ok(Ok(Ok(GetOptionResponse(v)))) }, [INFO] [stdout] | - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1063:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1055 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1063 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1059:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1058 | let args = expect!(ctx, this.star(&|this: &mut Self| this.s_expr())); [INFO] [stdout] | ---- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1059 | Ok(Ok(Ok(GetProofResponse(SExpr::Expr(args))))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1065:74 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1065 | &|this: &mut Self| { let v = expect!(ctx, this.s_expr()); Ok(Ok(Ok(GetProofResponse(v)))) }, [INFO] [stdout] | - ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1083:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1083 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1079:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1079 | Ok(Ok(Ok(GetUnsatAssumptionsResponse(args)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1102:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1102 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1098:28 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1098 | Ok(Ok(Ok(GetUnsatCoreResponse(args)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1113:12 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1110 | let key = then_expect!(ctx, self.term()); [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1111 | let value = then_expect!(ctx, self.term()); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1112 | then_expect!(ctx, self.paren_close()); [INFO] [stdout] 1113 | Ok(Ok((key, value))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1130:20 [INFO] [stdout] | [INFO] [stdout] 35 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 36 | Ok(Err(e)) => { return Err(UnrecoverableParseFailure::NoBacktrack { rule: $ctx.rule, loc: $ctx.loc, inner: e }); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 37 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1122 | let res = then_expect!(ctx, this.alts(ctx, vec![ [INFO] [stdout] | --- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1130 | Ok(Ok(res)) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1126:28 [INFO] [stdout] | [INFO] [stdout] 25 | Err(e) => { return Err(e.context($ctx)); }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 26 | Ok(Err(e)) => { return Ok(Err(RecoverableParseError::Context { rule: $ctx.rule, inner: Box::new(e) })) }, [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 27 | Ok(Ok(e)) => e [INFO] [stdout] | - these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1125 | let pairs = expect!(ctx, this.star(&|this: &mut Self| this.valuation_pair())); [INFO] [stdout] | ----- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1126 | Ok(Ok(Ok(GetValueResponse(pairs)))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1144:21 [INFO] [stdout] | [INFO] [stdout] 1142 | pub fn new(read: R) -> Self { [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 1143 | Self { [INFO] [stdout] 1144 | parser: Parser::new(read), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/parser.rs:1145:18 [INFO] [stdout] | [INFO] [stdout] 1142 | pub fn new(read: R) -> Self { [INFO] [stdout] | ------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] ... [INFO] [stdout] 1145 | err: None, [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/smt_client.rs:11:24 [INFO] [stdout] | [INFO] [stdout] 10 | pub fn new(reader: R, writer: W) -> Self { [INFO] [stdout] | --------- --------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | | [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 11 | Self { reader: Parser::new(reader), writer } [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021 [INFO] [stdout] --> src/smt_server.rs:66:24 [INFO] [stdout] | [INFO] [stdout] 65 | pub fn new(read: R, write: W, solver: S) -> Self { [INFO] [stdout] | ------- -------- --------- these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | | | [INFO] [stdout] | | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] | these values have significant drop implementation and will observe changes in drop order under Edition 2024 [INFO] [stdout] 66 | Self { reader: ScriptParser::new(read), writer: write, solver, print_success: true } [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #123739 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: aborting due to 113 previous errors; 2 warnings emitted [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `smt_multiplex` (bin "smt_multiplex") due to 114 previous errors; 2 warnings emitted [INFO] running `Command { std: "docker" "inspect" "50ab9fe8a8bab54a26e6b017d4b1ddfc3e5839d2fc8edfde632818271453fcea", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "50ab9fe8a8bab54a26e6b017d4b1ddfc3e5839d2fc8edfde632818271453fcea", kill_on_drop: false }` [INFO] [stdout] 50ab9fe8a8bab54a26e6b017d4b1ddfc3e5839d2fc8edfde632818271453fcea