[INFO] fetching crate ra_ap_syntax 0.0.241... [INFO] checking ra_ap_syntax-0.0.241 against try#da25749bf5e6ba5ed862ff361c19afff2a986b2d for pr-132712 [INFO] extracting crate ra_ap_syntax 0.0.241 into /workspace/builds/worker-7-tc2/source [INFO] validating manifest of crates.io crate ra_ap_syntax 0.0.241 on toolchain da25749bf5e6ba5ed862ff361c19afff2a986b2d [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+da25749bf5e6ba5ed862ff361c19afff2a986b2d" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] started tweaking crates.io crate ra_ap_syntax 0.0.241 [INFO] finished tweaking crates.io crate ra_ap_syntax 0.0.241 [INFO] tweaked toml for crates.io crate ra_ap_syntax 0.0.241 written to /workspace/builds/worker-7-tc2/source/Cargo.toml [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+da25749bf5e6ba5ed862ff361c19afff2a986b2d" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Updating crates.io index [INFO] [stderr] Locking 71 packages to latest compatible versions [INFO] [stderr] Adding itertools v0.12.1 (available: v0.13.0) [INFO] [stderr] Adding ra-ap-rustc_lexer v0.73.0 (available: v0.77.0) [INFO] [stderr] Adding rowan v0.15.15 (available: v0.15.16) [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+da25749bf5e6ba5ed862ff361c19afff2a986b2d" "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:4a844ea9eb2546a2d2c7022eacef16ef2e8229c7fbb2c7d4d55a9ceca922f72d" "/opt/rustwide/cargo-home/bin/cargo" "+da25749bf5e6ba5ed862ff361c19afff2a986b2d" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] 254de85d093074e4f6d3d42b8d53d51ea04e46014061ae66322668e88eaf2419 [INFO] running `Command { std: "docker" "start" "-a" "254de85d093074e4f6d3d42b8d53d51ea04e46014061ae66322668e88eaf2419", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "254de85d093074e4f6d3d42b8d53d51ea04e46014061ae66322668e88eaf2419", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "254de85d093074e4f6d3d42b8d53d51ea04e46014061ae66322668e88eaf2419", kill_on_drop: false }` [INFO] [stdout] 254de85d093074e4f6d3d42b8d53d51ea04e46014061ae66322668e88eaf2419 [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=allow" "-e" "RUSTDOCFLAGS=--cap-lints=allow" "-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:4a844ea9eb2546a2d2c7022eacef16ef2e8229c7fbb2c7d4d55a9ceca922f72d" "/opt/rustwide/cargo-home/bin/cargo" "+da25749bf5e6ba5ed862ff361c19afff2a986b2d" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 42f3b465f785a773275c6f49a0272baf4bee426684f7b0f8ed1b34c2643c4c2a [INFO] running `Command { std: "docker" "start" "-a" "42f3b465f785a773275c6f49a0272baf4bee426684f7b0f8ed1b34c2643c4c2a", kill_on_drop: false }` [INFO] [stderr] Copying to /tmp/fixit [INFO] [stderr] Running `cargo fix --edition` [INFO] [stderr] Migrating Cargo.toml from 2021 edition to 2024 [INFO] [stderr] Checking unicode-properties v0.1.3 [INFO] [stderr] Checking text-size v1.1.1 [INFO] [stderr] Compiling rustc_apfloat v0.2.1+llvm-462a31f5a5ab [INFO] [stderr] Checking drop_bomb v0.1.5 [INFO] [stderr] Compiling memoffset v0.9.1 [INFO] [stderr] Checking itertools v0.12.1 [INFO] [stderr] Checking countme v3.0.1 [INFO] [stderr] Checking hashbrown v0.14.5 [INFO] [stderr] Checking ra_ap_limit v0.0.241 [INFO] [stderr] Checking jod-thread v0.1.2 [INFO] [stderr] Checking dissimilar v1.0.9 [INFO] [stderr] Compiling syn v2.0.87 [INFO] [stderr] Checking crossbeam-channel v0.5.13 [INFO] [stderr] Checking cov-mark v2.0.0 [INFO] [stderr] Checking smol_str v0.3.2 [INFO] [stderr] Checking triomphe v0.1.14 [INFO] [stderr] Checking smallvec v1.13.2 [INFO] [stderr] Checking rayon v1.10.0 [INFO] [stderr] Checking ra-ap-rustc_lexer v0.73.0 [INFO] [stderr] Checking expect-test v1.5.0 [INFO] [stderr] Checking rowan v0.15.15 [INFO] [stderr] Checking ra_ap_text_edit v0.0.241 [INFO] [stderr] Compiling tracing-attributes v0.1.27 [INFO] [stderr] Checking tracing v0.1.40 [INFO] [stderr] Checking always-assert v0.2.0 [INFO] [stderr] Checking ra_ap_parser v0.0.241 [INFO] [stderr] Checking ra_ap_stdx v0.0.241 [INFO] [stderr] Checking ra_ap_syntax v0.0.241 (/tmp/fixit) [INFO] [stderr] Migrating src/lib.rs from 2021 edition to 2024 [INFO] [stderr] warning: failed to automatically apply fixes suggested by rustc to crate `ra_ap_syntax` [INFO] [stderr] [INFO] [stderr] after fixes were automatically applied the compiler reported errors within these files: [INFO] [stderr] [INFO] [stderr] * src/ast/generated/nodes.rs [INFO] [stderr] [INFO] [stderr] This likely indicates a bug in either rustc or cargo itself, [INFO] [stderr] and we would appreciate a bug report! You're likely to see [INFO] [stderr] a number of compiler warnings after this message which cargo [INFO] [stderr] attempted to fix but failed. If you could open an issue at [INFO] [stderr] https://github.com/rust-lang/rust/issues [INFO] [stderr] quoting the full output of this command we'd be very appreciative! [INFO] [stderr] Note that you may be able to make some more progress in the near-term [INFO] [stderr] fixing code with the `--broken-code` flag [INFO] [stderr] [INFO] [stderr] The following errors were reported: [INFO] [stderr] error: no rules expected `r#gen` [INFO] [stderr] --> src/ast/generated/nodes.rs:669:86 [INFO] [stderr] | [INFO] [stderr] 669 | pub fn gen_token(&self) -> Option { support::token(&self.syntax, T![r#gen]) } [INFO] [stderr] | ^^^^^ no rules expected this token in macro call [INFO] [stderr] | [INFO] [stderr] note: while trying to match `$` [INFO] [stderr] --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/ra_ap_parser-0.0.241/src/syntax_kind/generated.rs:716:20 [INFO] [stderr] | [INFO] [stderr] 716 | macro_rules ! T { [$] => { $ crate :: SyntaxKind :: DOLLAR } ; [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: Syntax... [INFO] [stderr] | ^ [INFO] [stderr] [INFO] [stderr] error: no rules expected `r#gen` [INFO] [stderr] --> src/ast/generated/nodes.rs:456:86 [INFO] [stderr] | [INFO] [stderr] 456 | pub fn gen_token(&self) -> Option { support::token(&self.syntax, T![r#gen]) } [INFO] [stderr] | ^^^^^ no rules expected this token in macro call [INFO] [stderr] | [INFO] [stderr] note: while trying to match `$` [INFO] [stderr] --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/ra_ap_parser-0.0.241/src/syntax_kind/generated.rs:716:20 [INFO] [stderr] | [INFO] [stderr] 716 | macro_rules ! T { [$] => { $ crate :: SyntaxKind :: DOLLAR } ; [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: Syntax... [INFO] [stderr] | ^ [INFO] [stderr] [INFO] [stderr] error: no rules expected `r#gen` [INFO] [stderr] --> src/ast/generated/nodes.rs:369:86 [INFO] [stderr] | [INFO] [stderr] 369 | pub fn gen_token(&self) -> Option { support::token(&self.syntax, T![r#gen]) } [INFO] [stderr] | ^^^^^ no rules expected this token in macro call [INFO] [stderr] | [INFO] [stderr] note: while trying to match `$` [INFO] [stderr] --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/ra_ap_parser-0.0.241/src/syntax_kind/generated.rs:716:20 [INFO] [stderr] | [INFO] [stderr] 716 | macro_rules ! T { [$] => { $ crate :: SyntaxKind :: DOLLAR } ; [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: Syntax... [INFO] [stderr] | ^ [INFO] [stderr] [INFO] [stderr] error: aborting due to 3 previous errors [INFO] [stderr] [INFO] [stderr] Original diagnostics will follow. [INFO] [stderr] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/ast/generated/nodes.rs:369:86 [INFO] [stdout] | [INFO] [stdout] 369 | pub fn gen_token(&self) -> Option { support::token(&self.syntax, T![gen]) } [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] = note: `--force-warn keyword-idents-2024` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/ast/generated/nodes.rs:456:86 [INFO] [stdout] | [INFO] [stdout] 456 | pub fn gen_token(&self) -> Option { support::token(&self.syntax, T![gen]) } [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/ast/generated/nodes.rs:669:86 [INFO] [stdout] | [INFO] [stdout] 669 | pub fn gen_token(&self) -> Option { support::token(&self.syntax, T![gen]) } [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the `expr` fragment specifier will accept more expressions in the 2024 edition [INFO] [stdout] --> src/lib.rs:235:19 [INFO] [stdout] | [INFO] [stdout] 235 | (match ($node:expr) { [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see Migration Guide [INFO] [stdout] = note: `--force-warn edition-2024-expr-fragment-specifier` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] help: to keep the existing behavior, use the `expr_2021` fragment specifier [INFO] [stdout] | [INFO] [stdout] 235 | (match ($node:expr_2021) { [INFO] [stdout] | ~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the `expr` fragment specifier will accept more expressions in the 2024 edition [INFO] [stdout] --> src/lib.rs:236:50 [INFO] [stdout] | [INFO] [stdout] 236 | $( $( $path:ident )::+ ($it:pat) => $res:expr, )* [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see Migration Guide [INFO] [stdout] help: to keep the existing behavior, use the `expr_2021` fragment specifier [INFO] [stdout] | [INFO] [stdout] 236 | $( $( $path:ident )::+ ($it:pat) => $res:expr_2021, )* [INFO] [stdout] | ~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the `expr` fragment specifier will accept more expressions in the 2024 edition [INFO] [stdout] --> src/lib.rs:237:25 [INFO] [stdout] | [INFO] [stdout] 237 | _ => $catch_all:expr $(,)? [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see Migration Guide [INFO] [stdout] help: to keep the existing behavior, use the `expr_2021` fragment specifier [INFO] [stdout] | [INFO] [stdout] 237 | _ => $catch_all:expr_2021 $(,)? [INFO] [stdout] | ~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/lib.rs:103:29 [INFO] [stdout] | [INFO] [stdout] 103 | let mut errors = if let Some(e) = self.errors.as_deref() { e.to_vec() } else { vec![] }; [INFO] [stdout] | ^^^^^^^^^^^^^^-----------^^^^^^^^^^^ [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:103:79 [INFO] [stdout] | [INFO] [stdout] 103 | let mut errors = if let Some(e) = self.errors.as_deref() { e.to_vec() } else { vec![] }; [INFO] [stdout] | ^ [INFO] [stdout] = note: `--force-warn if-let-rescope` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 103 | let mut errors = match self.errors.as_deref() { Some(e) => { e.to_vec() } _ => { vec![] }}; [INFO] [stdout] | ~~~~~ ++++++++++++ ~~~~ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/lib.rs:239:15 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^---------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | / match_ast! { [INFO] [stdout] 26 | | match node { [INFO] [stdout] 27 | | ast::Literal(it) => validate_literal(it, errors), [INFO] [stdout] 28 | | ast::Const(it) => validate_const(it, errors), [INFO] [stdout] ... | [INFO] [stdout] 41 | | } [INFO] [stdout] 42 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `$crate::match_ast` which comes from the expansion of the macro `match_ast` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:202:20 [INFO] [stdout] | [INFO] [stdout] 202 | if let Some(pair) = stack.pop() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^----------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:218:17 [INFO] [stdout] | [INFO] [stdout] 218 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 202 ~ match stack.pop() { Some(pair) => { [INFO] [stdout] 203 | assert_eq!( [INFO] [stdout] ... [INFO] [stdout] 217 | ); [INFO] [stdout] 218 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:280:8 [INFO] [stdout] | [INFO] [stdout] 280 | if let Some(token) = segment.self_token() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^-------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] ... [INFO] [stdout] 287 | } else if let Some(token) = segment.crate_token() { [INFO] [stdout] | --------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:287:5 [INFO] [stdout] | [INFO] [stdout] 287 | } else if let Some(token) = segment.crate_token() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:294:5 [INFO] [stdout] | [INFO] [stdout] 294 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 280 ~ match segment.self_token() { Some(token) => { [INFO] [stdout] 281 | if !is_path_start { [INFO] [stdout] ... [INFO] [stdout] 286 | } [INFO] [stdout] 287 ~ } _ => { match segment.crate_token() { Some(token) => { [INFO] [stdout] 288 | if !is_path_start || use_prefix(path).is_some() { [INFO] [stdout] ... [INFO] [stdout] 293 | } [INFO] [stdout] 294 ~ } _ => {}}}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/lib.rs:239:15 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^---------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:298:13 [INFO] [stdout] | [INFO] [stdout] 298 | / match_ast! { [INFO] [stdout] 299 | | match node { [INFO] [stdout] 300 | | ast::UseTree(it) => if let Some(tree_path) = it.path() { [INFO] [stdout] 301 | | // Even a top-level path exists within a `UseTree` so we must explicitly [INFO] [stdout] ... | [INFO] [stdout] 310 | | } [INFO] [stdout] 311 | | }; [INFO] [stdout] | |_____________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:298:13 [INFO] [stdout] | [INFO] [stdout] 298 | / match_ast! { [INFO] [stdout] 299 | | match node { [INFO] [stdout] 300 | | ast::UseTree(it) => if let Some(tree_path) = it.path() { [INFO] [stdout] 301 | | // Even a top-level path exists within a `UseTree` so we must explicitly [INFO] [stdout] ... | [INFO] [stdout] 310 | | } [INFO] [stdout] 311 | | }; [INFO] [stdout] | |_____________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:298:13 [INFO] [stdout] | [INFO] [stdout] 298 | / match_ast! { [INFO] [stdout] 299 | | match node { [INFO] [stdout] 300 | | ast::UseTree(it) => if let Some(tree_path) = it.path() { [INFO] [stdout] 301 | | // Even a top-level path exists within a `UseTree` so we must explicitly [INFO] [stdout] ... | [INFO] [stdout] 310 | | } [INFO] [stdout] 311 | | }; [INFO] [stdout] | |_____________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/validation.rs:298:13 [INFO] [stdout] | [INFO] [stdout] 298 | / match_ast! { [INFO] [stdout] 299 | | match node { [INFO] [stdout] 300 | | ast::UseTree(it) => if let Some(tree_path) = it.path() { [INFO] [stdout] 301 | | // Even a top-level path exists within a `UseTree` so we must explicitly [INFO] [stdout] ... | [INFO] [stdout] 310 | | } [INFO] [stdout] 311 | | }; [INFO] [stdout] | |_____________- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `$crate::match_ast` which comes from the expansion of the macro `match_ast` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:300:44 [INFO] [stdout] | [INFO] [stdout] 300 | ast::UseTree(it) => if let Some(tree_path) = it.path() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^--------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:306:21 [INFO] [stdout] | [INFO] [stdout] 306 | }, [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 300 ~ ast::UseTree(it) => match it.path() { Some(tree_path) => { [INFO] [stdout] 301 | // Even a top-level path exists within a `UseTree` so we must explicitly [INFO] [stdout] ... [INFO] [stdout] 305 | } [INFO] [stdout] 306 ~ } _ => {}}, [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:318:8 [INFO] [stdout] | [INFO] [stdout] 318 | if let Some(ast::Type::DynTraitType(ty)) = ty.ty() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:322:5 [INFO] [stdout] | [INFO] [stdout] 322 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 318 ~ match ty.ty() { Some(ast::Type::DynTraitType(ty)) => { [INFO] [stdout] 319 | if let Some(err) = validate_trait_object_ty(ty) { [INFO] [stdout] 320 | errors.push(err); [INFO] [stdout] 321 | } [INFO] [stdout] 322 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:319:12 [INFO] [stdout] | [INFO] [stdout] 319 | if let Some(err) = validate_trait_object_ty(ty) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^--^ [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:321:9 [INFO] [stdout] | [INFO] [stdout] 321 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 319 ~ match validate_trait_object_ty(ty) { Some(err) => { [INFO] [stdout] 320 | errors.push(err); [INFO] [stdout] 321 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:326:8 [INFO] [stdout] | [INFO] [stdout] 326 | if let Some(ast::Type::DynTraitType(ty)) = ty.ty() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:330:5 [INFO] [stdout] | [INFO] [stdout] 330 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 326 ~ match ty.ty() { Some(ast::Type::DynTraitType(ty)) => { [INFO] [stdout] 327 | if let Some(err) = validate_trait_object_ty(ty) { [INFO] [stdout] 328 | errors.push(err); [INFO] [stdout] 329 | } [INFO] [stdout] 330 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:327:12 [INFO] [stdout] | [INFO] [stdout] 327 | if let Some(err) = validate_trait_object_ty(ty) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^--^ [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:329:9 [INFO] [stdout] | [INFO] [stdout] 329 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 327 ~ match validate_trait_object_ty(ty) { Some(err) => { [INFO] [stdout] 328 | errors.push(err); [INFO] [stdout] 329 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:334:8 [INFO] [stdout] | [INFO] [stdout] 334 | if let Some(ast::Type::DynTraitType(ty)) = ty.ret_type().and_then(|ty| ty.ty()) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------------------------------------ [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:338:5 [INFO] [stdout] | [INFO] [stdout] 338 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 334 ~ match ty.ret_type().and_then(|ty| ty.ty()) { Some(ast::Type::DynTraitType(ty)) => { [INFO] [stdout] 335 | if let Some(err) = validate_trait_object_ty(ty) { [INFO] [stdout] 336 | errors.push(err); [INFO] [stdout] 337 | } [INFO] [stdout] 338 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:335:12 [INFO] [stdout] | [INFO] [stdout] 335 | if let Some(err) = validate_trait_object_ty(ty) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^--^ [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:337:9 [INFO] [stdout] | [INFO] [stdout] 337 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 335 ~ match validate_trait_object_ty(ty) { Some(err) => { [INFO] [stdout] 336 | errors.push(err); [INFO] [stdout] 337 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:357:8 [INFO] [stdout] | [INFO] [stdout] 357 | if let Some(vis) = mac.visibility() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^---------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:362:5 [INFO] [stdout] | [INFO] [stdout] 362 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 357 ~ match mac.visibility() { Some(vis) => { [INFO] [stdout] 358 | errors.push(SyntaxError::new( [INFO] [stdout] ... [INFO] [stdout] 361 | )); [INFO] [stdout] 362 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:366:8 [INFO] [stdout] | [INFO] [stdout] 366 | if let Some(mut_token) = const_ [INFO] [stdout] | ________^ - [INFO] [stdout] | |______________________________| [INFO] [stdout] 367 | || .const_token() [INFO] [stdout] 368 | || .and_then(|t| t.next_token()) [INFO] [stdout] 369 | || .and_then(|t| algo::skip_trivia_token(t, Direction::Next)) [INFO] [stdout] 370 | || .filter(|t| t.kind() == T![mut]) [INFO] [stdout] | ||________________________________________^ this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | |________________________________________| [INFO] [stdout] | [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:373:5 [INFO] [stdout] | [INFO] [stdout] 373 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 366 ~ match const_ [INFO] [stdout] 367 | .const_token() [INFO] [stdout] ... [INFO] [stdout] 370 | .filter(|t| t.kind() == T![mut]) [INFO] [stdout] 371 ~ { Some(mut_token) => { [INFO] [stdout] 372 | errors.push(SyntaxError::new("const globals cannot be mutable", mut_token.text_range())); [INFO] [stdout] 373 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation.rs:386:19 [INFO] [stdout] | [INFO] [stdout] 386 | } else if let Some(it) = ast::BinExpr::cast(token.clone()) { [INFO] [stdout] | ^^^^^^^^^^^^^^^--------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation.rs:390:9 [INFO] [stdout] | [INFO] [stdout] 390 | } else if ast::IfExpr::can_cast(token.kind()) [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 386 ~ } else { match ast::BinExpr::cast(token.clone()) { Some(it) => { [INFO] [stdout] 387 | if it.op_kind() == Some(ast::BinaryOp::LogicOp(ast::LogicOp::And)) { [INFO] [stdout] 388 | continue; [INFO] [stdout] 389 | } [INFO] [stdout] 390 ~ } _ => if ast::IfExpr::can_cast(token.kind()) [INFO] [stdout] 391 | || ast::WhileExpr::can_cast(token.kind()) [INFO] [stdout] ... [INFO] [stdout] 395 | return; [INFO] [stdout] 396 ~ }}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/validation/block.rs:16:8 [INFO] [stdout] | [INFO] [stdout] 16 | if let Some(stmt_list) = block.stmt_list() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^----------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/validation/block.rs:23:5 [INFO] [stdout] | [INFO] [stdout] 23 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 16 ~ match block.stmt_list() { Some(stmt_list) => { [INFO] [stdout] 17 | errors.extend(stmt_list.attrs().filter(|attr| attr.kind().is_inner()).map(|attr| { [INFO] [stdout] ... [INFO] [stdout] 22 | })); [INFO] [stdout] 23 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `impl Iterator>` will capture more lifetimes than possibly intended in edition 2024 [INFO] [stdout] --> src/algo.rs:23:6 [INFO] [stdout] | [INFO] [stdout] 23 | ) -> impl Iterator { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see [INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds [INFO] [stdout] --> src/algo.rs:21:11 [INFO] [stdout] | [INFO] [stdout] 21 | node: &SyntaxNode, [INFO] [stdout] | ^ [INFO] [stdout] = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024 [INFO] [stdout] = note: `--force-warn impl-trait-overcaptures` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit [INFO] [stdout] | [INFO] [stdout] 23 | ) -> impl Iterator + use<> { [INFO] [stdout] | +++++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/algo.rs:235:45 [INFO] [stdout] | [INFO] [stdout] 235 | let insert_pos = if let Some(prev) = last_lhs.clone().filter(|_| insert) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^----------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/algo.rs:237:25 [INFO] [stdout] | [INFO] [stdout] 237 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 235 ~ let insert_pos = match last_lhs.clone().filter(|_| insert) { Some(prev) => { [INFO] [stdout] 236 | TreeDiffInsertPos::After(prev) [INFO] [stdout] 237 ~ } _ => { [INFO] [stdout] 238 | cov_mark::hit!(insert_first_child); [INFO] [stdout] 239 | TreeDiffInsertPos::AsFirstChild(lhs.clone().into()) [INFO] [stdout] 240 ~ }}; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit.rs:88:16 [INFO] [stdout] | [INFO] [stdout] 88 | if let Some(ws) = ast::Whitespace::cast(token) { [INFO] [stdout] | ^^^^^^^^^^^^^^^---------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit.rs:93:13 [INFO] [stdout] | [INFO] [stdout] 93 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 88 ~ match ast::Whitespace::cast(token) { Some(ws) => { [INFO] [stdout] 89 | if ws.text().contains('\n') { [INFO] [stdout] ... [INFO] [stdout] 92 | } [INFO] [stdout] 93 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit.rs:103:16 [INFO] [stdout] | [INFO] [stdout] 103 | if let Some(ws) = ast::Whitespace::cast(token) { [INFO] [stdout] | ^^^^^^^^^^^^^^^---------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit.rs:110:13 [INFO] [stdout] | [INFO] [stdout] 110 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 103 ~ match ast::Whitespace::cast(token) { Some(ws) => { [INFO] [stdout] 104 | if ws.text().contains('\n') { [INFO] [stdout] ... [INFO] [stdout] 109 | } [INFO] [stdout] 110 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:28:35 [INFO] [stdout] | [INFO] [stdout] 28 | let position = if let Some(name) = self.name() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^----------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 29 | Position::after(name.syntax) [INFO] [stdout] 30 | } else if let Some(fn_token) = self.fn_token() { [INFO] [stdout] | --------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 31 | Position::after(fn_token) [INFO] [stdout] 32 | } else if let Some(param_list) = self.param_list() { [INFO] [stdout] | ----------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:30:17 [INFO] [stdout] | [INFO] [stdout] 30 | } else if let Some(fn_token) = self.fn_token() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:32:17 [INFO] [stdout] | [INFO] [stdout] 32 | } else if let Some(param_list) = self.param_list() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:34:17 [INFO] [stdout] | [INFO] [stdout] 34 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 28 ~ let position = match self.name() { Some(name) => { [INFO] [stdout] 29 | Position::after(name.syntax) [INFO] [stdout] 30 ~ } _ => { match self.fn_token() { Some(fn_token) => { [INFO] [stdout] 31 | Position::after(fn_token) [INFO] [stdout] 32 ~ } _ => { match self.param_list() { Some(param_list) => { [INFO] [stdout] 33 | Position::before(param_list.syntax) [INFO] [stdout] 34 ~ } _ => { [INFO] [stdout] 35 | Position::last_child_of(self.syntax()) [INFO] [stdout] 36 ~ }}}}}}; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:44:31 [INFO] [stdout] | [INFO] [stdout] 44 | let position = if let Some(ty) = self.ret_type() { [INFO] [stdout] | ^^^^^^^^^^^^^^^--------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 45 | Position::after(ty.syntax()) [INFO] [stdout] 46 | } else if let Some(param_list) = self.param_list() { [INFO] [stdout] | ----------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:46:13 [INFO] [stdout] | [INFO] [stdout] 46 | } else if let Some(param_list) = self.param_list() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:48:13 [INFO] [stdout] | [INFO] [stdout] 48 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 44 ~ let position = match self.ret_type() { Some(ty) => { [INFO] [stdout] 45 | Position::after(ty.syntax()) [INFO] [stdout] 46 ~ } _ => { match self.param_list() { Some(param_list) => { [INFO] [stdout] 47 | Position::after(param_list.syntax()) [INFO] [stdout] 48 ~ } _ => { [INFO] [stdout] 49 | Position::last_child_of(self.syntax()) [INFO] [stdout] 50 ~ }}}}; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:88:35 [INFO] [stdout] | [INFO] [stdout] 88 | let position = if let Some(name) = self.name() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^----------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 89 | Position::after(name.syntax) [INFO] [stdout] 90 | } else if let Some(trait_token) = self.trait_token() { [INFO] [stdout] | ------------------ this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:90:17 [INFO] [stdout] | [INFO] [stdout] 90 | } else if let Some(trait_token) = self.trait_token() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:92:17 [INFO] [stdout] | [INFO] [stdout] 92 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 88 ~ let position = match self.name() { Some(name) => { [INFO] [stdout] 89 | Position::after(name.syntax) [INFO] [stdout] 90 ~ } _ => { match self.trait_token() { Some(trait_token) => { [INFO] [stdout] 91 | Position::after(trait_token) [INFO] [stdout] 92 ~ } _ => { [INFO] [stdout] 93 | Position::last_child_of(self.syntax()) [INFO] [stdout] 94 ~ }}}}; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:117:35 [INFO] [stdout] | [INFO] [stdout] 117 | let position = if let Some(name) = self.name() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^----------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 118 | Position::after(name.syntax) [INFO] [stdout] 119 | } else if let Some(struct_token) = self.struct_token() { [INFO] [stdout] | ------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:119:17 [INFO] [stdout] | [INFO] [stdout] 119 | } else if let Some(struct_token) = self.struct_token() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:121:17 [INFO] [stdout] | [INFO] [stdout] 121 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 117 ~ let position = match self.name() { Some(name) => { [INFO] [stdout] 118 | Position::after(name.syntax) [INFO] [stdout] 119 ~ } _ => { match self.struct_token() { Some(struct_token) => { [INFO] [stdout] 120 | Position::after(struct_token) [INFO] [stdout] 121 ~ } _ => { [INFO] [stdout] 122 | Position::last_child_of(self.syntax()) [INFO] [stdout] 123 ~ }}}}; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:135:31 [INFO] [stdout] | [INFO] [stdout] 135 | let position = if let Some(tfl) = tfl { [INFO] [stdout] | ^^^^^^^^^^^^^^^^--- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 136 | Position::after(tfl.syntax()) [INFO] [stdout] 137 | } else if let Some(gpl) = self.generic_param_list() { [INFO] [stdout] | ------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 138 | Position::after(gpl.syntax()) [INFO] [stdout] 139 | } else if let Some(name) = self.name() { [INFO] [stdout] | ----------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:137:13 [INFO] [stdout] | [INFO] [stdout] 137 | } else if let Some(gpl) = self.generic_param_list() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:139:13 [INFO] [stdout] | [INFO] [stdout] 139 | } else if let Some(name) = self.name() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:141:13 [INFO] [stdout] | [INFO] [stdout] 141 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 135 ~ let position = match tfl { Some(tfl) => { [INFO] [stdout] 136 | Position::after(tfl.syntax()) [INFO] [stdout] 137 ~ } _ => { match self.generic_param_list() { Some(gpl) => { [INFO] [stdout] 138 | Position::after(gpl.syntax()) [INFO] [stdout] 139 ~ } _ => { match self.name() { Some(name) => { [INFO] [stdout] 140 | Position::after(name.syntax()) [INFO] [stdout] 141 ~ } _ => { [INFO] [stdout] 142 | Position::last_child_of(self.syntax()) [INFO] [stdout] 143 ~ }}}}}}; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:155:35 [INFO] [stdout] | [INFO] [stdout] 155 | let position = if let Some(name) = self.name() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^----------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 156 | Position::after(name.syntax) [INFO] [stdout] 157 | } else if let Some(enum_token) = self.enum_token() { [INFO] [stdout] | ----------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:157:17 [INFO] [stdout] | [INFO] [stdout] 157 | } else if let Some(enum_token) = self.enum_token() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:159:17 [INFO] [stdout] | [INFO] [stdout] 159 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 155 ~ let position = match self.name() { Some(name) => { [INFO] [stdout] 156 | Position::after(name.syntax) [INFO] [stdout] 157 ~ } _ => { match self.enum_token() { Some(enum_token) => { [INFO] [stdout] 158 | Position::after(enum_token) [INFO] [stdout] 159 ~ } _ => { [INFO] [stdout] 160 | Position::last_child_of(self.syntax()) [INFO] [stdout] 161 ~ }}}}; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:169:31 [INFO] [stdout] | [INFO] [stdout] 169 | let position = if let Some(gpl) = self.generic_param_list() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 170 | Position::after(gpl.syntax()) [INFO] [stdout] 171 | } else if let Some(name) = self.name() { [INFO] [stdout] | ----------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:171:13 [INFO] [stdout] | [INFO] [stdout] 171 | } else if let Some(name) = self.name() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:173:13 [INFO] [stdout] | [INFO] [stdout] 173 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 169 ~ let position = match self.generic_param_list() { Some(gpl) => { [INFO] [stdout] 170 | Position::after(gpl.syntax()) [INFO] [stdout] 171 ~ } _ => { match self.name() { Some(name) => { [INFO] [stdout] 172 | Position::after(name.syntax()) [INFO] [stdout] 173 ~ } _ => { [INFO] [stdout] 174 | Position::last_child_of(self.syntax()) [INFO] [stdout] 175 ~ }}}}; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:262:12 [INFO] [stdout] | [INFO] [stdout] 262 | if let Some(previous) = generic_param.syntax().prev_sibling() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^------------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] ... [INFO] [stdout] 266 | } else if let Some(next) = generic_param.syntax().next_sibling() { [INFO] [stdout] | ------------------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:266:9 [INFO] [stdout] | [INFO] [stdout] 266 | } else if let Some(next) = generic_param.syntax().next_sibling() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:270:9 [INFO] [stdout] | [INFO] [stdout] 270 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 262 ~ match generic_param.syntax().prev_sibling() { Some(previous) => { [INFO] [stdout] 263 | if let Some(next_token) = previous.next_sibling_or_token() { [INFO] [stdout] 264 | ted::remove_all(next_token..=generic_param.syntax().clone().into()); [INFO] [stdout] 265 | } [INFO] [stdout] 266 ~ } _ => { match generic_param.syntax().next_sibling() { Some(next) => { [INFO] [stdout] 267 | if let Some(next_token) = next.prev_sibling_or_token() { [INFO] [stdout] 268 | ted::remove_all(generic_param.syntax().clone().into()..=next_token); [INFO] [stdout] 269 | } [INFO] [stdout] 270 ~ } _ => { [INFO] [stdout] 271 | ted::remove(generic_param.syntax()); [INFO] [stdout] 272 ~ }}}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:263:16 [INFO] [stdout] | [INFO] [stdout] 263 | if let Some(next_token) = previous.next_sibling_or_token() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^-------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:265:13 [INFO] [stdout] | [INFO] [stdout] 265 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 263 ~ match previous.next_sibling_or_token() { Some(next_token) => { [INFO] [stdout] 264 | ted::remove_all(next_token..=generic_param.syntax().clone().into()); [INFO] [stdout] 265 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:267:16 [INFO] [stdout] | [INFO] [stdout] 267 | if let Some(next_token) = next.prev_sibling_or_token() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^---------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:269:13 [INFO] [stdout] | [INFO] [stdout] 269 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 267 ~ match next.prev_sibling_or_token() { Some(next_token) => { [INFO] [stdout] 268 | ted::remove_all(generic_param.syntax().clone().into()..=next_token); [INFO] [stdout] 269 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:299:12 [INFO] [stdout] | [INFO] [stdout] 299 | if let Some(param) = ¶m_to_remove { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^--------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:301:9 [INFO] [stdout] | [INFO] [stdout] 301 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 299 ~ match ¶m_to_remove { Some(param) => { [INFO] [stdout] 300 | self.remove_generic_param(param.clone()); [INFO] [stdout] 301 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:334:12 [INFO] [stdout] | [INFO] [stdout] 334 | if let Some(previous) = predicate.syntax().prev_sibling() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^--------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] ... [INFO] [stdout] 338 | } else if let Some(next) = predicate.syntax().next_sibling() { [INFO] [stdout] | --------------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:338:9 [INFO] [stdout] | [INFO] [stdout] 338 | } else if let Some(next) = predicate.syntax().next_sibling() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:342:9 [INFO] [stdout] | [INFO] [stdout] 342 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 334 ~ match predicate.syntax().prev_sibling() { Some(previous) => { [INFO] [stdout] 335 | if let Some(next_token) = previous.next_sibling_or_token() { [INFO] [stdout] 336 | ted::remove_all(next_token..=predicate.syntax().clone().into()); [INFO] [stdout] 337 | } [INFO] [stdout] 338 ~ } _ => { match predicate.syntax().next_sibling() { Some(next) => { [INFO] [stdout] 339 | if let Some(next_token) = next.prev_sibling_or_token() { [INFO] [stdout] 340 | ted::remove_all(predicate.syntax().clone().into()..=next_token); [INFO] [stdout] 341 | } [INFO] [stdout] 342 ~ } _ => { [INFO] [stdout] 343 | ted::remove(predicate.syntax()); [INFO] [stdout] 344 ~ }}}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:335:16 [INFO] [stdout] | [INFO] [stdout] 335 | if let Some(next_token) = previous.next_sibling_or_token() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^-------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:337:13 [INFO] [stdout] | [INFO] [stdout] 337 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 335 ~ match previous.next_sibling_or_token() { Some(next_token) => { [INFO] [stdout] 336 | ted::remove_all(next_token..=predicate.syntax().clone().into()); [INFO] [stdout] 337 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:339:16 [INFO] [stdout] | [INFO] [stdout] 339 | if let Some(next_token) = next.prev_sibling_or_token() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^---------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:341:13 [INFO] [stdout] | [INFO] [stdout] 341 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 339 ~ match next.prev_sibling_or_token() { Some(next_token) => { [INFO] [stdout] 340 | ted::remove_all(predicate.syntax().clone().into()..=next_token); [INFO] [stdout] 341 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:350:12 [INFO] [stdout] | [INFO] [stdout] 350 | if let Some((eq, last)) = self [INFO] [stdout] | ____________^ - [INFO] [stdout] | |___________________________________| [INFO] [stdout] 351 | || .syntax() [INFO] [stdout] 352 | || .children_with_tokens() [INFO] [stdout] 353 | || .find(|it| it.kind() == T![=]) [INFO] [stdout] 354 | || .zip(self.syntax().last_child_or_token()) [INFO] [stdout] | ||_____________________________________________________^ this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | |_____________________________________________________| [INFO] [stdout] | [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:362:9 [INFO] [stdout] | [INFO] [stdout] 362 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 350 ~ match self [INFO] [stdout] 351 | .syntax() [INFO] [stdout] ... [INFO] [stdout] 354 | .zip(self.syntax().last_child_or_token()) [INFO] [stdout] 355 ~ { Some((eq, last)) => { [INFO] [stdout] 356 | ted::remove_all(eq..=last); [INFO] [stdout] ... [INFO] [stdout] 361 | } [INFO] [stdout] 362 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:359:16 [INFO] [stdout] | [INFO] [stdout] 359 | if let Some(last) = self.syntax().last_token().filter(|it| it.kind() == WHITESPACE) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^--------------------------------------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:361:13 [INFO] [stdout] | [INFO] [stdout] 361 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 359 ~ match self.syntax().last_token().filter(|it| it.kind() == WHITESPACE) { Some(last) => { [INFO] [stdout] 360 | last.detach(); [INFO] [stdout] 361 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:368:12 [INFO] [stdout] | [INFO] [stdout] 368 | if let Some((eq, last)) = self [INFO] [stdout] | ____________^ - [INFO] [stdout] | |___________________________________| [INFO] [stdout] 369 | || .syntax() [INFO] [stdout] 370 | || .children_with_tokens() [INFO] [stdout] 371 | || .find(|it| it.kind() == T![=]) [INFO] [stdout] 372 | || .zip(self.syntax().last_child_or_token()) [INFO] [stdout] | ||_____________________________________________________^ this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | |_____________________________________________________| [INFO] [stdout] | [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:380:9 [INFO] [stdout] | [INFO] [stdout] 380 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 368 ~ match self [INFO] [stdout] 369 | .syntax() [INFO] [stdout] ... [INFO] [stdout] 372 | .zip(self.syntax().last_child_or_token()) [INFO] [stdout] 373 ~ { Some((eq, last)) => { [INFO] [stdout] 374 | ted::remove_all(eq..=last); [INFO] [stdout] ... [INFO] [stdout] 379 | } [INFO] [stdout] 380 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:377:16 [INFO] [stdout] | [INFO] [stdout] 377 | if let Some(last) = self.syntax().last_token().filter(|it| it.kind() == WHITESPACE) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^--------------------------------------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:379:13 [INFO] [stdout] | [INFO] [stdout] 379 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 377 ~ match self.syntax().last_token().filter(|it| it.kind() == WHITESPACE) { Some(last) => { [INFO] [stdout] 378 | last.detach(); [INFO] [stdout] 379 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:412:16 [INFO] [stdout] | [INFO] [stdout] 412 | if let Some(arg_list) = self.arg_list() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^--------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:417:13 [INFO] [stdout] | [INFO] [stdout] 417 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 412 ~ match self.arg_list() { Some(arg_list) => { [INFO] [stdout] 413 | ted::insert_raw( [INFO] [stdout] ... [INFO] [stdout] 416 | ); [INFO] [stdout] 417 ~ } _ => { [INFO] [stdout] 418 | ted::append_child(self.syntax(), generic_arg_list.syntax()); [INFO] [stdout] 419 ~ }} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:428:16 [INFO] [stdout] | [INFO] [stdout] 428 | if let Some(next_use_tree) = neighbor(self, dir) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:436:13 [INFO] [stdout] | [INFO] [stdout] 436 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 428 ~ match neighbor(self, dir) { Some(next_use_tree) => { [INFO] [stdout] 429 | let separators = self [INFO] [stdout] ... [INFO] [stdout] 435 | break; [INFO] [stdout] 436 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:449:12 [INFO] [stdout] | [INFO] [stdout] 449 | if let Some(u) = parent.clone().and_then(ast::Use::cast) { [INFO] [stdout] | ^^^^^^^^^^^^^^--------------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] ... [INFO] [stdout] 453 | } else if let Some(u) = parent.and_then(ast::UseTreeList::cast) { [INFO] [stdout] | --------------------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:453:9 [INFO] [stdout] | [INFO] [stdout] 453 | } else if let Some(u) = parent.and_then(ast::UseTreeList::cast) { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:461:9 [INFO] [stdout] | [INFO] [stdout] 461 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 449 ~ match parent.clone().and_then(ast::Use::cast) { Some(u) => { [INFO] [stdout] 450 | if u.use_tree().is_none() { [INFO] [stdout] 451 | u.remove(); [INFO] [stdout] 452 | } [INFO] [stdout] 453 ~ } _ => { match parent.and_then(ast::UseTreeList::cast) { Some(u) => { [INFO] [stdout] 454 | if u.use_trees().next().is_none() { [INFO] [stdout] ... [INFO] [stdout] 460 | u.remove_unnecessary_braces(); [INFO] [stdout] 461 ~ } _ => {}}}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:456:20 [INFO] [stdout] | [INFO] [stdout] 456 | if let Some(u) = parent { [INFO] [stdout] | ^^^^^^^^^^^^^^------ [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:458:17 [INFO] [stdout] | [INFO] [stdout] 458 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 456 ~ match parent { Some(u) => { [INFO] [stdout] 457 | u.remove_recursive(); [INFO] [stdout] 458 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:778:20 [INFO] [stdout] | [INFO] [stdout] 778 | if let Some(last) = self.syntax().last_token().filter(|it| it.kind() == WHITESPACE) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^--------------------------------------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:781:17 [INFO] [stdout] | [INFO] [stdout] 781 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 778 ~ match self.syntax().last_token().filter(|it| it.kind() == WHITESPACE) [INFO] [stdout] 779 ~ { Some(last) => { [INFO] [stdout] 780 | last.detach(); [INFO] [stdout] 781 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:793:20 [INFO] [stdout] | [INFO] [stdout] 793 | if let Some(old_ty) = self.ty() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^--------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:795:17 [INFO] [stdout] | [INFO] [stdout] 795 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 793 ~ match self.ty() { Some(old_ty) => { [INFO] [stdout] 794 | ted::replace(old_ty.syntax(), new_ty.syntax()); [INFO] [stdout] 795 ~ } _ => { [INFO] [stdout] 796 | ted::insert(Position::after(self.colon_token().unwrap()), new_ty.syntax()); [INFO] [stdout] 797 ~ }} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:847:12 [INFO] [stdout] | [INFO] [stdout] 847 | if let Some(ast::Expr::PathExpr(path_expr)) = self.expr() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:860:9 [INFO] [stdout] | [INFO] [stdout] 860 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 847 ~ match self.expr() { Some(ast::Expr::PathExpr(path_expr)) => { [INFO] [stdout] 848 | if let Some(path) = path_expr.path() { [INFO] [stdout] ... [INFO] [stdout] 859 | } [INFO] [stdout] 860 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:848:16 [INFO] [stdout] | [INFO] [stdout] 848 | if let Some(path) = path_expr.path() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^---------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:859:13 [INFO] [stdout] | [INFO] [stdout] 859 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 848 ~ match path_expr.path() { Some(path) => { [INFO] [stdout] 849 | if let Some(name_ref) = path.as_single_name_ref() { [INFO] [stdout] ... [INFO] [stdout] 858 | } [INFO] [stdout] 859 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:849:20 [INFO] [stdout] | [INFO] [stdout] 849 | if let Some(name_ref) = path.as_single_name_ref() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:858:17 [INFO] [stdout] | [INFO] [stdout] 858 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 849 ~ match path.as_single_name_ref() { Some(name_ref) => { [INFO] [stdout] 850 | path_expr.syntax().detach(); [INFO] [stdout] ... [INFO] [stdout] 857 | ted::insert_all_raw(Position::last_child_of(self.syntax()), children); [INFO] [stdout] 858 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:966:20 [INFO] [stdout] | [INFO] [stdout] 966 | if let Some(at_token) = self.at_token() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^--------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:982:17 [INFO] [stdout] | [INFO] [stdout] 982 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 966 ~ match self.at_token() { Some(at_token) => { [INFO] [stdout] 967 | // Remove `@ Pat` [INFO] [stdout] ... [INFO] [stdout] 981 | } [INFO] [stdout] 982 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:977:24 [INFO] [stdout] | [INFO] [stdout] 977 | if let Some(last) = [INFO] [stdout] | ________________________^ [INFO] [stdout] 978 | | self.syntax().last_token().filter(|it| it.kind() == WHITESPACE) [INFO] [stdout] | |_________________________--------------------------------------------------------------^ [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:981:21 [INFO] [stdout] | [INFO] [stdout] 981 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 977 ~ match self.syntax().last_token().filter(|it| it.kind() == WHITESPACE) [INFO] [stdout] 978 ~ { Some(last) => { [INFO] [stdout] 979 | last.detach(); [INFO] [stdout] 980 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:985:20 [INFO] [stdout] | [INFO] [stdout] 985 | if let Some(old_pat) = self.pat() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^---------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] ... [INFO] [stdout] 988 | } else if let Some(at_token) = self.at_token() { [INFO] [stdout] | --------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:988:17 [INFO] [stdout] | [INFO] [stdout] 988 | } else if let Some(at_token) = self.at_token() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:991:17 [INFO] [stdout] | [INFO] [stdout] 991 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 985 ~ match self.pat() { Some(old_pat) => { [INFO] [stdout] 986 | // Replace existing pattern [INFO] [stdout] 987 | ted::replace(old_pat.syntax(), pat.syntax()) [INFO] [stdout] 988 ~ } _ => { match self.at_token() { Some(at_token) => { [INFO] [stdout] 989 | // Have an `@` token but not a pattern yet [INFO] [stdout] 990 | ted::insert(ted::Position::after(at_token), pat.syntax()); [INFO] [stdout] 991 ~ } _ => { [INFO] [stdout] 992 | // Don't have an `@`, should have a name [INFO] [stdout] ... [INFO] [stdout] 1002| ) [INFO] [stdout] 1003~ }}}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:1011:12 [INFO] [stdout] | [INFO] [stdout] 1011 | if let Some(visibility) = visibility { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^---------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] ... [INFO] [stdout] 1026 | } else if let Some(visibility) = self.visibility() { [INFO] [stdout] | ----------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:1026:9 [INFO] [stdout] | [INFO] [stdout] 1026 | } else if let Some(visibility) = self.visibility() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/edit_in_place.rs:1028:9 [INFO] [stdout] | [INFO] [stdout] 1028 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 1011 ~ match visibility { Some(visibility) => { [INFO] [stdout] 1012 | match self.visibility() { [INFO] [stdout] ... [INFO] [stdout] 1025 | } [INFO] [stdout] 1026 ~ } _ => { match self.visibility() { Some(visibility) => { [INFO] [stdout] 1027 | ted::remove(visibility.syntax()); [INFO] [stdout] 1028 ~ } _ => {}}}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/expr_ext.rs:438:12 [INFO] [stdout] | [INFO] [stdout] 438 | if let Some(it) = ast::CallExpr::cast(syntax.clone()) { [INFO] [stdout] | ^^^^^^^^^^^^^^^----------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/expr_ext.rs:440:9 [INFO] [stdout] | [INFO] [stdout] 440 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 438 ~ match ast::CallExpr::cast(syntax.clone()) { Some(it) => { [INFO] [stdout] 439 | Some(Self::Call(it)) [INFO] [stdout] 440 ~ } _ => { [INFO] [stdout] 441 | ast::MethodCallExpr::cast(syntax).map(Self::MethodCall) [INFO] [stdout] 442 ~ }} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/make.rs:190:12 [INFO] [stdout] | [INFO] [stdout] 190 | if let Some(cl) = exp.1 { [INFO] [stdout] | ^^^^^^^^^^^^^^^----- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/make.rs:192:9 [INFO] [stdout] | [INFO] [stdout] 192 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 190 ~ match exp.1 { Some(cl) => { [INFO] [stdout] 191 | s.push_str(&format!(" = {} {cl}", exp.0)); [INFO] [stdout] 192 ~ } _ => { [INFO] [stdout] 193 | s.push_str(&format!(" = {}", exp.0)); [INFO] [stdout] 194 ~ }} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/make.rs:909:8 [INFO] [stdout] | [INFO] [stdout] 909 | if let Some(gen_params) = gen_params { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^---------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/make.rs:911:5 [INFO] [stdout] | [INFO] [stdout] 911 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 909 ~ match gen_params { Some(gen_params) => { [INFO] [stdout] 910 | format_to!(text, "{} ", gen_params.to_string()); [INFO] [stdout] 911 ~ } _ => { [INFO] [stdout] 912 | text.push(' '); [INFO] [stdout] 913 ~ }} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `impl Iterator` will capture more lifetimes than possibly intended in edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:69:33 [INFO] [stdout] | [INFO] [stdout] 69 | pub fn statements(&self) -> impl Iterator { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see [INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds [INFO] [stdout] --> src/ast/node_ext.rs:69:23 [INFO] [stdout] | [INFO] [stdout] 69 | pub fn statements(&self) -> impl Iterator { [INFO] [stdout] | ^ [INFO] [stdout] = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024 [INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit [INFO] [stdout] | [INFO] [stdout] 69 | pub fn statements(&self) -> impl Iterator + use<> { [INFO] [stdout] | +++++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:251:22 [INFO] [stdout] | [INFO] [stdout] 251 | let res = if let Some(name_ref) = self.name_ref() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^--------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:259:9 [INFO] [stdout] | [INFO] [stdout] 259 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 251 ~ let res = match self.name_ref() { Some(name_ref) => { [INFO] [stdout] 252 | match name_ref.token_kind() { [INFO] [stdout] ... [INFO] [stdout] 258 | } [INFO] [stdout] 259 ~ } _ => { [INFO] [stdout] 260 | match self.syntax().first_child_or_token()?.kind() { [INFO] [stdout] ... [INFO] [stdout] 271 | } [INFO] [stdout] 272 ~ }}; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `impl Iterator + Clone` will capture more lifetimes than possibly intended in edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:308:31 [INFO] [stdout] | [INFO] [stdout] 308 | pub fn segments(&self) -> impl Iterator + Clone { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see [INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds [INFO] [stdout] --> src/ast/node_ext.rs:308:21 [INFO] [stdout] | [INFO] [stdout] 308 | pub fn segments(&self) -> impl Iterator + Clone { [INFO] [stdout] | ^ [INFO] [stdout] = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024 [INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit [INFO] [stdout] | [INFO] [stdout] 308 | pub fn segments(&self) -> impl Iterator + Clone + use<> { [INFO] [stdout] | +++++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `impl Iterator + Clone` will capture more lifetimes than possibly intended in edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:321:33 [INFO] [stdout] | [INFO] [stdout] 321 | pub fn qualifiers(&self) -> impl Iterator + Clone { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see [INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds [INFO] [stdout] --> src/ast/node_ext.rs:321:23 [INFO] [stdout] | [INFO] [stdout] 321 | pub fn qualifiers(&self) -> impl Iterator + Clone { [INFO] [stdout] | ^ [INFO] [stdout] = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024 [INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit [INFO] [stdout] | [INFO] [stdout] 321 | pub fn qualifiers(&self) -> impl Iterator + Clone + use<> { [INFO] [stdout] | +++++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `impl Iterator>` will capture more lifetimes than possibly intended in edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:376:28 [INFO] [stdout] | [INFO] [stdout] 376 | pub fn comma(&self) -> impl Iterator { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see [INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds [INFO] [stdout] --> src/ast/node_ext.rs:376:18 [INFO] [stdout] | [INFO] [stdout] 376 | pub fn comma(&self) -> impl Iterator { [INFO] [stdout] | ^ [INFO] [stdout] = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024 [INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit [INFO] [stdout] | [INFO] [stdout] 376 | pub fn comma(&self) -> impl Iterator + use<> { [INFO] [stdout] | +++++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:387:16 [INFO] [stdout] | [INFO] [stdout] 387 | if let Some((single_subtree,)) = u.use_trees().collect_tuple() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:396:13 [INFO] [stdout] | [INFO] [stdout] 396 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 387 ~ match u.use_trees().collect_tuple() { Some((single_subtree,)) => { [INFO] [stdout] 388 | // We have a single subtree, check whether it is self. [INFO] [stdout] ... [INFO] [stdout] 395 | !is_self [INFO] [stdout] 396 ~ } _ => { [INFO] [stdout] 397 | // Not a single subtree [INFO] [stdout] 398 | false [INFO] [stdout] 399 ~ }} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:476:12 [INFO] [stdout] | [INFO] [stdout] 476 | if let Some(nfdl) = support::child::(node.syntax()) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^----------------------------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 477 | StructKind::Record(nfdl) [INFO] [stdout] 478 | } else if let Some(pfl) = support::child::(node.syntax()) { [INFO] [stdout] | ---------------------------------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:478:9 [INFO] [stdout] | [INFO] [stdout] 478 | } else if let Some(pfl) = support::child::(node.syntax()) { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:480:9 [INFO] [stdout] | [INFO] [stdout] 480 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 476 ~ match support::child::(node.syntax()) { Some(nfdl) => { [INFO] [stdout] 477 | StructKind::Record(nfdl) [INFO] [stdout] 478 ~ } _ => { match support::child::(node.syntax()) { Some(pfl) => { [INFO] [stdout] 479 | StructKind::Tuple(pfl) [INFO] [stdout] 480 ~ } _ => { [INFO] [stdout] 481 | StructKind::Unit [INFO] [stdout] 482 ~ }}}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:805:12 [INFO] [stdout] | [INFO] [stdout] 805 | if let Some(path_type) = support::children(self.syntax()).next() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^--------------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 806 | TypeBoundKind::PathType(path_type) [INFO] [stdout] 807 | } else if let Some(for_type) = support::children(self.syntax()).next() { [INFO] [stdout] | --------------------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 808 | TypeBoundKind::ForType(for_type) [INFO] [stdout] 809 | } else if let Some(args) = self.use_bound_generic_args() { [INFO] [stdout] | ----------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 810 | TypeBoundKind::Use(args) [INFO] [stdout] 811 | } else if let Some(lifetime) = self.lifetime() { [INFO] [stdout] | --------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:807:9 [INFO] [stdout] | [INFO] [stdout] 807 | } else if let Some(for_type) = support::children(self.syntax()).next() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:809:9 [INFO] [stdout] | [INFO] [stdout] 809 | } else if let Some(args) = self.use_bound_generic_args() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:811:9 [INFO] [stdout] | [INFO] [stdout] 811 | } else if let Some(lifetime) = self.lifetime() { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:813:9 [INFO] [stdout] | [INFO] [stdout] 813 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 805 ~ match support::children(self.syntax()).next() { Some(path_type) => { [INFO] [stdout] 806 | TypeBoundKind::PathType(path_type) [INFO] [stdout] 807 ~ } _ => { match support::children(self.syntax()).next() { Some(for_type) => { [INFO] [stdout] 808 | TypeBoundKind::ForType(for_type) [INFO] [stdout] 809 ~ } _ => { match self.use_bound_generic_args() { Some(args) => { [INFO] [stdout] 810 | TypeBoundKind::Use(args) [INFO] [stdout] 811 ~ } _ => { match self.lifetime() { Some(lifetime) => { [INFO] [stdout] 812 | TypeBoundKind::Lifetime(lifetime) [INFO] [stdout] 813 ~ } _ => { [INFO] [stdout] 814 | unreachable!() [INFO] [stdout] 815 ~ }}}}}}}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `impl Iterator>` will capture more lifetimes than possibly intended in edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:949:38 [INFO] [stdout] | [INFO] [stdout] 949 | pub fn lifetime_bounds(&self) -> impl Iterator { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see [INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds [INFO] [stdout] --> src/ast/node_ext.rs:949:28 [INFO] [stdout] | [INFO] [stdout] 949 | pub fn lifetime_bounds(&self) -> impl Iterator { [INFO] [stdout] | ^ [INFO] [stdout] = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024 [INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit [INFO] [stdout] | [INFO] [stdout] 949 | pub fn lifetime_bounds(&self) -> impl Iterator + use<> { [INFO] [stdout] | +++++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `impl Iterator>>` will capture more lifetimes than possibly intended in edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:1013:10 [INFO] [stdout] | [INFO] [stdout] 1013 | ) -> impl Iterator> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see [INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds [INFO] [stdout] --> src/ast/node_ext.rs:1012:9 [INFO] [stdout] | [INFO] [stdout] 1012 | &self, [INFO] [stdout] | ^ [INFO] [stdout] = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024 [INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit [INFO] [stdout] | [INFO] [stdout] 1013 | ) -> impl Iterator> + use<> { [INFO] [stdout] | +++++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `impl Iterator` will capture more lifetimes than possibly intended in edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:1046:36 [INFO] [stdout] | [INFO] [stdout] 1046 | pub fn lifetime_args(&self) -> impl Iterator { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see [INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds [INFO] [stdout] --> src/ast/node_ext.rs:1046:26 [INFO] [stdout] | [INFO] [stdout] 1046 | pub fn lifetime_args(&self) -> impl Iterator { [INFO] [stdout] | ^ [INFO] [stdout] = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024 [INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit [INFO] [stdout] | [INFO] [stdout] 1046 | pub fn lifetime_args(&self) -> impl Iterator + use<> { [INFO] [stdout] | +++++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `impl Iterator` will capture more lifetimes than possibly intended in edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:1055:38 [INFO] [stdout] | [INFO] [stdout] 1055 | pub fn lifetime_params(&self) -> impl Iterator { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see [INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds [INFO] [stdout] --> src/ast/node_ext.rs:1055:28 [INFO] [stdout] | [INFO] [stdout] 1055 | pub fn lifetime_params(&self) -> impl Iterator { [INFO] [stdout] | ^ [INFO] [stdout] = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024 [INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit [INFO] [stdout] | [INFO] [stdout] 1055 | pub fn lifetime_params(&self) -> impl Iterator + use<> { [INFO] [stdout] | +++++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `impl Iterator` will capture more lifetimes than possibly intended in edition 2024 [INFO] [stdout] --> src/ast/node_ext.rs:1061:43 [INFO] [stdout] | [INFO] [stdout] 1061 | pub fn type_or_const_params(&self) -> impl Iterator { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see [INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds [INFO] [stdout] --> src/ast/node_ext.rs:1061:33 [INFO] [stdout] | [INFO] [stdout] 1061 | pub fn type_or_const_params(&self) -> impl Iterator { [INFO] [stdout] | ^ [INFO] [stdout] = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024 [INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit [INFO] [stdout] | [INFO] [stdout] 1061 | pub fn type_or_const_params(&self) -> impl Iterator + use<> { [INFO] [stdout] | +++++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/lib.rs:239:15 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^---------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] ::: src/ast/prec.rs:17:9 [INFO] [stdout] | [INFO] [stdout] 17 | / match_ast! { [INFO] [stdout] 18 | | match parent { [INFO] [stdout] 19 | | ast::Expr(e) => self.needs_parens_in_expr(&e), [INFO] [stdout] 20 | | ast::Stmt(e) => self.needs_parens_in_stmt(Some(&e)), [INFO] [stdout] ... | [INFO] [stdout] 25 | | } [INFO] [stdout] 26 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/ast/prec.rs:17:9 [INFO] [stdout] | [INFO] [stdout] 17 | / match_ast! { [INFO] [stdout] 18 | | match parent { [INFO] [stdout] 19 | | ast::Expr(e) => self.needs_parens_in_expr(&e), [INFO] [stdout] 20 | | ast::Stmt(e) => self.needs_parens_in_stmt(Some(&e)), [INFO] [stdout] ... | [INFO] [stdout] 25 | | } [INFO] [stdout] 26 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/ast/prec.rs:17:9 [INFO] [stdout] | [INFO] [stdout] 17 | / match_ast! { [INFO] [stdout] 18 | | match parent { [INFO] [stdout] 19 | | ast::Expr(e) => self.needs_parens_in_expr(&e), [INFO] [stdout] 20 | | ast::Stmt(e) => self.needs_parens_in_stmt(Some(&e)), [INFO] [stdout] ... | [INFO] [stdout] 25 | | } [INFO] [stdout] 26 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/ast/prec.rs:17:9 [INFO] [stdout] | [INFO] [stdout] 17 | / match_ast! { [INFO] [stdout] 18 | | match parent { [INFO] [stdout] 19 | | ast::Expr(e) => self.needs_parens_in_expr(&e), [INFO] [stdout] 20 | | ast::Stmt(e) => self.needs_parens_in_stmt(Some(&e)), [INFO] [stdout] ... | [INFO] [stdout] 25 | | } [INFO] [stdout] 26 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/ast/prec.rs:17:9 [INFO] [stdout] | [INFO] [stdout] 17 | / match_ast! { [INFO] [stdout] 18 | | match parent { [INFO] [stdout] 19 | | ast::Expr(e) => self.needs_parens_in_expr(&e), [INFO] [stdout] 20 | | ast::Stmt(e) => self.needs_parens_in_stmt(Some(&e)), [INFO] [stdout] ... | [INFO] [stdout] 25 | | } [INFO] [stdout] 26 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/lib.rs:239:69 [INFO] [stdout] | [INFO] [stdout] 239 | $( if let Some($it) = $($path::)+cast($node.clone()) { $res } else )* [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] ::: src/ast/prec.rs:17:9 [INFO] [stdout] | [INFO] [stdout] 17 | / match_ast! { [INFO] [stdout] 18 | | match parent { [INFO] [stdout] 19 | | ast::Expr(e) => self.needs_parens_in_expr(&e), [INFO] [stdout] 20 | | ast::Stmt(e) => self.needs_parens_in_stmt(Some(&e)), [INFO] [stdout] ... | [INFO] [stdout] 25 | | } [INFO] [stdout] 26 | | } [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `$crate::match_ast` which comes from the expansion of the macro `match_ast` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/prec.rs:96:16 [INFO] [stdout] | [INFO] [stdout] 96 | if let Some(next) = next { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^---- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/prec.rs:101:13 [INFO] [stdout] | [INFO] [stdout] 101 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 96 ~ match next { Some(next) => { [INFO] [stdout] 97 | innermost = next; [INFO] [stdout] ... [INFO] [stdout] 100 | } [INFO] [stdout] 101 ~ } _ => { [INFO] [stdout] 102 | break; [INFO] [stdout] 103 ~ }} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ast/traits.rs:85:35 [INFO] [stdout] | [INFO] [stdout] 85 | let inner_attrs_node = if let Some(it) = [INFO] [stdout] | ___________________________________^ [INFO] [stdout] 86 | | support::child::(self.syntax()).and_then(|it| it.stmt_list()) [INFO] [stdout] | |_____________----------------------------------------------------------------------------^ [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] ... [INFO] [stdout] 89 | } else if let Some(it) = support::child::(self.syntax()) { [INFO] [stdout] | -------------------------------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 90 | Some(it.syntax) [INFO] [stdout] 91 | } else if let Some(it) = support::child::(self.syntax()) { [INFO] [stdout] | --------------------------------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 92 | Some(it.syntax) [INFO] [stdout] 93 | } else if let Some(it) = support::child::(self.syntax()) { [INFO] [stdout] | ---------------------------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 94 | Some(it.syntax) [INFO] [stdout] 95 | } else if let Some(it) = support::child::(self.syntax()) { [INFO] [stdout] | ---------------------------------------------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] 96 | Some(it.syntax) [INFO] [stdout] 97 | } else if let Some(it) = support::child::(self.syntax()) { [INFO] [stdout] | ------------------------------------------------ this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/traits.rs:89:9 [INFO] [stdout] | [INFO] [stdout] 89 | } else if let Some(it) = support::child::(self.syntax()) { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/traits.rs:91:9 [INFO] [stdout] | [INFO] [stdout] 91 | } else if let Some(it) = support::child::(self.syntax()) { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/traits.rs:93:9 [INFO] [stdout] | [INFO] [stdout] 93 | } else if let Some(it) = support::child::(self.syntax()) { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/traits.rs:95:9 [INFO] [stdout] | [INFO] [stdout] 95 | } else if let Some(it) = support::child::(self.syntax()) { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/traits.rs:97:9 [INFO] [stdout] | [INFO] [stdout] 97 | } else if let Some(it) = support::child::(self.syntax()) { [INFO] [stdout] | ^ [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ast/traits.rs:99:9 [INFO] [stdout] | [INFO] [stdout] 99 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 85 ~ let inner_attrs_node = match support::child::(self.syntax()).and_then(|it| it.stmt_list()) [INFO] [stdout] 86 ~ { Some(it) => { [INFO] [stdout] 87 | Some(it.syntax) [INFO] [stdout] 88 ~ } _ => { match support::child::(self.syntax()) { Some(it) => { [INFO] [stdout] 89 | Some(it.syntax) [INFO] [stdout] 90 ~ } _ => { match support::child::(self.syntax()) { Some(it) => { [INFO] [stdout] 91 | Some(it.syntax) [INFO] [stdout] 92 ~ } _ => { match support::child::(self.syntax()) { Some(it) => { [INFO] [stdout] 93 | Some(it.syntax) [INFO] [stdout] 94 ~ } _ => { match support::child::(self.syntax()) { Some(it) => { [INFO] [stdout] 95 | Some(it.syntax) [INFO] [stdout] 96 ~ } _ => { match support::child::(self.syntax()) { Some(it) => { [INFO] [stdout] 97 | Some(it.syntax) [INFO] [stdout] 98 ~ } _ => { [INFO] [stdout] 99 | None [INFO] [stdout] 100~ }}}}}}}}}}}}; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/syntax_editor/edit_algo.rs:105:12 [INFO] [stdout] | [INFO] [stdout] 105 | if let Some(index) = changed_ancestors [INFO] [stdout] | ^ ----------------- this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | ____________| [INFO] [stdout] | | [INFO] [stdout] 106 | | .iter() [INFO] [stdout] 107 | | .rev() [INFO] [stdout] 108 | | .position(|ancestor| ancestor.affected_range().contains_range(change.target_range())) [INFO] [stdout] | |_________________________________________________________________________________________________^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/syntax_editor/edit_algo.rs:120:9 [INFO] [stdout] | [INFO] [stdout] 120 | } else { [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 105 ~ match changed_ancestors [INFO] [stdout] 106 | .iter() [INFO] [stdout] 107 | .rev() [INFO] [stdout] 108 | .position(|ancestor| ancestor.affected_range().contains_range(change.target_range())) [INFO] [stdout] 109 ~ { Some(index) => { [INFO] [stdout] 110 | // Pop off any ancestors that aren't applicable [INFO] [stdout] ... [INFO] [stdout] 119 | }); [INFO] [stdout] 120 ~ } _ => { [INFO] [stdout] 121 | // This change is independent of any other change [INFO] [stdout] ... [INFO] [stdout] 126 | independent_changes.push(change_index as u32); [INFO] [stdout] 127 ~ }} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ted.rs:87:12 [INFO] [stdout] | [INFO] [stdout] 87 | if let Some(ws) = ws_before(&position, first) { [INFO] [stdout] | ^^^^^^^^^^^^^^^--------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ted.rs:89:9 [INFO] [stdout] | [INFO] [stdout] 89 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 87 ~ match ws_before(&position, first) { Some(ws) => { [INFO] [stdout] 88 | elements.insert(0, ws.into()); [INFO] [stdout] 89 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ted.rs:92:12 [INFO] [stdout] | [INFO] [stdout] 92 | if let Some(ws) = ws_after(&position, last) { [INFO] [stdout] | ^^^^^^^^^^^^^^^------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ted.rs:94:9 [INFO] [stdout] | [INFO] [stdout] 94 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 92 ~ match ws_after(&position, last) { Some(ws) => { [INFO] [stdout] 93 | elements.push(ws.into()); [INFO] [stdout] 94 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ted.rs:114:8 [INFO] [stdout] | [INFO] [stdout] 114 | if let Some(mut first) = it.next() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^--------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ted.rs:124:5 [INFO] [stdout] | [INFO] [stdout] 124 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 114 ~ match it.next() { Some(mut first) => { [INFO] [stdout] 115 | match it.last() { [INFO] [stdout] ... [INFO] [stdout] 123 | } [INFO] [stdout] 124 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ted.rs:162:12 [INFO] [stdout] | [INFO] [stdout] 162 | if let Some(item_list) = prev.parent().and_then(ast::ItemList::cast) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^------------------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ted.rs:166:9 [INFO] [stdout] | [INFO] [stdout] 166 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 162 ~ match prev.parent().and_then(ast::ItemList::cast) { Some(item_list) => { [INFO] [stdout] 163 | let mut indent = IndentLevel::from_element(&item_list.syntax().clone().into()); [INFO] [stdout] 164 | indent.0 += 1; [INFO] [stdout] 165 | return Some(make::tokens::whitespace(&format!("\n{indent}"))); [INFO] [stdout] 166 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let` assigns a shorter lifetime since Edition 2024 [INFO] [stdout] --> src/ted.rs:170:12 [INFO] [stdout] | [INFO] [stdout] 170 | if let Some(stmt_list) = prev.parent().and_then(ast::StmtList::cast) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^------------------------------------------- [INFO] [stdout] | | [INFO] [stdout] | this value has a significant drop implementation which may observe a major change in drop order and requires your discretion [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see issue #124085 [INFO] [stdout] help: the value is now dropped here in Edition 2024 [INFO] [stdout] --> src/ted.rs:174:9 [INFO] [stdout] | [INFO] [stdout] 174 | } [INFO] [stdout] | ^ [INFO] [stdout] help: a `match` with a single arm can preserve the drop order up to Edition 2021 [INFO] [stdout] | [INFO] [stdout] 170 ~ match prev.parent().and_then(ast::StmtList::cast) { Some(stmt_list) => { [INFO] [stdout] 171 | let mut indent = IndentLevel::from_element(&stmt_list.syntax().clone().into()); [INFO] [stdout] 172 | indent.0 += 1; [INFO] [stdout] 173 | return Some(make::tokens::whitespace(&format!("\n{indent}"))); [INFO] [stdout] 174 ~ } _ => {}} [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/ast/generated/nodes.rs:369:86 [INFO] [stdout] | [INFO] [stdout] 369 | pub fn gen_token(&self) -> Option { support::token(&self.syntax, T![gen]) } [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] = note: `--force-warn keyword-idents-2024` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/ast/generated/nodes.rs:456:86 [INFO] [stdout] | [INFO] [stdout] 456 | pub fn gen_token(&self) -> Option { support::token(&self.syntax, T![gen]) } [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/ast/generated/nodes.rs:669:86 [INFO] [stdout] | [INFO] [stdout] 669 | pub fn gen_token(&self) -> Option { support::token(&self.syntax, T![gen]) } [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0432]: unresolved import `test_utils` [INFO] [stdout] --> src/parsing/reparsing.rs:181:9 [INFO] [stdout] | [INFO] [stdout] 181 | use test_utils::{assert_eq_text, extract_range}; [INFO] [stdout] | ^^^^^^^^^^ use of undeclared crate or module `test_utils` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0432]: unresolved import `test_utils` [INFO] [stdout] --> src/tests.rs:11:5 [INFO] [stdout] | [INFO] [stdout] 11 | use test_utils::{bench, bench_fixture, project_root}; [INFO] [stdout] | ^^^^^^^^^^ use of undeclared crate or module `test_utils` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0432]: unresolved import `test_utils` [INFO] [stdout] --> src/ast/edit_in_place.rs:1059:9 [INFO] [stdout] | [INFO] [stdout] 1059 | use test_utils::assert_eq_text; [INFO] [stdout] | ^^^^^^^^^^ use of undeclared crate or module `test_utils` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the `expr` fragment specifier will accept more expressions in the 2024 edition [INFO] [stdout] --> src/lib.rs:235:19 [INFO] [stdout] | [INFO] [stdout] 235 | (match ($node:expr) { [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see Migration Guide [INFO] [stdout] = note: `--force-warn edition-2024-expr-fragment-specifier` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] help: to keep the existing behavior, use the `expr_2021` fragment specifier [INFO] [stdout] | [INFO] [stdout] 235 | (match ($node:expr_2021) { [INFO] [stdout] | ~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the `expr` fragment specifier will accept more expressions in the 2024 edition [INFO] [stdout] --> src/lib.rs:236:50 [INFO] [stdout] | [INFO] [stdout] 236 | $( $( $path:ident )::+ ($it:pat) => $res:expr, )* [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see Migration Guide [INFO] [stdout] help: to keep the existing behavior, use the `expr_2021` fragment specifier [INFO] [stdout] | [INFO] [stdout] 236 | $( $( $path:ident )::+ ($it:pat) => $res:expr_2021, )* [INFO] [stdout] | ~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the `expr` fragment specifier will accept more expressions in the 2024 edition [INFO] [stdout] --> src/lib.rs:237:25 [INFO] [stdout] | [INFO] [stdout] 237 | _ => $catch_all:expr $(,)? [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see Migration Guide [INFO] [stdout] help: to keep the existing behavior, use the `expr_2021` fragment specifier [INFO] [stdout] | [INFO] [stdout] 237 | _ => $catch_all:expr_2021 $(,)? [INFO] [stdout] | ~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0277]: the size for values of type `[u8]` cannot be known at compilation time [INFO] [stdout] --> src/tests.rs:112:22 [INFO] [stdout] | [INFO] [stdout] 112 | .filter_map(|file| { [INFO] [stdout] | ^^^^ doesn't have a size known at compile-time [INFO] [stdout] | [INFO] [stdout] = help: within `std::path::Path`, the trait `Sized` is not implemented for `[u8]` [INFO] [stdout] note: required because it appears within the type `std::path::Path` [INFO] [stdout] --> /rustc/da25749bf5e6ba5ed862ff361c19afff2a986b2d/library/std/src/path.rs:2135:12 [INFO] [stdout] = note: all function arguments must have a statically known size [INFO] [stdout] = help: unsized fn params are gated as an unstable feature [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0277]: the size for values of type `[u8]` cannot be known at compilation time [INFO] [stdout] --> src/tests.rs:116:29 [INFO] [stdout] | [INFO] [stdout] 116 | Err(err) => Some((file, err)), [INFO] [stdout] | ^^^^ doesn't have a size known at compile-time [INFO] [stdout] | [INFO] [stdout] = help: within `std::path::Path`, the trait `Sized` is not implemented for `[u8]` [INFO] [stdout] note: required because it appears within the type `std::path::Path` [INFO] [stdout] --> /rustc/da25749bf5e6ba5ed862ff361c19afff2a986b2d/library/std/src/path.rs:2135:12 [INFO] [stdout] = note: only the last element of a tuple may have a dynamically sized type [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0277]: the size for values of type `[u8]` cannot be known at compilation time [INFO] [stdout] --> src/tests.rs:116:29 [INFO] [stdout] | [INFO] [stdout] 116 | Err(err) => Some((file, err)), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time [INFO] [stdout] | [INFO] [stdout] = help: within `std::path::Path`, the trait `Sized` is not implemented for `[u8]` [INFO] [stdout] note: required because it appears within the type `std::path::Path` [INFO] [stdout] --> /rustc/da25749bf5e6ba5ed862ff361c19afff2a986b2d/library/std/src/path.rs:2135:12 [INFO] [stdout] = note: only the last element of a tuple may have a dynamically sized type [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0277]: the size for values of type `[u8]` cannot be known at compilation time [INFO] [stdout] --> src/tests.rs:115:26 [INFO] [stdout] | [INFO] [stdout] 115 | Ok(_) => None, [INFO] [stdout] | ^^^^ doesn't have a size known at compile-time [INFO] [stdout] | [INFO] [stdout] = help: within `std::path::Path`, the trait `Sized` is not implemented for `[u8]` [INFO] [stdout] note: required because it appears within the type `std::path::Path` [INFO] [stdout] --> /rustc/da25749bf5e6ba5ed862ff361c19afff2a986b2d/library/std/src/path.rs:2135:12 [INFO] [stdout] = note: only the last element of a tuple may have a dynamically sized type [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] Some errors have detailed explanations: E0277, E0432. [INFO] [stdout] [INFO] [stdout] For more information about an error, try `rustc --explain E0277`. [INFO] [stdout] [INFO] [stderr] error: could not compile `ra_ap_syntax` (lib test) due to 7 previous errors; 6 warnings emitted [INFO] [stderr] error: failed to migrate to next edition [INFO] [stderr] [INFO] [stderr] Caused by: [INFO] [stderr] process didn't exit successfully: `cargo fix --edition --allow-no-vcs --allow-dirty --frozen --all --all-targets --message-format=json` (exit status: 101) [INFO] running `Command { std: "docker" "inspect" "42f3b465f785a773275c6f49a0272baf4bee426684f7b0f8ed1b34c2643c4c2a", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "42f3b465f785a773275c6f49a0272baf4bee426684f7b0f8ed1b34c2643c4c2a", kill_on_drop: false }` [INFO] [stdout] 42f3b465f785a773275c6f49a0272baf4bee426684f7b0f8ed1b34c2643c4c2a